Haskell

Some of my code is available on my

GitHub Account

Look at this awesome ghd-produced stack trace from my Game of Life program.

Benchmark results comparing all different implementations, measured using the Criterion library. It can generate HTML reports with nice looking charts like these.

The emulator has a comprehensive test suite which can run in parallel. The screenshot shows the console UI reporting testing progress.

Third iteration of my Haskell Game of Life program using Repa partitioned arrays to efficiently work with the torus array data structure on multiple cores.

Some debug displays with tiles of Twitter avatars, FreeType 2 font rendering, UI layout code, etc.

Unicode glyphs packed tightly into an OpenGL texture for rendering.

Debug mode for dumping rendered glyphs / strings to the console. Unicode block elements are a useful debugging aid for quickly visualizing things in a terminal.

kD tree for finding a tight layout for rectangles inside a larger bounding one (bin packing). Useful for packing textures (fonts, lightmaps), UI elements, etc. Supports online bin packing, uses a special optimization to keep kD trees from degenerating (see code).

Support for multiple typefaces and Unicode glyphs can be seen in this image.

Found it! I like using Unicode characters for quickly visualizing something using only a terminal.

Showing a Diff between two versions of mtl. ANSI colors are supported to make everything a little quicker to interpret.

The OpenGL application visualizes an animation over the different starting points of the Julia Set. It is easy to split up the computation over multiple cores.

A couple of stills from the animated version which the applications displays. To avoid banding, a smoothed iteration count is being used.

The widely-known Mandelbrot Set for good measure.

A simple scene lit by a few light sources, created by combining basic shapes.

Using a smooth minimum function, distance fields can be combined without having hard edges at their interrsection points.

With distance fields it is very easy to distort the rendered shapes with various perturbations or transformations. Here a few sine waves are creating bumps in the surfaces.

With a triangle distance function scenes like the well-known Cornell Box can be rendered. The ambient occlusion is efficiently computed from the distance field. With an edge distance function, wireframe renderings can be produced. Notes on triangle distance estimation can be found here. A lossless, GPU friendly acceleration structure is described in A Complete Distance Field Representation.

See the Generalized Distance Functions paper and the Raymarching Toolbox Thread on Pouet.net for the distance functions used to render this scene.

The Haskell viewing application doing the pre-processing, functioning as a development and debugging aid, allowing different shaders to be explored. It automatically reloads and recompiles shaders when they change, showing an overlay displaying any errors. There's a flexible frame buffer system, supporting under and super sampling and saving of screenshots. Tiled rendering avoids shader timeouts and unresponsive UI.

An optimized I dubbed approach spheres. The scene is first rendered at a lower resolution with a higher distance threshold, and the last DE sphere is saved into a texture. The second full resolution pass then intersects with those spheres to start marching closer to the surface. Unfortunately, this does only help a little in most situations. Also see the Major Raymarching Optimization thread on Fractal Forums.

Various environment maps starting with their downsampled version on the left, then being pre-convolved with smaller and smaller exponent cosine lobes, down to a power one / diffuse lobe on the right.

Pure diffuse and specular reflection in the top row, varying degree of glossiness in the bottom row.

A selection of materials with all kinds of diffuse, glossy and specular reflection components under different illumination conditions. Rendered with a simple normalized Phong lighting model plus a Fresnel term.

The power 8 Mandelbulb. It is probably the most commonly used one. Integer powers also enjoy a more efficient implementation as the computation can be done without transcendental functions. The shading is an ambient occlusion glitch, which I thought looked rather neat.

Various renders of fractional powers between 2 and 6. The lower powers are less symmetric and show a more chaotic behavior. There's tremendous variety in the shapes the object can take.

Six more renders like above, simply because they look so nice. All images are super sampled with 64 samples per pixel. At lower quality, interactive frame rates can be achieved even on older GPUs, like the one in my 2009 MacBook Pro.

The lower powers often exhibit a whipped cream look reminiscent of Quaternion Julia Fractals. This early image still has a lot of artifacts.

Comparing ambient occlusion methods. The left side uses a cone occlusion test by checking sphere penetration along the normal with the DE, the right side is using the ray marching iteration count as a measure of occlusion.

Looks like a snowy mountain floating in space. Image inspired by a post on Fractal Forums. The ray marching iteration count is a surprisingly useful input for all kinds of creative effects.

A chrome power 8 Mandelbulb illuminated by the Dining Room HDR environment map from this collection.

A collection of twelve deep zooms into the surface of the Mandelbulb. There truly is no end to the amount of detail hidden inside the depths of this fractal. Be sure to view the image in full resolution (it is fairly big). All individual zooms have been rendered at 4096 * 4096 resolution and are downscaled to 512 * 512 here.

Another set of zooms to showcase the variety and beauty. I find the mixture of detailed and smooth regions very visually appealing.

Choosing pixels for super sampling by looking at the image contrast through the screen-space derivatives of the surface color. This unfortunately does not perform well in practice due to the divergence it introduces in the shader. The compaction and scatter passes required to avoid this would be difficult to implement with plain fragment shaders. A failed experiment, for now.

A collection of Mandelbulb images in different HDR environments (sources for the environment maps: 1 2 3 4). Very high resolution image, be sure to zoom in to see all the detail.

Screenshot of the interface running on an iPhone 6. The icons are resolution independent SVG, provided by Philips for Hue developers.

Same thing, just this time on OS X. Can access an entire house worth of lights from a single screen. Hue Dashboard's backend is running on a Raspberry Pi, the server administration tile with the raspberry logo can be seen at the bottom.

The UI for the light color picker. There's also the option to put lights into a special color loop mode or assign them a random color.