2015-2022, C++, Cuda, Java, JavaScript, Lua, Python
One of my favorite things about programming is it’s ability to have surprising and complex results from simple parts.
Fractals have this property; you can create a new fractal and discover details that have both always been there, and never been seen before.
In high school, Inspired by alternate ways of representing shapes objects, I came up with my own. I posited that any 3D+ volumetric object could be described by a function
F(x, y, z, …) -> Boolean
Where the input was a point in space, and the output was true if the object existed at that point.
But how would you render that?
Boolean Rendering
Evolution of a render
At this point I had written a ray based render for a physics class project. I had some ideas about the basics of rendering and lighting a 3D scene, but this new geometric format posed some serious challenges.
For instance how do performantly get a normal from a Boolean function? Or find an exact point of intersection?
This first version was written in Java using Processing
I didn’t know it at the time but I had effectively reinvented Ray Stepping
Ray stepping is a subset of Ray Marching that uses a fixed step size to check points along a ray. It wasn’t perfect (looking along the edges of the light cube in the above images) but it was good enough, and if you were willing to sacrifice enough time to rendering it could be almost perfect.
If you’re curious about more of the technical details I’d highly recommend checking out this presentation I did for my honors thesis where I break down many of the techniques I use.
Many Versions
I had the opportunity to pick the topic for an honors thesis in collage, and of course I chose this project. During that time I wrote many different implementations, including a interactive (if jankey) JavaScript one which you can play with here!
This version used Cuda on a GPU
These are from the JavaScript web renderer
Once I could render, the exciting thing became: what could I render?
After finishing my thesis the fun became generating the functions. I worked up with a grammar that could be randomly and recursively filled out to create interesting functions. If you constrained it to a a shape, like a sphere, and filtered out those that were mostly empty and mostly full, you could get some really amazing shapes.
My globe explorations did just that using C++ for rendering and Python for function generation with some mesmerizing results.
The previous versions I’ve shown try to stick to a more traditional global illumination or Phong based shading model, but there’s no reason that we have to stick to boring old photon emulation.
One of my more recent forays into this project was to create a new version written in Lua and ran via LuaJit that used a ray stepped edge detection algorithm of my own creation to render the edges of the objects as svgs. This resulted in complex intricate patterns, and bugs in my edge detection that were just as pretty as the indented results.
