Level of detail
Level of detail (LOD) is a technique in real-time computer graphics that varies the complexity of a 3D model according to how much it contributes to the final image. A model is rendered with many polygons when it is close to the viewer or fills a large part of the screen, and with progressively fewer polygons as it recedes, shrinks on screen, or becomes less important to the scene. The aim is to spend rendering work where it is visible and to avoid drawing detail that resolves to a handful of pixels.[1][2]
LOD is one of the standard ways to keep a frame rate stable under a fixed time budget. By lowering the number of vertices and triangles the GPU must transform and rasterize, it reduces the load on the geometry stages of the rendering pipeline and the number of draw calls a scene needs.[1][3] The principle extends beyond geometry: textures are stored as a chain of pre-shrunk versions (mipmaps) so a distant surface samples a smaller image, and shaders or material effects can be simplified for far objects as well.[1]
In virtual reality (VR) and augmented reality (AR) the technique carries extra weight. A head-mounted display renders the scene twice, once per eye, at high refresh rates, so any geometry that is drawn is paid for roughly twice per frame; cutting polygon counts on distant or peripheral objects is one of the main levers for holding frame rate. On standalone headsets built around mobile chips the budget is tight enough that aggressive LOD is close to mandatory.[4][5]
Origin
The idea is usually traced to James H. Clark's 1976 paper "Hierarchical geometric models for visible surface algorithms," published in Communications of the ACM.[2][1] Clark observed that it is wasteful to send many polygons through the pipeline for an object that covers only a few pixels, and proposed organizing a scene as a tree of models in which each node can be replaced by a coarser or finer description depending on viewing conditions. The same hierarchical structure also allowed a renderer to discard whole branches that fall outside the view, an early form of view-frustum culling.[2][1] Most later LOD methods build on this notion of multiple representations of the same object selected at run time.
How it works
An LOD system needs two things: a set of representations of an object at different complexities, and a rule for choosing among them each frame.
The selection rule is normally driven by how large the object appears on screen rather than by raw world-space distance, because a large object far away and a small object up close can occupy the same number of pixels. Engines express the switch point as a fraction of the view: in Unity's LOD Group component each level is given a transition value as a percentage of screen height, and the level stays active until the object shrinks past that threshold, at which point the next, coarser level takes over.[3][6] Unity numbers its levels from LOD0 (the highest detail) upward, with each higher index holding fewer triangles.[3]
Discrete, continuous and hierarchical LOD
| Type | Abbreviation | Approach | Note |
|---|---|---|---|
| Discrete LOD | DLOD | A fixed set of separate meshes is authored or generated in advance, and the renderer swaps between them at run time. | The classic and most common form; the swap can cause visible "popping".[1] |
| Continuous LOD | CLOD | The detail is stored as a continuum that can be refined or coarsened smoothly, even differently across one object. | Avoids hard jumps and supports per-region detail.[1][7] |
| Hierarchical LOD | HLOD | Groups of objects are merged and simplified together so an entire region of a scene can be drawn as one coarse representation. | Reduces draw-call count for distant clusters of geometry.[1] |
Discrete LOD is simple but suffers from popping, the sudden visible change when one mesh is exchanged for another. Two common mitigations are alpha-blending across the transition (cross-fading) and geometric morphing (geomorphing), which interpolates vertex positions so the change is gradual.[1][7] Unity's LOD Group, for example, supports a Cross Fade transition that blends the current and next level, and a SpeedTree mode that interpolates vertex positions between levels for trees.[6]
A further reduction beyond polygon meshes is the imposter or billboard: a distant object is replaced by a flat textured quad that always faces the camera, trading all of its geometry for a single image. For very far or low-importance objects this can stand in for thousands of triangles.[1][5]
Progressive meshes
A widely cited approach to continuous LOD is the progressive mesh, introduced by Hugues Hoppe at SIGGRAPH 1996.[7] A detailed mesh is reduced to a coarse base mesh by a sequence of edge collapse operations, each of which merges the two endpoints of an edge into a single vertex; the inverse operation, the vertex split, refines the mesh back toward the original. Storing the base mesh plus the ordered list of vertex splits gives a single structure that represents the model at every level between coarse and full detail, supports smooth geomorphing between levels, allows lossless compression, and can be transmitted progressively over a network.[7]
Hoppe extended this to view-dependent refinement in a 1997 SIGGRAPH paper, where a single mesh is refined non-uniformly within one frame: detail is added where the surface is inside the view frustum, faces the viewer, and shows large screen-space error, and is removed elsewhere. The paper reports a real-time algorithm that incrementally refines and coarsens the mesh and uses less than 15% of frame time on the graphics workstation of the day, with the cost amortized across consecutive frames during continuous motion.[8]
Virtual and augmented reality relevance
Stereoscopic rendering is the reason LOD matters more in headsets than on a flat display. A VR runtime renders the scene from two slightly offset viewpoints, one for each eye, every frame; in engine terms each eye has its own model-view-projection matrices.[4] Single-pass or instanced stereo rendering reduces the duplicated draw-call work by submitting both views together, but the geometry itself is still shaded for two eyes, so reducing triangle counts on distant objects compounds across both views.[4][5]
The constraint is sharpest on standalone headsets. A device built on a Qualcomm Snapdragon XR2-class mobile processor targets a much smaller draw-call budget per eye than a PC, while still rendering two eyes at high refresh rates, which is why shipped Quest titles lean on aggressive LOD chains, simplified shaders, baked lighting and dynamic resolution to hold frame rate.[5][4] A character that is acceptable at thousands of triangles up close is dropped to a few hundred triangles, or to an imposter, once it is far away.[5]
Foveated level of detail
Foveated rendering uses the structure of human vision (high acuity only in the small foveal region the eye is pointed at, sharply lower acuity in the periphery) to render the periphery at reduced quality. The same insight can drive geometric LOD: detail is kept high in the foveal region and reduced toward the periphery, a scheme sometimes called foveated geometry simplification or foveated LOD. With eye tracking the high-detail region follows the user's gaze, an approach often described as dynamic or gaze-contingent foveated rendering.[9][10] Combining foveation with LOD selection lets a renderer feed full geometric detail only into the region the user is actually fixating while progressively coarsening meshes in peripheral vision.[10]
Automatic LOD in modern engines
Manually authoring discrete LOD chains for every asset is labor-intensive, so engines have moved toward automation. Unreal Engine 5 introduced Nanite, a virtualized geometry system that removes the need for hand-authored LODs on static meshes. At import a mesh is broken into a hierarchy of small clusters of triangles; while rendering, Nanite swaps clusters in and out at the level of detail appropriate to the current view so that the geometry resolves to roughly pixel scale, and adjacent clusters connect without cracks.[11] Because the detail shown tracks screen resolution rather than discrete steps, Epic states that LOD transitions produce little or no visible popping, and the compressed data is streamed in on demand so that only the visible detail needs to be in memory.[11] Nanite is one production realization of the continuous and hierarchical LOD ideas that began with Clark and progressive meshes, applied to very high triangle counts.[11][7]
References
- ↑ 1.00 1.01 1.02 1.03 1.04 1.05 1.06 1.07 1.08 1.09 "Level of detail (computer graphics)". https://en.wikipedia.org/wiki/Level_of_detail_(computer_graphics).
- ↑ 2.0 2.1 2.2 Clark, James H.(October 1976). "Hierarchical geometric models for visible surface algorithms".{Template:Journal. 19(10)
- 547-554. doi:10.1145/360349.360354.
- ↑ 3.0 3.1 3.2 "Introduction to level of detail". Unity Technologies. https://docs.unity3d.com/Manual/LevelOfDetail.html.
- ↑ 4.0 4.1 4.2 4.3 "How to Optimize your Oculus Quest App w- RenderDoc: Walkthroughs of Key Usage Scenarios and Optimization Tips Part 1". Meta. https://developers.meta.com/horizon/blog/how-to-optimize-your-oculus-quest-app-w-renderdoc-walkthroughs-of-key-usage-scenarios-and-optimization-tips-part-1/.
- ↑ 5.0 5.1 5.2 5.3 5.4 "Optimizing Draw Calls in Unity for Mobile VR: The Definitive Guide". https://pinkcrow.net/development/optimizing-draw-calls-in-unity-for-mobile-vr/.
- ↑ 6.0 6.1 "LOD Group component reference". Unity Technologies. https://docs.unity3d.com/6000.3/Documentation/Manual/class-LODGroup.html.
- ↑ 7.0 7.1 7.2 7.3 7.4 Hoppe, Hugues (1996). "Progressive meshes". Proceedings of ACM SIGGRAPH 1996. pp. 99-108. https://hhoppe.com/proj/pm/.
- ↑ Hoppe, Hugues (1997). "View-dependent refinement of progressive meshes". Proceedings of ACM SIGGRAPH 1997. pp. 189-198. https://hhoppe.com/proj/vdrpm/.
- ↑ "About Dynamic Foveated Rendering (DFR) in Virtual Reality (VR)". https://pimax.com/blogs/blogs/about-dynamic-foveated-rendering-dfr-in-virtual-reality-vr.
- ↑ 10.0 10.1 (2026). "Performance-driven foveated VR rendering system for large 3D meshes".{Template:Journal. doi:10.1007/s10055-026-01316-3. https://link.springer.com/article/10.1007/s10055-026-01316-3.
- ↑ 11.0 11.1 11.2 "Nanite Virtualized Geometry in Unreal Engine". Epic Games. https://dev.epicgames.com/documentation/en-us/unreal-engine/nanite-virtualized-geometry-in-unreal-engine.