Skipping LOD on mobile is a guaranteed path to thermal throttling, dropped frames, and one-star reviews about battery drain. Every polygon your GPU rasterizes for a building 40 metres away is wasted budget that could have gone toward smooth gameplay. This guide walks through configuring LOD Groups in Unity URP and Godot 4's LOD system using free GLB assets from BitSoul's marketplace, covering transition thresholds, screen percentages, and the common mistakes that cancel out all your hard work.
Why Mobile LODs Are Non-Negotiable
Mobile GPUs are tile-based deferred renderers. They process geometry in screen-space tiles, meaning every visible triangle — regardless of how small it is on screen — costs fillrate and bandwidth. A 4,000-polygon building occupying 2% of the screen costs proportionally the same as one filling the entire display.
LOD systems solve this by swapping high-detail meshes for progressively simpler ones as the camera moves away. The goal is not visual perfection at every distance; it is imperceptible degradation. Players notice stutters. They rarely notice that the tower in the background has 200 triangles instead of 4,000.
Key numbers to keep in mind:
- Tile-fill budget: most mid-range mobile GPUs (Adreno 6xx, Mali-G77) start struggling above ~500K triangles per frame
- LOD crossover point: a mesh contributing less than 1% of screen height is a candidate for your lowest LOD
- Cull distance: anything below 0.5% screen coverage should be fully culled
Unity URP LOD Group Setup
Unity's `LODGroup` component handles LOD switching. When importing a GLB from BitSoul, Unity auto-imports it as a static mesh. You add LOD behaviour in the editor.
Step 1: Prepare LOD meshes
You need at least three mesh variants per asset:
- LOD0: original mesh (e.g. 3,000 tris)
- LOD1: 40–50% reduction (e.g. 1,200 tris) — use Blender's Decimate modifier with Collapse mode
- LOD2: 10–15% of original (e.g. 350 tris) — aggressive simplification acceptable, UVs may break
- Cull: no mesh, renderer disabled
Step 2: Configure LODGroup thresholds
Screen percentages in Unity are expressed as a fraction of the vertical screen height. Typical values for medium-scale props:
| LOD Level | Screen % Threshold | Triangle Count |
|-----------|-------------------|----------------|
| LOD0 | 60% → 100% | 3,000 |
| LOD1 | 15% → 60% | 1,200 |
| LOD2 | 3% → 15% | 350 |
| Culled | 0% → 3% | 0 |
In the `LODGroup` inspector, drag each LOD mesh into its slot, then drag the slider to match these percentages. For mobile, lower the LOD0 threshold — push the transition earlier than you think you need to.
Step 3: URP-specific settings
In your `UniversalRenderPipelineAsset`, confirm LOD Cross Fade is enabled if you want smooth dithered transitions. On mobile, cross-fading has a small GPU cost — test whether the visual quality justifies it on your target device. For pure performance, disable it and accept the pop.
```csharp
// Force LOD bias at runtime for quality/performance trade-off
void SetMobileLODBias(float bias)
{
QualitySettings.lodBias = bias;
// 0.5f = transitions happen earlier (better perf)
// 2.0f = transitions happen later (better visuals)
}
```
Set `lodBias` to `0.7` in your mobile quality tier. This shifts all LOD transitions 30% closer to the camera without manually re-authoring every LODGroup.
Godot 4 LOD Configuration
Godot 4 introduced automatic LOD generation for `MeshInstance3D` nodes, plus manual `VisibilityNotifier3D`-based culling.
Automatic LOD (Godot's built-in simplification)
Godot 4 can generate LODs at import time from your GLB. In the Import panel:
1. Select your `.glb` file
2. Enable Meshes → Generate LODs
3. Set LOD Bias — a multiplier on transition distances (default 1.0; use 0.5 for mobile)
4. Set Normal Merge Angle to 25° for hard-surface props
This produces automatic LOD meshes stored inside the `.res` file. No manual Blender work required for simple props.
Manual LOD with VisibilityRangeBegin / End
For assets where automatic simplification produces poor results (thin railings, complex silhouettes), use manual meshes with `GeometryInstance3D.visibility_range_begin` and `visibility_range_end`:
```gdscript
# In _ready(), configure range-based visibility
func configure_lod(lod0: MeshInstance3D, lod1: MeshInstance3D, lod2: MeshInstance3D) -> void:
lod0.visibility_range_end = 20.0 # switch to LOD1 after 20 m
lod0.visibility_range_end_margin = 1.0 # 1 m hysteresis
lod1.visibility_range_begin = 20.0
lod1.visibility_range_end = 60.0
lod1.visibility_range_end_margin = 2.0
lod2.visibility_range_begin = 60.0
lod2.visibility_range_end = 120.0 # cull beyond 120 m
```
The `margin` values create hysteresis — preventing rapid LOD flickering when the camera sits exactly at the transition boundary.
Godot 4 LOD checklist for mobile
- [ ] Import LOD generation enabled in `.import` settings
- [ ] `visibility_range_end` set on every `MeshInstance3D` with a significant poly count
- [ ] `GeometryInstance3D.lod_bias` set to 0.5 in your mobile `Environment` config
- [ ] `RenderingServer.set_default_clear_color()` matched to your skybox to avoid over-draw at edges
- [ ] Profile with Godot Profiler → GPU tab before and after to confirm triangle count drop
Common Mistakes That Kill LOD Gains
Forgetting shadow casters. LOD switching only affects the main camera pass. Shadows still use the full LOD0 mesh by default in both engines. In Unity URP, set `Shadow LOD Bias` in the pipeline asset. In Godot 4, set `MeshInstance3D.cast_shadow = SHADOW_CASTING_SETTING_OFF` on LOD1 and LOD2 meshes.
Skinned mesh LODs. LODGroup works on `SkinnedMeshRenderer` in Unity, but Godot 4's auto-LOD does not support skeletal meshes — you must create LOD variants manually and swap them with `AnimationTree` or code.
Not testing on device. Unity's Scene view and Godot's editor viewport both render at desktop resolution. LOD thresholds calibrated in the editor will fire too late on a 720p mobile screen. Always profile on target hardware with actual screen dimensions.
Free GLB models from BitSoul marketplace ship in a single LOD — which is standard for marketplace assets. Build your LOD pipeline as described above to take them to mobile-ready state without paying for additional mesh variants.
---
*This post is part of the Ultimate Guide to Free 3D Game Assets — BitSoul's complete reference for formats, texturing, rigging, optimization, and engine integration.*