Ω - Omega Deferred Graphics Engine


Omega, a Java based deferred lighting engine has been my little pet project for the past couple months. I originally began developing it as a 2D/3D engine to support my game Cubed, since I wanted to create a full Android version of the game. After writing a Wave OBJ parser I decided I needed lighting for my objects and I had wanted to try my hand at writing a deferred lighting system. And so it went. I continued to add, and develop new features, finally ending up with what you see above. Omega also includes a custom lighting algorithm that better simulates real lighting situations.

Color-Intensity Lighting

The default lighting model for games has been to assign a light 3 different color values(specular, diffuse, ambient) and use those to calculate an objects color. Though in the real world the model is much simpler, a light shines a certain color and at a certain brightness. After spending a few days researching lighting physics I developed the lighting model for Omega. In Omega each light is given a color and intensity in lumens. The specular reflectance is attached to the model instead of the light as would also be the case in real life. The ambient factor is then calculated based off of the lights attenuation and the light's intensity, since a higher intensity light will scatter more than that of a low intensity one. These values are then passed through a modified version of the Blinn-Phong algorithm, which then gets multiplied by the calculated attenuation factor, to create the final color for that point.

Scene Graph

Omega uses a vertical scene graph system to manage all rendering assets. All assets can have children and have their own transforms. Child assets can choose to inherit parent transforms and whether they and their children should be rendered. Assets come as 4 different nodes, SceneNode, ModelNode, CameraNode, and LightNode. Each node contains all the necessary information for that asset to be rendered. A renderer is included that manages culling, rendering and global positioning of all assets. Viewport culling is used to allow for maximum flexibility for camera matrices.

Post Processing

Also included is a post processing library called Blend. This library comes with a number of blending filters (such lighten,darken,color burn/dodge, multiply etc), gaussian blur filters and bloom lighting. I wanted individual objects to have a number of masks so that they could decide when and how they were rendered in post processing, though I didn't want to have to manage a large array of mask textures. So I developed a GLSL masking technique that converted a high precision floating point number into a bit-mask giving me the ability to store up to 24 masks within a single texture. You can read more about the implementation on my blog


  • Color-Intensity Lighting
  • Exponential Shadow Maps
  • Vertical Scene Graph
  • Easy Post Processing Effects
  • Texture Atlasing
  • Sprite Batcher
  • Wave Object Parser
  • Event Handling
  • Game Loop Logic Manager