Implementation based on Real-Time Hatching (Hoppe et al.)

The goal was to produce a hand-drawn effect on rendered scenes in real time, comparing combinations of a cel-shaded effect, outline drawing through two different techniques, and a modified version of the hatching technique from Real-Time Hatching. The effects were produced using Cg shaders, with the OGRE 3D engine handling rendering, scene management, mesh and texture loading, and passing of values to the shaders.

We created two algorithms for producing a cel-shaded appearance, each creating step functions to limit the number of shades. The first method applied the step function to the RGB channels, while the second converted the colors to HSL space before applying the function to the saturation and lightness channels. Outlines were produced first through the use of a Sobel filter, applied as a post-processing effect, and secondly by re-rendering the geometry scaled slightly larger and culling front-faces. Hatching was produced with the method outlined in the paper, blending between toroidal mip-mapped textures with different auto-generated patterns of hatch marks to shade the model.

Implementation based on Parallel Controllable Texture Synthesis (Hoppe et al.)

The goal was to synthesize deterministic patches of texture from a small example patch. Our main source was Parallel Controllable Texture Synthesis (Lefebvre and Hoppe), though we deviated from their method due to time constraints (2 week long project). Our final results are still wanting, so we plan to continue work when schedules allow for it.

The general idea of our method is to replicate the patch to produce a larger image, upsampling the patch by making a texture where each pixel corresponds to a coordinate in the exemplar. These coordinates are then jittered, and for each pixel in the generated image, the neighborhood is compared to the exemplar's neighborhood and corrected so as to produce similar patterns to those found in the exemplar. Our method still falls short on producing results that are consistently similar to the exemplar, often producing noticeably anomalous regions. We also do not have any compensation for textures with regular, structured patterns, such as bricks, where warping is noticeable.

Deferred rendering pipeline with basic game engine components

This was yet another project I made with my friend Matt for a class. The idea was to try and get a photon mapping implementation as outlined in Hardware Accelerated Global Illumination by Image Space Photon Mapping (McGuire and Luebke). The deferred rendering component was primarily my doing, with Matt creating the texture loading and error libraries.

At the moment, this is my goto code when I need something rendered. Features include texture loading, obj model loading, direct and deferred rendering, a ray tracing component, shader loading and compilation, and a rudimentary scene graph. There are also libraries for vector math, matrix math, and quaternion calculations, for transforming vertices. The photon mapping implementation is incomplete and as I use this code to experiment, not all of it us functional. The initial push for creating this was about a week, where I wrote over 6000 lines of C++ which Matt helped refine and restructure. Further changes then took place over several days to produce the final product.

Boid flocking simulation

This project was done in CUDA C with a parallel construction. The simulation follows three rules as outlined by Craig Reynolds: separation, cohesion, and alignment as per the description of the boid simulation in Flocks, Herds, and Schools: A Distributed Behavioral Model by Craig Reynolds in the proceedings of SIGGRAPH 1987. Visualization of the boids was done using OpenGL, with isosceles triangles representing each boid. Triangles were generated using a geometry shader written by my project partner, Matt McMullan. We had mixed results with this, where sometimes the boids would function normally and sometimes would have no data due to an issue with our usage of CUDA that we never tracked down.

Implementation based on Interactive watercolor rendering with temporal coherence and abstraction (Bousseau et. al)

This implementation was created in Unity3D as part of a game called Mar. After working on the cross-hatching rendering technique I was interested in working with other non-photorealistic rendering techniques, specifically watercolor style. I had in mind a game that would look like a geometric, abstract painting, and after proposing the plan to Matt, we began development, with him focusing mainly on the game mechanic implementations while I found several papers on various watercolor rendering techniques and began testing them out.

Fly Away: A stop motion video

A piece of paper on a covered tabletop folds itself into an origami crane and flies away. This was done as stop motion using image matting, compositing, and inpainting. A combination of code written using OpenCV and GIMP plugins were used to produce the final result. I produced the OpenCV code and used several existing GIMP plugins. GIMP was mostly used for touch-ups and for fixing and replacing failure cases for my inpainting code (of which there were many) and to help cover failure cases of matting and compositing. This project focused more heavily on the final resulting video than on the success or failure of the techniques I used.

Setup, data collection (shooting footage), coding, editing, and final video creation were performed over the course of 3 weeks as an individual project. I received consultation on my setup and photography from Mary Gordon, who also loaned me equipment (and kindly helped me in setup and tear-down).

Ripple Shader

This project was inspired by characters such as Toph from Avatar: the Last Airbender and DareDevil from Marvel Comics who "see" the world through sound or other vibrations. This effect is also seen in recent Batman media (DC Comics), specifically the Arkham series of video games and the film The Dark Knight, where a sonar style system gives Batman a visual of the city. These vibrations are often visualized in media as ripples spreading through the environment which outline objects, showing a stylized view to indicate this unique style of "sight."

For this implementation, a Fast Fourier Transform (FFT) analysis of a sound file was used to generate the ripples, giving a sort of music visualizer. The implementation was made using OpenFrameworks and GLSL. Several test songs were used, including Settle Down by Kimbra which was used for the video below. Due to the computational intensity of both screen recording and producing the output, the video is somewhat choppy.

Master's Thesis: Controller for Jumping Animations to Achieve Target Positions

Abstract:

Animating a character for video games and films is difficult and time consuming, requiring hours of artist labor to produce each animation. These animations are set and inflexible, requiring changes to the animation or sometimes fully new animations to suit new characters or situations for natural looking movements. Jumping is one such animation, where the size, mass, strength, and environment affect the movement of the character. Traditionally these animations are produced by manually posing the character for certain key frames and interpolating between the frames to produce a smooth animation. The more detailed or lengthy an animation, the more work required to specify it. Physics-based simulation for animation production can reduce this work, creating animations for a variety of situations based on constants set for the character and environment. These animations can then be easily recreated or adjusted for different environments by changing the constants set for generation.

This thesis work presents a simulation-based method of control for a character, focusing on the lower body, to produce jumping animations for a variety of situations and body parameters. Two methods of simulation are described, one using a torque calculation and the other using an energy calculation to determine poses for the character. My simulation takes as input a mesh representing the character, a tree of joints describing the skeleton, a set of muscles, mass assigned to each limb of the body, and a description of the desired path through desired timings, gravity, and desired displacement. An inverse kinematic solver is used to aid in posing the character.

Contributions of this thesis include an implementation of a simulation to produce jump animations in \unity{}, a description of character poses based on torque as well as another based on energy, a sampling-based method for choosing a target position, and visualization of the produced animations in several ways to aid in debugging, analysis and presentation.

WebGL Rendering Library

This project started off severala times as a personal project and was born out of the mess I created when making short webgames. More recently, my goal became putting live examples of my work on this website for easier perusal. I am working to mimic the straightforwardness of OpenFrameworks and Unity scripting so that this can be used for rapid prototyping. There are other WebGL engines and libraries that I could use but part of the reason for this project is for personal satisfaction and learning.

The test page has an error log giving compile and link status of shaders, some debugging information about different objects, a constantly updating feed of the vector bases for the camera (view->world matrix component vectors) and cube model (model->world matrix component vectors for the cube). There's a known issue that I've been trying to pinpoint in which the cube flattens to a hexagon whose plane is orthogonal to the axis of rotation when rotated about certain axes. I've sideboarded the issue as I thought that it was a vector normalization issue or a mistake in my quaternion rotation math, but have yet to create a change in the behavior and have thus moved on temporarily to add more required features so that I may start porting my work and putting it online.

Work on this project is ongoing and I will continue adding features as the need arises.

Panda3D

Samples of work developed using the Panda3D engine. Although I have used the engine and have a moderate degree of familiarity, I wouldn't use it for production, as it is more of a teaching and learning tool. It was important in my skill development however, showing a distinctly more programmatic approach to composing scenes and dealing with game and engine logic than is found in Unity, which has a more graphically based "drag and drop" type of workflow. There is one actual game demonstrated here, while the other examples were part of an individual assignment to produce a simple vehicle (in my case, a penguin with an attached rocket) with a light source that could be moved through the environment to avoid or collide with obstacles (an oversized mushroom and a boulder) in the level.

The individual assignment required each person to produce their own art as well as their own code. I produced the models of the penguin, rocket, mushroom, and boulder, as well as the textures for each, and created a simple environment where a random configuration of mushrooms and boulders were spawned, and the penguin would then be able to navigate. I produced a particle effect for the rocket as well as placed a light for the flames coming from the back.

The group assignment was a game called Alzarian's Artifact, and was based off of the ideas "raise" and "elude" (randomly assigned). The idea is that the player has explored some ruins, and discovered an artifact which allows them to control the stone around them, only to find that there are monsters stalking through the halls. They then elude the monster by raising walls out of the stone beneath their feet, escaping while the monster is stuck, or hiding behind the walls, exploiting the monsters' poor eyesight. The player is able to raise a small wall (a limited number per level) and place small lights to better see the dark rooms while they move to the marked doorways leading to the next level and eventually out. My responsibilities were mainly lighting, as well as a particle effect for lamps, environment modelling,

Unnamed Unity3D Game

An unnamed game developed with the Unity3D engine about a robotic dog. It was developed as a class project, and the assigned "theme" for the game was hamartia. Our concept was a robotic dog produced by the military who is loyal and obedient to a fault, progressing through the levels of the game and slowly damaging itself. Eventually, though the dog completes its tasks, it is far too damaged to be useful to the project and the scientists running the project order him disassembled in favor of building a more able prototype.

My responsibilities in this project involved work on customized character and camera controllers, as well as prefab creation, asset imports, level design for one of the levels, asset server management and troubleshooting, general Unity troubleshooting for the whole team, terrain creation, applying collision solids to imported models, animation import and association (with scripts and models) and finally particle effects for a flame effect used by the dog for a flamethrower (used for clearing brush obstacles from the player's path).

Supernova

A game in the early stages that I'm developing with my friend Rosa Tung. We're currently working in Unity to develop this somewhat abstract game, in which you play in a zero gravity multiplayer environment as a sphere, with the ability to absorb small particles of light. These light particles can be shot at other spheres or used as an attack. Absorb too many light particles and you'll explode, but too few and you implode.

Some of the effects we're working on are a "fat cell" type of look for the spheres, giving them a membranous feel. We also aim to experiment with different control schemes to produce a control scheme which immerses the player and enables them to navigate and attack easily.

Subterrane

Subterrane is an underground horror-exploration game. You play as an athletic caver who has slipped unexpectedly into a deep hole. Your journey to climb out takes you deeper into the earth where you find some of the creatures who live in the caves. This game was developed in Unity3D with a team of 5.

The material applied to the crystals and mushrooms was provided courtesy of Anton Hand.

Mar

Mar is an abstract physics game about shepherding the mar balls through their dangerous, puzzling environments, inspired by Lemmings and World of Goo. The mar proceed according to a few simple rules:

• Start moving right
• If they hit an obstacle or wall, reverse direction

Implementation was carried out by a team of 2 over a period of 7 weeks, with 1 week for initial concepts and design though the design process continued throughout the development of the game.

Space to Fly

Instructions:
1. Press space to fly upwards
2. If you aren't flying upwards, you fall
3. Avoid hitting the green and blue
4. Pressing P will pause the game

This was an experiment to learn how to use html canvas elements. I'm still using this game and a few other simple tests to experiment with the best way to construct a JavaScript game engine (or at least the best design for me to work with). For working code, I'm moving towards a WebGL drawing component so that I can more easily test shaders and effects, but I've preserved this iteration as an example of one of my quick web prototypes.