Side Projects: Xibalba

This is actually the project around which this blog formed, a turn based roguelike-like game of procedural dungeons, faint mesoamerican stylings, dice rolls, and general geekery.

So far it's seen more use as a rendering playpen than an actual game, although messing around with various representations of immutable game state has been fun.

Oh, and for the curious, I did indeed mis-spell the name for a goodly portion of the project. This is what happens when you start naming things at dark o'clock one night and don't check them for ages.

On the graphics side:

• Deferred shading forms the core of the pipeline. I wanted lots of light sources, and wanted an excuse to mess around with deferred rendering. It's been fun.
• A single main light uses a conventional forward-rendering technique with exponential shadow maps. This forms the focal point, being centred on the player character, and also serves to illustrate line of sight.
• Transparent objects are forward-rendered after the deferred pass, although I don't like this approach at all. Planning on doing some stuff with screen-door transparency for water at least, essentially stealing the work done by Media Molecule for LBP.
• Zeroth order particle systems! I've a minor obsession with these, entirely deterministic effects with all particle motion calculated in the vertex shader for a given time.
• Star-shaped bloom. This is just a very boring post-process, but it's summed over many increasingly downsampled versions of the final image so has quite a large effect considering the main blur kernel is rather small.
• SSAO. Actually, this is no longer a 'proper' SSAO implementation. After messing around with a few different approaches, I eventually settled on a very crude approximation of the depth Laplacian using difference of gaussians, plus some falloff over large distance deltas. This gives a rather stylized effect that I really like. It only works well for quite compressed scenes due to fixed kernel size - perfect for a top-down view though!

First working implementation of the deferred render targets:


Prototyping water, note that only the main (forward rendered, shadowed) light affects the water surface:


The 'notSSAO' post process, dialled up to 11. This also shows a chunk of the map lit almost entirely by deferred lights cenred on the glowing mushrooms:


And last repeat screenshot for this post, the basic particles with a simple lit and shadowed alpha-tested rendering mode:


I'll try to get this running on my partner's PC and get some new screenshots of this for a later post. Have to admit, it was nice going over the early screenshots and see it evolve.

Side Projects: Gnomon

As I'm frantically running around doing stuff, I figured it'd be a good time to dump some of the small projects I've worked on in my spare time.

First up, the little Clojure/Scala interop project tentatively called Gnomon. Nothing to see here graphically, the fun part is just having a little space in which to evaluate Clojure directly. Rendering commands are pushed from the Edit Window thread (using the (render-command ...) and (render-static ...) macros) by simply converting the s-exprs to strings, and then evaluated on the render thread. The bulk of the app is written in Scala, but all the fun stuff happens in Clojure.

The editor itself is amazingly crude, but it was more a proof-of-concept for a joint Scala/Clojure project. There's a little awkwardness due to Scala frequently emitting a variety of name-mangled classes, but it still works surprisingly well - Clojure provides a certain flexibility and ridiculously easy runtime augmentation, while it's easier to generate a (more) efficient statically-typed framework in Scala, and Java interop on both sides provides for easy communication.

I'd love to follow this up at a later date with a proper project.