Education

Mar 2017 - Jan 2020

IT Systems Engineering (M.Sc.)

Hasso Plattner Institute, Potsdam
Grade: 1.2
Thesis:
“Design and Implementation of a Physically-Based Renderer using Multi-Frame Sampling”
Oct 2013 - Jul 2016

IT Systems Engineering (B.Sc.)

Hasso Plattner Institute, Potsdam
Grade: 1.3

Skills

Programming languages: C++, Rust, C, Python, TypeScript, JavaScript, Java, C#, Ruby
Graphics APIs: OpenGL, Vulkan, WebGL, DirectX, GLSL, HLSL, Wayland, OpenXR, skia, FFmpeg, gstreamer, OpenCV, Qt
Infrastructure: git, bash, Docker, multi-platform development (Linux, Windows, macOS), cross-compilation, arm64 + wasm deployments, Jira, SQL
Topics: physically based rendering, multi-threaded programming, virtual reality, video and audio pipelines, HDR videos and displays

Misc

  • Credited “3D Programmer” for Anno 1800
  • CHI 2019 video showcase award for “TrussFormer: 3D Printing Large Kinetic Structures”
  • Web3D 2020 publication of ”Physically-based Environment and Area Lighting using Progressive Rendering in WebGL”

Work experience

Apr 2022 - current

Incari

Senior graphics developer (Apr 2024 - current)
Graphics developer (Apr 2022 - Mar 2024)
At Incari, I am responsible for the architecture and implementation of 2D and 3D rendering pipelines. We are targeting both Desktop systems running Windows or Linux as well as embedded devices running Android and Embedded Linux distributions.
  • developed the rendering backend for a 2D vector graphics renderer using Google skia, including ability to import Figma documents
  • ported the rendering system to embedded ARM64 platforms using OpenGL ES3
  • implemented XR rendering via OpenXR and the Varjo Native SDK
  • enabled seamless integration of 2D and 3D rendering pipelines via render-to-texture
  • ported the renderer to be used as a dynamic library for Android
  • maintained the video processing pipeline using gstreamer
  • designed and prototyped a Vulkan rendering backend
May 2020 - Mar 2022

~sedna

Research and development engineer
I developed core technologies for a Linux-based digital signage system using C++, OpenGL and FFmpeg.
  • implemented support for HDR monitor output + HDR video input, targeting both monitors and videos using PQ and HLG encoding
  • integrated hardware decoding of H.265 and H.254 video streams using NVDEC
  • benchmarked and optimized the video processing pipeline (including demuxing and decoding of the video stream) with FFmpeg
  • implemented features and performance improvements for the rendering pipeline using OpenGL
  • evaluated and prototyped support for Vulkan video output and ALSA audio output
Mar 2018 - Aug 2018

Human Computer Interaction Lab at Hasso Plattner Institute

Working Student
Feb 2017 - Feb 2018

CG Internals

Working Student
Aug 2016 - Jan 2017

Ubisoft, Studio Blue Byte Mainz

Graphics programming (internship)
I worked on the DirectX-based C++ game engine used for Anno 1800.
  • reworked the PBR material rendering of the engine to match the look of Substance Painter, which increased artist productivity
  • implemented Sample Distribution Shadow Maps (SDSM), a shadow mapping technique based on calculating partitions using computer shaders
  • added multiple visual effects including: rain based on compute shader particles, realistic interaction of plants with wind, dynamic generation of water puddles

Portfolio

vkpaper

https://github.com/cgphilipp/vkpaper


vkpaper is a wallpaper daemon for Wayland based compositors, written in C++ and using Vulkan as the rendering backend. It allows users to render shaders (in Shadertoy compatible format) as their wallpaper. Additionally, I introduced transition shaders to allow users to write their own transition between their wallpapers.
In this video I show three transition shaders I wrote: a noisy transition, a growing ellipse and a simple move-in animation. Shader credit goes to knarkowicz and nimitz

master thesis renderer
(click for demo)

https://github.com/cgphilipp/thesis-renderer

For my master thesis I implemented a PBR renderer using multi-frame sampling. I.e. the sampling operations for shadow mapping, depth-of-field and area lighting are spread out between multiple frames. This allows rendering of high-quality effects on the web, even on low-powered devices!
The renderer was implemented as a part of webgl-operate using TypeScript + WebGL and packed into a static website with npm + webpack. As part of the project, I contributed improved glTF loading + an improved workflow for generating prefiltered diffuse and specular cube maps.

breezebike
(click for demo)

https://github.com/cgphilipp/breezebike

breezebike is a modern navigation web service for cyclists using the BRouter bike routing service. I implemented the appliation using SvelteKit and leveraged MapLibre for smooth, hardware accelerated map with vector tiles.

who the chess?
(click to play)

https://github.com/cgphilipp/who-the-chess

I implemented a chess quiz as a single-page-application using a Rust backend. By querying the WikiData datasets using SPARQL, I automatically gathered the necessary information about chess grandmasters and transformed the data to JSON.
By combining htmx and server-side rendering, I implemented a responsive quiz with auto-completion. All necessary assets are compiled into a single Rust executable, making deployment super easy!