CausalLoop.NET

I tried a new way of rendering voxel datasets. This first iteration is just a proof of concept which appears very promising.
The goal I had in mind when starting this project was to be able to render large voxel based game scenes at realtime performance. My approach consists of automatically converting the original voxel data into a set of heightmaps which are structured in space using a bounding-volume-hierarchy (BVH-tree). The actual rendering is done using ray-tracing.
It is still vastly unoptimized, but runs at >60fps already on a single GPU (at a output resolution of 1024^2).

The following rendering shows a fairly simple scene (data consists of about 17mio voxels before conversion).
The differently colored patches visualize the differnet heightmaps used.

This rendering was produced by evaluating the famous mandelbrot fractal, but instead of just counting the number of iterations for each pixel I wanted to draw the positions of the full sequence/trajectory (until bailout) of points from each starting point. Since the iterative function is quite chaotic the points within the sequence scatter all over the image in a very unpredictable fashion.
The challenge of rendering this image lies in the fact that when displaying a tiny region of the overall space only a tiny amount of points will fall in the view and billions of them will fall somewhere else where they don’t contribute to the final rendering at all. In order to not waste billions of iterations to get just a few rendered pixels I used the Metropolis/Hastings algorithm. This technique will “mutate” past trajectories (or paths) which did successfully fall in the view in order to produce (to a high chance) more points which will also fall in that view. This algorithm works well, because similar starting points will produce similar trajectories (but trajectories will diverge in some exponential fashion). This technique is also quite useful when computing global illumination of 3D scenes as this is sampling-wise quite a similar problem.

I created this image by raytracing using a distance function approximation of the Mandelbulb fractal. The rendering of the fractal is 3 dimensional and it has a lot of depth which is not really visible, because the degree of detail is infinte at all levels and therefore it is impossible to extract depth-cues from the details.
For that reason I’ve extended the rendering to produce stereoscopic outputs which greatly enhances the appearence of the actual shape. It is quite stunning to browse through different regions in full stereo-3D.

You can download a hi-res anaglyph stereo-rendering here (note: left/right is swapped due to my oddly swapped glasses)

This video shows realtime raytracing of procedural volumetric data (warped metaballs) including reflection, shading, 2 lights, shadows and ambient-occlusion.
Computation is done in CUDA and executed on a GeForce285GTX. The video quality is not so great as something went wrong with the frame rate. I didn’t have any good grabber at hand.

This is a test of displaying VirtualReality on a regular LCD-monitor.
The simple 3D scene appears as a hologram on the screen. You can easily look around obstacles just as if the screen would be a window or portal instead of a flat surface showing an image.
It has been filmed with an iPod so the quality isn’t all that great and the colors distorted a little which yields stronger ghosting, but I think you can still clearly see the effect.

NOTE: My Red/Cyan 3D-glasses seem to be a little odd as they have the RED glass on the RIGHT eye. Usually this seems to be the other way around, so if your 3D glasses have the red glass on the left just wear them up-side-down for a proper 3d effect.