SDF Worlds 🌍, Unity Unified RT 🎯, C++ final ⚙️
🚀 Pushing Game Tech Forward
Escaping the Engine Trap: SDF Worlds, WebGPU, and Actually Shipping a Game
Graphics programmer Mike Turitzin explains how he’s building a WebGPU-based signed distance field (SDF) engine specifically to ship a PC game — without falling into the “engine forever, no game” trap. He walks through his journey from 90s Quake mods to Figma rendering, and why he returned to graphics with an obsessive, long-term learning routine. The episode demystifies SDFs, ray marching, and hybrid CPU/GPU physics, while sharing concrete advice on tools, scope, and writing the minimum code that actually moves a game forward.
How C++ `final` Helps Devirtualize and Why Your Game Cares
Virtual functions make C++ code flexible but can be costly in tight loops due to vtable lookups, branch mispredictions, and blocked optimizations. This article shows how the `final` keyword helps compilers eliminate that cost by enabling devirtualization: resolving calls at compile time and inlining them. Using small, clear examples, it illustrates the generated assembly with and without `final`. The takeaway: use `final` where further inheritance isn’t needed, and benchmark the impact on your code.
🧪 Smarter Workflows & Performance
Goodbye Colliders: GPU Ray Tracing Against Meshes in Unity 6
Unity’s new Unified Ray Tracing API lets you ray trace directly against scene meshes on the GPU without requiring RTX hardware. This tutorial walks through setting up the ray tracing context, building an acceleration structure from MeshRenderers, defining CPU/GPU structs, dispatching a ray generation shader, and reading results back on the CPU. You’ll see how to visualize rays and hits in the Scene view and learn about URT’s current limitation of only exposing intersection data. The repo also includes an advanced example that pulls normals and other attributes via Unity’s internal geometry utilities.
Stop Waiting on the Unity Editor: Headless Tests with dotnet test
Large Unity projects suffer from sluggish edit–compile–test loops due to editor startup, domain reloads, and Mono overhead. This article walks through creating a “headless” .NET test project that links your Unity scripts, references UnityEngine DLLs, and runs everything through `dotnet test`. The result: tests that run in a couple of seconds instead of tens, even as your suite grows. Along the way, you’re nudged toward a cleaner architecture that separates game logic from views and greatly improves CI and AI workflows.