Featured Projects

Quartz (2019)

Windows/Linux, C++, Qt, Vulkan, NVIDIA RTX

Physically based Vulkan RTX path tracer featuring a declarative scene description language based on ECMAScript 7.

Quartz is an interactive unidirectional path tracing renderer built on top of Qt 3D near-realtime simulation framework and is powered by NVIDIA RTX technology (via the Vulkan ray tracing extension). It supports rendering of complex 3D scenes and implements a physically based material model with metalness workflow.

QuadrantUI (2018)

C++, Qt, OpenGL, Direct3D 11, Unreal Engine 4

Game UI middleware based on Qt Quick and QML.

QuadrantUI brings fluid, highly dynamic user interfaces into games. It easily integrates into any game engine and currently supports rendering with OpenGL and Direct3D 11.

Extensive, out of the box, Unreal Engine 4 integration is provided via an additional plugin.

Physically Based Shading (2017)

Windows/Linux, C++, OpenGL 4, Vulkan, Direct3D 11, Direct3D 12

Physically based shading & image based lighting implemented in multiple graphics APIs.

Shading model combines Lambertian diffuse BRDF with Cook-Torrance microfacet specular BRDF. For direct lighting up to three analytical light sources are supported. Indirect lighting is approximated by an irradiance map and a reflection environment map pre-filtered for various roughness values. Split-sum approximation is used to achieve sufficient image quality without taking multiple samples of the environment.

Strongbow Nature Remix (2017)

C++, Unreal Engine 4, HTC Vive

Graphically rich interactive virtual reality experience for HTC Vive.

This is a promotional project for Strongbow brand I was involved in during my time at UNIT9 digital agency.

I was working closely with artists helping them achieve the best visual quality possible (authoring shaders, helping with asset pipeline, setting up animations). I also developed car AI algorithms used to create believable procedural traffic and helped with optimizing performance.

Procedural Terrain (2016)

C++, Unreal Engine 4, SQLite

Procedural terrain generator in the style of Sim City 2000, with network chunk replication.

The heightmap is generated in 33x33 chunks (32+1 samples per side, additional sample is needed for seamless tiling), by several octaves of two dimensional Improved Perlin Noise. New heightmap chunks are generated during gameplay within player's immediate vicinity, and are cached for future re-use in a SQLite database (indexed by 64-bit spatial hash). Chunk generation is off-loaded to worker threads in order to minimize blocking the game thread.

Escape Velocity (2015)

C++, Unreal Engine 4, Samsung GearVR

Interactive virtual reality experience for GearVR powered by UE4.

My role in this project involved graphics programming and performance optimizations for the target device. Working with a relatively limited mobile GPU proved challenging and required a lot of creative thinking when authoring visual effects. Also, for the experience to be comfortable, the application had to render at smooth 60fps.

OpenCL Image Processing Toolkit (2012)

Linux, C, OpenCL, GTK 3

GPU accelerated image processing application using OpenCL.

Image processing operations run in OpenCL kernels and results are displayed via OpenGL. The UI is made in GTK3.

I was responsible for the main program structure (subsystem initialization, configuration handling, main loop), OpenCL initialization code, a robust OpenGL/OpenCL buffer sharing system and a plugin API. I also wrote a universal GPU-accelerated convolution filter.

Other Projects

Overflight (2016)

C#, Unity 5, Samsung GearVR

Multiplayer game for Samsung GearVR powered by Unity.

My involvement in this project included network programming, UI development and enemy AI improvements.

Hello Boing (2015)

Amiga OCS, m68k assembly

Executable Graphics competition entry that won 1st place at Decrunch 2015 demo-party in Wrocław, Poland.

Written in hand-optimized Motorola 68000 assembly it renders a raytraced Boing Ball (unofficial Amiga logo) with ambient occlusion in under 30 seconds on stock Commodore Amiga 500 with 512kB of Chip RAM. Resulting image is displayed in 5 bitplanes with frequent mid-frame palette switching via the Copper to display a total of 96 unique colors simultaneously.

BENDER-I Virtual Computer (2015)

Linux/Windows, C++, SDL2, 6502 assembly

MOS 6502-based virtual computer simulator.

BENDER-I (or B1 for short) is a fictional computer system I've created for fun. The name is, of course, a tribute to Bender Bending Rodríguez, a fictional character in the animated series Futurama, who happens to be powered by the same CPU as B1 computer.

B1 computer system consists of the venerable MOS Technology 6502 microprocessor, 64kB of RAM, a video processing unit providing text-mode 40 by 25 character display and a simple 8-bit mono sound generator.

Aurora (2013)

Windows, C++, CUDA, Maya API

GPU accelerated Monte Carlo distribution raytracer using NVIDIA CUDA. A plugin for Autodesk Maya 2014.

This project is accompanying my master's thesis titled „Light modeling in Computer Graphics on the GPU“, written under the supervision of Mr. Wojciech Kowalewski PhD at Faculty of Mathematics and Computer Science, Adam Mickiewicz University of Poznań.

Minecraft Network Protocol Proxy (2011)

Linux/macOS, C, Glib

Modular Minecraft network protocol proxy.

The main purpose of this project is to manipulate and/or analyze Minecraft protocol data in real-time on either server- or client-side being completely transparent to both parties.

xlsh (2011)

Linux, C, PAM

This project aims to provide a convenient replacement for standard login program found on many POSIX compliant systems.

It provides a basic login shell, similar to one found in GNU HURD, that apart from performing a login action, can also reboot or shutdown the system. It uses PAM for authorization and session management.

When desired using the xlshd daemon it can also successfully replace a display manager such as GDM.

Vorticity / Arsen (2010)

Windows/Linux, C++, OpenGL, NVIDIA Cg, ARToolKit

Vorticity is an OpenGL 3D engine written in C++. I've started early drafts and development work in 2009 and then continued in 2010 during "Arsen" augmented reality game project.

The engine is heavily based on dynamic scene graph concept where each node performs computations that lead to synthesis of final frame image. This approach allows for great flexibility in expanding the rendering pipeline by addition of Node classes like new light, geometry types or animation controllers.

GRUB 3D (2009)

C, GRUB2 bootloader

GRUB 3D is a proof-of-concept pseudo-3D maze crawler that can run as a GRUB2 bootloader module.

It uses legacy VESA 2.0 video mode to display graphics. Levels are rendered by casting rays through a 2D grid of blocks. Textures are drawn with nearest-neighbour filtering and affine projection. Experimental support for non-animated sprites is present in the code but not used in the demo level.

Fuzzy Racer (2009)

Linux, C, TORCS

Fuzzy logic racing bot.

An AI racing robot written by me and my friend Miłosz Kosobucki as final assignment for Fuzzy Set Theory course at Faculty of Mathematics and Computer Science, Adam Mickiewicz University in Poznań, Poland.

FSproxy (2009)

Windows, C, WinAPI, QEMU

A small Windows application that runs in the background and provides access to files on various Linux/UNIX filesystems.

The QEMU emulator is running with administrative privileges, with physical block devices attached as virtual HDDs. A minimal Linux system boots up in the emulator, enumerates and mounts all known filesystems on those HDDs and then publishes each partition via the Samba protocol on a virtual TUN/TAP interface.

exRay (2008)

Windows, C++, WinAPI

exRay is a classic recursive raytracing renderer I've developed as a personal research project during my BSc studies.

The algorithm presented here is the classic Whitted ray-tracing extended with some very basic Monte Carlo like sampling. The rendering process is fully multithreaded with almost perfect scaling (rendering time halves when number of participating CPU cores is multiplied by two) and the image is synthesized from top to bottom with each worker thread rendering a single scanline at a time.

A Subjective Experience… (2005)

Windows, C++, OpenGL, FMOD

A 16 seconds real-time animation created for Abstract 2005 science and computer graphics festival in Gliwice, Poland.

It features several fast camera takes on a classic still life scene rendered in real-time with OpenGL and ends with a joke error message – a reference to the Amiga computer.