Projects
Please reach out if you'd like access to the private GitHub repos these projects.
This page showcases all my projects through the years, big and small. They are mostly ordered chronologically, with the highlights being nearer the top. However, all my top hits can be seen in my demo reel on the right, and include the following favorites of mine:
-
TreeVigorate - a Maya plugin for rapid strand-based trees
-
Mini Minecraft - a Minecraft clone built with OpenGL
-
CUDA Path Tracer and Boids - projects with the GPU
-
VR EIC and Gesture Controlled OBS - my projects from NASA
-
A Fluid Simulator I made with some friends
-
Real-time PBR
-
Fun shaders
-
...and more!
​
Please keep scrolling for more information about each!
TreeVigorate — Rapid Natural Tree Generation for Maya
C++, MEL, Maya C++ API
This tool was developed in a team of two and seeks to implement the 2024 paper, Interactive Invigoration: Volumetric Modeling of Trees with Strands by Li et al., as a plugin for Maya, allowing for rapid realistic tree generation with strand-based meshes and artist control.
The tree generation code itself was developed by Li et al for their previous paper, Rhizomorph: The Coordinated Function of Shoots and Roots, which we then ported over to work with Maya, and expanded upon to include features from the paper mentioned before.
I was in charge of implementing the following features: growing and pruning of subtrees, using Delaunay triangulation for strand particles and culling long edges, changing sun direction, the Maya UI using MEL, porting the Rhizomorph code, node selection, advanced settings, and exporting leaf transformation matrices.
Mini Minecraft
GLSL, C++, OpenGL, QT Creator
This large group project recreates Minectaft's basics with added custom features, fully coded in C++ and GLSL, running on OpenGL.
In our group of three, I was responsible for and implemented the following features: infinite procedural terrain generation using a Perlin noise height field and dynamic blending between biomes, texture mapping, optimized alpha blending for transparent textures, texture animation for water and lava, and post-process screen shaders for being under water/lava.
Additionally, I chose to add a day/night cycle with directional color-changing lighting and instance-rendered swaying grass that reacts to player movement.
CUDA Path Tracer
C++, CUDA
This path tracer was built using CUDA kernels, running each ray as a parallel thread, before compositing and outputting them as a single converging image.
It supports diffuse, specular, transmissive, dielectric, and PBR (using the GGX Microfacet model) materials.
The program supports scene importing through a JSON file, gLTFs with their textures, and .hdr environment maps.
Due to the complex nature of models and their high number of triangles, I implemented a Bounding Volume Hierarchy to check for triangle intersections using binned BVH construction and the Sample Area Heuristic method for deciding bounding box splits (visualized on the left).
Additionally, users can toggle physically accurate depth of field and stochastic sampled anti-aliasing in the ImGUI window, which also supports extra features showcased in the video.
For performance improvements, I incorporated stream compaction to discard idle threads and material sorting for memory adjacency. The performance analysis of these features and the path tracer as a whole can be seen in my detailed rundown in my ReadMe at the GitHub repo linked above.
CUDA Boids
C++, CUDA
This simple flocking program uses the power of multithreading on the GPU to simulate an incredibly high number of flocking particles. For example, the GIF on the right showcases 50,000 boids running at 300-400fps on my personal laptop, with a timestep of 0.02s.
To achieve this, I implemented three different algorithms with respective kernels and compared their performance: Naive, which checks every single boid against each other; Uniform Grid Flocking, which divides the area into cells and only checks boids in close enough cells; and Coherent Grid Flocking, which optimizes the lookup of nearby cells by sorting boid arrays for adjacent memory lookup.
This final algorithm proves to be the fastest, at about a 0.1-0.2x speedup from the second, and a 20-30x speedup over the naive, which also can't render above 100k boids, while the others easily go up to a million.
My full results and analysis can be viewed at the GitHub repo linked above, but needless to say, the multithreaded capabilities of the GPU are incredible, and I explored this further in other projects on my repo and in the path tracer right above.
VR Earth Information Center
C#, Unity
I developed this virtual reality application in three weeks as part of my internship at NASA Goddard Space Flight Center, in order to create an interactive experience version of the Earth Information Center (EIC). This project seeks to engage the greater public with NASA's Earth observing missions, data, and their connection.
The application lets users see and interact with the Scientific Visualization Studio's visualizations and with the satellites that gathered the necessary data in real time to highlight the pipeline from missions and instruments to data and visualizations. Users can observe the satellites in their real orbit around their respective visualization globes and grab them for a closer look, or place them in a "display box" to observe them at their true scale and read specific information about their mission.
The soundtrack was composed by The Studio at JPL for the EIC at Kennedy Space Center Visitor Complex.
Gesture Recognition Controls for OBS Studio
C++, Orbbec SDK, Azure Kinect SDK, WebSocket, OBS
I developed this application during my internship at NASA Goddard Space Flight Center, in order to increase engagement with Earth Information Center Hyperwalls (massive screens showcasing NASA Earth science content, which can be seen here) through interaction.
The application uses a Femto Mega depth camera to gather skeletal information about all visitors, determines who's facing the Hyperwall screen, evaluates whether they are performing one of five distinct gestures, aggregates all their data, and uses WebSocket to send the highest voted gesture to OBS Studio, which runs the Hyperwall content. The five gestures and resulting actions are:
- Pointing Left/Right: Skipping back/forward
- V pose: show only Visualizations
- O pose: show only Dashboards
- T pose: show the full playlist
This extension to EIC Hyperwalls is now available to the public and will be used at the Frost Science Museum in Miami and other locations soon.
Real-Time Physically Based Rendering
GLSL, C++, OpenGL, QT Creator
This multi-part real-time rendering project uses the Cook-Torrance BRDF model with GGX approximation for physically based rendering, and deferred rendering with pixel-space ray marching to achieve screen-space reflections. Reflections are precomputed into separate diffuse and glossy components, with varying mip levels for the glossy component to achieve variable surface roughness. The glossy BRDF precomputation follows the implementation in Unreal Engine 4.
The renderer also supports Signed Distance Functions, subsurface scattering using a separable BSSRDF, and model importing.
The helm in the video is a public model from SketchFab, and the SDF function is a combination of base geometry SDFs from Inigo Quilez's blog.
Fluid Dynamics Simulator
C++, Visual Studio
This independent group project implements and expands upon Jos Stam's 2003 Siggraph paper titled "Real-Time Fluid Dynamics for Games." We worked in a group of three over a three-week-long winter break, with no prior experience in fluid dynamics.
I was in charge of adding additional real-time user interaction features, including: adding fluids, adding bursts of velocity, toggling the velocity field, and adding and removing colorful barriers.
To achieve the visual velocity field, I first created a normal map texture from the velocity grid, which I used to rotate and scale instance-rendered arrows, which are drawn in a post-process overlay step. The original normal map is also toggleable for debugging purposes.
Monte Carlo Path Tracer
GLSL, C++, OpenGL, QT Creator
This Monte Carlo Path Tracer uses multi-importance sampling with direct light and BSDF sampling for Physically Based Rendering scenes.
It supports specular reflective, specular transmissive, diffuse, and microfacet materials. Scenes are read from JSON files, and primitive intersections are calculated in real-time. This project also supports environment maps, custom textures, and .obj files.
​
Each of these renders (the classic Monte Carlo box, Veach's scene, a glass ball in an environment map, and a custom scene of mine) were rendered in 10 seconds or less, purely on the GPU, with 100 ray bounces.
Maya L-System Plugin
C++, Python, MEL
This Maya plugin allows users to easily generate models using basic L-System grammar. Users can choose between a window GUI that creates each component individually, a custom node that can be instanced, or another custom node that uses an instancer to create each element for faster processing times.
The window includes sliders and a text field to set L-System parameters and grammar, as well as a browse button to import grammar from a .txt file.
The first node includes the same but uses the Maya time slider for iteration count, and grammar must be entered manually. I also created a GUI window for an instancer to easily create multiple copies of these trees to quickly create a larger terrain.
The second node has manual iteration editing, and allows for fruit to be added with a * symbol in the grammar. In its standard setting, it creates these with spheres and creates branches with cylinders, but these can be modified for any pair of selected objects.
Behavior Animator
C++, Visual Studio
This project implements behavior animations using system dynamics with a desired 2nd-order mass-spring-damper system and various individual, group, and compound behaviors that build on it. Users can edit behavior-specific and universal variables in the handy GUI.
The individual behaviors are: Seek, Flee, Arrival, Departure, Avoidance, and Wander. Group behaviors are: Alignment, Separation, and Cohesion. Compound behaviors are Flock and Follow the Leader.
Mesh Editor
GLSL, C++, OpenGL, QT Creator
This mesh editor parses OBJ files and creates a half-edge mesh data structure that is then buffered and drawn with OpenGL.
The accompanying GUI allows for selecting and highlighting elements of the mesh, which can then be navigated between using keyboard commands. Vertex positions and face colors can also be altered in the GUI.
I have also implemented buttons for splitting an edge (creating 2 new half-edges and a vertex), triangulating a face, extruding a face, and smoothing the whole mesh using the Catmull-Clark subdivision algorithm.
Pre- and Post-Process Shader
GLSL, C++, OpenGL, QT Creator
This project incorporates different pre- and post-processing OpenGL shaders and an interactive camera for a small scene of Mario.
The pre-process shaders are: Blinn-Phong reflection, Matcap reflection, and a custom vertex and fragment shader that turns Mario into a rainbow bouncy ball.
The post-process shaders are: a Sobel shader, a Gaussian blur shader, a distorting magnifying glass following the mouse position, and a custom "underwater" shader with distorting bubbles.
Worl-Eye Screen Saver
GLSL, C++, OpenGL, QT Creator
This small project utilizes some OpenGL basics to draw a creepy eye screen saver that follows the user's mouse with its gaze. The program passes a bouncing circle to the GPU that stays within screen bounds, and the rest is done in the shaders. The red veins and the iris are generated with a modified Worley noise and are drawn on the circle using a simple geometric distance function from the circle origin, which allows for this origin to be moved in the shader code depending on mouse position.
Particle Physics Simulator
C++, Visual Studio
This project implements particle dynamics functionality for small primitive-shape particles and fire-able exploding fireworks.
The particles' attributes, such as velocity, amount, lift time, color, alpha, size, etc., can be manually adjusted, as well as the external forces acting upon the fireworks and their sparks, such as wind force, attractor and repellor force, gravity, and drag. Their attributes are calculated by updating a state vector in each frame using Euler integration and 2nd Order Runga Kutta.
Forward and Inverse Kinematics Animator with Skinning
C++, Visual Studio
This project implements forward and inverse kinematics of a humanoid skeleton, and the skinning of that skeleton with any humanoid mesh. In forward kinematics mode, the model can be animated with BVH files. In inverse kinematics mode, users can move around end-limb joints and the root joint, and the model will adjust its body accordingly. The project uses linear blending for skinning.
This project also includes a Unity plugin where the model walks to an adjustable target position. When inverse kinematics is enabled, it adjusts to differences in terrain.
I implemented code for basic rotation, Catmull-Rom splines for interpolation, quaternion splines and arithmetic for rotation interpolation, and kinematics algorithms including limb-based and cyclic coordinate descent.
Interactive 3D Rasterizer
C++, QT Creator
This rasterizer takes in OBJ files and displays them in OpenGL. It implements perspective-correct interpolation, z-buffering, UV texture mapping, Lambertian diffuse shading, and a toggle-able wireframe mode that incorporates Bresenham's line algorithm. It also has an interactive camera with keyboard controls to move and rotate around the objects.
Spline Editor
C++, Visual Studio
This project allows users to create splines using Linear Interpolation; Catmull-Rom Bezier splines using the DeCasteljau algorithm, the matrix formulation, or the Bernstein polynomial formulation; and C2 continuous Hermite splines.
Users can place key points and the program will automatically construct the connecting curves and overarching spline with appropriate control points which can be visualized and moved. Users can also animate a small object that moves along the spline, and can use the splines to construct rotating animations using either Euler angles or quaternions.
Configurable Scene Graph
C++, QT Creator
This is an interactive scene graph tool to manipulate a humanoid figure. This example shows a hardcoded scene of the Sysiphus myth, but as shown, the GUI easily allows adding extra nodes.
The scene graph is managed by a tree data structure comprised of unique pointers to custom Node objects, with methods to traverse through the transformation matrix nodes.
I have also added configurable spin boxes to the GUI to allow for real-time modifications of node attributes, such as translation coordinates, scale amounts, rotation degrees, and geometry color.
Walter
Unity Web Game
This 2D platformer was created in 10 days with a team of 5 for GameBoy Jam 11.
I was the team's programmer and wrote scripts for game management, menu navigation, player movement, and shader manipulation.
Spirit Lantern
Unity Web Game
This isometric action game was initially built in 44 hours with a team of 6 during the Spring 2023 ATX GameMaker's GameJam and then was slightly expanded for showcasing during South By Southwest.
​
I participated in creating the idea for the core gameplay and then served as one of two programmers on the team. I wrote scripts for player and enemy interactions, the gameplay loop, UI, and generating the end score.
​
I conducted playtesting and incorporated player feedback for the final version.
Car Joust
Unity Web Game
I developed this multiplayer dueling web game by myself. It expands upon the basic Unity player-control tutorial with full car mechanics driven by wheel colliders, a more in-depth obstacle spawner, pause screen, automated traffic, split-screen camera for the two players that can switch between first- and third-person, and an options screen that implements data persistence.
