Description

Lumion is a widely-used real-time architectural visualization tool. At Lumion (Act-3D), I contributed to modernizing its legacy Effects11 rasterizer into a pathtracer using DirectX 12 Raytracing.
My work focused on raytracing integration, porting, GPU performance & debugging tools, shader tooling, and R&D features.

Information

Duration: September 2019 - present
Role: Intern → Junior → Senior Graphics Programmer
Skills: C++, HLSL, DirectX12, DXR, Shader/GPU tooling
Tools: Visual Studio, PIX, NSight, Git, CMake, Jira, RenderDoc
Team members: Act-3D graphics and engine teams

Contributions

• Integrated DXR 1.1: BLAS/TLAS, SBT, inline RT, and RT collections
• Unified raster + raytracing: bindless rendering, V-Buffer, and instance management
• Implemented denoising: NRD (ReLAX, ReBLUR, Sigma), OIDN/OIDN2
• Developed features: raytraced water, grass, glass, shadows, GI, and fake caustics
• Prototyped GPU kD-tree building (photon mapping/caustics), advanced RT grass, and RT characters
• Created shader tooling: SM4/5 to SM6+ HLSL migration, reflection, and shader includes
• Improved offline + runtime shader pipelines with multi-threading and shader variants
• Tooling: (debug/perf) markers, crash diagnostics, memory allocations exporter
• Open-source contributions: DXC, HlslTools, DirectX-Headers

Trailers

Watch official Lumion 2024 trailer – © Act-3D B.V.
Features I contributed to in this version include
(real-time) denoising, RT glass, and fake caustics.

Watch official Lumion 2023 trailer – © Act-3D B.V.
Features I contributed to in this version include reflections, shadows, and GI.

Description

Wisp was a real-time raytracing library that could've been integrated into your favorite engine or tool, made by a team of nine students. It was used in a Maya extension that allowed you to view a deferred, full raytracing, hybrid and path traced preview of the current scene.
The goal of the project was to allow artists to have a quick overview of what their end-product would look like; saving time and improving their workflow. Maya didn't provide that in the regular viewport, so the deferred preview was a step up to view the effects of modeling real-time. Previewing the reflections, global illumination and shadows is a nice bonus for RTX and GTX Pascal cards.

Information

Duration: October 2018 - December 2019
Role: Graphics/Optimization programmer
Skills: C++, HLSL, DirectX12, DXR, Raytracing
Tools: GitHub/Git, Sourcetree, CMake, Visual Studio, Jira, PIX, Nsight
Team members: 8 graphics programmers, 1 engine programmer

Contributions

• Raytraced reflections
• Variable roughness; filtering reflections (spatial reconstruction)
• Optimizations, refactoring and bug fixing
• Frustum culling
• Basic deferred rendering
• Scene graph parenting

Description

Oxsomi Core 3 is a C framework that abstracts graphics and platform APIs, with Vulkan and DirectX12 backends with raytracing support, a shader pipeline targeting DXIL and SPIR‑V, and runs across Windows, Linux, macOS, and Android.
Built entirely from scratch, it includes systems for memory management, math/vector types, platform abstraction, file I/O, encryption, hashing, and custom file formats.
Core 3 evolved from Core 1, which had a Vulkan-only renderer and supported Android and Windows.

Information

Duration: December 2017 - present
Role: Sole developer
APIs: Vulkan, D3D12
Architectures: x86_64, aarch64
Platforms: Windows, Android, Linux, macOS
Languages: C, HLSL, Python
Tools: Git/GitHub, CMake, Conan, Visual Studio, Android NDK, NSight, Renderdoc, PIX
Libraries (Only if compiler is enabled): dxc, spirv-reflect, spirv-tools

Contributions

• Designed cross-platform abstraction layer (file system, windowing, threading)
• Implemented Vulkan + DirectX 12 backends
• Added raytracing support
• Developed shader toolchain for HLSL targeting DXIL and SPIR-V via DXC/spirv-tools
• Built runtime reflection system using custom annotation syntax, spirv-reflect and forked d3d12shader.h
• Created archive file format for packed resources (shaders, pipelines, assets)
• Implemented vector math & container libraries and memory helpers (double free, memleak, etc.)
• Added encryption & hashing functions used across the framework
• Built multi-platform build pipeline using CMake + Conan (x86_64 + ARM64)
• Enabled deployment to Windows, macOS, Linux, and Android using platform SDKs

Description

Switchbait was a custom voxel engine, created for a top-down shooter and mainly meant as a learning opportunity for everyone in the team. We each had our goals set (optimization, serialization, etc.) and improved the engine with these points.
Unfortunately, the game's direction wasn't aligned with the engine's capabilities and the producers pushed the game to areas the engine wasn't built for.

Information

Duration: May 2018 - June 2018
Role: Graphics, optimization and gameplay programmer
Skills: OpenGL, GLSL, C++, Nintendo switch and Windows development
Tools: Perforce, Jira, Visual Studio
Team members: 18 people

Contributions

• Spawning and maintaining particles through compute shaders
• Creating a particle editing tool useable for artists
• Implementing a batching system (multi draw indirect) to prevent draw call overhead
• Basic mesh culling and instancing

Description

Rail recon is a twin stick shooter with a neon theme based on a few old arcade games, made by a twelve student team. It was created as a concept within 2 weeks, it was then developed further for 6 weeks.
It started as a three person team, two weeks later became a six person team and finally six more people joined in. I was among the six who joined in at the last four weeks of development until release. The game is released on steam and has had a few thousand downloads and has several positive reviews.

Information

Duration: May 2017 - January 2018
Role: Gameplay programmer
Skills: Unreal, C++, Blueprints
Tools: Perforce, Visual Studio, Hacknplan
Team members: 4 programmers, 4 artists, 2 designers, 1 producer, 1 audio designer

Contributions

• Implementation and communication of mechanics:
•   Energy; shield & charge system
•   Gameplay elements such as triggerable buttons, doors, rotators, exit door
• Implementation of graphical effects and gameplay:
•   Charging station animation and logic
•   Door animations and logic
• Communication with designers, artist and producers

Description

Harpoon was a project that was used in Shiploader; a modloader for the game Raft. This API was intended to be used by the modding community as an alternative. This was due to the existing modding tool using the source code of the game and distributing it and mods being very version dependent.
The alternative was code injection and not just patching a dll; where an executable requests Unity to load mods, which use a library for wrapping the low-level code.
This is accomplished by loading a C DLL into memory, which calls functions provided onto a heap; these functions are Unity mono functions, which load a C# dll and execute it. The C# dll is then able to access everything in Unity through C# reflection and Harmony through patching functions (More info here).

Information

Duration: August 2018 - February 2019
Role: Programmer
Skills: C, C++, C#, Unity, Harmony, Code injection, Mono injection, Reflection, Reverse engineering
Tools: GitHub, Sourcetree, Visual Studio
Team members: Solo project, but used in team project

Contributions

• Getting an understanding of how the Windows API works with multiple processes
• Being able to call functions in other programs through the WinApi
• Loading and executing a payload in a different address space (defeating ASLR)
• Using mono to load dlls into C#
• Using C# reflection and patching an already existing program

Description

A combined suite of tools for reverse engineering NDS games.
NFSU is a modular ROM editor that supports viewing and editing palettes, tilemaps, archives, and other formats common in DS games.
Armulator is a custom ARM9/7 emulator written in C++ to step through compiled DS game code. Together, they enable modding, visualization, and runtime code analysis of DS binaries.

Information

Duration: On & Off during November 2017 - September 2021
Role: UI, tool and emulation programmer
Languages: Qt, C++, GLSL, OpenGL, ARM/Thumb assembly
Tools: Perforce, Trello, GitHub, CMake, Visual Studio
Team members: Solo project, with feedback from friends & colleagues and help on creating icons

Contributions

• Built GUI editor for parsing NDS formats (palette, tilemap, archive)
• Created custom struct parser using C++ templates and dynamic type layouts
• Wrote shaders for BGR5-tiled image previews with OpenGL
• Built archive/tree view for dynamic loading of NARC and other DS-specific formats
• Developed custom ARM7TDMI/ARM9 (Thumb + ARM) emulator in C++
• Implemented instruction decoder, memory mapper, and simple CPU pipeline
• Added disassembler, step-through debugger, and assembler

Description

Mineblowers was a marmalade game made in 3 weeks, which utilises a custom controller. The idea was to create a unique user experience with an unexpected controller.
We chose for a bike pump as a controller, because it was easy to obtain and it fit in with our minecart-style game.
The faster you pump, the faster you travel. If you travel too fast, you fall off and have to start over. The fastest score wins, this was implemented with a simple leaderboard. Since one of my team members had worked on this at Rail Recon before, I spoke to him and implemented it with a tool in our project.

Information

Duration: November 2017 - January 2018
Role: Gameplay/tools programmer
Skills: Unreal, Blueprints
Tools: Perforce, Trello
Team members: 2 programmers, 3 artists, 3 designers

Contributions

• Implementation of the spline system of the cart and procedural generation of the rails.
• Worked together with designers to get the spline editing system to be more user-friendly.
• Worked on the death system alongside another programmer.