Jonas Hack

The Nox Game Engine is a 2D engine with Global Illumination using Radiance Cascades.
The engine is fairly complete, including scene & resource management, GameObjects and multiple demos. My contribution was mostly in the rendering, specifically the lighting. On a modern computer, the engine calculates full global illumination in screen space at up to 100 fps.

The lighting consists of the following stages:

• GameObject Registration


• Transfer Stage
  
  • Data Packing
  • Automatic Buffer Updates


• G-Buffer (Deferred)
  
  • Batched & Culled Tilemap
  • Instanced Sprites


• Light Preparation
  
  • Jump Flood Algorithm
  • SDF Creation
  • Build Cascades


• Light Composition
  
  • Merge Cascades
  • Tonemapping

A PBR Pathtracer (on the GPU, supporting Vulkan ray tracing extensions). The goal of the project was to deepen my understanding of physically-based rendering. Even though this is a team project, I was entirely responsible for the lighting calculations.

• Sphere Intersection
• Plane Intersection
• Torrance-Sparrow BRDF
• Importance Sampling
• Sky-Radiance
• Temporal Denoising

Volume Creation

The first task is to analyze and annotate the scene's navigable areas. The naive approach of scene voxelization serves as a good starting point, but scales badly with large scenes. To mitigate this, I combine adjacent voxels into larger AABB Volumes, in a process similar to greedy meshing. This results in a volume count reduction of 90%, bringing a massive performance improvement. Afterwards the volumes are tested for intersections and the adjacency matrix is filled accordingly.

Pathfinding

The pathfinding itself follows a rather tried-and-tested approach. Each navigation agent supplies requests to a navigation manager, which then buffers and hands them off to a worker thread. On completion, it invokes callbacks with the resulting path. The chosen algorithm is the commonly used A*. I paid special attention to minimizing garbage collection overhead. All data containers are allocated once at the beginning and then only cleared, not destroyed, for each request.

Post-Processing

I created multiple shaders and integrated them into Unity's existing Volume-based Post-Processing Stack. This way, the effects can be used and tuned using the workflow artists are already familiar with. When combined, the effects turn any game into a painting, though with a noticeable performance impact.

• Cell Shading
• Kuwahara Filter
• Oil Paint Filter
• Outline

Texture Filtering

In the area of artistic stylization, another interesting approach has recently become popular: Applying brush strokes to the normal map, in order to create areas of solid light in the final render. This off-loads the effort from the game engine entirely onto the arists. It is usually a laborious process, where all textures of a material have to be modified identically, in order to create a convincing effect.

I automated this, by extending the classical Kuwahara filter, to accept multiple textures as input. When calculating the variance inside a quadrant, I take all the textures into account and then choose the same quadrant for all textures. This way, all the textures of the material have identical brush strokes, generated using a compute shader at the click of a button. Admittedly automated image filtering cannot match manual artistic intent, but it serves as a great starting point to be refined by an artist. The tool is not meant to stand on its own, but to be a part of a larger workflow, to be a time saver.

is a project I made with a friend for the hackaTUM 2021 hackathon.
It is a climate conscious network monitor, which keeps track of the CO2 produced by the devices running in the LAN. It is a neat little piece of software meant to increase climate change awareness.
My main contributions were in UI/UX and general desktop development, while my buddy handled networking.
Code available on Github.

A software raytracer (running on the CPU using Java). It supports multi-threading, spheres, skydomes, planes and phong-lighting.
I made it in order to manually explore the mathematical principles behind the methods that shading languages such as glsl and hlsl provide by default. This experiment serves as an interesting contrast to my latest projects on light simulation.