Manually placing thousands of rocks, trees, and props across a 4km² game world takes weeks. With UE5's Procedural Content Generation (PCG) Framework, the same result takes hours — and updates automatically when your asset library changes.
What the PCG Framework Does (and What It Doesn't)
The PCG Framework, introduced in Unreal Engine 5.2 and substantially improved in 5.3–5.5, is a node-based system for generating and placing content at runtime or in the editor. It operates on point data: every output position, rotation, and scale is a "point" processed through a graph before being stamped as an actor or static mesh instance.
PCG excels at scattering foliage, rocks, debris, and props across large surfaces; driving density by slope angle, altitude, or distance from splines; runtime generation that responds to game state (roads clearing foliage); and generating modular structures from rules such as walls, fences, and pipes.
What PCG is not: it isn't a traditional foliage tool, and it doesn't replace Houdini for complex procedural geometry. Think of it as a powerful placement and instancing layer that sits between your art assets and the game world.
PCG graphs live on `PCGVolume` actors. Drop one into your level, assign a PCG Graph asset, and the system generates content within the volume's bounds immediately. All graph execution happens in background threads, so even heavy graphs don't block the editor.
Setting Up Your First PCG Graph
Open the PCG Graph Editor from `Content > PCG > New PCG Graph`. The editor is a standard UE5 node graph with four column types: Input nodes (surface samplers, spline samplers), modifier nodes (filters, transforms), attribute nodes (density, metadata), and output nodes (Static Mesh Spawner).
A minimal rock-scatter graph looks like this:
```
[Surface Sampler] → [Density Filter] → [Static Mesh Spawner]
```
The Surface Sampler generates points across the terrain surface at a defined point-per-square-meter density. The Density Filter removes points based on a density attribute — random by default, but it can sample landscape layers to exclude roads or water. The Static Mesh Spawner instances your mesh at each surviving point.
Key Surface Sampler settings to configure immediately:
- Points per Square Meter: start at 0.5–2 for rocks, up to 10 for grass
- Unbounded: leave OFF — always bound your samplers to the PCGVolume
- Seed: change this to get different random distributions without touching other settings
One common gotcha: the Surface Sampler uses the world's collision channel. If your terrain has no complex collision, points won't generate. Enable Complex Collision on your landscape or set the sampler's Ray Cast Channel to Visibility.
Preparing Static Mesh Assets for PCG Scattering
PCG's Static Mesh Spawner creates Hierarchical Instanced Static Meshes (HISMs) by default — the same instancing path that makes GPU instancing in Unity so efficient. Your asset prep follows the same rules as any HISM-heavy scene.
Pivot point placement is critical. PCG places each point's transform directly on the mesh's pivot. If your rock mesh has its pivot at the bounding-box center, it will float above the terrain by half its height. Set the pivot to the bottom center of the mesh's base in Blender or your DCC tool before export.
LODs are mandatory at scale. A scene with 20,000 rock instances needs aggressive LODs:
| LOD Level | View Distance | Triangle Target |
|-----------|--------------|----------------|
| LOD 0 | 0–15 m | 2,000–4,000 tris |
| LOD 1 | 15–40 m | 800–1,200 tris |
| LOD 2 | 40–100 m | 200–400 tris |
| LOD 3 / Nanite fallback | 100 m+ | 50–100 tris |
Nanite compatibility: enable Nanite on your static meshes if targeting PC or console. PCG fully respects Nanite — spawned HISMs use Nanite virtual geometry automatically, eliminating draw calls at scale. On mobile or VR targets, rely on the LOD chain above instead.
Collision on spawned instances: the Static Mesh Spawner strips complex collision from instances by default. If you need physics-accurate collision (for Chaos destruction, for example), override the Override Collision Profile setting in the Spawner node and assign `BlockAll` or a custom trace channel.
You can find rock, tree, and foliage assets pre-configured for PCG workflow at BitSoul's marketplace — many are already LOD-chained and pivot-corrected for direct drop-in use.
Point Modifiers: Controlling Density, Rotation, Scale, and Altitude
Raw Surface Sampler output places points uniformly and upright. Point modifier nodes transform those points into natural-looking placements.
Transform Points applies randomized offset, rotation, and scale. For rocks, a typical setup uses a Z position offset of −0.02 to −0.05 m to slightly sink meshes into the terrain, full yaw randomization (Z: 0–360°), and uniform scale variation of 0.6–1.4×. Avoid non-uniform scale unless your LODs account for it.
Projection re-casts each point downward against the terrain surface after transforms are applied. This is essential: Transform Points can shift a point's Z position, and without re-projection it will float. Always follow Transform Points with a Projection node targeting your landscape.
Slope-based filtering uses a Get Actor Data node sampling the landscape normal, then an Attribute Filter comparing the dot product of the normal to world-up. Points on slopes steeper than ~35° get culled:
```
[Transform Points] → [Projection] → [Get Normal]
→ [Dot Product vs World Up] → [Attribute Compare (> 0.82)]
→ [Filter Points] → [Static Mesh Spawner]
```
Altitude banding works identically: sample the point's Z position, compare against min/max thresholds, and filter. Alpine rocks above 800 m, lowland grass below 200 m — configure it once and it applies automatically across the entire landscape.
Runtime Performance and PCG Debugging Tips
PCG graphs re-execute whenever their PCGVolume is dirtied. In the editor this happens on any actor move or setting change. Marking the graph Runtime Generated allows re-execution in-game — useful for destructible environments, but expensive if triggered frequently.
Profile your graph with the built-in tools: select your PCGVolume, open the PCG Graph Editor, and press Execute with Debug. Each node's execution time appears inline. The Surface Sampler is almost always the bottleneck — reduce point density first before optimizing downstream nodes.
Partition Actors are mandatory in World Partition maps. Without them, a PCGVolume spanning a 4 km² world generates all content synchronously on load. Enable `Is Partitioned` on the PCG component so the graph generates only within loaded streaming cells.
Debugging missing output comes down to three culprits 99% of the time:
- The PCGVolume has no overlap with terrain collision
- Sampler density is so low that zero points survive the Density Filter
- The Static Mesh Spawner has no mesh assigned — it silently produces nothing
Use the Inspect output pin on any node to visualize point data mid-graph. It renders point positions as crosses in the viewport and is far faster than adding debug draw nodes.
Build at Scale with PCG-Ready Assets
PCG amplifies your environment art — but the output quality is only as good as the assets going in. Poorly pivoted meshes, missing LODs, or unoptimized materials become obvious at 10,000-instance density.
Browse PCG-optimized static mesh packs, foliage kits, and modular prop collections at BitSoul's marketplace. Assets ship with correct pivot placement, full LOD chains, and Nanite-ready exports so you can drop them into a Static Mesh Spawner and start generating at scale immediately.