LODs and billboards for low poly models: the complete guide

Low poly doesn't mean you can skip levels of detail. A three hundred triangle tree is cheap on its own. A forest of two thousand of them is six hundred thousand triangles, most of them a few pixels wide, and the leaves of the far ones are thousands of tiny triangles the GPU has to draw and then throw away. Levels of detail swap a model for a lighter one as it gets farther from the camera, and at the far distance they swap it for a flat picture.

This guide covers what a LOD set is and how engines choose between levels, what counts are reasonable for low poly work, how to make the lower levels so the swap doesn't show, billboards and impostors for the distance, what LODs save and what they don't, and the setup in each engine. The articles under it go through Unity's LOD Group, billboard trees in Unity, Godot's LODs and visibility ranges and tree colliders in full. Every level of detail wants one material per tree, and that's the subject of the materials article.

• Unity's LOD Group from separate model filesHow to build a LOD Group in Unity from three separate model files, what the screen-height thresholds mean, the naming convention that makes the importer build the group for you, fade modes, LOD Bias, and how LOD Groups work with batching and instancing.
• Billboard trees in Unity for the far distanceWhat a tree billboard is, how to make the picture, the two ways to show one in Unity (a quad with a cutout material, or a Billboard Renderer), how terrain trees do it for you, and the settings that keep it from looking flat.
• Godot 4 LODs: mesh LODs and visibility rangesGodot 4 has two LOD systems, the automatic mesh LODs the importer generates and the visibility ranges you set on nodes. This covers how to control each, fading between levels, and how they work with MultiMesh for a forest.
• Tree colliders in Unity: a capsule on the trunkWhy a tree's collider should be a capsule around the trunk with nothing around the canopy, how to set it up on a placed tree and on a terrain tree, what Generate Colliders on the importer gets wrong, and the same setup in Godot and Unreal.

What a level of detail is

A LOD set is the same model at several triangle counts. LOD0 is the full one, LOD1 is lighter, LOD2 is lighter still, and the engine draws whichever fits the model's size on screen. The swap point is usually a fraction of the screen's height. While the model is taller than, say, a quarter of the screen it's drawn at LOD0, between a quarter and a tenth it's drawn at LOD1, and so on, until at some size it's culled entirely.

Because the swap happens when the model is already small, the lighter versions can be rough. The silhouette and the colors have to stay the same between levels, or the swap shows as a pop. A LOD1 with half the triangles and the same outline goes unnoticed. One with a different shape draws the eye every time the camera moves.

Reasonable counts for low poly work

These are for a game that runs on ordinary hardware. Halve them for a mobile game. A desktop game with a small scene can double them and never notice.

Two things cost more than triangle count, and you should know about them before you make a LOD:

• Draw calls. A model with one material is one draw call however many triangles it has. A model with four materials is four. A forest of trees with four materials each spends more time in draw calls than in triangles, and no LOD fixes that. A palette texture with one material does.
• Overdraw. Foliage made of many separate planes with transparent cutouts draws the same pixels over and over. A canopy that's a closed mesh of solid triangles costs less at any triangle count. When you make LOD1 for a tree, merging the foliage into fewer solid pieces does more good than halving the triangles.

Making the levels

Each lower level should be the same tree, simplified:

• Keep the trunk and main boughs. They're the silhouette and they cost little.
• Simplify the foliage. Fewer lumps, or one skin over the crown, at a lower resolution. Keep the color.
• Drop the twigs at LOD2. Nobody sees them at that size and they're most of the small triangles.
• Keep the pivot and the bounds. The engine measures the model's screen size from its bounds, and if LOD1's bounds differ from LOD0's the swap point jumps.

PolyMason's tree builder makes the levels this way when you select them at export. LOD1 halves the foliage detail. LOD2 drops the twigs and skins the crown with one coarse mesh. Both keep the trunk, the boughs and the palette, and the zip's manifest lists the exact triangle count of each.

Automatic decimation, which every engine and modeling tool has, works well on smooth organic models and badly on low poly ones, because it removes the facets that are the style. Use it for LOD2 and below if you must, and check the result.

Billboards and impostors

Past the last mesh level, the right level of detail is a picture. A billboard is one quad, or two crossed, with a rendered image of the model on it and transparency around it, turned to face the camera. That's two triangles for one quad and four for a crossed pair, whatever the model was, and at the distance where it's used nobody can tell it from the mesh. Trees are the classic case. In most games a distant forest is billboards.

The image is the model rendered on a transparent background, straight on, and for crossed quads from the side as well. Render it with the same lighting the scene uses, or unlit, since the quad will be lit as a flat surface. PolyMason renders both pictures when you select billboards, and writes the crossed quads that carry them.

An impostor is the same idea with more pictures. The model is rendered from many angles into one texture, and the shader picks the nearest angle as the camera moves. Unreal and Unity both have impostor tools, but for low poly trees the two-quad billboard is usually enough.

Transitions

A hard swap between levels is a pop, and the eye is good at seeing pops. Engines soften it two ways. With cross-fading, both levels draw for a moment and blend. With dithering, the outgoing level dissolves into the incoming one over a few frames. Both cost a little, and they're worth it for anything the player looks at. For billboards, a cross-fade between the last mesh level and the picture hides the flatness of the quad appearing.

What LODs save, and what they don't

LODs save triangles, vertex shading, and the fill cost of tiny triangles. They don't save draw calls, which are the other half of the bill. A thousand billboarded trees are still a thousand draw calls unless they're batched or instanced. Every engine has a way to draw many copies of one mesh in one call, and a forest needs it whatever its LODs. Unity has static batching and GPU instancing, Godot has MultiMesh, and Unreal has instanced static meshes. The engine articles cover how each one pairs with LODs.

In each engine

Unity holds the levels in a LOD Group component, with screen-height thresholds and a Culled slot. If a model's children are named _LOD0, _LOD1 and _LOD2, the importer builds the group for you. Billboards are a BillboardRenderer, or a quad with a cutout material. The LOD Group article sets it up from separate files, and the billboard article makes the far level.

Godot 4 generates mesh LODs itself on import and picks between them automatically. An OBJ imported as a single mesh needs Generate LODs checked in the Import dock, and in older 4.x releases it needs Import As set to Scene. When you want control, you make each level its own MeshInstance3D with a visibility range and fade between them. The Godot article covers both.

Unreal reduces the mesh itself in the Static Mesh editor's LOD settings, or imports each level as a file, and it has hierarchical instancing and impostors for the far end. The Unreal import article shows where the LOD settings are.

Whichever engine you use, a tree also needs a collider, and it should not be the mesh. The tree colliders article explains what to use instead.

The other guides

• Flat shading in Unity for low poly modelsWhy a low poly model goes smooth when it lands in Unity, what the importer's Normals and Smoothing Angle settings do, the three places you can fix it, and how to keep the colors flat as well. Three articles underneath go into the detail.
• The OBJ file format, explained for game enginesWhat's in an OBJ file and its MTL, what it leaves out (units, axes, colors), how it compares with FBX, GLB and STL, and how to import one into Unity, Godot and Unreal so the model doesn't arrive tiny, sideways or gray.
• Free low poly assets for GodotWhere to get free low poly models that work in Godot 4, what each source's license allows, and which formats to prefer. It also covers importing an OBJ or GLB with its colors and flat shading intact, adding a collider, and scattering a forest.
• How to make low poly trees for gamesThe method behind a low poly tree that looks like its species: the silhouette that identifies it, the trunk, where the boughs leave and how the trunk divides, foliage as a few closed meshes, two greens, triangle budgets, and the export a game engine wants. The same steps work in the builder and by hand in Blender.

Or build a tree and see what comes out.