# AssetPro - WorldGen — Runtime Procedural Infinite Terrain Generator

**URL:** <https://forums.unrealengine.com/t/assetpro-worldgen-runtime-procedural-infinite-terrain-generator/2719382>\
**Category:** Product Discussion\
**Tags:** fab\
**Created:** [May 1, 2026, 11:10am UTC](https://forums.unrealengine.com/t/assetpro-worldgen-runtime-procedural-infinite-terrain-generator/2719382 "2026-05-01T11:10:29Z")\
**Posts on this page:** 18\
**Page:** 1

<div class="post-metadata">

**Author:** ![DigitalWorlds](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@DigitalWorlds](https://forums.unrealengine.com/u/DigitalWorlds)\
**Post date:** [May 1, 2026, 11:10am UTC](https://forums.unrealengine.com/t/assetpro-worldgen-runtime-procedural-infinite-terrain-generator/2719382/1 "2026-05-01T11:10:29Z")

</div>

WorldGen is a runtime C++ plugin for Unreal Engine 5 that generates infinite procedural terrain with async chunk streaming, layered noise, biome blending, and foliage scattering — all without blocking the game thread.

Drop WorldStreamingManager into your level and get a fully streaming open world in minutes.

_V1.1 adds a dedicated dense grass system with player-radius culling, per-asset resolution/radius control, and slope-aware instance sinking._

_V1.2 adds hydraulic erosion — particle-based droplet simulation that carves valleys, sharpens ridges, and deposits sediment, running entirely on the background thread._

_V1.3 adds multiplayer support — terrain streams around every connected player simultaneously. Dedicated servers build collision only, skipping all visual and foliage work._

_V1.4 adds terrain deformation (experimental) — sculpt terrain in real-time with configurable spherical brushes. Includes fixes to texture world scaling and foliage grid placement independence from mesh resolution._

_V1.5 adds distance-based LOD — configurable resolution tiers per ring distance keep near-terrain high-polycount for smooth deformation while reducing memory and build cost at distance._

_V1.6 adds three critical production fixes: (1) Floating-point precision fix eliminates texture stretching at extreme world distances (2M+ units) by using local coordinates for UV math instead of world coordinates. (2) Dynamic road expansion — roads now generate deterministically in all chunks as the player explores, with automatic pathfinding to the existing network. (3) Erosion safeguard — erosion is automatically disabled at low LOD resolutions (≤32) to prevent artifacts, and the LOD array is optimized to [256, 256, 128, 64] for the best quality-to-performance balance._

[V1.0 Preview Video](https://youtu.be/TwrdOEUZhhM)

[Playable Demo](https://1drv.ms/f/c/a3cb1733695c0eb1/IgB2u8dP3KEVTJM0izrGVMvAAYu2pfuusNfPgfAQ9HcovgY?e=sLsGur)

[V1.1 Dense Grass Video](https://youtu.be/u2aFDdRHsAA)

──────────────────────────────

CORE FEATURES

──────────────────────────────

▸ Infinite Chunk Streaming — actor pool recycles chunks at runtime (no spawn/destroy overhead). Configurable view distance up to any radius.

▸ Async Mesh Generation — geometry built entirely on a thread pool. Game thread is never blocked.

▸ Async Collision Cooking — bUseAsyncCooking enabled by default.

▸ Seamless Chunk Normals — 1-vertex border overlap ensures no visible seams between tiles.

▸ Layered Noise Stack — stack up to N noise layers. Layer 0 acts as a continental mask controlling where mountains appear vs flat plains.

▸ FastNoise Lite Integration — Perlin, OpenSimplex2, Cellular, Ridged Multifractal, Domain Warp Progressive (MIT licensed, ships with source).

▸ Domain Warping — global warp offsets applied to all coordinates for natural terrain variation.

▸ Biome Blending — vertex color blend weights for Grass / Rock / Snow / Beach / Underwater. Plug directly into any landscape material.

▸ Beach Layer — configurable height band above sea level. Beach weight baked into UV1.x for smooth sand transitions.

▸ Foliage System — BiomeFoliageAsset data assets drive HISM scatter on the thread pool. Per-mesh density, height, slope, and scale constraints. Per-entry collision toggle — enable only on meshes that need physical interaction.

▸ Dense Grass System — UWorldGenGrassAsset data assets drive ISM ground cover on a dedicated high-resolution grid independent of mesh resolution. Grid is world-snapped and player-radius culled (identical behaviour to Landscape Grass Output). Per-asset Grass Resolution, Grass Radius, density, slope constraints, scale, and normal alignment. Grass follows the player seamlessly at runtime.

▸ **Hydraulic Erosion** — particle droplet simulation with configurable strength, deposition, evaporation, sediment capacity and brush radius. Fully async, zero game thread cost. Enable per-world with a single toggle. _(V1.6: Auto-disabled at low resolution for artifact prevention)_

▸ Slope Sink Depth — automatically sinks grass blades into the terrain on slopes to prevent floating. Scales with sin(slope angle), configurable per asset. Instances reused across chunk recycling.

▸ Terrain Deformation — sculpt terrain in real-time using spherical brushes. Deformation persists when chunks reload. _(Experimental)_

▸ Distance-Based LOD — configurable per-ring resolutions keep high vertex density near the player while reducing memory and build cost at distance. _(V1.6: Optimized default array [256, 256, 128, 64])_

▸ Road Network — terrain-following roads with corridor flattening and foliage removal. _(V1.6: Dynamic expansion — roads generate in newly discovered chunks as the player explores)_

▸ **Floating-Point Precision Fix** _(V1.6)_ — eliminates texture stretching at extreme world distances (2M+ units) by using local coordinates for UV calculation. Critical for open-world exploration beyond a few million units.

▸ Multiplayer Support — terrain streams around all connected players simultaneously. Each player's chunk position is tracked independently. Per-player gravity delay applied on spawn, including late joiners.

▸ Dedicated Server Mode — on a dedicated server, WorldGen builds collision geometry only. Visual mesh, foliage, and grass are skipped. Server cost scales with player count, not visual quality.

▸ Water Plane — follows player on a configurable timer. Covers full view distance.

▸ Editor Preview — CallInEditor button rebuilds terrain without entering Play mode.

──────────────────────────────

TECHNICAL HIGHLIGHTS

──────────────────────────────

▸ Pure C++ runtime — no Blueprints required (Blueprint-friendly exposed parameters)

▸ ProceduralMeshComponent-based geometry

▸ Fully exposed parameter categories with tooltips and clamped slider ranges

▸ Seeded RNG per chunk — deterministic foliage placement

▸ Terrain Coverage readout in the Details panel (e.g. "9 × 9 chunks — 9.0 km × 9.0 km")

▸ Grass and foliage collision independently toggleable per asset entry

▸ Listen server, client, and dedicated server configurations supported with no additional setup

──────────────────────────────

INCLUDED

──────────────────────────────

▸ Full C++ source

▸ Pre-built landscape material (M\_LandscapeAutoTextured) with biome blending wired up

▸ Sample foliage and grass data assets (grass biome)

▸ Sample tree and pine meshes with materials

▸ Demo map

──────────────────────────────

PERFECT FOR

──────────────────────────────

Open-world games, survival games, exploration prototypes, procedural world tools, and any project needing infinite streaming terrain without writing low-level noise or chunk management code. V1.6 is production-ready with critical floating-point precision fixes verified for games requiring exploration at extreme world distances.

──────────────────────────────

ADDITIONAL NOTES

──────────────────────────────

- Requires the **ProceduralMeshComponent** plugin (bundled with Unreal Engine 5, enabled by default).

- Includes **FastNoise Lite** (MIT license, Jordan Peck / Auburn) — ships in plugin source tree, safe for commercial use.

──────────────────────────────

WHAT'S FIXED IN V1.6

──────────────────────────────

**Texture Stretching at Extreme Distance (CRITICAL)**

Eliminated diagonal checkerboard stretching pattern that appeared at 2M+ units from world origin. Root cause: UV coordinates calculated using absolute world coordinates. At extreme distances, single-precision floats lose precision in division, causing uneven texture sampling. Fix: Use local coordinates (relative to chunk origin) for UV math. One-line change, massive visual impact.

**Dynamic Road Expansion (FEATURE)**

Roads now generate deterministically across the entire world as the player explores. Previously, roads only appeared in chunks loaded at BeginPlay. V1.6 adds ExpandRoadsForChunk() which automatically pathfinds new roads to the existing network when new chunks are discovered.

**Erosion Safeguard (STABILITY)**

Erosion simulation automatically disables at resolution ≤32 to prevent unacceptable artifacts. Combined with the optimized default LOD array [256, 256, 128, 64], terrain is now stable at all recommended resolutions without visual glitches.

> **[WorldGen — Infinite Procedural Terrain | Runtime Streaming | Multiplayer | UE5](https://www.fab.com/listings/e4e93fbe-9326-40b8-a043-a809f788306a)**
>
> WorldGen is a runtime C++ plugin for Unreal Engine 5 that generates infinite procedural terrain with async chunk streaming, layered noise, biome blending, and foliage scattering — all without blocking the game thread.Drop WorldStreamingManager into...

---

<div class="post-metadata">

**Author:** ![DigitalWorlds](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@DigitalWorlds](https://forums.unrealengine.com/u/DigitalWorlds)\
**Post date:** [May 10, 2026, 8:22am UTC](https://forums.unrealengine.com/t/assetpro-worldgen-runtime-procedural-infinite-terrain-generator/2719382/2 "2026-05-10T08:22:23Z")

</div>

[Playable Demo](https://1drv.ms/f/c/a3cb1733695c0eb1/IgB2u8dP3KEVTJM0izrGVMvAAYu2pfuusNfPgfAQ9HcovgY?e=sLsGur)

[V1.0 Preview](https://youtu.be/TwrdOEUZhhM)

[V1.1 Dense Grass Video](https://youtu.be/u2aFDdRHsAA)

[V1.2 Erosion Video](https://youtu.be/Tr2KYbDN1Kc)

[V1.3 Multiplayer Support Video](https://youtu.be/gpBPtbA9Y7M)

[V1.4 Runtime Terrain Deformation](https://youtu.be/nNpDtOwHjbg)

[V1.5 Terrain LOD System](https://youtu.be/o6l6AdZh8rg)

────────────────────

---

<div class="post-metadata">

**Author:** ![DigitalWorlds](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@DigitalWorlds](https://forums.unrealengine.com/u/DigitalWorlds)\
**Post date:** [May 10, 2026, 8:25am UTC](https://forums.unrealengine.com/t/assetpro-worldgen-runtime-procedural-infinite-terrain-generator/2719382/4 "2026-05-10T08:25:55Z")

</div>

# **WorldGen Plugin — V1.6 Documentation**

**By CodeLikeMe | UE5 | Runtime Infinite Terrain**

* * *

## **Overview**

WorldGen is a runtime infinite terrain streaming plugin for Unreal Engine 5.4–5.7. Unlike editor-time terrain tools, WorldGen generates and streams terrain _while your game runs_ — no baking, no pre-generation, no loading screens. Chunks build on background threads, stream around the player seamlessly, and recycle without ever spawning or destroying actors at runtime.

**Designed for:** Indie developers building open-world games who want production-ready terrain streaming without writing engine-level code.

**The core promise:** Most terrain tools run in the editor. This one runs in your game.

* * *

## **What’s New in V1.6**

### **Critical Bug Fixes _(V1.6)_**

| **Fix** | **Impact** | **Status** |
| --- | --- | --- |
| **Texture Stretching at Extreme Distance** | Eliminates diagonal checkerboard pattern at 2M+ units | ✓ Fixed |
| **Dynamic Road Expansion** | Roads now generate in all chunks as player explores | ✓ Complete |
| **Erosion Safeguard** | Prevents artifacts at low LOD resolution (≤32) | ✓ Implemented |

### **Verified & Tested _(V1.6)_**

- ✓ Smoke tested on UE5.5, UE5.6, UE5.7 (zero errors/warnings)

- ✓ LOD array optimized: (256, 256, 128, 64)

- ✓ All Fab submission requirements verified

* * *

## **What’s in V1.6 (Complete Feature List)**

| **Feature** | **Notes** |
| --- | --- |
| Infinite chunk streaming | Actor pool — no spawn/destroy at runtime |
| Async mesh generation | Thread pool — game thread never blocked |
| Async collision cooking | Background physics build |
| Seamless chunk normals | 1-vertex border overlap eliminates lighting seams |
| FastNoise Lite | Perlin, Simplex, Cellular, Ridged Multi, Domain Warp |
| Layered noise | Up to N layers with continental masking |
| Domain warping | Global XY warp applied before all layer evaluation |
| Far terrain | Second low-res LOD ring for massive draw distances |
| Water plane | Flat ocean at sea level, follows player on a timer |
| Beach layer | Height-based sand zone with terrain flattening |
| Slope-aware blending | No sand on cliffs; rock injected on steep faces |
| Underwater blend | Per-pixel world-position Z cutoff — no vertex interpolation artifact |
| Material parameter sync | `SeaLevelZ` auto-pushed to your terrain material |
| HISM foliage system | Per-biome data assets, per-entry placement rules |
| Foliage clustering | Natural clump patterns for trees and rocks |
| Per-entry view distance | Trees at 4 chunks, ground clutter at 1 |
| Grow in Shade | Ground cover layers alongside trees without blocking |
| Per-entry foliage collision toggle | Enable collision only on meshes that need physical interaction |
| **Dense ISM grass system** _(V1.1)_ | Radius-based world-snapped scatter grid — density independent of tile size |
| **Per-asset grass radius & resolution** _(V1.1)_ | Each grass asset controls its own spawn radius and grid density |
| **Slope Sink Depth** _(V1.1)_ | Auto-sinks blades into terrain on slopes, proportional to slope angle |
| **Hydraulic erosion** _(V1.2)_ | Particle droplet simulation — carves valleys, deposits sediment, fully async |
| **Multiplayer support** _(V1.3)_ | Server streams terrain around all connected players. Dedicated server builds collision only — no foliage, grass, or visual mesh |
| **Per-player gravity delay** _(V1.3)_ | Terrain load delay applied per-player including late joiners |
| **Terrain deformation** _(V1.4)_ | Sculpt terrain in real-time with spherical brushes; persistent height deltas; DeformTerrain() and ClearDeformation() API |
| **Fixed texture world scale** _(V1.4)_ | Texture scale now independent of tile size and resolution |
| **Fixed foliage grid** _(V1.4)_ | Foliage placement independent of mesh resolution |
| **Distance-based LOD** _(V1.5)_ | Configurable per-ring resolution array; high resolution near player, lower at distance; seamless transitions |
| **LOD toggle** _(V1.5)_ | Enable/disable LOD system; flat Resolution fallback when disabled |
| **Increased resolution support** _(V1.5)_ | Now supports 256+ vertices per side (previously capped at 128) |
| **Texture Stretching Fix** _(V1.6)_ | UV coordinates use local math instead of world math — eliminates precision loss at extreme distances |
| **Dynamic Road Expansion** _(V1.6)_ | Roads generate in newly discovered chunks as player moves; automatic pathfinding to existing network |
| **Erosion Safety** _(V1.6)_ | Erosion disabled at resolution ≤32 to prevent unacceptable artifacts |
| Enable/disable toggles | Foliage, grass, erosion, deformation, LOD, and roads can be switched off independently |
| Road network | A\* terrain-following roads with corridor flattening and dynamic expansion |
| Editor preview | Preview Terrain / Clear Terrain buttons in Details panel |
| Coverage label | Live readout of loaded terrain footprint in km |

* * *

## **Installation**

1. Copy the `WorldGen` folder into your project’s `Plugins/` directory.

2. Right-click your `.uproject` and choose **Generate Visual Studio project files**.

3. Open the solution, build, and launch the editor.

4. The plugin is automatically enabled — no manual activation needed.

* * *

## **Quick Start**

### **1. Place the streaming manager**

- In the **Place Actors** panel search for `WorldStreamingManager`.

- Drag one into your level. Place it roughly where you want the world origin.

### **2. Assign a terrain material**

- Create a material (see **Material Setup** below).

- Assign it to **WorldGen \> Terrain Material** on the streaming manager.

### **3. Preview in editor**

- Select the streaming manager and click **Preview Terrain** in the Details panel.

- Terrain builds asynchronously — it appears within a second or two.

- Adjust parameters and click **Preview Terrain** again to rebuild.

### **4. Play**

- Hit Play — terrain streams automatically around the player character.

- No additional setup required.

* * *

## **Material Setup**

WorldGen bakes all terrain blend weights into vertex data. Your material reads these channels to drive layer blending.

### **Vertex Color Channels**

| **Channel** | **Node in Material** | **Value** |
| --- | --- | --- |
| `VertexColor.R` | `Vertex Color > R` | **Water** — 1.0 below sea level, 0.0 above. Binary step, not a gradient. |
| `VertexColor.G` | `Vertex Color > G` | **Grass** — base layer remainder |
| `VertexColor.B` | `Vertex Color > B` | **Rock** — height + slope based |
| `VertexColor.A` | `Vertex Color > A` | **Snow** — high-altitude cap |

### **UV Channels**

| **Channel** | **Node in Material** | **Value** |
| --- | --- | --- |
| `UV1.R` | `TextureCoordinate(1) > R` | **Beach** — 1.0 at waterline, fades to 0 at top of beach band |
| `UV1.G` | `TextureCoordinate(1) > G` | **Road** — 1.0 at centerline, 0 at corridor edge |

### **Material Parameter**

| **Parameter Name** | **Type** | **Set By** |
| --- | --- | --- |
| `SeaLevelZ` | Scalar | Auto-pushed by WorldStreamingManager at BeginPlay and on parameter change |

### **Recommended Blend Order**

Build your material as a chain of Lerp nodes, outermost last:

```auto
Grass (base)
  → Lerp(Grass, Rock, Alpha = VertexColor.B)
  → Lerp(above, Snow, Alpha = VertexColor.A)
  → Lerp(above, Beach, Alpha = TextureCoordinate(1).R)
  → Lerp(above, Road, Alpha = TextureCoordinate(1).G) [optional]
  → Lerp(above, Underwater, Alpha = underwater_mask)

```

### **Underwater Mask (Per-Pixel — Recommended)**

Replace `VertexColor.R` as the underwater Lerp alpha with a world-position comparison to eliminate waterline interpolation artifacts:

```auto
AbsoluteWorldPosition → Mask(B/Z)
  → Subtract(SeaLevelZ parameter)
  → Multiply(-1)
  → Divide(500)
  → Saturate
  → Lerp Alpha for Underwater layer

```

This runs per-pixel and produces a clean, artifact-free waterline on any slope.

* * *

## **Parameter Reference**

All parameters are on the `AWorldStreamingManager` actor in the Details panel.

### **WorldGen | General**

| **Property** | **Default** | **Description** |
| --- | --- | --- |
| Seed | 42 | Master world seed. Change for a completely different world. |
| Tile Size (cm) | 200,000 | Width/height of each terrain chunk. 200,000 = 2 km per tile. |
| Resolution | 64 | Vertices per side per chunk. Used as fallback when LOD is disabled. |
| Height Scale | 1.0 | Global height multiplier applied after noise. |
| View Distance (chunks) | 4 | Near-terrain chunk radius. 4 = 9×9 = 81 chunks. |
| Terrain Load Delay (s) | 4.0 | Seconds to suspend gravity at startup while async collision cooks. Increase if the player falls through terrain in the first few seconds. Applied per-player, including late joiners. |
| Terrain Material | null | Your terrain material (or material instance). |
| **Enable LOD** _(V1.5)_ | true | Enable distance-based LOD system. When off, all chunks use flat Resolution. |
| **LOD Resolutions** _(V1.5)_ | [256, 256, 128, 64] | Array of resolutions per Chebyshev distance ring. Index 0 = player’s chunk, 1 = one ring out, etc. Last entry reused for all further rings. **Recommended (V1.6):** [256, 256, 128, 64] — avoids resolution 32 artifacts. |

### **WorldGen | Height Range**

| **Property** | **Default** | **Description** |
| --- | --- | --- |
| Min Height (cm) | -175,000 | Ocean floor. More negative = deeper oceans. |
| Max Height (cm) | 175,000 | Mountain peak. |
| Sea Level | 0.50 | Normalized [0–1]. 0.5 = midpoint between Min and Max Height. |

### **WorldGen | Terrain Layers**

| **Property** | **Default** | **Description** |
| --- | --- | --- |
| Rock Start | 0.65 | Normalized height where rock begins. Must be above Sea Level. |
| Rock Blend | 0.10 | Grass-\>rock transition width. Small = sharp cliff edge. |
| Snow Start | 0.75 | Normalized height where snow begins. |
| Snow Blend | 0.06 | Rock-\>snow transition width. |

### **WorldGen | Mountains**

| **Property** | **Default** | **Description** |
| --- | --- | --- |
| Mountain Threshold | 0.25 | Controls mountain coverage. Raise for more flat plains. |
| Mountain Blend | 0.30 | Plains-\>mountains transition smoothness. |

### **WorldGen | Noise**

| **Property** | **Default** | **Description** |
| --- | --- | --- |
| Noise Layers | 4 layers | Stack of noise layers. Layer 0 is always the continental base. |
| Warp Strength | 8,000 | Domain warp amplitude in cm. 0 = disabled. |
| Warp Frequency | 0.000033 | Domain warp frequency. |

#### **Default Noise Layer Stack**

| **#** | **Name** | **Type** | **Frequency** | **Octaves** | **Role** |
| --- | --- | --- | --- | --- | --- |
| 0 | Continental | Perlin | 0.000001 | 3 | Land/ocean distribution and mountain mask |
| 1 | Ridged | Ridged Multi | 0.000005 | 3 | Mountain ridges and peaks |
| 2 | Mountains | Simplex | 0.010000 | 1 | Mid-frequency mountain detail |
| 3 | Ridges | Perlin | 0.000180 | 2 | Fine ridge detail (disabled by default) |

### **WorldGen | Beach**

| **Property** | **Default** | **Description** |
| --- | --- | --- |
| Beach Width | 0.04 | Normalized height band above sea level treated as beach. 0.04 = 4% of height range. |
| Beach Flatten Strength | 0.85 | How flat the beach zone becomes. 1.0 = perfectly flat sand. |

### **WorldGen | Water**

| **Property** | **Default** | **Description** |
| --- | --- | --- |
| Enable Water Plane | true | Flat water surface at sea level. |
| Water Material | null | Material for the water plane. |
| Water Update Interval (s) | 2.0 | How often the plane repositions to follow the player. |

### **WorldGen | Far Terrain**

| **Property** | **Default** | **Description** |
| --- | --- | --- |
| Enable Far Terrain | true | Low-res LOD ring beyond the near grid. |
| Far Tile Multiplier | 4 | Each far tile covers 4×4 near tiles. |
| Far View Distance (tiles) | 3 | Far tile ring radius. 3 = 7×7 far tile grid. |
| Far Tile Resolution | 8 | Vertices per side on far tiles. 8 is sufficient at that range. |

### **WorldGen | Roads**

| **Property** | **Default** | **Description** |
| --- | --- | --- |
| Enable Roads | false | Generate a road network at BeginPlay and expand into newly discovered chunks. |
| Road Half Width (cm) | 800 | Corridor radius. Terrain flattened within this distance of road centerline. |
| Road Flatten Strength | 0.90 | How aggressively terrain flattens to road height. |
| Max Settlement Nodes | 6 | Number of flat sites found and connected. |
| Search Radius (chunks) | 6 | World radius scanned for settlement candidates. |
| Max Settlement Slope (deg) | 20 | Terrain steeper than this is rejected as a settlement site. |
| Road Z Offset (cm) | 10 | Height the road mesh floats above terrain. |
| Path Slope Sensitivity | 5.0 | How strongly A\* routing avoids slopes. Higher = roads follow valleys more aggressively. |
| Path Cell Size (tile fraction) | 0.25 | A\* grid resolution. Smaller = finer paths, slower generation. |
| Road Mesh | null | Static mesh per road segment (optional). |
| Road Material | null | Material for road mesh. |

### **WorldGen | Foliage**

| **Property** | **Default** | **Description** |
| --- | --- | --- |
| Enable Foliage | true | Master toggle. Disable for fast terrain iteration. |
| Foliage Assets | empty | Array of `UBiomeFoliageAsset` — one per biome. |

### **WorldGen | Grass _(V1.1)_**

| **Property** | **Default** | **Description** |
| --- | --- | --- |
| Enable Grass | true | Master toggle for the dense grass system. Disable for faster iteration. |
| Grass Assets | empty | Array of `UWorldGenGrassAsset` — one per grass type. |

### **WorldGen | Erosion _(V1.2)_**

| **Property** | **Default** | **Description** |
| --- | --- | --- |
| Enable Erosion | false | Apply hydraulic erosion to terrain heightmaps. Runs fully on the background thread. **Note (V1.6):** Erosion is automatically disabled at resolution ≤32 to prevent artifacts. |
| Droplets | 4,000 | Water droplets simulated per chunk. More = more detail, longer build time. |
| Erosion Strength | 0.3 | How aggressively droplets erode terrain. Higher = deeper channels. |
| Deposition Rate | 0.3 | How quickly droplets deposit sediment when slowing down. Higher = more valley fill. |
| Evaporation Rate | 0.05 | Rate at which droplet water evaporates each step. Higher = shorter, more localised erosion paths. |
| Sediment Capacity | 4.0 | Maximum sediment a droplet can carry per unit of speed and water. Higher = deeper valleys. |
| Inertia | 0.05 | Momentum factor. 0 = pure gradient descent (sharp channels). 0.05–0.1 = natural meandering. |
| Brush Radius | 3 | Erosion/deposition brush radius in vertices. Larger = smoother spread. |

* * *

## **What’s Fixed in V1.6**

### **Texture Stretching at Extreme Distance**

**Problem:** Diagonal checkerboard stretching pattern visible on terrain at extreme world distances (starting ~850K units away).

**Root Cause:** UV coordinates calculated using absolute world coordinates. At 2M+ units, single-precision floats lose precision in division operations, causing uneven texture sampling.

**Solution:** Use local coordinates (relative to chunk origin) for UV calculation.

**Before:**

```auto
const float WorldX = OriginX + (X * Step - Half);
UVs[I] = FVector2D(WorldX / TextureScale, WorldY / TextureScale);
// Precision loss at extreme distances

```

**After:**

```auto
const float LocalX = X * Step - Half;
UVs[I] = FVector2D(LocalX / TextureScale, LocalY / TextureScale);
// High precision with small numbers

```

**File:** `Plugins/WorldGen/Source/WorldGen/Private/WorldChunk.cpp` (lines 385–396)

**Video Tutorial:** See `TextureStretching_FloatingPointPrecision_Script.md` for a complete 14-minute debug walkthrough with visual aids.

* * *

### **Dynamic Road Expansion _(V1.6)_**

**Problem:** Roads only appeared in chunks present at `BeginPlay`. New chunks discovered during gameplay had no roads.

**Solution:** Implemented `ARoadNetwork::ExpandRoadsForChunk()` to automatically:

1. Scan newly loaded chunks for settlement candidates

2. Pathfind new roads to the existing road network

3. Skip expensive spline rebuilding (performance optimized)

**Result:** Roads now generate deterministically across the entire world as the player explores.

**Files Modified:**

- `RoadNetwork.cpp/h` — new `ExpandRoadsForChunk()` method

- `WorldStreamingManager.cpp` — calls `ExpandRoadsForChunk()` when chunks are acquired

* * *

### **Erosion Safety _(V1.6)_**

**Problem:** At resolution 32 and below, erosion simulation creates visible artifacts and random terrain spikes.

**Solution:** Automatically disable erosion when chunk resolution ≤ 32.

**File:** `WorldChunk.cpp` (line 192)

```auto
if (Erosion.bEnabled && Erosion.Droplets > 0 && Res > 32)
{
    // Erosion is disabled for resolution <= 32 because the output artifacts become unacceptable.
    // ... erosion simulation ...
}

```

**Recommendation:** Use LOD array `[256, 256, 128, 64]` to avoid problematic low resolutions.

* * *

## **Terrain Deformation _(V1.4)_**

WorldGen supports real-time terrain deformation via spherical brushes. Deformation is sculpted with height deltas that persist across chunk rebuilds and are compatible with all LOD resolutions.

### **Deformation API**

**Sculpt terrain:**

```auto
AWorldStreamingManager::DeformTerrain(
    FVector WorldPosition, // Center of deformation sphere
    float Radius, // Sphere radius in cm
    float Strength, // Height delta to apply (-1.0 to 1.0)
    float Falloff // Gradient softness (0–1). 1.0 = hard edge, 0.0 = smooth fade
)

```

**Remove all deformation:**

```auto
AWorldStreamingManager::ClearDeformation()

```

### **Usage Example**

```auto
// Raise terrain under the player by 500 cm with a 2000 cm radius
ManagerRef->DeformTerrain(PlayerPos, 2000, 5.0f, 0.8f);

// Lower terrain (negative strength) with hard edge
ManagerRef->DeformTerrain(PlayerPos, 500, -3.0f, 1.0f);

// Reset deformation
ManagerRef->ClearDeformation();

```

### **Deformation Notes**

- Deformation applies to all active chunks within the sphere radius.

- Height deltas are stored per-chunk and persist across terrain reloads and parameter changes.

- Deformation quality depends on chunk resolution — use higher LOD resolutions near the player for finer detail.

- Currently terrain deformation is **experimental** — expect polish in future versions.

* * *

## **Foliage Setup**

### **Creating a Biome Foliage Asset**

1. In Content Browser: **Add \> Miscellaneous \> Data Asset \> BiomeFoliageAsset**.

2. Set **Biome** to the terrain zone this asset covers (Grass, Rock, Snow, or Beach).

3. Add entries in the **Entries** array — one per foliage mesh.

4. Assign the asset to **WorldGen \> Foliage Assets** on the streaming manager.

### **FFoliageEntry Properties**

| **Property** | **Default** | **Description** |
| --- | --- | --- |
| Mesh | null | Static mesh to scatter. |
| Density | 0.002 | Instances per m². 0.002 ≈ 1 per 500 m². |
| Min/Max Normalized Height | 0–1 | Height range [0–1] where this entry appears. |
| Min/Max Slope Degrees | 0–30 | Slope range where this entry spawns. |
| Vertical Offset (cm) | 0 | Z offset after terrain snap. Negative = sink into ground. |
| Position Jitter (cm) | 0 | Extra random XY displacement per instance. |
| Scale Range | 0.8–1.2 | Random uniform scale min/max. |
| Seed Offset | 0 | Unique scatter pattern per entry. |
| View Distance (chunks) | 2 | Chunk radius within which this entry spawns. Trees: 3–4. Clutter: 1. |
| Grow in Shade | false | Allow spawning alongside other foliage. Enable for ground cover under trees. |
| Enable Collision | false | Enable collision on instances. Leave off for decorative props — only enable when the player needs to physically interact with this mesh. |

#### **Clustering**

| **Property** | **Default** | **Description** |
| --- | --- | --- |
| Enable Clustering | false | Clump instances around random centers. Natural for trees, shrubs, rock formations. |
| Cluster Count | 6 | Centers per chunk. |
| Cluster Radius (cm) | 5,000 | Instances beyond this radius from any center won’t spawn. |
| Cluster Falloff | 2.0 | Density drop-off from center to edge. 2 = smooth quadratic. |

### **Recommended Foliage Asset Setup**

| **Asset** | **Biome** | **Typical Entries** |
| --- | --- | --- |
| `DA_Foliage_Grass` | Grass | Large trees (density 0.001, View Distance 4), shrubs (density 0.003, View Distance 2), grass tufts (density 0.01, View Distance 1, Grow in Shade ✓) |
| `DA_Foliage_Rock` | Rock | Rock formations (density 0.002, clustering), cliff moss |
| `DA_Foliage_Snow` | Snow | Dead trees, snow-covered rocks |
| `DA_Foliage_Beach` | Beach | Driftwood, sea grass, shells |

* * *

## **Dense Grass System _(V1.1)_**

The dense grass system is a separate scatter layer from the foliage system. It uses a world-snapped ISM grid that moves with the player, giving density that is independent of terrain tile size. This allows hundreds of grass blades per square meter without being limited by chunk vertex count.

### **Creating a Grass Asset**

1. In Content Browser: **Add \> Miscellaneous \> Data Asset \> WorldGenGrassAsset**.

2. Assign a low-poly grass blade mesh to **Mesh**.

3. Set **Biome** to the terrain type where this grass should appear.

4. Assign the asset to **WorldGen \> Grass Assets** on the streaming manager.

Create one asset per grass type (e.g. green grass, dry grass, flowers, pebbles). Each asset spawns on its own independent grid and ISM component.

### **UWorldGenGrassAsset Properties**

| **Property** | **Default** | **Description** |
| --- | --- | --- |
| Biome | Grass | Terrain type this grass appears on (Grass, Rock, Snow, Beach). |
| Mesh | null | Static mesh to scatter. Use low-poly blade cards for best performance. |
| Density | 0.8 | Spawn probability per grid cell (0–1). 1.0 fills every grid point. |
| Min/Max Slope Degrees | 0–25 | Grass won’t spawn outside this slope range. 25° keeps grass off cliff faces. |
| Scale Range | 0.8–1.2 | Random scale per instance. |
| Vertical Offset (cm) | 0 | Z offset after terrain snap. Use small negative values to hide blade bases. |
| Align to Normal | true | Rotate blades to be perpendicular to the terrain surface rather than straight up. |
| Slope Sink Depth (cm) | 30 | Auto-sinks blades into terrain on slopes (proportional to sin of slope angle). Prevents floating on angled surfaces when Align to Normal is on. |
| Enable Collision | false | Enable collision on grass instances. Almost never needed — leave off. |
| Grass Resolution | 128 | Scatter grid points per axis. 128 = up to 16,384 grid points within the radius. |
| Grass Radius (cm) | 10,000 | Radius around the player within which this grass spawns. 10,000 cm = 100 m. |

### **Grass System Tips**

- Keep **Grass Radius** small (10,000–20,000 cm). A 20 m radius at 128 resolution produces dense coverage without overwhelming the ISM.

- **Slope Sink Depth 10–30 cm** prevents the most common floating blade issue on angled terrain. Pair with Align to Normal for best results.

- Use **2–3 grass assets** with different meshes (short, tall, wide) and offset seeds for natural variation.

- Grass does not need collision — leave **Enable Collision** off on all grass assets.

* * *

## **Hydraulic Erosion _(V1.2)_**

WorldGen’s erosion system simulates water droplets flowing down terrain slopes, picking up sediment and depositing it in valleys. This runs entirely on background threads — enabling erosion adds zero game-thread cost.

**What it produces:**

- Carved river valleys following natural drainage paths

- Sharp ridge erosion on mountain peaks

- Sediment fans and alluvial deposits in flat areas

- Smoother transitions between terrain features

**To enable:** Check **WorldGen \> Enable Erosion** on the streaming manager and click **Preview Terrain**.

**Note (V1.6):** Erosion is automatically disabled at resolution ≤ 32 to prevent artifacts. Use LOD array [256, 256, 128, 64] for best results.

### **Tuning Guide**

| **Goal** | **Parameters to adjust** |
| --- | --- |
| More dramatic valleys | Raise Erosion Strength, raise Sediment Capacity |
| Smoother, wider erosion | Raise Brush Radius (3–5), lower Erosion Strength |
| Longer river channels | Lower Evaporation Rate (0.01–0.03) |
| More sediment fans | Raise Deposition Rate (0.5–0.7) |
| Natural meandering | Inertia 0.05–0.1; higher = less wandering |
| Faster preview iteration | Lower Droplets to 1,000–2,000 for rough preview; raise to 8,000+ for final quality |

### **Erosion Performance Notes**

- Erosion runs on the background thread alongside mesh building — no game-thread cost.

- Build time scales linearly with Droplets. 4,000 droplets at Resolution 64 adds ~5–10ms per chunk on a modern CPU.

- Erosion does not affect collision accuracy — it modifies the heightmap before mesh and collision are built.

* * *

## **Multiplayer _(V1.3)_**

WorldGen supports both listen server and dedicated server multiplayer out of the box. No additional setup is required — place one `WorldStreamingManager` in your level as usual.

### **How It Works**

**Listen server / host:**

- The server player’s origin is detected via `GetStreamingOrigins()`.

- Terrain streams around all connected players simultaneously.

- Each player’s chunk position is tracked independently — a chunk loads if _any_ player is within range.

**Clients:**

- Each client runs its own `WorldStreamingManager` instance.

- On clients, `GetStreamingOrigins()` returns only the local player’s position, keeping each client responsible for its own terrain.

**Dedicated server:**

- Terrain is built for all connected players.

- The dedicated server skips all visual mesh data, foliage, and grass — it builds collision geometry only.

- This keeps server memory and CPU cost minimal while ensuring accurate physics for all players.

### **Per-Player Gravity Delay**

The **Terrain Load Delay** setting is applied per-player, including late joiners. When a new player connects, gravity is suspended for that controller for the delay duration, then restored. This prevents falling through terrain before async collision finishes cooking.

Increase **Terrain Load Delay** if players occasionally fall through terrain on first spawn.

### **Multiplayer Setup Checklist**

- Place one `WorldStreamingManager` in your level — no duplication needed.

- Ensure your **Game Mode** is compatible with the number of players you expect.

- If using a **dedicated server** , enable server support in your project packaging settings.

- **Do not set `bNetLoadOnClient = false`** on the streaming manager — this prevents clients from running their own terrain instance.

* * *

## **Performance Guide**

### **Recommended Settings by Target**

| **Target** | **Resolution** | **View Distance** | **LOD Array** | **Far Terrain** | **Foliage** | **Grass** |
| --- | --- | --- | --- | --- | --- | --- |
| High-end PC | 64–96 | 5–6 | [256,256,128,64] | On, FarVD 4 | Full | Radius 20,000, Res 256 |
| Mid-range PC | 64 | 4 | [256,256,128,64] | On, FarVD 3 | View Distance 2 max | Radius 10,000, Res 128 |
| Low-end / Console | 32–48 | 3 | [128,128,64,64] | On, FarVD 2 | View Distance 1 only | Radius 5,000, Res 64 |

**Note (V1.6):** Avoid resolution 32 in LOD array due to erosion artifacts. Minimum recommended is 64.

### **Key Performance Notes**

- **Resolution** is the biggest single cost. Going from 64 to 128 quadruples geometry per chunk.

- **Foliage View Distance** drives HISM instance count. Keep large trees at 3–4, dense ground clutter at 1.

- **Enable Foliage = false** during parameter tuning — rebuilds are 10× faster.

- `AddInstances` runs on the game thread. Keep per-biome instance counts below ~15,000 per chunk.

- Async collision is enabled by default. Do not disable it — it prevents game thread hitches on chunk load.

- **Grass Radius** is the primary grass cost lever. Halving the radius quarters the instance count.

- **Erosion** adds build time per chunk proportional to Droplets but zero game-thread cost. 4,000 droplets is a good production default.

- **Dedicated servers** skip all visual and foliage work — server memory scales only with collision geometry and connected player count.

* * *

## **Known Limitations (V1.6)**

- **Dense grass not supported via HISM at extreme density.** Keep Grass Radius reasonable (≤ 20,000 cm). Full GPU grass is a V2.0 feature.

- **Terrain deformation is experimental.** The feature is functional but may receive optimizations and UI polish in future releases.

- **Landscape Grass Tool incompatible.** WorldGen uses `ProceduralMeshComponent`, not UE’s `Landscape` — native Landscape Grass does not work.

- **Slope estimation in `SampleHeight()`** uses Layer 0 only — cheap approximation, not a full gradient.

- **No runtime parameter changes.** Changing noise layers, tile size, or LOD array at runtime requires calling `PreviewTerrain()` or triggering a full terrain rebuild.

- **Material required.** WorldGen provides vertex data only — you must build the terrain material yourself using the channel reference above.

- **Erosion is deterministic per-seed but not seamlessly continuous across chunks.** Each chunk is eroded independently — very wide river channels near chunk borders may not fully connect. This is a known architectural tradeoff of chunk-based streaming.

- **Multiplayer: all players must have the same terrain parameters.** `WorldStreamingManager` is not replicated — clients generate terrain independently using the same seed and settings. If parameters differ between client and server builds, terrain will not match.

- **Erosion disabled at resolution ≤ 32.** Low resolutions produce unacceptable artifacts. Use resolution ≥ 64.

* * *

## **FAQ**

**Q: My terrain has no foliage.** A: Check that your `BiomeFoliageAsset` has meshes assigned, the asset is in the `Foliage Assets` array, and `Enable Foliage` is on. Also verify `Rock Start` is above `Sea Level` — if Rock Start ≤ Sea Level the grass zone disappears.

**Q: I see green (grass) bleeding through the beach or underwater.** A: Set up the underwater mask using `AbsoluteWorldPosition` (see Material Setup above). The vertex color R channel alone causes interpolation artifacts on slopes crossing the waterline.

**Q: Chunk seams are visible.** A: This is usually the material, not the geometry. The mesh normals are seamless by design (1-vertex border overlap). Check that your material is not using an unsmoothed normal map.

**Q: Preview Terrain is slow.** A: Disable foliage (`Enable Foliage = false`) and reduce `View Distance` to 2 while iterating on noise parameters.

**Q: Road splines stay visible after I disable roads.** A: Click `Clear Terrain` — this also clears any existing road splines.

**Q: Can I use this in a shipped game?** A: Yes. FastNoise Lite (MIT licensed) is included in the plugin source. The license ships with purchasers automatically since the file is in the plugin tree.

**Q: My grass blades are floating above the terrain on slopes.** A: Enable **Align to Normal** on the grass asset and increase **Slope Sink Depth** (10–30 cm). The sink depth is proportional to the sine of the slope angle, so it automatically scales with steepness.

**Q: Grass only appears near the player’s starting position.** A: Check that `Enable Grass` is on and `Grass Assets` is populated. Also verify the `Biome` on each grass asset matches the terrain type at your spawn location — if Rock Start is too low, the spawn area may be rock-classified and grass assets with Biome = Grass won’t fire.

**Q: Enabling erosion causes terrain spikes or broken geometry.** A: This usually means the heightmap contains un-normalized values. Enable erosion only after verifying the default noise settings produce smooth terrain. Erosion operates on normalized [0–1] heights — extreme height scale values can produce instability. Try reducing `Erosion Strength` to 0.1 and `Droplets` to 1,000 first to confirm the effect before increasing.

**Q: Erosion makes every chunk look the same — no variation.** A: Erosion is seeded per chunk using the master seed, so each chunk erodes differently. If results look repetitive, the terrain may be too uniform before erosion. Add more noise layer variation or increase `WarpStrength` to create more distinct starting shapes.

**Q: In multiplayer, my client player falls through the terrain.** A: Increase **Terrain Load Delay** on the streaming manager. The delay is applied per-player and suspends gravity while async collision cooks. 4–6 seconds is usually sufficient; if players still fall through, increase further.

**Q: On a dedicated server, terrain generates but I see no foliage or grass.** A: This is intentional. Dedicated servers build collision-only geometry and skip all visual and foliage work to minimise server cost. Only clients receive foliage and visual meshes.

**Q: Two players see different terrain.** A: Ensure both builds (client and server) use identical `WorldStreamingManager` settings, especially `Seed`, `TileSize`, `Resolution`, and all noise parameters. Any difference in noise configuration will produce different terrain heights.

**Q: What is LOD and how do I use it?** A: LOD (Level of Detail) allows different terrain chunks to be built at different resolutions based on distance from the player. By default (V1.6), the player’s chunk is 256 vertices/side, adjacent chunks are 256, one ring out is 128, and distant chunks are 64. This keeps deformation quality high near the player without burning memory on distant terrain. Disable `Enable LOD` to revert to flat `Resolution` for all chunks.

**Q: How do I change LOD resolutions?** A: Edit the `LOD Resolutions` array on the streaming manager. Index 0 is the player’s chunk (Chebyshev distance 0), index 1 is one ring out (distance 1), etc. The last entry is reused for all further rings. For V1.6, the default [256, 256, 128, 64] is recommended — it avoids resolution 32 artifacts.

**Q: I’m getting poor deformation quality.** A: Deformation quality depends on chunk resolution. Enable LOD and set higher resolutions in the `LOD Resolutions` array for chunks near the player (e.g., `[256, 128, 64]` instead of `[128, 128, 64]`). Brush deformation on 256-resolution terrain is much finer than on 64-resolution terrain.

**Q: Can I blend deformation with erosion?** A: Yes. Deformation applies height deltas after erosion is evaluated. You can sculpt eroded terrain and the deltas persist through chunk reloads. Enable both `Enable Erosion` and sculpt with `DeformTerrain()` for combined effect.

**Q: Deformation is slow or hitchy.** A: Deformation rebuilds affected chunks immediately. If you’re deforming many chunks at once, space out `DeformTerrain()` calls across multiple frames or reduce the `Strength` to affect fewer chunks. Currently deformation is experimental — expect optimization in future versions.

**Q: Texture stretching at extreme distance — is it fixed?** A: Yes (V1.6). The fix changes UV calculation from world coordinates to local coordinates. This eliminates floating-point precision loss and the diagonal stretching pattern at 2M+ units. See BugFixes.md and the video tutorial for technical details.

**Q: Why are roads not appearing in newly discovered chunks?** A: If you’re on V1.5 or earlier, upgrade to V1.6. V1.6 adds `ExpandRoadsForChunk()` which automatically generates roads in newly loaded chunks as the player explores. The system is now complete and deterministic across the entire world.

* * *

## **Roadmap**

### **Completed**

| **Version** | **Date** | **Feature** |
| --- | --- | --- |
| V1.0 | 2025 | Infinite chunk streaming, layered noise, biome blending, water, beach, HISM foliage |
| V1.1 | 2026 | Dense ISM grass system with world-snapped radius grid, per-asset resolution/radius, slope sink |
| V1.2 | 2026 | Hydraulic erosion (particle droplet simulation, fully async, border-safe) |
| V1.3 | 2026 | Multiplayer support — multi-origin streaming, dedicated server collision-only mode, per-player gravity delay |
| V1.4 | 2026 | Terrain deformation (experimental), fixed texture world scale, fixed foliage grid placement |
| V1.5 | 2026 | Distance-based LOD system with configurable per-ring resolutions, seamless transitions, increased resolution support up to 256+ |
| V1.6 | 2026 | **Texture stretching fix** , **dynamic road expansion** , **erosion safeguard** , LOD optimization |

### **V1.7 — Editor Tooling _(Planned)_**

- Visual noise layer editor in the WorldGenEditor module

- Biome map preview texture rendered in-editor

- Better far terrain seam handling at horizon

### **V2.0 — PCG Grass & Production Roads _(Planned)_**

- PCG integration for GPU-side grass scatter

- Expose chunk heightmap data to a PCG graph

- Native UE5 frustum and distance culling for grass blades at full density

- Production-quality road network (A\* terrain-following, corridor foliage removal, bridges/tunnels)

### **V2.1 — PCG Biomes _(Planned)_**

- PCG-driven biome distribution with temperature and humidity maps

- River system

- Settlement system with road-connected villages

* * *

## **Credits**

**Plugin:** CodeLikeMe  
**Noise Library:** FastNoise Lite by Jordan Peck / Auburn (MIT License)  
**Engine:** Unreal Engine 5.4 by Epic Games

* * *

## **Want to Build It Yourself?**

The full system was built from scratch and documented step-by-step on the CodeLikeMe channel as the **WorldEngine — Runtime Infinite Terrain Generator** tutorial series. Every system in this plugin — the chunk pool, the noise stack, the foliage scatter — is covered in detail.

**Tutorial series:** [https://www.youtube.com/playlist?list=PLNTm9yU0zou6B6eqrPrRjODBd2OD-BVsh](https://www.youtube.com/playlist?list=PLNTm9yU0zou6B6eqrPrRjODBd2OD-BVsh)

The plugin is for developers who want to skip straight to shipping. The series is for developers who want to understand every line.

---

<div class="post-metadata">

**Author:** ![Pryzmski](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@Pryzmski](https://forums.unrealengine.com/u/Pryzmski)\
**Post date:** [June 16, 2026, 12:29am UTC](https://forums.unrealengine.com/t/assetpro-worldgen-runtime-procedural-infinite-terrain-generator/2719382/5 "2026-06-16T00:29:39Z")

</div>

Great asset however currently the road system is pretty broken and creates weird floating looping twisted roads, terrain clipping and other issues, hopefully this can be improved, apart from that an amazing asset.

---

<div class="post-metadata">

**Author:** ![DigitalWorlds](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@DigitalWorlds](https://forums.unrealengine.com/u/DigitalWorlds)\
**Post date:** [July 15, 2026, 6:08am UTC](https://forums.unrealengine.com/t/assetpro-worldgen-runtime-procedural-infinite-terrain-generator/2719382/6 "2026-07-15T06:08:41Z")

</div>

## **What’s New in V1.7**

### **Grass System Overhaul _(V1.7)_**

[Grass System Upgrade — Natural Tree Clustering & World-Space Grid | WorldGen 1.7.1](https://youtu.be/HdwEuup45oU)

[![image](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/2/1/221eeb131ba34c31df43f88463820a54762cce91.png)](https://youtu.be/HdwEuup45oU)

| **Change** | **Impact** |
| --- | --- |
| **GrassGridSize replaces GrassResolution** | Grid spacing is now a fixed world-space distance in cm, independent of GrassRadius. Two assets with different radii but the same GrassGridSize land on identical world positions — no z-fighting when stacking near/far trees. |
| **Natural Clustering** | New `bCluster`, `NumClusters`, `ClusterRadius`, and `ClusterFalloff` properties on `WorldGenGrassAsset`. Instances clump around world-space-fixed cluster centers — walk away and come back, same trees. |
| **Position Jitter** | Extra random XY displacement per instance, with terrain height resampled at the jittered position. Breaks up the regular grid feel. |

### **Foliage System Fixes _(V1.7)_**

| **Fix** | **Impact** |
| --- | --- |
| **Foliage on new chunks as player moves** | Chunks now track the ChebDist they were built with. When a chunk crosses into `MaxFoliageDistance` range as the player approaches, it rebuilds with foliage. Previously foliage only appeared on the initial chunk set. |
| **ISM replaces HISM for chunk foliage** | Chunk foliage now uses `UInstancedStaticMeshComponent` instead of `UHierarchicalInstancedStaticMeshComponent`. Eliminates the BVH rebuild game-thread spike on chunk load. |
| **bUseHISM toggle per entry** | Advanced toggle on `FFoliageEntry` for users who want HISM culling on high-density entries. Off by default — only useful for non-Nanite meshes with very high instance counts per chunk. |
| **MaxFoliageDistance** | New streaming manager property controls how many chunks from the player receive foliage. Chunks outside this range are built without foliage until the player approaches. |

### **Custom Noise Library _(V1.7)_**

| **Change** | **Impact** |
| --- | --- |
| **CLMNoise replaces FastNoise Lite** | Replaced the third-party FastNoise Lite library with CLMNoise — a purpose-built, license-free noise engine with no external dependencies. Supports Perlin, Simplex, Cellular, Ridged Multifractal, and Domain Warp. Identical API, identical output — zero migration required. |

---

<div class="post-metadata">

**Author:** ![DigitalWorlds](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@DigitalWorlds](https://forums.unrealengine.com/u/DigitalWorlds)\
**Post date:** [July 15, 2026, 6:13am UTC](https://forums.unrealengine.com/t/assetpro-worldgen-runtime-procedural-infinite-terrain-generator/2719382/7 "2026-07-15T06:13:05Z")

</div>

## **What’s New in V1.8**

### **Exclusion Volumes _(V1.8)_**

[How to Place Buildings & Dungeons in a Procedural Open World | WorldGen - Exclusion Volumes| UE5](https://youtu.be/bs77lphvyUY)

[![image](https://d3kjluh73b9h9o.cloudfront.net/original/4X/4/1/0/410ac98869aa416236733612938bc2f5cec899f1.png)](https://youtu.be/bs77lphvyUY)

| **Feature** | **Description** |
| --- | --- |
| **AWorldGenExclusionVolume** | Place a box actor in your level to carve a clean area out of the procedural world. Terrain flattens to the volume’s Z height, foliage and grass are suppressed inside. Use to place hand-authored villages, dungeons, streaming levels, and quest locations without procedural content fighting your content. |
| **Auto Flatten Height** | Volume automatically uses its own Z location as the target flatten height. Move the volume to the desired floor level — no manual height entry needed. |
| **Smooth Blend Radius** | Configurable blend radius outside the box edge. Terrain ramps smoothly from flat inside to natural outside — no hard cliff at the boundary. |
| **Terrain / Foliage toggle** | Flatten Terrain and Suppress Foliage/Grass are independently toggleable. Use as a full exclusion zone (flat + clean) or a foliage-only exclusion zone (natural terrain shape, no foliage). |
| **Works with PreviewTerrain** | Exclusion zones are collected and applied in both Play mode and editor Preview Terrain — no Play required to visualise the result. |

---

<div class="post-metadata">

**Author:** ![DigitalWorlds](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@DigitalWorlds](https://forums.unrealengine.com/u/DigitalWorlds)\
**Post date:** [July 15, 2026, 6:21am UTC](https://forums.unrealengine.com/t/assetpro-worldgen-runtime-procedural-infinite-terrain-generator/2719382/8 "2026-07-15T06:21:56Z")

</div>

## **What’s New in V1.9**

[Spawn Resources & NPCs in a Procedural Open World | UE5](https://youtu.be/Eio92iwp0GM)

[![image](https://d3kjluh73b9h9o.cloudfront.net/original/4X/0/d/c/0dc5e37fb41cf2466c192e4b34a2ab7eef7a515a.png)](https://youtu.be/Eio92iwp0GM)

### **Terrain Query API**

| **Feature** | **Description** |
| --- | --- |
| **`SampleTerrainAt(FVector2D WorldPos)`** | Returns `FHeightmapSample` with height, slope, surface normal, normalized height, and all biome blend weights (Grass/Rock/Snow/Beach/Water). Accounts for HeightScale, beach flattening, exclusion zones, and terrain deformation. |
| **`GetHeightAtWorldPos(FVector2D WorldPos)`** | Returns terrain world Z at any XY position. Synchronous, safe to call every frame. |
| **Biome weights in `FHeightmapSample`** | `GrassWeight`, `RockWeight`, `SnowWeight`, `BeachWeight`, `WaterWeight` — match the vertex color channels used by the terrain material. |

### **Actor Spawner System**

| **Feature** | **Description** |
| --- | --- |
| **`UWorldGenSpawnerAsset`** | Data asset defining an Actor class to scatter around the player. Same pattern as GrassAssets and FoliageAssets — assign to `WorldStreamingManager::SpawnerAssets`. |
| **Biome / slope / height filtering** | Uses `SampleTerrainAt()` to validate each candidate position before spawning. |
| **World-snapped deterministic grid** | Same seed → same positions every run. Walk away and come back — same actors in the same spots. |
| **Rate-limited streaming** | `MaxSpawnsPerFrame` prevents hitching when entering a dense area. Actors outside `SpawnRadius` are automatically destroyed. |
| **Exact surface placement** | Line trace finds the exact terrain collision surface — accounts for mesh discretization and beach flattening. |
| **Consumed positions** | `MarkSpawnConsumed()`, `GetConsumedSpawnKeys()`, `RestoreConsumedSpawnKeys()` — track mined/collected actors and persist across sessions via your save game. |

> **Note:** The Actor Spawner is single-player only in V1.9. Multiplayer replication is planned for V1.10.

* * *

## **Terrain Query API**

### **`SampleTerrainAt()`**

```auto
UFUNCTION(BlueprintCallable, Category = "WorldGen|Query")
FHeightmapSample SampleTerrainAt(FVector2D WorldPos) const;

```

Returns full terrain data at a world XY position. Accounts for HeightScale, beach flattening, exclusion zone flattening, and terrain deformation deltas.

**`FHeightmapSample` fields:**

| **Field** | **Type** | **Description** |
| --- | --- | --- |
| `Height` | float | World Z in cm. |
| `NormalizedHeight` | float | 0–1 between MinHeight and MaxHeight. |
| `Slope` | float | Surface slope in degrees. 0 = flat, 90 = vertical cliff. |
| `Normal` | FVector | Surface normal vector. |
| `GrassWeight` | float | Grass biome blend weight [0–1]. Matches VertexColor.G. |
| `RockWeight` | float | Rock biome blend weight. Matches VertexColor.B. |
| `SnowWeight` | float | Snow biome blend weight. Matches VertexColor.A. |
| `BeachWeight` | float | Beach blend weight. Matches UV1.x. |
| `WaterWeight` | float | Water blend weight. 1.0 below sea level. Matches VertexColor.R. |

### **`GetHeightAtWorldPos()`**

```auto
UFUNCTION(BlueprintCallable, Category = "WorldGen|Query")
float GetHeightAtWorldPos(FVector2D WorldPos) const;

```

Returns terrain world Z at any world XY. Equivalent to `SampleTerrainAt(WorldPos).Height`.

### **Usage Examples**

**Spawn an actor on terrain:**

```auto
float Z = Manager->GetHeightAtWorldPos(FVector2D(X, Y));
GetWorld()->SpawnActor<AMyActor>(MyClass, FVector(X, Y, Z), FRotator::ZeroRotator);

```

**Spawn only in grass biome on flat ground:**

```auto
FHeightmapSample S = Manager->SampleTerrainAt(FVector2D(X, Y));
if (S.GrassWeight > 0.5f && S.Slope < 20.f)
    GetWorld()->SpawnActor<AMyActor>(MyClass, FVector(X, Y, S.Height), FRotator::ZeroRotator);

```

* * *

## **Actor Spawner System**

### **Creating a Spawner Asset**

1. In Content Browser: **Add \> Miscellaneous \> Data Asset \> WorldGenSpawnerAsset**
2. Set the properties below.
3. Assign to **WorldGen|Spawner \> Spawner Assets** on the streaming manager.

Create one asset per actor type. Each asset has its own grid, radius, and filtering rules.

### **`UWorldGenSpawnerAsset` Properties**

| **Property** | **Default** | **Description** |
| --- | --- | --- |
| **Actor Class** | null | Actor class to spawn. |
| **Biome** | Grass | Terrain biome where this actor appears. |
| **Density** | 0.05 | Spawn probability per grid cell (0–1). Keep low — these are real Actors, not ISM instances. 0.05 = 5% of grid cells. |
| **Grid Size (cm)** | 5000 | World-space distance between spawn candidate positions. 5000 = one candidate every 50 m. |
| **Spawn Radius (cm)** | 50000 | Player radius within which actors are spawned and maintained. Actors outside this distance are destroyed. |
| **Min/Max Normalized Height** | 0–1 | Height range [0–1] where this actor can appear. |
| **Min/Max Slope Degrees** | 0–30 | Slope range. 30 = keeps actors off steep cliffs. |
| **Vertical Offset (cm)** | 0 | Z offset after terrain snap. |
| **Seed Offset** | 0 | Change for a different scatter pattern. |
| **Max Spawns Per Frame** | 3 | Limits how many actors spawn per frame. Prevents hitching when entering a dense area. |

### **Streaming Behaviour**

The spawner uses a **world-snapped grid** — positions are derived from `floor(WorldPos / GridSize) * GridSize`. The same world position always produces the same seeded RNG decision, so positions are deterministic regardless of player path.

When the player moves more than 200 cm, `UpdateSpawners()` runs:

1. Destroy any actors outside `SpawnRadius` or already destroyed
2. For each grid cell within radius: check consumed set → RNG density → slope → height → biome → line trace → spawn

### **Consumed Positions**

Actors that the player mines, collects, or destroys can be permanently suppressed using the consumed key system.

**Mark a position consumed (call when player interacts):**

```auto
// WorldPos = the spawned actor's XY location
// Asset = the WorldGenSpawnerAsset that spawned it
Manager->MarkSpawnConsumed(FVector2D(Actor->GetActorLocation()), SpawnerAsset);

```

**Save consumed positions:**

```auto
// In your save game logic:
TArray<int64> Keys = Manager->GetConsumedSpawnKeys();
// → write Keys to your USaveGame object

```

**Restore on load:**

```auto
// After loading your save game, before Play:
Manager->RestoreConsumedSpawnKeys(LoadedKeys);

```

The consumed key list is your game’s responsibility to persist. WorldGen provides the list and the lookup — your save system reads and writes it.

### **Performance Notes**

- Keep **Density** below 0.1 for actors with ticking components. Unlike grass (thousands of ISM instances), actors have real game-thread cost.
- **Max Spawns Per Frame = 3** means entering a dense area spawns actors gradually over several player steps, not all at once.
- **Line trace** is called once per actor lifetime (on first spawn). At 3 spawns per 200 cm of movement, this is negligible.
- **Grid Size 5000+ cm** is recommended. Smaller grids increase iteration cost during `UpdateSpawners`.

### **Recommended Configurations**

| **Asset** | **Biome** | **Density** | **Grid Size** | **Radius** | **Use** |
| --- | --- | --- | --- | --- | --- |
| DA\_IronOre | Rock | 0.08 | 8000 cm | 60000 cm | Mining resource |
| DA\_Mushroom | Grass | 0.12 | 3000 cm | 20000 cm | Harvestable plant |
| DA\_EnemySpawn | Rock | 0.03 | 15000 cm | 80000 cm | Enemy camp site |
| DA\_Flower | Beach | 0.20 | 2000 cm | 10000 cm | Ambient flora |

### **Limitations (V1.9)**

- **Single-player only.** The spawner runs independently on each machine in multiplayer — actors are not replicated. Multiplayer-safe spawning (server-authoritative, replicated consumed keys) is planned for V1.10.
- Consumed positions are **session-only** by default. Use `GetConsumedSpawnKeys()` and `RestoreConsumedSpawnKeys()` to persist across sessions.
- Moving a spawner asset’s `GridSize` or `SeedOffset` at runtime invalidates existing consumed keys (different keys for the same world positions).

* * *

## **Parameter Reference — New in V1.9**

### **WorldGen | Spawner**

| **Property** | **Default** | **Description** |
| --- | --- | --- |
| Enable Spawner | true | Master toggle. |
| Spawner Assets | empty | Array of `UWorldGenSpawnerAsset`. |

### **WorldStreamingManager — New Blueprint Functions**

| **Function** | **Category** | **Description** |
| --- | --- | --- |
| `SampleTerrainAt(WorldPos)` | WorldGen | Query |
| `GetHeightAtWorldPos(WorldPos)` | WorldGen | Query |
| `MarkSpawnConsumed(WorldPos, Asset)` | WorldGen | Spawner |
| `GetConsumedSpawnKeys()` | WorldGen | Spawner |
| `RestoreConsumedSpawnKeys(Keys)` | WorldGen | Spawner |

* * *

---

<div class="post-metadata">

**Author:** ![DigitalWorlds](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@DigitalWorlds](https://forums.unrealengine.com/u/DigitalWorlds)\
**Post date:** [July 15, 2026, 6:27am UTC](https://forums.unrealengine.com/t/assetpro-worldgen-runtime-procedural-infinite-terrain-generator/2719382/9 "2026-07-15T06:27:10Z")

</div>

[WorldGen 1.9.1 — Mined Resources That Don’t Respawn | Consumed Spawn Positions | UE5](https://youtu.be/azzsxiYWkbk)

[![image](https://d3kjluh73b9h9o.cloudfront.net/original/4X/c/d/a/cda2eed35c91e2f805c62242847ae4276eaa4088.png)](https://youtu.be/azzsxiYWkbk)

WorldGen’s spawner system now tracks consumed positions — ore nodes, harvestable plants, and any actor the player mines or collects won’t respawn in the same spot. Full save/load support with three Blueprint calls.

---

<div class="post-metadata">

**Author:** ![DigitalWorlds](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@DigitalWorlds](https://forums.unrealengine.com/u/DigitalWorlds)\
**Post date:** [July 15, 2026, 6:28am UTC](https://forums.unrealengine.com/t/assetpro-worldgen-runtime-procedural-infinite-terrain-generator/2719382/10 "2026-07-15T06:28:32Z")

</div>

# 🌍 WorldGen V1.10 — Spatial Biomes

**Runtime infinite terrain for UE5 (5.4–5.7) — generates and streams while your game runs, no baking, no loading screens.**

V1.10 is out, and the headline feature is **Spatial Biomes** : your world now shifts between four climate zones as you explore — with smooth gradients and **zero material rework**.

## Spatial Biomes

[Spatial Biomes for Infinite Procedural Terrain in UE5](https://youtu.be/-5eJZ4bmPrs)

[![image](https://d3kjluh73b9h9o.cloudfront.net/original/4X/8/f/5/8f502b268a877aa909a168b3f2766969bde2eb9c.png)](https://youtu.be/-5eJZ4bmPrs)

Two independent noise fields sample every terrain vertex:

- **Temperature** — cold ↔ hot (~3 km zones)
- **Moisture** — dry ↔ wet (~5 km zones)

Those two axes give you four corners:

| | Dry | Wet |
| --- | --- | --- |
| **Cold** | Tundra | Boreal |
| **Hot** | Desert | Tropical |

Everything _between_ corners is bilinearly interpolated — no hard borders, no seams. Terrain gradually turns from snowy tundra into boreal forest into lush tropics as you walk.

Each biome drives three things:

- **Snow Start** — how far down snow creeps (Tundra caps at ~15% height; Desert basically never)
- **Rock Start** — where exposed rock begins
- **Grass Mult** — ground-cover density (Tropical lush at 1.4×, Tundra/Desert sparse at 0.2×)

## Desert Sand — no material changes

Desert zones get a sandy floor that fades out with elevation. It rides the **same UV1.x channel as the existing beach layer** — so if your material already handles beaches, sand just works. Nothing to rewire.

## The best part: one checkbox

1. Enable **WorldGen → Biomes → Enable Spatial Biomes**
2. Hit **Preview Terrain**

It’s **off by default and fully backward compatible** — existing projects are untouched until you flip it on. Reuses the current vertex-color / UV channels (no shader rework), and it’s deterministic + async like everything else in WorldGen: streams around the player, never blocks the game thread.

## Everything else still in the box

Infinite async chunk streaming · hydraulic erosion · distance LOD · multiplayer (dedicated + listen) · real-time terrain deformation · exclusion volumes for hand-authored POIs · terrain query API + actor spawner · CLMNoise (no third-party dependencies).

---

<div class="post-metadata">

**Author:** ![DigitalWorlds](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@DigitalWorlds](https://forums.unrealengine.com/u/DigitalWorlds)\
**Post date:** [July 15, 2026, 6:43am UTC](https://forums.unrealengine.com/t/assetpro-worldgen-runtime-procedural-infinite-terrain-generator/2719382/11 "2026-07-15T06:43:33Z")

</div>

# [🧭 WorldGen V1.11 — Runtime Navigation Mesh](https://youtu.be/yLKdvkNyHBg)

[![image](https://d3kjluh73b9h9o.cloudfront.net/original/4X/a/f/a/afa7133129eb470f4458c3fdd96c8d8009ddba34.png)](https://youtu.be/yLKdvkNyHBg)

**Runtime infinite terrain for UE5 — generates and streams while your game runs.**

V1.11 brings AI navigation to the infinite world: a navmesh that **streams and follows the player** just like the terrain does.

## Runtime Navigation Mesh

One checkbox on `WorldStreamingManager` spawns and manages an `ANavMeshBoundsVolume` that:

- **Follows the player** and stays centered on the active streaming area
- **Restricts its Z extent to above sea level** — no wasted navmesh under the ocean
- Uses **Nav Invokers** for demand-driven tile generation, so nav tiles build on the fly around the player instead of all at once

Your AI can path across procedurally streamed terrain with no manual navmesh setup and no baking.

## Setup

1. Enable it on the `WorldStreamingManager`
2. Set **Project Settings → Navigation System → Runtime Generation = Dynamic**

## Honest note (Experimental)

Runtime navigation is marked **Experimental**. At very large tile sizes (the 2 km default), Unreal’s own runtime navmesh only covers part of the area around the player — a UE Recast limitation, not a WorldGen one. For reliable coverage today, use a **smaller tile size / view distance**. It’s off by default, so nothing changes in existing projects until you turn it on.

---

<div class="post-metadata">

**Author:** ![DigitalWorlds](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@DigitalWorlds](https://forums.unrealengine.com/u/DigitalWorlds)\
**Post date:** [July 15, 2026, 6:46am UTC](https://forums.unrealengine.com/t/assetpro-worldgen-runtime-procedural-infinite-terrain-generator/2719382/12 "2026-07-15T06:46:29Z")

</div>

# 🛣 WorldGen V1.12 — Procedural Roads & Settlements

**Runtime infinite terrain for UE5 — no baking, no loading screens.**

V1.12 grows a **road network** across your infinite world — settlements and the roads between them, all generated from the world seed.

[Roads That Build Themselves — Procedural Roads in UE5](https://youtu.be/jBjgRP4tObk)

[![image](https://d3kjluh73b9h9o.cloudfront.net/original/4X/d/9/a/d9ad1c3905b360f4aca5afbd2a414b4737d4e9f8.png)](https://youtu.be/jBjgRP4tObk)

[Procedural Roads Are Easy. Junctions Are Not — Until Now.](https://youtu.be/MeMKtE15Lyg)

[![image](https://d3kjluh73b9h9o.cloudfront.net/original/4X/d/f/5/df579f6d3cac48e6668b1551b4661aa3370aa728.png)](https://youtu.be/MeMKtE15Lyg)

## Deterministic settlements

Settlements are placed **deterministically from the world seed** — infinite, reproducible, and **seam-free with no global pass**. Every chunk computes the same network near it, so roads line up perfectly across chunk borders no matter which direction you explore from.

## Roads that follow the land

- Towns are connected by a planar **Relative Neighborhood Graph** — no crossings, fully connected, ≤4 roads per town
- Routed with **slope-weighted A\*** : prefers valleys, avoids water, and rides **above water as a causeway** when it has to cross
- Terrain is **graded to every road** — flat bed, feathered shoulders, and a painted `UV1.G` tarmac weight — plus a flat pad graded around each settlement

## Junctions

Two-road towns become one continuous **through-road** ; three- and four-road towns add perpendicular **T-branches**. Everything renders as **spline-mesh roads** with uniform tiling, bed-matched width, and optional near-player collision.

---

<div class="post-metadata">

**Author:** ![DigitalWorlds](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@DigitalWorlds](https://forums.unrealengine.com/u/DigitalWorlds)\
**Post date:** [July 15, 2026, 6:48am UTC](https://forums.unrealengine.com/t/assetpro-worldgen-runtime-procedural-infinite-terrain-generator/2719382/13 "2026-07-15T06:48:36Z")

</div>

# 🌉 WorldGen V1.13 — Bridges, Props & Data Assets

**Runtime infinite terrain for UE5 — streams around the player, never blocks the game thread.**

V1.13 is a big road upgrade: **bridges over water** , **roadside props** , reusable **data assets** , and completely **hitch-free** road streaming.

## Bridges

 ![image](https://d3kjluh73b9h9o.cloudfront.net/original/4X/f/6/8/f68821783d53890d52f32d1670f7c9e43aa2fead.jpeg)

Roads now **span water** instead of grading the seabed up to meet them. Bridge spans use their own **mesh + material** and are detected for free from the road’s clamped height — no extra terrain sampling. Optional **gorge bridging** handles deep land gaps too, and **pylons** drop to the ground via extend-to-ground props.

## Roadside props

Instanced meshes scattered along every road — light poles, mile posts, guard rails, bollards, pylons — each with per-type **spacing, side offset, both-sides + flip, scale, rotation, snap/extend-to-ground, bridge/non-bridge filters, and optional collision**.

## Road & settlement data assets

All road/bridge/prop look-and-feel lives on a `WorldGenRoadAsset`; settlement placement on a `WorldGenSettlementAsset`. **Assign once on the manager, reuse across levels.**

## Hitch-free streaming

Road mesh building is **time-sliced across frames** , and collision cooks only in a **sliding window around the player** — no spike on region load or when you step onto a bridge.

### 🔧 V1.13.1 point release

- **Per-instance collision range** for grass & foliage: one asset with a large radius + a small **Collision Range** gives a full visual field with physics only on instances near the player — replacing the old two-asset near/far trick (no doubled instances, no z-fighting)
- Fixed grass/foliage sinking below terrain at chunk borders on slopes
- Noise-sampling performance pass

---

<div class="post-metadata">

**Author:** ![DigitalWorlds](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@DigitalWorlds](https://forums.unrealengine.com/u/DigitalWorlds)\
**Post date:** [July 15, 2026, 6:50am UTC](https://forums.unrealengine.com/t/assetpro-worldgen-runtime-procedural-infinite-terrain-generator/2719382/14 "2026-07-15T06:50:32Z")

</div>

# 🌵 WorldGen V1.14 — Climate-Driven Foliage & Terrain Shaping

**Runtime infinite terrain for UE5.**

V1.14 makes the Spatial Biomes from V1.10 actually **shape what grows** — and the **land itself**. Cactus only in deserts, pine only in the boreal north, deserts that flatten into plains.

[Per-Biome Geography & Foliage](https://youtu.be/pV6OBQsXN6A)

[![image](https://d3kjluh73b9h9o.cloudfront.net/original/4X/7/8/5/78573487093c12c43c76ff626e999ff4ba8847be.png)](https://youtu.be/pV6OBQsXN6A)

## Climate biome filtering for foliage & grass

Each foliage _entry_ and each grass _asset_ gets a **Climate Biomes** bitmask (Tundra / Boreal / Desert / Tropical). Combined with the surface biome (grass/rock/snow/beach), it picks a cell of the biome matrix — e.g. **cactus in Desert only, pine in Boreal only**. Default is _all climates_, and it only filters when **Enable Spatial Biomes** is on, so existing assets are untouched.

## Biome Blend (sharpen)

A new control sharpens the temperature/humidity fields so each biome has a **flat 100% interior** and blends only at its edges — distinct regions instead of one global gradient. Leave it at 0.5 for the original fully-smooth look.

## Per-biome terrain height shaping

- **Height Amplitude** — flattens a biome by compressing terrain toward sea level (deserts default flatter)
- **Height Bias** — nudges a flattened biome up or down so it can stay a plateau
- **Height Biome Sharpness** — how tightly the height transition follows the biome edge

Gentle by default, always **continuous and seam-free**. Because the shaping lives in the noise generator, the road network sits on the shaped ground (no berms), and `SampleTerrainAt()` / `GetHeightAtWorldPos()` reflect it too.

## New sample content

A **Cactus** mesh + materials and a Desert-only `DA_ISM_Cactus` foliage asset that demonstrates the climate filter, Pine/Tree set to their climates, and the demo map configured with biomes.

---

<div class="post-metadata">

**Author:** ![DigitalWorlds](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@DigitalWorlds](https://forums.unrealengine.com/u/DigitalWorlds)\
**Post date:** [August 10, 2026, 5:20am UTC](https://forums.unrealengine.com/t/assetpro-worldgen-runtime-procedural-infinite-terrain-generator/2719382/15 "2026-08-10T05:20:58Z")

</div>

**WorldGen V1.15 — Water Waves & Underwater is live**

[![WorldGen 1.15 waves](https://d3kjluh73b9h9o.cloudfront.net/original/4X/4/b/5/4b57c84d433da96444c6d78372528ca9b8bdb6cd.jpeg)](https://youtu.be/gO_Iq6o248s)

 ![HighresScreenshot00007](https://d3kjluh73b9h9o.cloudfront.net/original/4X/5/b/8/5b8f6495fcb00d22ae1a7488e02f44a518ef039d.jpeg)

 ![HighresScreenshot00006](https://d3kjluh73b9h9o.cloudfront.net/original/4X/1/2/6/12618d9aeb11882bbe9e3891cdf67c33840e8a88.jpeg)

 ![HighresScreenshot00005](https://d3kjluh73b9h9o.cloudfront.net/original/4X/a/4/6/a466f82cd1de324c430c53dfc2c0dd22967b60ca.jpeg)

 ![HighresScreenshot00004](https://d3kjluh73b9h9o.cloudfront.net/original/4X/f/1/4/f148c28b27f6f6d34960acdf0545983a10e7fb69.jpeg)

 ![HighresScreenshot00003](https://d3kjluh73b9h9o.cloudfront.net/original/4X/8/6/5/865452db23529e22f0eed44f1c32b66413671cf8.jpeg)

 ![HighresScreenshot00002](https://d3kjluh73b9h9o.cloudfront.net/original/4X/6/e/4/6e4649d208b6b0d495fc296d737478d2b642bac5.jpeg)

 ![HighresScreenshot00001](https://d3kjluh73b9h9o.cloudfront.net/original/4X/4/f/d/4fd7910d7fa9f81277c69ea8d4979d15d221d351.jpeg)

 ![HighresScreenshot00000](https://d3kjluh73b9h9o.cloudfront.net/original/4X/6/0/1/601f75adc04bb8af4bc3a632591357cea7981500.jpeg)

V1.15 is out. This one is focused on the water: real waves on the surface and a proper underwater view when you drop below it.

**Subdivided water & WPO waves**  
Turn on Subdivide Water and the flat water plane is swapped for a subdivided procedural surface (density set by Water Cell Size), so a water material can drive World Position Offset waves. The mesh follows the player and grid-snaps, so the waves don’t swim as you move. The flat single-quad plane stays available when the toggle is off.

**Wave Height**  
One manager value drives your water material’s WaveHeight scalar through a dynamic instance, and the same value feeds the underwater water level, so the waves and the underwater line stay in sync.

**Wet Zone Offset**  
Widen the shoreline wet/foam band (the water vertex-colour channel, VertexColor.R) above sea level, without moving the water plane, changing beach flattening, or affecting SampleTerrainAt(). Useful for a believable damp shoreline that reaches a bit further up the beach than the water itself.

**Underwater camera post-process**  
A bundled MPC\_WorldGen Material Parameter Collection carries WaterLevelZ (sea level plus Wave Height) and a per-frame CameraUnderwater factor. The included M\_UnderwaterPostProcess material tints and refracts the whole screen when the camera drops below the waterline. Assign it to an unbound Post Process Volume and it works.

All the V1.14 biome work, the road and settlement network, and everything before it are unchanged. Supports UE 5.4 through 5.8, full C++ source with Blueprint API.

Fab: [WorldGen — Infinite Procedural Terrain | Runtime Streaming | Multiplayer | UE5 | Fab](https://www.fab.com/listings/e4e93fbe-9326-40b8-a043-a809f788306a)

Happy to answer questions about the water material setup or the underwater post-process here.

---

<div class="post-metadata">

**Author:** ![user\_1d196b89c3b0b367b729fe69df94d8e9ea01af98f0e6d87e2e610d](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@user\_1d196b89c3b0b367b729fe69df94d8e9ea01af98f0e6d87e2e610d](https://forums.unrealengine.com/u/user_1d196b89c3b0b367b729fe69df94d8e9ea01af98f0e6d87e2e610d)\
**Post date:** [August 12, 2026, 10:49am UTC](https://forums.unrealengine.com/t/assetpro-worldgen-runtime-procedural-infinite-terrain-generator/2719382/16 "2026-08-12T10:49:13Z")

</div>

![QQ20260812-184853](https://d3kjluh73b9h9o.cloudfront.net/original/4X/5/5/0/550c61f23c9819cfd0ce9ac5ba69cadfac51920a.png)

Hello,Actually, I don’t want to know how you developed this plugin; I just want to understand how to use it. The video tutorials don’t provide any explanations on this. I’m having trouble figuring out how to use settlements and roads – I’ve tried several times but still can’t create roads or settlements.On your sample map as well, there are no settlements only roads.Why isn’t the grid information for it included in the data related to the settlement?

---

<div class="post-metadata">

**Author:** ![user\_1d196b89c3b0b367b729fe69df94d8e9ea01af98f0e6d87e2e610d](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@user\_1d196b89c3b0b367b729fe69df94d8e9ea01af98f0e6d87e2e610d](https://forums.unrealengine.com/u/user_1d196b89c3b0b367b729fe69df94d8e9ea01af98f0e6d87e2e610d)\
**Post date:** [August 12, 2026, 11:22am UTC](https://forums.unrealengine.com/t/assetpro-worldgen-runtime-procedural-infinite-terrain-generator/2719382/17 "2026-08-12T11:22:35Z")

</div>

![QQ20260812-184853](https://d3kjluh73b9h9o.cloudfront.net/original/4X/d/6/0/d60b5aa7320f10c29557ca68790a36eaf1737d72.jpeg)I am using UE5.7, and the flat terrain feature does not work.

---

<div class="post-metadata">

**Author:** ![DigitalWorlds](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@DigitalWorlds](https://forums.unrealengine.com/u/DigitalWorlds)\
**Post date:** [August 12, 2026, 11:41pm UTC](https://forums.unrealengine.com/t/assetpro-worldgen-runtime-procedural-infinite-terrain-generator/2719382/18 "2026-08-12T23:41:38Z")

</div>

Hi — thanks for the details, and sorry for the trouble. Both of these have simple explanations, let me walk through them.

**1. Roads & “settlements”**

The key thing to know: in WorldGen a **settlement is not a village of buildings**. It’s a **road-network node** — a flattened junction pad where up to 4 roads meet. The plugin generates the roads, the flattened junctions and (optionally) roadside props, but it does **not** place any building meshes. You add buildings yourself (by hand, or with the Actor Spawner). So on the sample map the settlements _are_ there — they’re the flat spots the roads converge on. That’s also why you “only see roads”: the settlement itself is just flat ground.

To actually see where the settlements are, open your **Road Asset** and tick **Show Debug Shapes** — you’ll get a tall marker and a blue junction square drawn on every settlement.

To generate roads at all, you need **all three** of these set on the **WorldStreamingManager → WorldGen | Roads** :

1. **Enable Roads** ✔
2. **Road Asset** — use the included **DA\_HighWay** (`WorldGen/Content/Data/`)
3. **Settlement Asset** — use the included **DA\_Settlement**

If any one of the three is empty, nothing is generated. If all three are set and you still get no roads near you, your terrain is probably too steep for a town: on the **Settlement Asset** , raise **Max Settlement Slope** , and lower **Settlement Cell (tiles)** for denser towns. Settlements only form on land that’s above sea level, below the snow line, and under that slope limit.

On “why the network/grid isn’t stored in the settlement data” — that’s by design. The road + settlement network is **not baked or saved** anywhere; it’s recomputed deterministically at runtime from the world **Seed** + **Settlement Cell (tiles)**. The data asset only holds the _rules_ (cell size, slope, flatten pad). The same seed always produces the same towns in the same places, everywhere, infinitely — which is what makes the world seamless and streamable. There’s nothing to store.

**2. “Flat terrain feature does not work” (Exclusion Volume)**

Good news first: I just tested this in a clean **UE 5.7** project and the Exclusion Volume flatten works correctly — it’s not a 5.7 bug (it behaves the same on every engine version).

What you’re seeing is a **resolution** issue. The Exclusion Volume flattens terrain **vertices** , and at the default settings (2 km tile, Resolution 128) the terrain vertices are about **15 m apart**. If your box is only a few meters across, it contains barely one vertex, so there’s essentially nothing to flatten and it looks like it does nothing.

Two ways to fix it:

- **Make the volume bigger** (and/or raise **Blend Radius** ) so it spans several vertices. At default resolution a clean flat pad wants to be well over ~50 m across; **or**
- **Increase terrain density** so vertices are closer together: raise **LOD Resolutions[0]** (e.g. 128 → 256) and/or lower **Tile Size** (e.g. 200000 → 100000). Either gives you a finer, crisper flat area.

Keep **Flatten Terrain** ✔ and **Flatten Strength = 1**. With **Auto Flatten Height** on, the terrain flattens to the volume’s Z height, so just move the volume up or down to set the floor level.

Hope that unblocks you — if the roads still don’t appear after setting all three assets, tell me your Settlement Cell / Max Slope values and I’ll help you tune them.

---

<div class="post-metadata">

**Author:** ![DigitalWorlds](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@DigitalWorlds](https://forums.unrealengine.com/u/DigitalWorlds)\
**Post date:** [September 14, 2026, 1:52am UTC](https://forums.unrealengine.com/t/assetpro-worldgen-runtime-procedural-infinite-terrain-generator/2719382/20 "2026-09-14T01:52:57Z")

</div>

**[WorldGen V1.16 — Roadside & Settlement Buildings is live](https://youtu.be/iPHaIF4jpZ0)**

[![WorldGen 1.16 Roadside Buildings](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/6/2/2623087f2a28609fb2aff2a13f9bcf5de307b20e.jpeg)](https://youtu.be/iPHaIF4jpZ0)

V1.16 is out on Fab. This update lets the Actor Spawner populate your road network, so buildings place themselves along roads and around settlements on infinite procedural terrain.

**Roadside and town buildings**  
A spawner asset can now target the road network. Proximity Target is set to Anywhere, Near a Road, or Near a Settlement junction, with an edge-to-edge proximity band controlling the gap between the road or town-pad edge and the building’s nearest wall. Align To Target faces buildings toward the road or the town centre, and Stay On Graded Shoulder keeps them standing on ground that was shaped for the road rather than floating or buried.

**Footprint-aware placement**  
Every spawn keeps its whole footprint (the actor’s real oriented box, measured from its meshes) off the tarmac, out of junction and settlement pads, and clear of other spawns. Rest On Ground sits the building on the surface whatever the mesh pivot.

**Automated test suite**  
A shippable WorldGenTestRunner actor (plus the WorldGen.RunTests console command and a -WorldGenTest launch switch) flies to junctions across the world, waits for terrain, roads and spawns to settle, then checks road continuity, overlaps, buried or floating tiles, missing meshes, open ports, seams and building placement. It captures a screenshot per junction and writes a JSON and text report, so you can run it on any map after any change.

**Road network fixes**  
A 28-junction sweep out to 90 km went from 91 defects to 0. Exit roads now build as soon as either town is in range, every road gets its own junction port, pads always cover the junction box, converging roads no longer float or sink on the approach, shore towns are raised to the road floor, and water bridges get graded abutments.

**Also included**  
Demo buildings (gas station, diner, shop row, warehouse) with ready-made spawner assets wired into the demo map, plus a diagnostics API (GetGradedHeightAt, GetSpawnedActorsForTest, IsStreamingIdle and road-network idle/junction getters).

Supports UE 5.4 through 5.8, full C++ source with Blueprint API.

Fab: [WorldGen - Infinite Procedural Terrain | Runtime Streaming | Multiplayer | UE5 | Fab](https://www.fab.com/listings/e4e93fbe-9326-40b8-a043-a809f788306a)

Happy to answer questions about the spawner setup or the road placement here.
