Opacity Micromaps: Smarter Shadows for the Real World
By this point you have completed the Simple Game Engine tutorial, you have built something genuinely beautiful. Your ray-traced shadows fall across floors and walls with physical precision. Solid objects cast solid silhouettes; and soft shadows genuinely make those shadows look nice. The light knows where the geometry is, and darkness follows accordingly. For a simple architectural scene — a box room, a table, a few chairs — the result is nearly perfect, and it arrives without drama.
But the real world is not made of boxes and chairs. Step outside and you immediately encounter a world that refuses to cooperate with simple ray-triangle intersection. Trees do not cast crisp rectangular shadows. A wrought-iron fence does not block light uniformly. Curtains billow with gaps of light. Hair is not a surface, it is a million semi-transparent strands. The visual richness of nature — and of the human world that imitates it — comes almost entirely from objects that are geometrically simple but optically complex.
In real-time rendering, we handle this complexity with a technique called alpha testing (sometimes called alpha masking). Instead of modeling every leaf on a tree with real geometry, we take a broad, flat quadrilateral and paint a leaf texture onto it. The texture carries an alpha channel — a value from zero to one that says how opaque each texel is. At the edges of the leaf, the alpha is zero: transparent, ignore this pixel. In the body of the leaf, the alpha is one: opaque, this pixel exists. With this trick, a single flat triangle can represent a convincingly complex silhouette.
During rasterization, alpha testing is inexpensive. The GPU evaluates the alpha at each screen pixel and simply discards the transparent ones. For shadow maps, a similar shortcut applies: a depth-only alpha-tested shadow pass is well-understood and well-optimized.
Ray tracing changes the equation. In a ray-traced shadow system, a shadow ray does not project a texture onto a screen — it intersects with geometry in three-dimensional space. When that ray hits a leaf-triangle, it cannot simply ask "did I hit something?" It must ask "did I hit something that is actually solid at this precise point?" To answer that question, it must look up the alpha texture at the exact point of intersection. And it must do this for every triangle the ray might pass through. For a single tree with thousands of leaf triangles, and a scene with many trees, rendered at high resolution with multiple shadow rays per pixel — the arithmetic quickly becomes staggering.
This is not a hypothetical problem. Alpha-tested foliage is one of the most common sources of performance bottlenecks in real-time ray-traced scenes. Profiling tools consistently reveal that any-hit shader invocations — the shader stage responsible for this alpha lookup — dominate the GPU’s time whenever nature appears on screen.
Opacity Micromaps (OMMs) are Vulkan’s answer to this problem, delivered through the VK_KHR_opacity_micromap extension. The core idea is elegant and, once understood, almost obvious: rather than forcing the GPU to discover the opacity of each part of each triangle at runtime, we pre-bake that information into the GPU’s acceleration structure before the first frame is ever drawn. We subdivide each triangle into a grid of tiny micro-triangles and classify each one as permanently opaque, permanently transparent, or edge-case unknown. The hardware traversal unit reads this classification directly, without running any shader code, and makes instant decisions about whether a ray is blocked.
The result is that the expensive any-hit shader fires dramatically less often — only for that thin ring of edge pixels where certainty is genuinely ambiguous. For the vast majority of a leaf’s surface, the answer is known in advance. The hardware acts on that knowledge in a single cycle.
This course will give you a complete conceptual understanding of why this problem exists, how micromaps solve it, and what the implementation looks like in the simple engine’s source code. We will begin with the visual language of shadows themselves — why they look the way they do, and why foliage breaks the assumptions that fast shadow algorithms rely on. We will then descend into the GPU’s ray traversal hardware to understand exactly where the performance cost originates. From there we will build up the micromap concept from scratch, walking through the subdivision model, the 2-state and 4-state classification formats, and the way micromap data attaches to acceleration structures. Finally, we will tour the engine’s OpacityMicromapBuilder implementation and discuss when this optimization earns its keep — and when it doesn’t.
No prior knowledge of GPU hardware internals is required, but you should be comfortable with the basics of ray tracing: what a BVH is, how shadow rays work, and what an acceleration structure does. If those concepts feel solid, you are ready to begin.