Frustum Culling, Occlusion Culling, and Mesh LOD Pop-in: How 3D Game Engines Discard Geometry

Introduction: The Geometric Optimization Problem in Modern Games

A modern open-world game scene—such as the dense forests of The Witcher 3, the sprawling urban corridors of Cyberpunk 2077, or the vast terrain of Horizon Zero Dawn—routinely contains tens of millions of polygons, hundreds of light sources, and gigabytes of high-resolution textures. If a graphics processing unit (GPU) were forced to process and rasterize every single triangle present in the virtual world for every single frame, modern hardware would collapse under the computational load, delivering single-digit frame rates.

Real-time 3D rendering is fundamentally an art of elimination. Game engines do not achieve high frame rates by rendering faster; they achieve them by aggressively discarding geometry that the player cannot see.

This elimination occurs through a multi-tiered pipeline of visibility determination: View Frustum Culling, Occlusion Culling, and Level of Detail (LOD) management. When calibrated properly, these systems save massive amounts of CPU draw calls and GPU rasterization bandwidth. When pushed too aggressively or desynchronized by rapid camera movements, they produce one of PC gaming's most noticeable visual flaws: geometry pop-in.

View Frustum Culling: Discarding Out-of-Bound Geometry

The primary and least computationally expensive visibility test performed by a game engine is View Frustum Culling.

                   [Camera Position / Eye]
                            / \
                           /   \
         Near Clip Plane  /=====\
                         /   ▲   \
                        /    │    \   <--- Inside Frustum (RENDERED)
                       / [Visible] \
                      /   Object    \
        Far Clip Plane /=============\
                      /               \
       [Culled: Left]  [Culled: Deep]  [Culled: Right]

The Geometry of the Camera Frustum

In 3D computer graphics, the camera view is not an infinite box. It is shaped like a pyramid with its top sliced off, formally known as a frustum. The frustum is mathematically defined by six bounding planes:

1. Near Clipping Plane: Geometry closer to the camera than this plane is clipped to prevent clipping through the camera lens.
2. Far Clipping Plane: Geometry further than this distance is clipped to cap draw distance.
3. Left, Right, Top, and Bottom Planes: Established by the camera's Field of View (FOV) and monitor aspect ratio.

Bounding Volumes & Plane Testing

Testing millions of individual vertex coordinates against six planes on the CPU would create massive processing overhead. Instead, game engines wrap every 3D model in a simplified geometric proxy known as a Bounding Volume:

• Axis-Aligned Bounding Box (AABB): A simple rectangular box aligned with world axes.
• Bounding Sphere: A sphere defined by a center coordinate and a radius.

Before a draw call is submitted to DirectX, Vulkan, or the GPU driver, the engine performs dot-product arithmetic between the bounding volume's extrema and the six plane equations. If the bounding sphere lies entirely outside any of the six planes, the entire mesh is discarded instantly. The GPU never receives a single vertex or draw call for that object.

Occlusion Culling: The Battle Against Hidden Pixels

While frustum culling removes everything behind the player or outside their field of view, it cannot solve the problem of overdraw—objects that reside inside the camera frustum but are completely concealed behind foreground obstacles, such as buildings, terrain ridges, or interior walls.

Rendering a fully detailed medieval village that sits behind a massive castle wall is a massive waste of rasterization bandwidth. Game engines deploy Occlusion Culling to eliminate these hidden meshes.

[Player Viewpoint] ───► [Massive Stone Castle Wall] ───X (BLOCKED)
                              │
                    (Occlusion Culling Test)
                              │
                    ┌─────────┴─────────┐
                    ▼                   ▼
           [Hidden NPC Market]   [Hidden Blacksmith]
           (DRAW CALLS KILLED)   (ZERO GPU RASTER)

The Three Major Occlusion Techniques

1. Potentially Visible Sets (PVS) / Cell-Portal Systems:
   • Predominantly used in indoor, corridor-heavy games (pioneered by engines like id Tech and Source).
   • The map is partitioned into distinct rooms (cells) connected by doorways or windows (portals). If a portal is not visible within the current frustum, the engine does not render any geometry inside the connected room.
2. Hardware Occlusion Queries:
   • The engine sends simplified bounding boxes of distant meshes to the GPU and asks: "Did any pixels of this bounding box pass the depth (Z-buffer) test?"
   • If zero pixels pass, the actual high-poly mesh is culled on subsequent frames.
   • The Latency Trap: Querying the GPU requires waiting for rasterization results. This introduces a 1-to-2 frame synchronization delay between CPU and GPU, which can lead to objects vanishing or popping into view when spinning the camera rapidly.
3. Hierarchical Z-Buffering (HZB) & Compute Shader Culling:
   • Modern engines (such as Unreal Engine 5 and Unity HDRP) downsample the previous frame's depth buffer into a mipmapped pyramid of depth values (Hierarchical Z-Buffer).
   • Compute shaders test millions of object bounding boxes against this depth pyramid in parallel on the GPU. Because this occurs entirely on-chip within GPU memory, it avoids CPU-GPU pipeline stalls and enables massive scale rendering.

Level of Detail (LOD) & The Physics of Pop-In

Even when an object is inside the frustum and not occluded, rendering a 100,000-polygon statue that occupies only 8 pixels on screen is inefficient. To resolve this, engines employ Level of Detail (LOD) systems.

Discrete LOD vs. Continuous / Virtualized Geometry

• Discrete LODs (LOD 0 to LOD 4): 3D artists export multiple distinct versions of the same asset. LOD 0 is the ultra-detailed version viewed at close range (e.g., 50,000 triangles). LOD 1 cuts geometry by 50% at 20 meters. LOD 4 reduces the asset to a simple billboard or low-poly hull (e.g., 200 triangles) at 200 meters.
• Dithered Crossfading: To hide the sudden swap between discrete meshes, engines use a stippled screen-door transparency blend across 10 to 20 frames, allowing the eye to register a smooth transition rather than an abrupt jump.
• Virtualized Micropolygon Geometry (Unreal Engine Nanite): Instead of discrete artist-authored LOD meshes, modern virtualized pipelines analyze mesh clusters in real time, streaming and rendering only triangles that match pixel resolution 1:1, fundamentally eliminating traditional discrete LOD transitions.

Why Pop-In Occurs: The Triangle of Asset Streaming

When players witness buildings, foliage, or high-resolution textures snapping into view suddenly ("popping"), it is rarely a bug in the game code. It is an operational bottleneck across three subsystems:

1. Storage I/O Latency: The mechanical hard drive or saturated SATA SSD cannot read the high-poly mesh from disk into system RAM in time.
2. VRAM Transfer Bandwidth: The PCIe bus cannot upload the asset textures and vertex buffers into GPU memory fast enough during rapid camera movement.
3. Occlusion Prediction Lag: When turning a corner at high velocity, the camera enters an area faster than the HZB or occlusion query system can invalidate the occlusion flag, causing objects to appear with a 50-millisecond delay.

Diagnostic Matrix: Rendering Culling Artifacts and Visual Glitches

Understanding the visual manifestations of culling failures allows PC gamers and developers to correctly isolate engine settings from hardware bottlenecks:

Optimizing real-time rendering environments requires a balanced architecture that respects the physical constraints of storage, memory bandwidth, and rasterization capacity. By referencing technical breakdowns on 365Finds, players and modders can fine-tune game engine configuration files and driver overrides to eliminate jarring geometry pop-in without destroying frame pacing or GPU stability.

References

• Visibility and Occlusion Culling - Unreal Engine Documentation
• Occlusion culling - Unity Manual
• Rasterizer Stage - Win32 apps | Microsoft Learn
• Basic 3D theory - Game development | MDN