Dim: A Light in the Dark

Dim is an atmospheric puzzle game developed in Unity I worked on a few years back in a group of 5 people. In it I was the main developer as well as mechanic designer.

The main puzzle mechanic revolves around the player being able to collect and distribute energy “charges” which he can use to interact with the environment. Similar to a modern day battery, the player has the ability to charge and discharge specific energy containers. This triggers environmental effects (lights turning of, machines starting/stopping) as well as additional puzzle logic. A key example is that of elevators: based on the energy state of the attached container elevates to a different height. Additionally NPCs and other systems also interact with this quantized energy state system to allow for complex puzzles.

Technically the mechanic is implemented using an event system which allows concrete implementations to listen to state changes in associated containers and react accordingly. This allowed for the rapid development of additional layers while ensuring a continued correct behavior of the core system. Additionally, simple juice inducing effects were extremely straight forward to implement, allowing me to delegate this responsibility.

//Affect animations based on energy levels
public class AnimationMotor : BaseEnergyStorageListener
    public override void OnEnergyChange(int newEnergy)
       bool active = newEnergy >= activationEnergy;
       animator.SetBool(IS_ACTIVE_ID, active);

Mindbend Engine

Mindbend Engine

The Mindbend Engine is my first attempt at writing a custom rendering engine. Inspired by Marble Marcher and the articles by Inigo Quilez i decided to write a small game engine to push the limits of modern game development.

In essence, the Mindbend Engine is a rendering engine that uses SDFs (Signed Distance Fields) and Raymarching to visualize mathematically defined structures. The potential of the theory is mind-blowing. Shapes that are impossible or incomputable to draw with traditional triangle based engines become the norm. Additionally procedural effects and other recursive rendering have no added costs. This allows for amazing effects, like bending geometry over time (think of Inception), multiplying objects and boolean mesh operations.

If it is so great, then why aren’t people using this already?
A big part comes from the technical limitations. Similarly to ray tracing, ray marching requires very expensive per pixel computations. This highly limits the amount of objects allowed at one time and requires more high end hardware. None the less Nvidia and AMD have been working very hard towards improving support for these technologies in the latest years. In a few years, this technical limitations won’t be a problem anymore.

From a game development standpoint I believe that we haven’t seen many games using these technologies extensively because there simply aren’t the right tools around. My goal with Mindbend is to create an engine that allows designers to prototype objects at runtime, by writing SDFs and assigning dynamic parameters. Established concepts like meshes and traditional rigidbody physics algorithms fall apart, objects need to be defined in a purely algebraic form and physics needs to be approximated using point-based approximations. Once the appropriate tools are put in place to properly take care of these limitations, new games will be born that challenge our understand of reality.

This project is still in it’s early stages and is not more than a proof of concept. Currently I am working on creating a runtime interface to allow runtime definition of SDFs and consequently quick runtime Shader compilation.