Wildgate Environment Shaders
The cloud shader was one of the biggest parts of our project. The volume of the clouds is defined by a 3D texture that is procedurally generated by a compute shader. The compute shader work was done by Rachel Haub and Rick Gilliland. I was the main tech artist responsible for the Unreal Engine side of the shader, which takes the 3D texture and constructs the final shape of the clouds and adds lighting.
I also authored the uber shader used for all POIs, as well as an asteroid shader which was used for all asteroids including the ice and lava asteroids.
Wildgate Ship Shaders
I created an uber shader that was used for all ships, hardpoint items, and turrets.
Some parts of the ship were separate blueprint actors but we wanted a unified gradient across the whole ship, so the shader used gameplay data to create a unified coordinate space across all ship parts. I also worked on the actor component that retrieved the data from each actor’s parent ship and updated the materials.
I worked on the ship shields shader with Lucas Panian. The shield meshes were generated from code by Lucas, and use vertex color sets to store custom data that allows the shader to detect when shield panels are damaged.
Wildgate Character Shaders
I authored the uber shader used for all weapons, as well as the skin and clothing of all characters. I made a variation of this shader for skin tints, and separate shaders for hair and eyes.
The faceplate shader used for our robot character was a unique shader, as we wanted to create a depth effect while keeping the material opaque.
For the liquid containers in some of our weapons, I made a shader that simulates liquid movement by masking parts of the mesh, then creating the appearance of a liquid surface using the mesh backfaces. I also created the gameplay component that passes in the player’s movement data so the shader can scale the animation based on velocity.
One of our characters has the ability to become hidden; his opaque material dissolves out and is replaced by a transparent effect that fades based on distance. The character gets rendered to the custom depth buffer, so that we can do a depth check to cull backfaces.
Wildgate Miscellaneous Shaders
I created a portal shader by intersecting the camera ray with an ellipsoid shape and constructing UVs to fake depth.
Many of the ship helm control UI elements were done with shaders. I created one shader that could show the ship’s forward, angular, and vertical momentum all in a circular display, and another shader that was showed the status of the brake, boost, and shields.
Raymarched Clouds
Language: OpenGL
I created a cloud-like effect by raymarching through octaves of simplex noise, with a nested raymarch towards the light source to create shadows. This was implemented as a custom shader in Substance Designer.
Pathtracer
Language: C++
A path tracing renderer assignment for the Computer Graphics course at Carnegie Mellon. It can render diffuse, reflective, and refractive materials. Global illumination is done via Monte Carlo path tracing with Russian Roulette to terminate the paths. The renderer can use .exr files as environment maps to add light to scenes. It also generates a Bounding Volume Hierarchy for each mesh to accelerate triangle mesh intersection.
Crowd Simulation
Language: C#
I read the paper ‘A Synthetic-Vision Based Steering Approach for Crowd Simulation’ (SIGGRAPH 2010) by Ondrej et al. and attempted to replicate their results with a C# script in Unity. The paper describes an algorithm to simulate obstacle avoidance in humans by creating a synthetic optic flow for each individual. Each individual continuously calculates the change in bearing angle between themselves and all obstacles in their field of vision, turning to eliminate the danger of collision as well as slowing down if collision is imminent. Using this method, Ondrej et al. were able to show the emergence of patterns within crowds and eliminate deadlocks.
When implementing the algorithm, I had to make some adjustments such as changing model parameters. Some parameters chosen in the paper didn't work well in my simulation, most likely due to differences in scale, and had to be adjusted.
Flocking Simulation
Language: C++, Python
I created a flocking simulation in C++ for my final project in the Computer Graphics course at Dartmouth. The program simulates flocking behavior, following the Boids model established by Craig Reynolds. The particles in the program all obey rules of cohesion, alignment, and separation. The resulting behavior simulates the movement of animals groups such as flocks of birds or schools of fish.
I later wrote a new version of this script in Python to run in Maya, and added goal steering behavior. The above video is a demo created in Maya using the script.
Mathematical Model
I formulated a mathematical model based on this flocking simulation for a 2 week research project in my applied math course. A poster detailing my research can be viewed by clicking on the image above.
Viscoelastic Fluid Simulation
Engine: Unity Language: C#
For a project in my Technical Animation course at Carnegie Mellon, I read the paper 'Particle-based Viscoelastic Fluid Simulation' by Clavet et al. (2005), and implemented it in Unity. The goal of this paper was to improve the traditional Lagrangian fluid simulation method by introducing a new procedure to enforce incompressibility and anti-clustering, called double density relaxation. The double density relaxation prevents clustering by taking into account density as well as a new term called near-density, which creates a repulsive force between neighboring particles. Viscoelasticity is a combination of elasticity, plasticity, and viscosity. Elasticity is created by inserting springs between particles, which apply displacement to the particles depending on the spring’s rest length and stiffness constant. Plasticity is determined by the extent to which the springs change their rest length as the fluid moves.
Using this algorithm, I was able to simulate a variety of fluid behaviors. I ran simulations ranging from 300 to 10,000 particles. For 300 particles, I was able to achieve an frame rate of around 20fps, allowing the fluid to be interactible.
FABRIK IK Solver
Engine: Unity Language: C#
For a project in my Technical Animation course at Carnegie Mellon, I read the paper 'FABRIK: A fast, iterative solver for the Inverse Kinematics problem' by Aristidou & Lasenby (2011), and implemented it in Unity. This paper describes a new algorithm to solve for joint positions in an inverse kinematic system. The method is called Forward and Backward Reaching Inverse Kinematics, and computes joint positions by locating positions on a line instead of solving for rotational angles. The result is efficient and produces reliable results. I implemented the algorithm for a single chain as well as a chain with multiple end effectors.
Cloth Simulation
Engine: Unity Language: C#
A spring-mass cloth simulation script written for my Technical Animation course at Carnegie Mellon. It can perform four different integration methods, which can affect the cloth appearance and the maximum allowable timestep for the simulation.