Turbo Engine

Turbo Engine is a custom-built 3D game engine built using the Universal Windows Platform targeting the Xbox One. The engine is a student project that was created by a team of nine programmers at the DigiPen Institute of Technology.

I was the technical director on this project, and I was also responsible for all of the rendering code within the engine. Since we used UWP, we had to create our graphics engine using Direct3D 11 or Direct3D 12. We opted for D3D11 in this case, as we believed that using the newer API may lead to troubles hitting our expected milestones due to its increased complexity.

Rendering Techniques

PBR

In our pursuit of producing a modern renderer for the engine, we naturally chose to use Physically Based Rendering rather than an older and simpler technique such as the Phong Lighting Model. The implementation featured in the Turbo Engine is mostly based off of Unreal 4's PBR implementation.

Deferred Rendering

Although forward rendering produces a much simpler implementation and a smaller memory footprint, deferred rendering was the logical choice for the engine, as it has long been an industry standard rendering technique and allows for more complex scene lighting and post-processing / screen-space effects.

Shadow Mapping

The shadow mapping featured in the engine only supports directional lights, but does use a simple filtering technique to produce softened shadows.

Dynamic Resolution Scaling

As our primary target platform for the engine was the Xbox One, we had a very limited pool of memory and computational resources to work with, further restrained by limitations set forth by UWP. To help deal with this, I had implemented dynamic resolution scaling into the renderer. If the previously rendered frame failed to render within 1/60 seconds or less, the output resolution is scaled down by 1% until performance improves. The output is scaled up to full resolution using simple linear interpolation.

Screen Space Reflections

In order to increase the sense of realism and coherency within the rendered scene, I decided to implement screen space reflections. The implementation is workable, but required improvement, as it suffered from severe banding artifacts and poor performance. Surfaces that have a low roughness value automatically have reflections calculated on them.

To simulate glossy reflections off of non-perfect-mirror surfaces, a sampling kernel scaled based on the roughness value of the surface is used to determine the reflected color. Future projects of mine opted for more robust methods of generating blurred reflections, such as screen-space cone tracing.

Screen Space Ambient Occlusion

A basic version of SSAO had been implemented in the engine to simulate ambient light bounce.

Other

Entity-Component-System

The core of the Turbo engine is built around the Entity-Component-System design pattern, which separates data from functionality in order to increase code efficiency and maintainability. To help enforce this design pattern, I designed and implemented a framework that leverages C++ template metaprogramming to simplify usage code.

Since the components (units of data) are stored in contiguous blocks of memory where they are iterated over by systems (units of functionality), there is a large potential for a performance boost through cpu cache coherency.