Hi there! I am Daniel Li, known online as FallingSky65. I'm a senior at Montgomery Blair High School with a passion for graphics programming. Here are some of my selected projects:
Find me on GitHub! I make commits now and then.
This is a path tracer program I wrote in 2023, before I began to use GitHub regularly. The original code is unchanged from when I last updated it on September 4, 2023.
This program renders a simple scene by simulating photon interactions with surfaces, with each intersection reflecting and accumulating colored light. The code is run entirely on a single CPU thread and the program stores the results for 1/10/50/100 photons per pixel, and displays the final result in a new window.
Here are the results, each image is 960x720 pixels, and every photon is capped at 4 bounces in the scene.
From left to right: 1 photon per pixel, 10 photons per pixel, 50 photons per pixel, 100 photons per pixel:
This is a program I wrote in July 2024, and it implements procedural terrain generation in a voxel engine inspired by Minecraft. It is written in C++ and uses raylib (also raylib-cpp for cpp bindings) for graphics, and it implements on-the-fly optimized mesh generation.
I built SatPathVisualizer as a C++ library for creating satellite orbit path visualizations. Industry methods for creating these visualizations, typically for satellite missions, often require using paid/closed-source/external services. This project aimed to solve that by creating an open source library under the MIT license.
I had the opportunity to present this work at the 2024 American Geophysical Union conference:
In total, I've built five fluid simulation projects, each focused on learning and implementing new techniques for faster and more optimized fluid modeling.
This was my first fluid simulation, inspired by this YouTube video by Sebastian Lague. It uses smoothed particle hydrodynamics (SPH) (Müller 2003) to simulate fluid physics for 512 particles at 60 FPS. It runs on a single CPU thread in C++, and graphics were done using raylib and GLSL shaders.
This was my second fluid simulation, and it improved on the first in three main ways:
This simulation could handle 20x more particles than my first, simulating physics for 10,000 particles at 60 FPS.
This is my third fluid simulation. Unlike the previous two, which were particle-based (Lagrangian) and ran on the CPU, this was grid-based (Eulerian) and ran on the GPU using Metal compute shaders. Seeing the performance boost from the multithreaded parallel processing in my second iteration, this version was focused on learning GPU programming so I could harness the GPU chip for more powerful parallel compute.
This is my fourth fluid simulation. Using the GPU programming I learned from my third iteration, this version reimplements the 3D SPH Lagrangian model but with the simulation GPU-accelerated by Metal compute shaders. I implemented a GPU parallel bitonic sort to facilitate this change in architecture (CPU sorts are not optimal on a GPU). This pushed my performance to 32k particles at 60 FPS.
This is my fifth and most recent fluid simulation. Using the Metal graphics API locks my code to Apple's ecosystem of hardware and software, so for better cross-platform compatibility I switched to a WebGPU backend. This version boasts a hybrid bitonic sort to take advantage of local workgroup memory to reduce VRAM bandwidth bottlenecking, as well as improved physics and surface tension modeling. It can handle 100,000 particles at 60 FPS, nearly 200 times that of my first simulation.