Engine foundation
Core, Framework, Graphics and Runtime layers; Win32 and XCB windowing; input abstraction; scene loading; game objects, transforms, and components.
C++20 / Vulkan engine
Oillak Engine
A one-game engine experiment for learning low-level graphics by building the stack: windowing, input, scenes, Vulkan resources, textures, lighting, benchmarks, and eventually physical snow.
Current snapshot
Foundation is done. Lighting is the active climb.
Oillak is still an early engine, but it has moved past the first triangle stage. The project now has a layered runtime, component scenes, camera control, an asset path, texture/material handling, a test-hardened loader path, and the first CPU-side performance meter.
Texture/material path
Real model textures now travel through OBJ/MTL, UVs,
.oilmesh, material descriptors, texture loading, and
the Vulkan draw path.
FrameStats + IBenchmark
The engine can report frame statistics every few seconds, and headless benchmarks can measure CPU-side work without a window or GPU.
Board
What is interesting right now
The board has shifted from “can the model show a real texture?” to “can the rendered surface read like a lit 3D object instead of flat paper?”
Normals + directional light
Replace the render bridge's color slot with normals, copy OBJ normals into the GPU vertex, update the Vulkan layout and shaders, then shade textures with ambient plus directional light.
Helms Deep scene
Add the larger Helms Deep model as its own sandbox scene, so scene loading, camera scale, and model handling get tested on a heavier showcase asset.
Doom showcase polish
Center the Doom diorama, add rotation, and give the large Doom scene an automatic orbit camera so the textured model is easier to inspect and present.
Texture proof + hardening
TextureLoader failure paths, forced RGBA, corrupt files,
generated test assets, material paths, and .oilmesh
material-path preservation are covered.
Multi-material models
Today one mesh uses one material. A later material phase splits draw ranges into submeshes and switches descriptor sets per material.
Roadmap
Measured snow, not magic snow
The long-term goal is an MLS-MPM snow benchmark scene. The order is deliberate: graphics baseline first, simulation base second, measurement third, and only then heavier optimization or threading.
-
01
Graphics baseline
Texture proof and the CPU-side meter are in place. Active work is normals plus simple directional light; dynamic buffers and multi-material draw support remain after that.
-
02
Simulation base
Fixed timestep, flat particle arrays, and the first minimal MLS-MPM demo before chasing parallelism.
-
03
Benchmark + review
A snow benchmark scene with measured frame times, followed by an architecture review before multithreading or GPU compute.
Sandbox
Small scenes, growing showcase pressure
Scene cycling
Sandbox scenes are registered through the engine and cycled with Space, making the demo app a small but useful test bed.
Camera modes
The camera can follow a target in locked third-person mode or switch to free flight, which keeps scene debugging comfortable.
Model spawning
Doom and T-Rex scale the loader beyond primitives. Helms Deep is queued next as a heavier model scene.
Learning lab
From Transistor to Triangle
The Oillak learning lab is now bundled into this site. It is a visual prototype for exploring how CPU code, memory, Vulkan objects, command buffers, shaders, and the GPU pipeline turn data into pixels.
Open the learning lab