Foliage is one of the fastest ways to wreck a frame rate. A single tree built from dense polygon geometry can cost more draw calls than an entire building, and most engines offer zero automatic optimization out of the box. This guide covers the complete workflow — alpha card meshes in Blender, LOD chain reduction, vertex-color wind painting, and engine-specific import settings — so your foliage ships clean and runs fast.
Why Full-Geometry Foliage Destroys Your GPU Budget
A realistic leaf modeled with individual polygon geometry runs 500–2,000 triangles per leaf. Multiply that by 300 leaves per branch, 12 branches per tree, and 50 trees in view and you're looking at nearly a billion triangles before any other geometry loads. The real killer isn't polygon count — it's overdraw and draw calls. Each alpha-blended mesh adds a full sort pass to the render queue, and engines batch poorly when alpha is involved.
The industry solution is the alpha card: a flat quad with a high-resolution leaf texture that includes an alpha channel punched out around the leaf shape. From a distance it's indistinguishable from geometry. Up close it's clearly flat, which is why LODs matter. A production foliage asset typically uses full cards at LOD0, reduces card count by 60% at LOD1, and switches to a billboard sprite at LOD3.
Building the Alpha Card Mesh in Blender
Start with a 1×1 plane, UV unwrap it flat, and assign a leaf texture with an alpha channel (PNG or TGA, not JPG). Duplicate and rotate planes to build a branch cluster. Keep each card at 2 triangles — no subdivision, no bevel.
Organize your cluster to roughly match the silhouette of a real leaf cluster. Aim for 8–12 cards per cluster for LOD0. Stack them at slight offsets (0.02–0.05 m) on the Z axis so no two cards are coplanar, which prevents Z-fighting.
Alpha texture requirements:
- Resolution: 1024×1024 minimum, 2048×2048 for hero assets
- Format: PNG with embedded alpha, or TGA with separate alpha channel
- Premultiplied alpha: OFF (straight alpha for most engine importers)
- Pack multiple leaf types into one atlas to reduce material draw calls
In Blender, set your material blend mode to Alpha Clip for baking previews. Switch to Alpha Hashed for renders — it handles transparency sorting better. When exporting to engines, the engine overrides this setting with its own blend mode. You can find pre-built alpha card leaf atlases and full foliage packs at the BitSoul marketplace if you'd rather start from tested assets.
Crafting the LOD Chain
Foliage LODs are not like hard-surface LODs. You're not decimating polygon loops — you're reducing card count and simplifying silhouettes.
| LOD Level | Cards/Cluster | Poly Count | Switch Distance |
|-----------|--------------|-----------|----------------|
| LOD0 | 12 cards | ~24 tris | 0–8 m |
| LOD1 | 6 cards | ~12 tris | 8–20 m |
| LOD2 | 3 cards | ~6 tris | 20–50 m |
| LOD3 | 1 billboard | ~2 tris | 50+ m |
Build each LOD as a separate mesh object in Blender. Name them `Foliage_LOD0`, `Foliage_LOD1`, etc. — UE5 and Unity both read LOD suffixes on import. Godot 4 requires manual LOD assignment in the import settings panel.
For LOD3 billboards, use a camera-facing plane in Blender and bake a full render of the LOD0 tree to a texture. Set up an Orthographic camera facing front, render at 512×512, and export with alpha. This gives you a cheap sprite that reads correctly from most angles.
Wind Animation: Vertex Colors vs. Skeleton Approach
There are two production approaches to foliage wind:
Vertex color masking (preferred for real-time): Paint the trunk dark (no wind movement) and the leaf tips bright (maximum sway). The engine shader reads vertex color channel R as a wind influence multiplier. This adds zero bones and zero skinning cost — the GPU handles the math in the vertex shader.
In Blender, switch to Vertex Paint mode and paint `R = 0.0` at the base, blending to `R = 1.0` at the leaf tips. Export as GLB to preserve vertex colors.
```python
# Quick vertex color validation in Blender Python
import bpy
obj = bpy.context.active_object
mesh = obj.data
if mesh.vertex_colors:
vc = mesh.vertex_colors.active
r_values = [loop.color[0] for loop in vc.data]
print(f"R channel range: {min(r_values):.2f} – {max(r_values):.2f}")
else:
print("No vertex colors found — paint wind mask before export")
```
Skeleton approach (for engines needing it): Create a simple 2-bone armature — trunk bone and branch bone. Parent the leaf cards to the branch bone. This works well in Godot 4's AnimationPlayer, which can drive bone rotation with a sine wave in GDScript. Use the skeleton method when the engine's foliage shader doesn't support vertex color wind masks, or when you need authored timing-specific animations like a branch snapping in a gust.
Engine Import and Material Setup
Unreal Engine 5: Import the GLB as a Static Mesh. Create a material with the Two Sided Foliage shading model — this gives subsurface scattering on leaves without a Translucency pass. Plug your leaf texture into Base Color and Opacity Mask, set Blend Mode to Masked, and wire vertex color R into the World Position Offset node via a Sine expression multiplied by wind speed.
Unity URP: Assign the URP Nature/SpeedTree shader or build a custom Shader Graph with an Unlit master node. Add a `_WindStrength` float property, multiply it by vertex color R, and output to Position offset. Enable Alpha Clipping with a threshold around 0.15.
Godot 4: Import the GLB with `import/generate_lods` enabled. Create a ShaderMaterial:
```gdscript
shader_type spatial;
render_mode cull_disabled;
uniform sampler2D leaf_tex : hint_default_white;
uniform float wind_strength = 0.05;
void vertex() {
float wind = COLOR.r * sin(TIME * 2.0 + VERTEX.x * 5.0) * wind_strength;
VERTEX.x += wind;
VERTEX.y += wind * 0.5;
}
void fragment() {
vec4 tex = texture(leaf_tex, UV);
ALBEDO = tex.rgb;
ALPHA_SCISSOR_THRESHOLD = 0.15;
ALPHA = tex.a;
}
```
Ship It
Alpha cards, solid LOD chains, and vertex-color wind masks are the three pillars of production-quality foliage. Get these right in Blender before engine import and your foliage will run at 60 fps on mid-range hardware with dozens of trees in view. If you're looking for tested foliage packs — or assets to use as reference while building your pipeline — browse the BitSoul marketplace. Every asset is engine-ready and format-verified.