Indirect light defines the look of a 3D game environment more than almost any single asset choice. Godot 4 ships two real-time global illumination systems — VoxelGI for enclosed spaces and SDFGI for open worlds — and choosing the wrong one, or mis-configuring either, costs you both visual quality and frame budget. This guide covers both systems, how to pick between them, what your GLB assets need to do to participate, and the performance dials that matter most.
VoxelGI vs. SDFGI: choosing the right system
Neither system is a drop-in replacement for the other. They solve different problems:
| System | Best for | GI type | Dynamic? | Cost |
|--------|----------|---------|----------|------|
| VoxelGI | Indoor scenes, enclosed levels | Baked + dynamic | Partial | Medium |
| SDFGI | Open worlds, large outdoor areas | Fully dynamic | Yes | Medium-high |
VoxelGI voxelises the scene into a 3D grid, bakes indirect light and reflections, and can optionally re-bake at runtime when dynamic objects move. It works well for dungeon corridors, building interiors, or tightly bounded outdoor areas. Keep your VoxelGI node's extents as tight as possible — every unit of volume it covers costs voxelisation memory and bake time.
SDFGI generates a signed distance field from the scene and propagates light through it continuously, making it the right choice for day/night cycles, open terrain, or any world where the sky contributes most of the ambient light. It streams in cascades as the camera moves, so large scenes stay manageable, but it carries a higher per-frame GPU cost than VoxelGI.
If your level has both enclosed and outdoor sections, you can layer them: add an SDFGI `Environment` for the exterior and VoxelGI nodes for interior rooms, disabling each when the camera leaves its area.
Configuring VoxelGI in Godot 4
Add a `VoxelGI` node to your scene. The key settings:
```gdscript
# Set extents to match your room bounds — e.g. a 20x5x20m room
$VoxelGI.size = Vector3(20, 5, 20)
# Subdiv: 64 is fine for small rooms, 128 for larger spaces
$VoxelGI.subdiv = VoxelGI.SUBDIV_128
# Bake from the editor (Scene > Tools > Bake VoxelGI)
# Or trigger at runtime:
$VoxelGI.bake()
```
Mesh requirements for VoxelGI participation: Your GLB assets must have `GeometryInstance3D.gi_mode` set to `STATIC` (the default for imported meshes with Lightmap enabled in Godot's import settings) or `DYNAMIC` if they move. Set `gi_mode = DISABLED` on any mesh you don't want to contribute — particle emitters, UI elements, overlapping decals.
Normal maps matter here. VoxelGI reads surface normals to determine light direction per voxel. Baking with flat normals on chamfered hard-surface assets produces muddy indirect light. Ensure your GLB normals are correct before baking.
Probe data persistence
VoxelGI bake data is saved as a `.voxelgi` resource alongside your scene. Commit this file with your project — losing it means a full re-bake per level. For procedurally generated levels, call `VoxelGI.bake()` once at load time; it takes 1–3 seconds for typical room sizes.
Setting up SDFGI for open-world environments
Enable SDFGI in the `WorldEnvironment` node under Environment > SDFGI. Unlike VoxelGI, there's no bake step — SDFGI populates itself as the scene loads.
Critical SDFGI settings:
```
Cascades: 6–8 for large open worlds (each cascade doubles the coverage range)
Min Cell Size: 0.2 for high detail near the camera; 0.5 for performance mode
Max Distance: match your far clip plane — excess range wastes GPU cycles
Bounce Feedback: 0.5 (default); increase to 0.75 for warmer ambient bounces in interior spaces
```
Fog interaction: SDFGI naturally illuminates volumetric fog when Godot's `FogVolume` is present. Forest mist or cave atmosphere picks up the correct ambient colour without manual light placement — a significant time saver.
Asset-side requirements for SDFGI are minimal compared to VoxelGI — no bake step, no saved data file. However, assets with heavily tiled UV sets and repeated texture patches can produce GI aliasing at SDFGI's cascade borders. Break up large flat surfaces — terrain, cliff faces — with vertex colour variation or material blending to reduce visible cascade seams.
Asset prep and performance tuning
A checklist before finalising GI in any scene:
- [ ] All static meshes: `gi_mode = STATIC`; dynamic meshes: `gi_mode = DYNAMIC` or `DISABLED`
- [ ] LOD transitions (`GeometryInstance3D.lod_bias`) set to 1.0 — lower values drop GI contribution at ranges still visible to the player
- [ ] Emissive materials have `emission_enabled = true` and `emission_energy` capped at 4.0 — values above 8 blow out SDFGI indirect colour
- [ ] No shadow-casting meshes with zero thickness — single-sided leaves, flat decal planes — VoxelGI will skip their shadow contribution
Performance targets by platform:
| Platform | Recommended GI | Cascade count | Cell size |
|----------|---------------|---------------|-----------|
| PC / Console | SDFGI | 6 | 0.2 |
| Mid-range mobile | VoxelGI (tight extents) | — | 128 subdiv |
| Low-end mobile | LightmapGI (baked only) | — | — |
For scenes targeting low-end hardware, disable SDFGI entirely and fall back to Godot 4's `LightmapGI` node — it bakes indirect light to a UV2 lightmap texture and costs zero runtime GPU cycles after bake.
The free GLB assets available on the BitSoul marketplace import into Godot 4 with correct normals, UV2 sets, and vertex colour data already in place. They participate in VoxelGI and SDFGI bakes without manual rework. For props that need emission — glowing screens, lamps, neon signage — the emissive texture channel is already authored to Godot-compatible values.
Global illumination in Godot 4 is one of the highest-leverage upgrades you can make to a scene with minimal per-asset work. Once you match the right system to your level geometry and set the expected asset flags, realistic indirect light follows in minutes. Start with game-ready GLB assets from the BitSoul marketplace and spend your time on the GI configuration that actually matters.
---
*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.*