This is my current little passion project. It's a pretty flat C++ Vulkan renderer using the Vulkan C bindings. I'm aiming to make as little abstractions as possible so I can learn the API as I go along and implement and change things somewhat quickly. The renderer is decoupled from the gameplay code (which is built upon Flecs ECS) in case I'd want to port some of it. It has basic audio support as well using Miniaudio.

The renderer currently supports loading- and rendering glTF models and KTX textures. It also supports multiple glTF skinned meshes and very simple animation clip blending. Textures and skeletons are "bindless" , ie. stored in arrays and indexed into by shaders. This is pretty flexible as all currently used assets can be pooled, instead of re-binding descriptors at every change.

The renderer supports HDR skyboxes for image based lighting and it maps to the final LDR colour space using the Khronos Neutral Tonemapper.

It furthermore supports rendering solid opaque- and translucent volumetric shapes using raymarchers and it composits their results with the regular polygonal meshes. It has several pipelines for both graphics- and compute shaders that run during a frame.

It currently runs and builds for Windows and Ubuntu.

The Gunk was Image & Form's first foray into larger 3d games, using Unreal Engine 4.

During this project I worked as the Code Lead and I was also responsible for developing the rendering tech for the gunk slime and its corrupting visual effect on the world.

The Gunk renders the gunk slime using a combination of Conetracing and Raymarching on Signed Distance Field (SDF) volume textures. These textures are generated from voxels which the player can interact with. The game keeps track of all voxels in order to drive other gameplay systems and events. The SDF generation is based on the Jump Flood Algorithm (JFA).

The Gunk's main target platform was the Xbox Series X/S and Xbox One, which meant that I worked a lot with profiling and debugging for those machines.

The default render pipeline in Unreal Engine 4 was refactored a little bit in order to be able to run our raymarching compute shaders as Async Compute on the Xboxes, concurrently with Unreal's own shadow pass.

The development of this game took place after the success of Dig 2, which meant that the team got to experience some pretty big changes at the company. Something which really helped us was that we got strenghtened by the expert 3d game artists at The Station. I'm really proud of all of us for releasing this ambitious title.

SteamWorld Dig 2 was a double edged sword, a cool and fun game to work on with an extremely hectic development process and tight deadline.

During this project I worked as a gameplay programmer and worked on several different systems in the game. For instance: conveyor belts, foliage interaction, upgrade stations, fast travel points, homing missiles, editor tools and a lot of other things. One larger responsibility was the map system for which I made a build-time script which read the level files and built a path-findable graph of them which the game used to render the in-game maps and to highlight waypoints.

Dig 2 released on Nintendo Switch, so I also worked with debugging on this platform.

SteamWorld Heist was my introduction to the world of professional game development. I joined the team as a junior programmer quite late in the development cycle, and I got to jump right in with fixing bugs, writing gameplay code and applying polish. It was a crash course in Image & Form's proprietary engine for SteamWorld games.

SteamWorld Heist's main target platform was the Nintendo 3DS, so I also got to do development and do debugging for that platform. After the main release I worked on its DLC and iOS port.

I also wrote a DirectX 11 render backend for Heist (as a complement to its OpenGL renderer), which was never released due to time constraints. It was however later used as a base for the renderer for the Dig 2 Xbox port.