Foliage and vegetation

Foliage is the umbrella term for the plants in a game world: trees, bushes, grass, flowers and ground cover. It is one of the more difficult parts of a scene to optimise. A forest means thousands of copies of a few assets, leaves full of holes and gaps, and wind moving everything at once. Epic's documentation notes: "High densities of foliage can cause performance issues" (Unreal Engine Documentation: Foliage Mode).

Good vegetation work is half art (shape, colour, believable growth) and half technical discipline (how many, how far, how expensive). This page is about the second half and how it shapes the first. For placing plants by rules instead of by hand, see procedural placement and scattering; for the ground they grow on, see terrain and landscapes; for tree-generating software, see vegetation and procedural tools.

#Layers of vegetation

Think of vegetation in layers, because each one is built and drawn differently.

#Cards and modelled geometry

Classic game foliage uses cards: flat quads textured with a photo or bake of leaves, with an alpha mask cutting out the leaf shapes. Cards are cheap in triangles but expensive in pixels, because the transparent parts of the quad still cost shading and overdraw (Unreal Engine tech blog: Bringing Nanite to Fortnite Battle Royale in…). Overlapping cards in a bush shade the same screen pixels many times. See opacity, masked and translucent materials and overdraw.

Nanite changes this balance. On Fortnite, Epic found that "masked materials in Nanite incur a significant cost during base pass shading" and that "negative space in the alpha maps adds additional overdraw cost", so "it was usually faster to avoid masked materials and instead rely on increasing triangle counts of the mesh" (Unreal Engine tech blog: Bringing Nanite to Fortnite Battle Royale in…). Its Nanite trees had about 300,000 to 500,000 vertices, against 10,000 to 20,000 for the non-Nanite versions (Unreal Engine tech blog: Bringing Nanite to Fortnite Battle Royale in…). See virtualised geometry.

Simplification has a side effect on leaves: Fortnite's trees "would lose their canopies in the distance". Epic's fix, Preserve Area, spreads the lost area over the remaining triangles, and Epic advises enabling it only on foliage that shows the problem (Unreal Engine tech blog: Bringing Nanite to Fortnite Battle Royale in…).

#Instancing and culling

Foliage depends on instancing: drawing many copies of one mesh in a single call.

• Unreal. Meshes placed with Foliage Mode "are automatically grouped together into batches that are rendered using hardware instancing" (Unreal Engine Documentation: Foliage Mode). Instances are culled beyond an End Cull Distance and can fade out before that with a material node (Unreal Engine Documentation: Foliage Mode). Note that "the entire cluster of instances change LODs simultaneously" (Unreal Engine Documentation: Foliage Mode). With World Partition, the default foliage grid is 256 m (Unreal Engine Documentation: Foliage Mode).
• Unity. Terrain trees and details are drawn up to Tree Distance and Detail Distance, in metres, and a Detail Density Scale thins them globally (Unity Manual: Terrain settings reference).
• Godot. A MultiMesh "can draw up to millions of objects in one go", but "there is no screen or frustum culling possible for individual instances", so visibility is all or nothing (Godot Engine documentation: Optimization using MultiMeshes). Split large fields into chunks so off-screen chunks can be culled.

#Costs of wind animation

Most foliage moves with World Position Offset (WPO), a material that shifts vertices every frame. It affects almost every other system.

• Shadows. In Unreal, WPO geometry "always invalidates cached pages every frame" in virtual shadow maps (Unreal Engine Documentation: Virtual Shadow Maps). See shadows and virtual shadow maps.
• Global illumination. Lumen's software ray tracing does not support WPO (Unreal Engine Documentation: Lumen Technical Details).
• Nanite. Fortnite replaced "complex logic driving World Position Offset" with wind baked into a texture, so each vertex only looks up "a single position and quaternion", but this "only supports rigid animation" (Unreal Engine tech blog: Bringing Nanite to Fortnite Battle Royale in…). The team also turned wind off at distance, because it is "fairly indistinguishable out in the distance" (Unreal Engine tech blog: Bringing Nanite to Fortnite Battle Royale in…).

The same approach works in any engine: animate what the player is close to, and freeze or simplify the rest.

#Lighting foliage

Foliage is thin, layered and full of holes, which confuses lighting systems built for solid walls.

• In Unreal, foliage needs Affect Distance Field Lighting enabled to appear in Lumen, and foliage and instanced meshes are only supported in the Lumen scene if they use Nanite (Unreal Engine Documentation: Lumen Technical Details).
• Fortnite hit "severe over-occlusion on foliage meshes" and grass aliasing in Lumen's screen traces; skipping reflection rays on foliage saved 1 to 2 ms (Unreal Engine tech blog: Lumen brings real-time global illumination to…).
• Godot's Terrain3D includes a "shadow impostor" for distant foliage (GitHub: Terrain3D).

#How to make one

The steps below make a card-based bush and plant it in Unreal Engine 5. They follow the atlas workflow Théophile Lebeau describes for Assassin's Creed Shadows (ArtStation: Assassin's Creed Shadows : Foliage) and Epic's Foliage Mode tools (Unreal Engine Documentation: Foliage Mode). On a Nanite project, swap the cards for modelled leaves (step 4).

1. Model or scan the leaves. Make a handful of leaves and small twigs as high-poly meshes; Lebeau modelled his in Maya (ArtStation: Assassin's Creed Shadows : Foliage). Lay them out flat in a square, for example a 2048 × 2048 atlas with three or four leaf clusters.
2. Bake the atlas to masks. Bake the layout into opacity, normal, roughness and translucency maps; Lebeau baked in Substance Designer to masks that drive roughness, normals and translucency (ArtStation: Assassin's Creed Shadows : Foliage). See texture atlases.
3. Pack colour and damage separately. Store a greyscale for colour variation in one channel and leaf damage in another, as in the Assassin's Creed Shadows atlas, so the same texture can be recoloured per season or biome (ArtStation: Assassin's Creed Shadows : Foliage). See channel packing.
4. Build the cards or the leaves. For a non-Nanite project, place quads over each cluster and cut each card's outline close to the leaves, because the transparent parts of a card still cost shading and overdraw (Unreal Engine tech blog: Bringing Nanite to Fortnite Battle Royale in…). For Nanite, Epic found it "usually faster to avoid masked materials and instead rely on increasing triangle counts of the mesh" (Unreal Engine tech blog: Bringing Nanite to Fortnite Battle Royale in…).
5. Assemble the bush and its LODs. Arrange 20–40 cards around a few branches (an example count), then make lower LODs with fewer, larger cards and a billboard or impostor at the end. See level of detail.
6. Paint it with Foliage Mode. Add the mesh to Foliage Mode and paint with the Paint, Erase, Fill, Lasso or Single tools (Unreal Engine Documentation: Foliage Mode). Painted instances are "automatically grouped together into batches that are rendered using hardware instancing" (Unreal Engine Documentation: Foliage Mode).
7. Set cull distances per layer. Give bushes and grass an End Cull Distance of tens of metres and trees hundreds (Unreal Engine Documentation: Foliage Mode); see the worked numbers above for how fast grass instances grow with distance.
8. Add wind last, with a cut-off. Use a masked World Position Offset wind and disable it at distance, because WPO invalidates cached shadow pages every frame (Unreal Engine Documentation: Virtual Shadow Maps).

#Video tutorials

#Use in recent games

The games below are described in more detail in the examples above.

• Assassin's Creed Shadows (Ubisoft, 2024). A seasonal vegetation atlas with separate colour and damage channels and Designer-made LUTs (ArtStation: Assassin's Creed Shadows : Foliage).
• Fortnite Battle Royale, Chapter 4 (Epic Games, 2022). Nanite trees made of opaque geometry instead of masked cards, with Preserve Area against thinning canopies and baked wind (Unreal Engine tech blog: Bringing Nanite to Fortnite Battle Royale in…).
• Ghost of Tsushima (Sucker Punch, 2020). Fields of individual grass blades generated on the GPU, each with "their own procedural appearance and animation" (GDC 2021: Advanced Graphics Summit: Procedural Grass in…).
• Horizon Zero Dawn (Guerrilla Games, 2017). A GPU procedural placement system dressed the world, and "only 3 people actually made the nature assets for the whole production" (80 Level: The Procedural Nature of the Horizon Zero Dawn). Guerrilla's GDC talk on the game's vegetation is embedded below.

#In different engines and tools

Tree generators such as SpeedTree, The Grove and Unreal's Procedural Vegetation Editor are compared in vegetation and procedural tools.

#Common mistakes

• Loose card shapes. Large transparent margins on cards waste pixels (Unreal Engine tech blog: Bringing Nanite to Fortnite Battle Royale in…).
• Wind on everything at every distance. It breaks shadow caching and costs time far away (Unreal Engine Documentation: Virtual Shadow Maps; Unreal Engine tech blog: Bringing Nanite to Fortnite Battle Royale in…).
• One giant MultiMesh in Godot. It cannot be partly culled (Godot Engine documentation: Optimization using MultiMeshes).
• Grass drawn too far. Each extra metre of detail distance adds instances by the square.
• Forgetting Lumen settings on foliage. Missing foliage in GI looks like floating, unlit plants (Unreal Engine Documentation: Lumen Technical Details).

#Further reading and watching