ACM SIGGRAPH 2023: Sag Free Initialization for Complex Hair Simulations

Tencent Lightspeed & Quantum Studios, 2022 - 2023

graphics.cs.utah.edu
A continuation on sag-free initializations with the goal of addressing sag on complex hair simulations with full collision, friction, and many thousands of individual guide hairs. Hair simulation using XPBD Cosserat Rods coupled to a MPM continuum friction model.

ACM SIGGRAPH 2022: A general two-stage initialization for sag-free deformable simulations

University of Utah, 2020 - 2022

graphics.cs.utah.edu
I worked under Prof. Gurav Chopra and the Envision Center visualizing protein molecules in VR. I started with a simple instanced renderer. From there I implemented billboarding to reduce the poly count; a compute-based atom culling algorithm to address fill rate bottlenecks, a fluid rendering inspired iso surface renderer to address Van Der waals shells, and octahedral imposters to address background rendering. I came up with the idea of running a linear regression on the atom positions to better align axis-aligned-bounding-boxes. I ended up with the ability to render 50k+ atoms complete with labels and bonds at the speed and fidelity VR applications require.

Intelligent Adaptive Splitting for Vector Representations

Adobe, 2021 - Present

Currently working on publication. Discrete parameters like the number of nodes in a Bezier curve are often optimized through handcrafted heuristics. This provides a theoretically sound and generalizable framework to intelligently perform discrete node additions (or splitting) on vector representations like splines, diffusion curves, or gradient meshes. Applications include curve fitting, image fitting, and adaptive simulations.

Yarn-Level Cloth Simulation

University of Utah, 2020

An implementation of J. Kadors yarn-level cloth simulation with a couple of differences. Implicit backwards Euler time integration with Newton steps. Massively parallelized CUDA implementation from collision detection to sparse matrix creation and PCG solve.

Protein VR Visualization

I worked under Prof. Gurav Chopra and the Envision Center visualizing protein molecules in VR. I started with a simple instanced renderer. From there I implemented billboarding to reduce the poly count; a compute-based atom culling algorithm to address fill rate bottlenecks, a fluid rendering inspired iso surface renderer to address Van Der waals shells, and octahedral imposters to address background rendering. I came up with the idea of running a linear regression on the atom positions to better align axis-aligned-bounding-boxes. I ended up with the ability to render 50k+ atoms complete with labels and bonds at the speed and fidelity VR applications require.

2D SPH fluid simulation with two-way coupled solids

A 2D SPH fluid simulation that leverages compute shaders in OpenGL to dramatically speed up frame times. The fluid particles are simulated with a spatial hashing algorithm synchronized with atomics. Integration was done with RK4. Solids are simulated as fluid particle clusters with particle impulses obtained through parallel reduction. Rendering is done through the use of a variable radius blur combined with a threshold function. On a RTX 2070 Super, the simulation can support up to half a million particles with ~5ms per time step (dt=8ms). The video on the left is playedback at realtime on my laptop with each scene containing ~100k particles.

C++ Game Engine

A 2D game engine written from scratch using OpenGL and GLFW. It has a build-in constraint based physics engine with a SPT broad phase. Similar to Unity, it was its own transform parenting system and an implementation of several GUI functions like: GUI event dispatches, anchored based UI scaling, instanced atlas text rendering and sliced sprite rendering.

At the Envision Center, we got a request for an interactive manual for engine disassembly from an engine manufacturer. The manual was a monster with hundreds of steps each with individual substeps, warnings, and descriptions. It was cumbersome to work with, difficult to organize, and untenable with the amount of states needed. A traditional keyframe animation system simply wouldn’t do. I spent a good couple of weeks just going over the design and in the end I came up with a system of annotated object hierarchies that could then be automatically compiled into traditional keyframe animations through simple graph traversal rules. My system took advantage of the hierarchical structure that CAD engineers typically maintained for engines while keeping everything neat, extensible, quick to modify, and easy to organize. Picture not provided due to IP concerns.

Playing around with particles

A somewhat early stage clone of an old esoteric simulation game called The Powder Toy using compute shaders.