unreal-landscape

Unreal 5.8 Landscape

---
name: unreal-landscape
description: Operational Unreal Engine 5.8 guidance for Landscape creation and import, valid component topology, scale, sculpting, non-destructive Edit Layers, Landscape Patches and Splines, materials, Target Layers, physical surfaces, grass and foliage, Runtime Virtual Texturing, World Partition integration, Nanite Landscapes, collision, performance, and debugging. Use when designing, building, automating, profiling, or repairing terrain and outdoor-world workflows.
---

# Unreal 5.8 Landscape

## Ownership boundary

This skill owns heightfield topology, sculpt/paint state, Landscape materials, terrain collision, and
Landscape-specific Splines/Patches. Route generic path math to
[`unreal-splines`](../unreal-splines/SKILL.md), procedural population to
[`unreal-pcg`](../unreal-pcg/SKILL.md), and cell/source/Data Layer/HLOD policy to
[`unreal-world-partition`](../unreal-world-partition/SKILL.md).

Route a terrain task to the smallest relevant reference. Tie terrain decisions to gameplay traversal, sightlines, collision, navigation, streaming, and target-device budgets.

## Select the terrain representation

- Use **Landscape** for large heightfield terrain that needs efficient LOD, painting, foliage, collision, and world streaming.
- Use **Static Meshes/Nanite meshes** for caves, overhangs, vertical cliffs, floating geometry, small hero formations, or topology a heightfield cannot represent.
- Combine them: Landscape supplies broad traversable ground; meshes supply silhouettes and non-heightfield forms.
- Use **Landscape Splines** when a road/path must deform or paint terrain. Use a normal Spline Component when deformation is not required.
- Use **Landscape Patches** for procedural, non-destructive height/weight edits baked into the final Landscape.
- Use **PCG**, Landscape Grass, Foliage Mode, or Procedural Foliage according to output lifetime and authoring needs; do not let several systems own the same vegetation population.

Read [selector-import-layout.md](references/selector-import-layout.md) before creating or importing a Landscape.

## Route by task

| Need | Load |
|---|---|
| Choose terrain system, import/export, establish scale | [selector-import-layout.md](references/selector-import-layout.md) |
| Choose components, sections, quads, dimensions, resolution | [components-dimensions-scale.md](references/components-dimensions-scale.md) |
| Sculpt non-destructively; use Edit Layers or Patches | [edit-layers-sculpting-patches.md](references/edit-layers-sculpting-patches.md) |
| Build materials, paint Target Layers, physical surfaces | [materials-painting.md](references/materials-painting.md) |
| Select Landscape Grass, foliage painting, procedural foliage, or PCG | [grass-foliage-pcg.md](references/grass-foliage-pcg.md) |
| Build roads, water deformation, decals, and terrain/object blends | [splines-water-rvt.md](references/splines-water-rvt.md) |
| Stream Landscape with World Partition | [world-partition-streaming.md](references/world-partition-streaming.md) |
| Tune Nanite, LOD, collision, rendering, and memory | [nanite-performance-collision.md](references/nanite-performance-collision.md) |
| Diagnose artifacts and run production test gates | [debugging-patterns.md](references/debugging-patterns.md) |
| Verify claims and maturity | [sources.md](references/sources.md) |

## Execute in this order

1. State playable bounds, elevation range, smallest required terrain feature, movement agents, target hardware, and streaming model.
2. Choose Landscape versus mesh ownership for each terrain form.
3. Choose valid heightmap dimensions, component/section topology, XY vertex spacing, and Z scale before detailed authoring.
4. Enable Edit Layers at creation and define a named layer stack: base import, broad sculpt, gameplay corrections, splines, patches, and paint as needed.
5. Prove graybox traversal, slopes, sightlines, landmarks, collision, and navigation before expensive material/foliage work.
6. Build a small material layer contract and matching Layer Info assets; validate physical surfaces.
7. Add roads/water and other procedural deformation on dedicated special layers.
8. Add vegetation with one clear owner per population and explicit collision/nav/HLOD requirements.
9. Configure World Partition, Nanite, RVT, LOD, and collision only from measured needs.
10. Rebuild derived data and test a cooked target build through representative and worst-case routes.

## Hard rules

- Landscape is a heightfield. Do not force caves, overhangs, or arbitrary topology into it.
- **Edit Layers** store non-destructive height/weight edits; material **Target Layers** store named paint weights. Never use the terms interchangeably.
- Component count and section count have CPU/draw-call cost. More resolution is not free terrain detail.
- Do not rescale a finished Landscape casually. Scale changes invalidate assumptions about slope, texture density, foliage, collision, navigation, water, and world coordinates.
- Nanite does not remove the non-Nanite Landscape data. UE 5.8 retains both for systems including RVT and water, increasing streaming and memory requirements.
- A stale Nanite representation is not a trustworthy editor preview. Rebuild/save before visual or performance conclusions.
- Do not paint gameplay-critical surface identity only into an unvalidated visual material. Confirm Layer Info and physical-material results through traces and movement/audio tests.
- Do not use dense Actor Foliage for decoration; it costs like ordinary actors.
- Never tune Landscape in the editor alone. Profile cooked target builds for rendering, collision, navigation, streaming, memory, and shader compilation.

## Answer contract

Return:

1. **Selected representation and assumptions**.
2. **Topology and scale** — dimensions, components, sections, XY/Z scale, elevation range.
3. **Ownership** — Edit Layers, Target Layers, splines/patches, vegetation system, streaming.
4. **Exact actions and parameter effects**.
5. **Performance, collision, navigation, and packaging consequences**.
6. **Failure checks and recovery**.
7. **Verification** — visible and measured pass criteria on target hardware.

Do not invent a universal Landscape size, material-layer count, or component layout. Derive them from world extent, required precision, content density, and measured budgets.

## Ownership boundary

This skill owns heightfield topology, sculpt/paint state, Landscape materials, terrain collision, and
Landscape-specific Splines/Patches. Route generic path math to
[`unreal-splines`](/unreal/unreal-splines/), procedural population to
[`unreal-pcg`](/unreal/unreal-pcg/), and cell/source/Data Layer/HLOD policy to
[`unreal-world-partition`](/unreal/unreal-world-partition/).

Route a terrain task to the smallest relevant reference. Tie terrain decisions to gameplay traversal, sightlines, collision, navigation, streaming, and target-device budgets.

## Select the terrain representation

- Use **Landscape** for large heightfield terrain that needs efficient LOD, painting, foliage, collision, and world streaming.
- Use **Static Meshes/Nanite meshes** for caves, overhangs, vertical cliffs, floating geometry, small hero formations, or topology a heightfield cannot represent.
- Combine them: Landscape supplies broad traversable ground; meshes supply silhouettes and non-heightfield forms.
- Use **Landscape Splines** when a road/path must deform or paint terrain. Use a normal Spline Component when deformation is not required.
- Use **Landscape Patches** for procedural, non-destructive height/weight edits baked into the final Landscape.
- Use **PCG**, Landscape Grass, Foliage Mode, or Procedural Foliage according to output lifetime and authoring needs; do not let several systems own the same vegetation population.

Read [selector-import-layout.md](/unreal/unreal-landscape/selector-import-layout/) before creating or importing a Landscape.

## Route by task

| Need | Load |
|---|---|
| Choose terrain system, import/export, establish scale | [selector-import-layout.md](/unreal/unreal-landscape/selector-import-layout/) |
| Choose components, sections, quads, dimensions, resolution | [components-dimensions-scale.md](/unreal/unreal-landscape/components-dimensions-scale/) |
| Sculpt non-destructively; use Edit Layers or Patches | [edit-layers-sculpting-patches.md](/unreal/unreal-landscape/edit-layers-sculpting-patches/) |
| Build materials, paint Target Layers, physical surfaces | [materials-painting.md](/unreal/unreal-landscape/materials-painting/) |
| Select Landscape Grass, foliage painting, procedural foliage, or PCG | [grass-foliage-pcg.md](/unreal/unreal-landscape/grass-foliage-pcg/) |
| Build roads, water deformation, decals, and terrain/object blends | [splines-water-rvt.md](/unreal/unreal-landscape/splines-water-rvt/) |
| Stream Landscape with World Partition | [world-partition-streaming.md](/unreal/unreal-landscape/world-partition-streaming/) |
| Tune Nanite, LOD, collision, rendering, and memory | [nanite-performance-collision.md](/unreal/unreal-landscape/nanite-performance-collision/) |
| Diagnose artifacts and run production test gates | [debugging-patterns.md](/unreal/unreal-landscape/debugging-patterns/) |
| Verify claims and maturity | [sources.md](/unreal/unreal-landscape/sources/) |

## Execute in this order

1. State playable bounds, elevation range, smallest required terrain feature, movement agents, target hardware, and streaming model.
2. Choose Landscape versus mesh ownership for each terrain form.
3. Choose valid heightmap dimensions, component/section topology, XY vertex spacing, and Z scale before detailed authoring.
4. Enable Edit Layers at creation and define a named layer stack: base import, broad sculpt, gameplay corrections, splines, patches, and paint as needed.
5. Prove graybox traversal, slopes, sightlines, landmarks, collision, and navigation before expensive material/foliage work.
6. Build a small material layer contract and matching Layer Info assets; validate physical surfaces.
7. Add roads/water and other procedural deformation on dedicated special layers.
8. Add vegetation with one clear owner per population and explicit collision/nav/HLOD requirements.
9. Configure World Partition, Nanite, RVT, LOD, and collision only from measured needs.
10. Rebuild derived data and test a cooked target build through representative and worst-case routes.

## Hard rules

- Landscape is a heightfield. Do not force caves, overhangs, or arbitrary topology into it.
- **Edit Layers** store non-destructive height/weight edits; material **Target Layers** store named paint weights. Never use the terms interchangeably.
- Component count and section count have CPU/draw-call cost. More resolution is not free terrain detail.
- Do not rescale a finished Landscape casually. Scale changes invalidate assumptions about slope, texture density, foliage, collision, navigation, water, and world coordinates.
- Nanite does not remove the non-Nanite Landscape data. UE 5.8 retains both for systems including RVT and water, increasing streaming and memory requirements.
- A stale Nanite representation is not a trustworthy editor preview. Rebuild/save before visual or performance conclusions.
- Do not paint gameplay-critical surface identity only into an unvalidated visual material. Confirm Layer Info and physical-material results through traces and movement/audio tests.
- Do not use dense Actor Foliage for decoration; it costs like ordinary actors.
- Never tune Landscape in the editor alone. Profile cooked target builds for rendering, collision, navigation, streaming, memory, and shader compilation.

## Answer contract

Return:

1. **Selected representation and assumptions**.
2. **Topology and scale** — dimensions, components, sections, XY/Z scale, elevation range.
3. **Ownership** — Edit Layers, Target Layers, splines/patches, vegetation system, streaming.
4. **Exact actions and parameter effects**.
5. **Performance, collision, navigation, and packaging consequences**.
6. **Failure checks and recovery**.
7. **Verification** — visible and measured pass criteria on target hardware.

Do not invent a universal Landscape size, material-layer count, or component layout. Derive them from world extent, required precision, content density, and measured budgets.

unreal 5.8 landscape operational unreal engine 5.8 guidance for landscape creation and import, valid component topology, scale, sculpting, non-destructive edit layers, landscape patches and splines, materials, target layers, physical surfaces, grass and foliage, runtime virtual texturing, world partition integration, nanite landscapes, collision, performance, and debugging. use when designing, building, automating, profiling, or repairing terrain and outdoor-world workflows. components, dimensions, and scale components, dimensions, and scale topology landscape components are the base units for rendering, visibility, collision, and streaming proxies. all components in one landscape are square and use the same size. - a component uses one section or 2×2 sections. - a section is the unit of landscape lod transition. - each section is a draw call, and every component carries render-thread cpu cost. - valid component quad dimensions follow the landscape texture/mip layout: power-of-two vertices produce power-of-two-minus-one quads for one section, or power-of-two-minus-two component quads for 2×2 sections. - epic recommends no more than 1024 components for the largest landscapes; treat this as an upper guideline, not a target. use epic's valid-dimensions table or the creation ui rather than cropping an arbitrary image to “almost” fit. tradeoffs more, smaller components - finer culling and lod granularity; - smaller localized edit/stream units; - more component cpu overhead and potentially more section draw calls. fewer, larger components - lower component count; - coarser culling, lod, collision, and streaming granularity; - heavier individual visible/rebuild units. 2×2 subsections can provide the same terrain resolution with fewer components than four separate one-section components, but still create four section draw calls per component. xy scale xy scale defines vertex spacing in centimeters. at 100, adjacent vertices are one meter apart. - smaller spacing expresses smaller terrain features but covers less world area for the same heightmap and can increase pressure for more components. - larger spacing covers more area but produces coarser silhouettes, collision, slopes, and deformation. do not chase texture detail with geometry. use materials, normal/detail maps, meshes, decals, and vegetation for sub-vertex detail. z scale z scale maps 16-bit height values into world height. increasing it expands vertical range but also magnifies each height step and changes gameplay slopes. pick the range before sculpting and leave headroom for intentional edits. layout procedure 1. convert desired world width to centimeters. 2. choose the coarsest xy vertex spacing that still represents required gameplay terrain. 3. select a valid overall resolution and component topology that covers the extent. 4. calculate z scale from the source elevation range. 5. create a small representative slice with the intended topology. 6. test terrain silhouette, traversal, collision, navigation, lod, material, and edit speed. 7. profile component/section cost before committing the entire world. never infer from resolution alone two landscapes with the same vertex resolution can have different physical sizes, precision, component counts, and runtime behavior. always report resolution together with xy/z scale, section size, sections per component, and component count. debugging and production patterns debugging and production patterns diagnose by layer 1. topology — valid resolution, correct component/section layout, xy/z scale. 2. authoring stack — correct active edit layer, order, visibility, lock, alpha, procedural owner. 3. paint contract — material name, target layer, layer info type, filled base, weight data. 4. derived systems — splines, water, patches, grass/foliage/pcg, rvt, nanite, collision, navigation. 5. streaming — loaded region/proxy and dependent world partition cells. 6. runtime budget — shader, texture, virtual texture, geometry, shadow, instances, collision, i/o. useful visualizers and stats - landscape component/section/quads color overlays in manage mode. - view > landscape visualizers > layer debug for target layer channels. - lit > visualizers > layer contribution for edit layer contribution. - player collision and visibility collision view modes. - landscape.rendernanite 0/1 for controlled representation comparison. - stat virtualtexturing and stat virtualtexturememory for rvt. - stat unit, stat gpu, gpu visualizer, unreal insights. restore diagnostic overrides before final captures. common symptom table | symptom | first checks | |---|---| | tile seam/crack | source edge pixels, flip y, xy/z scale, proxy freshness, nanite skirt | | sculpt has no effect | wrong/locked edit layer, special procedural layer, alpha zero | | spline does not deform | missing spline edit layer, raise/lower disabled, width/falloff | | black/default material | compile error, missing layer info/base fill, sampler/permutation | | wrong physical surface | dominant target layer and physical material assignment | | grass missing | grass output name/mask, grass type, landscape-only boundary, culling | | rvt contribution missing | bounds, asset type, writer list, pass type, sort priority | | nanite visual stale | dirty proxy; build/save/cook nanite representation | | character floats/clips | collision mip or render displacement differs from collision | | navmesh breaks after sculpt | navigation not rebuilt or slope/step/agent settings no longer fit | production test matrix | axis | minimum cases | |---|---| | edit | sculpt/paint, undo, save/reload, layer reorder/hide, neighbor regions | | import | clean reimport, tiled seams, round-trip export, source checksum | | traversal | walk, fastest vehicle, steepest intended slope, world edge, teleport | | rendering | near/far, nanite on/off, scalability tiers, target feature levels | | surface | each target layer, transitions, traces, footsteps/effects | | derived | splines, water, patches, vegetation, pcg, nav, hlod/rvt | | build | pie, standalone, cooked development, shipping-equivalent target | | soak | repeated cross-world route and memory stabilization | acceptance - terrain supports intended mental map, sightlines, and traversal; - no missing collision or navigation at streaming/edit boundaries; - layer ownership is understandable and reversible; - derived data can be rebuilt reproducibly; - target frame, memory, disk, cook, and streaming budgets are met; - no final conclusion relies on stale nanite/rvt/nav/pcg data. edit layers, sculpting, and patches edit layers, sculpting, and patches edit layer contract landscape edit layers are stack-based, non-destructive containers for heightmap, weightmap, and visibility data. new landscapes enable them automatically in ue 5.8. the default project limit is eight and is configurable. use a small semantic stack, for example: text baseimport broadsculpt gameplaycorrections splineprocedural patchprocedural paintartdirection more layers increase evaluation, authoring, merge, and diagnosis cost. add a layer only when it represents distinct ownership or must be independently hidden/reordered. editing rules - lock completed/owned layers. - use visibility and layer contribution (lit > visualizers > layer contribution) to isolate effects. - record whether height/paint alpha is intentionally additive, subtractive, or zero. - erase on an edit layer removes that layer's contribution; it is not necessarily “sculpt terrain downward.” - collapse and collapse all layers are destructive. save/source-control before flattening. - deleting a layer deletes its height, weight, visibility, and assigned blueprint brush data. sculpting workflow 1. sculpt broad landforms before detail. 2. establish playable grades, ledges, sightlines, drainage/water bounds, and landmarks. 3. use smooth sparingly; repeated smoothing erases intentional terrain language. 4. put gameplay corrections on a separate layer so art changes cannot silently remove them. 5. rebuild/check collision and navmesh after meaningful height changes. 6. test movement agents and cameras, not only the landscape viewport. special procedural layers spline edit layer stores landscape spline deformation/paint. it accepts procedural spline data and cannot be hand-sculpted or painted. patch edit layer stores landscape patch components. patches can read textures/render targets and alter height/weight data. patch inputs are editor-only and results are baked into the final landscape, so the procedural source does not add runtime memory/performance by itself. use patches for reusable stamps, local terrain fitting, or actor-owned deformation that must remain editable. use ordinary sculpt layers for unique manual art. change validation after reordering, changing alpha, importing, or modifying a procedural layer: - isolate every layer contribution; - inspect boundaries between loaded regions/components; - recheck landscape splines, water, and patches; - validate painted target layers and physical surfaces; - rebuild nanite representation if enabled; - rebuild navigation and dependent pcg/hlod as applicable; - save/reload and cook a representative map. grass, foliage, and pcg grass, foliage, and pcg choose one owner per population | need | default system | boundary | |---|---|---| | material/paint-driven passive ground cover | landscape grass output + landscape grass type | works only with landscape terrain; coupled to material layer weights | | hand-authored instance painting | foliage mode + static mesh foliage | efficient instancing and direct art control | | ecological offline simulation | procedural foliage | experimental editor workflow in current documentation | | rule-driven spatial generation, exclusions, runtime generation | pcg | route graph implementation to $unreal-pcg | | unique behavior/identity | actor or pcg spawn actor | costs like actors; keep density low | do not simultaneously generate the same grass/tree class through landscape grass, foliage, and pcg. establish ownership, exclusion, regeneration, and source-control policy. landscape grass workflow 1. derive a mask from a named landscape target layer using landscapegrassoutput. 2. create a landscape grass type and entries for meshes, density, scale, rotation, alignment, and cull distances. 3. attach the grass type to the corresponding grass output input. 4. paint/fill the driving landscape layer. 5. validate density, collision expectations, shadows, wind, lod/nanite, and culling in a cooked build. landscape grass is appropriate for passive visual distribution. if individual plants need durable identity, interaction, or authoritative state, they are not merely grass instances. foliage mode workflow - prefer static mesh foliage for decoration; it is hardware-instanced and batched. - actor foliage has the rendering/gameplay cost of ordinary actors. use only where behavior requires it. - define slope, height, scale, alignment, collision, density scaling, cull distance, shadow, and navigation impact in governed foliage type assets. - use reapply deliberately; it can change many existing instances. - validate instance attachment after landscape edits and choose the ue 5.8 foliage snapping behavior intentionally. procedural foliage the current guide still places procedural foliage under experimental editor settings. use it only after validating plugin availability, resimulation determinism, source-control output, cook behavior, and iteration cost. performance and gameplay - use foliage.densityscale only for types configured to participate in scalability. - cull distances, lod/nanite, shadow policy, wpo/wind, overdraw, and material cost determine final expense—not draw calls alone. - collision on dense small foliage is usually wasteful; collision/navigation blockers on important trees require explicit testing. - rebuild or update navigation after collision-relevant vegetation changes. - treat visually dense forests as ai sightline and path-design content, not only rendering content. acceptance - no duplicate ownership; - deterministic regeneration where required; - no vegetation on roads, entrances, traversal clearance, or critical sightlines; - expected collision/nav/physical-surface behavior; - stable memory and frame time through density scalability extremes; - no visible cull/lod transition beyond the project's budget. landscape materials and painting landscape materials and painting keep three concepts separate - edit layer: non-destructive authoring stack for height/weight/visibility edits. - target layer: named weightmap channel exposed by the landscape material and painted/imported in paint mode. - layer info asset: defines storage/blending behavior and can associate a physical material with a target layer. names are case-insensitive in the material system but must remain stable and governed. renaming one side of the contract can turn a layer weight into zero. blend selector - use weight blending for mutually normalized base surfaces such as soil/grass/rock. - use alpha/non-weight blending for an independent overlay whose ordering is intentional. - use height blending when per-layer height data should influence the transition; verify zero-weight intersections and normal behavior. weight-blended layers share a normalized total. erasing a fully weighted layer cannot reveal a nonexistent underlying weight; paint the desired replacement layer instead. authoring workflow 1. define a small semantic layer list and required outputs: base color, normal, roughness, displacement, physical surface, grass mask, pcg mask. 2. build reusable material functions and parameters rather than duplicating graphs per layer. 3. create matching landscapelayerblend, landscapelayersample, or custom weight logic. 4. assign the material to a test landscape. 5. create the correct weight-blended or non weight-blended layer info for each target layer. 6. fill a deliberate base layer before local painting. 7. paint boundary, full-weight, zero-weight, steep-slope, distant-lod, and wet/snow overlay cases. 8. trace/test physical surfaces and derived grass/pcg masks. performance controls - every visible component compiles the material permutation needed by the layers used there. - use landscapelayerswitch to remove operations when a layer contributes zero in a region. - share samplers/material functions where correct and watch texture-sampler limits on target feature levels. - prefer a few meaningful layers to many nearly identical variants. - mobile technically supports multiple layers subject to sampler limits; epic recommends only three. treat target measurement as the deciding constraint. - use rvt when caching complex terrain shading or terrain/object blending produces a measured benefit, not as mandatory architecture. physical surface validation assign physical materials through the intended landscape layer/material path. test several points per surface, transitions, thin paint, and cooked builds with traces returning physical material. visual appearance and returned physical surface must agree wherever footsteps, effects, friction, or gameplay depend on it. common failures - black/default landscape: material compile error, missing layer info, no filled base layer, or unsupported sampler/permutation. - paint layer absent: name mismatch or material never samples it. - erase seems ineffective: weight normalization; paint the replacement layer. - wrong footsteps: dominant layer/physical material assignment differs from visual expectation. - shader explosion/hitch: too many expensive layers/combinations and unbounded permutations. nanite, performance, lod, and collision nanite, performance, lod, and collision nanite landscape boundary nanite can improve landscape rendering performance, especially with virtual shadow maps. it does not add source terrain detail or inherently improve image quality; the source data is identical. ue 5.8 keeps both representations at runtime: - nanite landscape data for nanite rendering; - non-nanite landscape data for systems including rvt, water, and other landscape functions. therefore nanite adds streaming and memory data. measure the total system rather than assuming “nanite replaces landscape lod.” workflow 1. capture non-nanite target performance and memory. 2. enable nanite on the landscape. 3. build nanite data through the documented landscape build/save path. 4. confirm every proxy is up to date before comparing visuals or timing. 5. inspect seams; enable nanite skirt and tune skirt depth only if needed. 6. if using nanite tessellation/displacement, validate material settings, rebuilt data, shadows, collision mismatch, and scalability. 7. compare gpu, cpu, memory, streaming, cook time, disk size, and edit iteration. landscape.nanite.liverebuildonmodification is experimental and live rebuild can significantly slow editing. keep it off by default and perform controlled rebuilds. epic's page also shows a differently ordered legacy spelling in prose; confirm the exact cvar through console help in the installed build before scripting it. landscape performance levers - component and section count; - visible component count and lod distribution; - material shader/texture cost and layer permutations; - grass/foliage instance count, wpo, shadows, overdraw, culling; - rvt page generation/uploads and pool memory; - nanite/vsm/tessellation cost; - collision mip and physics queries; - streaming and derived-data readiness. profile the dominant cost; do not apply every lever at once. collision mip - collision mip level controls complex/visibility collision detail. - simple collision mip level controls simple/player collision detail. - higher mip values reduce geometry/memory but increase mismatch from rendered terrain. - epic notes that common cases keep collision mip at 0 and simple collision mip at 1 or 2; validate against the actual movement/query requirements rather than adopting this blindly. - per-component overrides can reduce cost in inaccessible areas. render displacement/tessellation does not automatically redefine gameplay collision. keep visible displacement within the acceptable collision error or provide another collision/gameplay solution. target capture record: - stat unit, stat gpu, insights trace, gpu profile; - visible components/sections and draw calls; - landscape/material/gpu time; - texture, rvt, nanite, and total memory; - streaming hitches at fastest traversal; - collision query behavior and navigation rebuild/pathing; - cold cook/load and warm traversal. terrain selector, import, and initial layout terrain selector, import, and initial layout representation selector | requirement | default representation | |---|---| | broad continuous ground, hills, valleys | landscape | | cave, arch, overhang, vertical cut | static/nanite mesh integrated with landscape | | small isolated terrain prop | static mesh | | road that raises/lowers and paints terrain | landscape spline on a spline edit layer | | local procedural height/weight stamp | landscape patch on a patch edit layer | | runtime deformable arbitrary surface | a dedicated runtime deformation/mesh solution; landscape authoring is not the default | prototype the transition between landscape and meshes. hide seams through placement, material/rvt blending, decals, rocks, or vegetation; do not rely on a single shading trick. before creation/import record: - playable xy extent and non-playable vista extent; - minimum and maximum elevation, including depth below datum; - desired xy vertex spacing and smallest shape the heightfield must express; - valid heightmap resolution and component topology; - world partition use and tiled-import convention; - coordinate origin, tile naming/order, y-axis orientation, units, and z-scale formula; - source heightmap version and checksum/path for reproducibility. supported heightmap paths ue 5.8 supports 16-bit grayscale png, 8-bit .r8, 16-bit .r16, and raw with a json sidecar. prefer 16-bit source data for smooth elevation precision. target-layer weightmaps are normally single-channel 8-bit data. for a new landscape: 1. enter landscape mode (shift+2). 2. choose import from file or create new. 3. enable edit layers. 4. select the material only if its target layer contract is already known. 5. for world partition tiled import, set and record partition grid/region settings and accept the tiled path prompt. 6. confirm heightmap resolution, component topology, xy scale, z scale, and flip y axis before import. 7. import, then immediately verify seams, orientation, elevation extrema, and world size. z-scale calculation epic documents: text z scale = elevation range in meters × 100 × 0.001953125 the source range must include the full desired vertical span, not merely the height above sea level. document where the source zero/datum maps into the ue height range. existing landscape import modes - original: original resolution at gizmo location. - expand: expand data to fit. - resample: resample to the existing landscape. - subregion: import without resolution checks; used for world partition subregions. resampling changes data. keep the source and export a verification copy after the operation. acceptance - no tile rotation/flip/seam mismatch; - known world points match source coordinates and elevations; - slopes and plateaus support intended movement/camera; - a round-trip export records the blended result or selected edit layer intentionally; - the import can be repeated from a clean checkout with the same result. ue 5.8 primary sources ue 5.8 primary sources checked against epic's unreal engine 5.8 documentation on 2026-07-19. landscape core - landscape overview - creating landscapes - landscape technical guide - importing and exporting landscape heightmaps - editing landscapes - landscape edit layers - landscape patch system - landscape splines shading and population - landscape materials - landscape paint mode - foliage mode - procedural foliage tool - runtime virtual texturing - water system runtime and performance - using nanite with landscapes - landscape collision guide - world partition - ue 5.8 release notes maturity notes - core landscape, edit layers, materials, splines, foliage, collision, and world partition integration are documented production workflows. - landscape.nanite.liverebuildonmodification is experimental. - procedural foliage remains under experimental editor settings in the current guide. - procedural vegetation editor is experimental and is intentionally not a default workflow in this skill. prefer the current 5.8 page and installed-engine console help over remembered behavior from earlier releases. landscape splines, water, and rvt landscape splines, water, and rvt landscape spline workflow use when a road, path, riverbed, or embankment must deform and optionally paint the landscape. 1. create a dedicated spline edit layer. 2. author control points and segments in landscape manage mode. 3. set width, side falloff, end falloff, tangent/rotation, and segment direction. 4. enable raise terrain and/or lower terrain only where the segment should deform height. 5. assign layer name when the spline should paint a target layer. 6. assign spline meshes with consistent forward axis, collision, lod/nanite, and material policy. 7. inspect intersections, sharp curvature, component boundaries, landscape seams, and navigation. landscape splines do not affect height until a spline edit layer exists. route general spline motion or spline mesh implementation to $unreal-splines. water integration boundary the water plugin supplies spline-driven oceans, lakes, and rivers integrated with landscape. establish before authoring: - water body type and spline ownership; - landscape deformation/edit layer ownership; - water surface height and terrain datum; - shore/riverbank material transition; - collision, swimming/boat physics, nav, and gameplay volumes; - world partition loading and distant representation. do not let a water body, landscape spline, manual sculpt, and patch all deform the same bank without a documented stack order. verify the terrain with each layer isolated. rvt selector use runtime virtual texturing when it materially helps: - cache expensive landscape shading; - blend static meshes/spline roads into terrain; - add decal-like static surface contributions; - provide a common terrain/object material-data surface. rvt is a gpu-generated cache, not durable gameplay data. writers are expected to be static; skeletal, movable, or animated components are poor writers. rvt workflow 1. enable virtual texture support and restart. 2. create an rvt asset with a material type and memory/resolution plan. 3. make the landscape material write through runtimevirtualtextureoutput and sample/fallback intentionally. 4. place an rvt volume and set bounds from the landscape/required writers. 5. add the rvt asset to writer components and choose main pass behavior. 6. use world-space normals for consistent blending. 7. define sort priority when multiple alpha writers overlap; equal-priority order is undefined. 8. validate a fallback path for feature levels without rvt when the content must remain visible. rvt performance/debug text stat virtualtexturing stat virtualtexturememory - larger/more detailed rvts consume more pool memory and uploads. - ycocg base-color encoding reduces banding but uses about 25% more memory and adds decode cost. - a writer rendered only to rvt may still have collision; disable it when not needed. - diagnose missing writers by checking volume bounds, asset/material type match, render to virtual textures, main pass setting, and sort priority. world partition and landscape streaming world partition and landscape streaming use with ../../unreal-world-partition/skill.md. landscape defines terrain topology; world partition defines cell residency and streaming sources. large-world setup 1. choose landscape topology and source tile convention before world partition import. 2. import tiled heightmaps with recorded world partition grid size, world partition region size, flip y axis, xy scale, and z scale. 3. verify all landscape streaming proxies, component boundaries, edit ownership, and source-control files. 4. establish streaming sources/ranges from maximum traversal speed and target-device readiness. 5. build and validate landscape-related hlod/distant content where applicable. 6. rebuild navigation, pcg, foliage, rvt streaming low mips, and nanite data after relevant landscape changes. do not assume landscape component, landscape streaming proxy, world partition cell, hlod cell, pcg grid, and navigation tile are the same unit. name each size explicitly. editor workflow - load only the region required for an edit, but check seams with neighboring regions loaded. - keep broad import/re-tile operations reproducible and coordinated; they can touch many external actor/proxy files. - disable automatic expensive derived rebuilds while making broad edits only when a deliberate final-build step exists. - use location/region loading and source control to prevent invisible work on unloaded neighbors. seam validation at each tile/proxy boundary inspect: - height continuity and normals; - target layer/weightmap continuity; - material/rvt and virtual-texture behavior; - landscape spline and water deformation; - collision and physical surface; - navmesh connectivity; - pcg/grass/foliage density and exclusion; - nanite proxy freshness and skirt behavior. runtime acceptance - fastest traversal cannot reach missing terrain collision; - camera vistas do not expose unloaded holes or unacceptable lod changes; - returning across cells does not grow memory indefinitely; - runtime data layer transitions do not leave terrain-dependent content inconsistent; - server and clients have compatible collision/navigation/world state; - cooked target traces show streaming, material, and landscape work inside budgets. route streaming-source, cell, data layer, hlod, and commandlet diagnosis to $unreal-world-partition.

Components, dimensions, and scale

# Components, dimensions, and scale

## Topology

Landscape Components are the base units for rendering, visibility, collision, and streaming proxies. All components in one Landscape are square and use the same size.

- A component uses one section or `2×2` sections.
- A section is the unit of Landscape LOD transition.
- Each section is a draw call, and every component carries render-thread CPU cost.
- Valid component quad dimensions follow the Landscape texture/mip layout: power-of-two vertices produce power-of-two-minus-one quads for one section, or power-of-two-minus-two component quads for `2×2` sections.
- Epic recommends no more than 1024 components for the largest Landscapes; treat this as an upper guideline, not a target.

Use Epic's valid-dimensions table or the creation UI rather than cropping an arbitrary image to “almost” fit.

## Tradeoffs

### More, smaller components

- finer culling and LOD granularity;
- smaller localized edit/stream units;
- more component CPU overhead and potentially more section draw calls.

### Fewer, larger components

- lower component count;
- coarser culling, LOD, collision, and streaming granularity;
- heavier individual visible/rebuild units.

`2×2` subsections can provide the same terrain resolution with fewer components than four separate one-section components, but still create four section draw calls per component.

## XY scale

XY scale defines vertex spacing in centimeters. At 100, adjacent vertices are one meter apart.

- Smaller spacing expresses smaller terrain features but covers less world area for the same heightmap and can increase pressure for more components.
- Larger spacing covers more area but produces coarser silhouettes, collision, slopes, and deformation.

Do not chase texture detail with geometry. Use materials, normal/detail maps, meshes, decals, and vegetation for sub-vertex detail.

## Z scale

Z scale maps 16-bit height values into world height. Increasing it expands vertical range but also magnifies each height step and changes gameplay slopes. Pick the range before sculpting and leave headroom for intentional edits.

## Layout procedure

1. Convert desired world width to centimeters.
2. Choose the coarsest XY vertex spacing that still represents required gameplay terrain.
3. Select a valid overall resolution and component topology that covers the extent.
4. Calculate Z scale from the source elevation range.
5. Create a small representative slice with the intended topology.
6. Test terrain silhouette, traversal, collision, navigation, LOD, material, and edit speed.
7. Profile component/section cost before committing the entire world.

## Never infer from resolution alone

Two Landscapes with the same vertex resolution can have different physical sizes, precision, component counts, and runtime behavior. Always report resolution together with XY/Z scale, section size, sections per component, and component count.

Debugging and production patterns

# Debugging and production patterns

## Diagnose by layer

1. **Topology** — valid resolution, correct component/section layout, XY/Z scale.
2. **Authoring stack** — correct active Edit Layer, order, visibility, lock, alpha, procedural owner.
3. **Paint contract** — material name, Target Layer, Layer Info type, filled base, weight data.
4. **Derived systems** — splines, water, patches, grass/foliage/PCG, RVT, Nanite, collision, navigation.
5. **Streaming** — loaded region/proxy and dependent World Partition cells.
6. **Runtime budget** — shader, texture, virtual texture, geometry, shadow, instances, collision, I/O.

## Useful visualizers and stats

- Landscape component/section/quads color overlays in Manage mode.
- `View > Landscape Visualizers > Layer Debug` for Target Layer channels.
- `Lit > Visualizers > Layer Contribution` for Edit Layer contribution.
- Player Collision and Visibility Collision view modes.
- `Landscape.RenderNanite 0/1` for controlled representation comparison.
- `stat virtualtexturing` and `stat virtualtexturememory` for RVT.
- `stat unit`, `stat gpu`, GPU Visualizer, Unreal Insights.

Restore diagnostic overrides before final captures.

## Common symptom table

| Symptom | First checks |
|---|---|
| Tile seam/crack | source edge pixels, Flip Y, XY/Z scale, proxy freshness, Nanite skirt |
| Sculpt has no effect | wrong/locked Edit Layer, special procedural layer, alpha zero |
| Spline does not deform | missing Spline Edit Layer, raise/lower disabled, width/falloff |
| Black/default material | compile error, missing Layer Info/base fill, sampler/permutation |
| Wrong physical surface | dominant Target Layer and Physical Material assignment |
| Grass missing | Grass Output name/mask, Grass Type, Landscape-only boundary, culling |
| RVT contribution missing | bounds, asset type, writer list, pass type, sort priority |
| Nanite visual stale | dirty proxy; build/save/cook Nanite representation |
| Character floats/clips | collision mip or render displacement differs from collision |
| NavMesh breaks after sculpt | navigation not rebuilt or slope/step/agent settings no longer fit |

## Production test matrix

| Axis | Minimum cases |
|---|---|
| Edit | sculpt/paint, undo, save/reload, layer reorder/hide, neighbor regions |
| Import | clean reimport, tiled seams, round-trip export, source checksum |
| Traversal | walk, fastest vehicle, steepest intended slope, world edge, teleport |
| Rendering | near/far, Nanite on/off, scalability tiers, target feature levels |
| Surface | each Target Layer, transitions, traces, footsteps/effects |
| Derived | splines, water, patches, vegetation, PCG, nav, HLOD/RVT |
| Build | PIE, standalone, cooked Development, shipping-equivalent target |
| Soak | repeated cross-world route and memory stabilization |

## Acceptance

- terrain supports intended mental map, sightlines, and traversal;
- no missing collision or navigation at streaming/edit boundaries;
- layer ownership is understandable and reversible;
- derived data can be rebuilt reproducibly;
- target frame, memory, disk, cook, and streaming budgets are met;
- no final conclusion relies on stale Nanite/RVT/nav/PCG data.

Edit Layers, sculpting, and patches

# Edit Layers, sculpting, and patches

## Edit Layer contract

Landscape Edit Layers are stack-based, non-destructive containers for heightmap, weightmap, and visibility data. New Landscapes enable them automatically in UE 5.8. The default project limit is eight and is configurable.

Use a small semantic stack, for example:

```text
BaseImport
BroadSculpt
GameplayCorrections
SplineProcedural
PatchProcedural
PaintArtDirection
```

More layers increase evaluation, authoring, merge, and diagnosis cost. Add a layer only when it represents distinct ownership or must be independently hidden/reordered.

## Editing rules

- Lock completed/owned layers.
- Use visibility and **Layer Contribution** (`Lit > Visualizers > Layer Contribution`) to isolate effects.
- Record whether height/paint alpha is intentionally additive, subtractive, or zero.
- Erase on an Edit Layer removes that layer's contribution; it is not necessarily “sculpt terrain downward.”
- `Collapse` and `Collapse All Layers` are destructive. Save/source-control before flattening.
- Deleting a layer deletes its height, weight, visibility, and assigned Blueprint Brush data.

## Sculpting workflow

1. Sculpt broad landforms before detail.
2. Establish playable grades, ledges, sightlines, drainage/water bounds, and landmarks.
3. Use Smooth sparingly; repeated smoothing erases intentional terrain language.
4. Put gameplay corrections on a separate layer so art changes cannot silently remove them.
5. Rebuild/check collision and NavMesh after meaningful height changes.
6. Test movement agents and cameras, not only the landscape viewport.

## Special procedural layers

### Spline Edit Layer

Stores Landscape Spline deformation/paint. It accepts procedural spline data and cannot be hand-sculpted or painted.

### Patch Edit Layer

Stores Landscape Patch components. Patches can read textures/render targets and alter height/weight data. Patch inputs are editor-only and results are baked into the final Landscape, so the procedural source does not add runtime memory/performance by itself.

Use patches for reusable stamps, local terrain fitting, or actor-owned deformation that must remain editable. Use ordinary sculpt layers for unique manual art.

## Change validation

After reordering, changing alpha, importing, or modifying a procedural layer:

- isolate every layer contribution;
- inspect boundaries between loaded regions/components;
- recheck Landscape Splines, water, and patches;
- validate painted Target Layers and physical surfaces;
- rebuild Nanite representation if enabled;
- rebuild navigation and dependent PCG/HLOD as applicable;
- save/reload and cook a representative map.

Grass, foliage, and PCG

# Grass, foliage, and PCG

## Choose one owner per population

| Need | Default system | Boundary |
|---|---|---|
| Material/paint-driven passive ground cover | Landscape Grass Output + Landscape Grass Type | Works only with Landscape terrain; coupled to material layer weights |
| Hand-authored instance painting | Foliage Mode + Static Mesh Foliage | Efficient instancing and direct art control |
| Ecological offline simulation | Procedural Foliage | Experimental editor workflow in current documentation |
| Rule-driven spatial generation, exclusions, runtime generation | PCG | Route graph implementation to `$unreal-pcg` |
| Unique behavior/identity | Actor or PCG Spawn Actor | Costs like actors; keep density low |

Do not simultaneously generate the same grass/tree class through Landscape Grass, Foliage, and PCG. Establish ownership, exclusion, regeneration, and source-control policy.

## Landscape Grass workflow

1. Derive a mask from a named Landscape Target Layer using `LandscapeGrassOutput`.
2. Create a Landscape Grass Type and entries for meshes, density, scale, rotation, alignment, and cull distances.
3. Attach the Grass Type to the corresponding Grass Output input.
4. Paint/fill the driving Landscape layer.
5. Validate density, collision expectations, shadows, wind, LOD/Nanite, and culling in a cooked build.

Landscape Grass is appropriate for passive visual distribution. If individual plants need durable identity, interaction, or authoritative state, they are not merely grass instances.

## Foliage Mode workflow

- Prefer **Static Mesh Foliage** for decoration; it is hardware-instanced and batched.
- **Actor Foliage** has the rendering/gameplay cost of ordinary actors. Use only where behavior requires it.
- Define slope, height, scale, alignment, collision, density scaling, cull distance, shadow, and navigation impact in governed Foliage Type assets.
- Use Reapply deliberately; it can change many existing instances.
- Validate instance attachment after Landscape edits and choose the UE 5.8 foliage snapping behavior intentionally.

## Procedural Foliage

The current guide still places Procedural Foliage under Experimental editor settings. Use it only after validating plugin availability, resimulation determinism, source-control output, cook behavior, and iteration cost.

## Performance and gameplay

- Use `foliage.DensityScale` only for types configured to participate in scalability.
- Cull distances, LOD/Nanite, shadow policy, WPO/wind, overdraw, and material cost determine final expense—not draw calls alone.
- Collision on dense small foliage is usually wasteful; collision/navigation blockers on important trees require explicit testing.
- Rebuild or update navigation after collision-relevant vegetation changes.
- Treat visually dense forests as AI sightline and path-design content, not only rendering content.

## Acceptance

- no duplicate ownership;
- deterministic regeneration where required;
- no vegetation on roads, entrances, traversal clearance, or critical sightlines;
- expected collision/nav/physical-surface behavior;
- stable memory and frame time through density scalability extremes;
- no visible cull/LOD transition beyond the project's budget.

Landscape materials and painting

# Landscape materials and painting

## Keep three concepts separate

- **Edit Layer**: non-destructive authoring stack for height/weight/visibility edits.
- **Target Layer**: named weightmap channel exposed by the Landscape material and painted/imported in Paint mode.
- **Layer Info asset**: defines storage/blending behavior and can associate a Physical Material with a Target Layer.

Names are case-insensitive in the material system but must remain stable and governed. Renaming one side of the contract can turn a layer weight into zero.

## Blend selector

- Use **weight blending** for mutually normalized base surfaces such as soil/grass/rock.
- Use **alpha/non-weight blending** for an independent overlay whose ordering is intentional.
- Use **height blending** when per-layer height data should influence the transition; verify zero-weight intersections and normal behavior.

Weight-blended layers share a normalized total. Erasing a fully weighted layer cannot reveal a nonexistent underlying weight; paint the desired replacement layer instead.

## Authoring workflow

1. Define a small semantic layer list and required outputs: base color, normal, roughness, displacement, physical surface, grass mask, PCG mask.
2. Build reusable material functions and parameters rather than duplicating graphs per layer.
3. Create matching `LandscapeLayerBlend`, `LandscapeLayerSample`, or custom weight logic.
4. Assign the material to a test Landscape.
5. Create the correct Weight-Blended or Non Weight-Blended Layer Info for each Target Layer.
6. Fill a deliberate base layer before local painting.
7. Paint boundary, full-weight, zero-weight, steep-slope, distant-LOD, and wet/snow overlay cases.
8. Trace/test physical surfaces and derived grass/PCG masks.

## Performance controls

- Every visible component compiles the material permutation needed by the layers used there.
- Use `LandscapeLayerSwitch` to remove operations when a layer contributes zero in a region.
- Share samplers/material functions where correct and watch texture-sampler limits on target feature levels.
- Prefer a few meaningful layers to many nearly identical variants.
- Mobile technically supports multiple layers subject to sampler limits; Epic recommends only three. Treat target measurement as the deciding constraint.
- Use RVT when caching complex terrain shading or terrain/object blending produces a measured benefit, not as mandatory architecture.

## Physical surface validation

Assign Physical Materials through the intended Landscape layer/material path. Test several points per surface, transitions, thin paint, and cooked builds with traces returning physical material. Visual appearance and returned physical surface must agree wherever footsteps, effects, friction, or gameplay depend on it.

## Common failures

- **Black/default Landscape**: material compile error, missing Layer Info, no filled base layer, or unsupported sampler/permutation.
- **Paint layer absent**: name mismatch or material never samples it.
- **Erase seems ineffective**: weight normalization; paint the replacement layer.
- **Wrong footsteps**: dominant layer/Physical Material assignment differs from visual expectation.
- **Shader explosion/hitch**: too many expensive layers/combinations and unbounded permutations.

Nanite, performance, LOD, and collision

# Nanite, performance, LOD, and collision

## Nanite Landscape boundary

Nanite can improve Landscape rendering performance, especially with Virtual Shadow Maps. It does not add source terrain detail or inherently improve image quality; the source data is identical.

UE 5.8 keeps both representations at runtime:

- Nanite Landscape data for Nanite rendering;
- non-Nanite Landscape data for systems including RVT, water, and other Landscape functions.

Therefore Nanite adds streaming and memory data. Measure the total system rather than assuming “Nanite replaces Landscape LOD.”

## Workflow

1. Capture non-Nanite target performance and memory.
2. Enable `Nanite` on the Landscape.
3. Build Nanite data through the documented Landscape build/save path.
4. Confirm every proxy is up to date before comparing visuals or timing.
5. Inspect seams; enable Nanite Skirt and tune skirt depth only if needed.
6. If using Nanite tessellation/displacement, validate material settings, rebuilt data, shadows, collision mismatch, and scalability.
7. Compare GPU, CPU, memory, streaming, cook time, disk size, and edit iteration.

`Landscape.Nanite.LiveRebuildOnModification` is Experimental and live rebuild can significantly slow editing. Keep it off by default and perform controlled rebuilds. Epic's page also shows a differently ordered legacy spelling in prose; confirm the exact CVar through console help in the installed build before scripting it.

## Landscape performance levers

- component and section count;
- visible component count and LOD distribution;
- material shader/texture cost and layer permutations;
- grass/foliage instance count, WPO, shadows, overdraw, culling;
- RVT page generation/uploads and pool memory;
- Nanite/VSM/tessellation cost;
- collision mip and physics queries;
- streaming and derived-data readiness.

Profile the dominant cost; do not apply every lever at once.

## Collision mip

- `Collision Mip Level` controls complex/visibility collision detail.
- `Simple Collision Mip Level` controls simple/player collision detail.
- Higher mip values reduce geometry/memory but increase mismatch from rendered terrain.
- Epic notes that common cases keep Collision Mip at 0 and Simple Collision Mip at 1 or 2; validate against the actual movement/query requirements rather than adopting this blindly.
- Per-component overrides can reduce cost in inaccessible areas.

Render displacement/tessellation does not automatically redefine gameplay collision. Keep visible displacement within the acceptable collision error or provide another collision/gameplay solution.

## Target capture

Record:

- `stat unit`, `stat gpu`, Insights trace, GPU profile;
- visible components/sections and draw calls;
- Landscape/material/GPU time;
- texture, RVT, Nanite, and total memory;
- streaming hitches at fastest traversal;
- collision query behavior and navigation rebuild/pathing;
- cold cook/load and warm traversal.

# Terrain selector, import, and initial layout

## Representation selector

| Requirement | Default representation |
|---|---|
| Broad continuous ground, hills, valleys | Landscape |
| Cave, arch, overhang, vertical cut | Static/Nanite mesh integrated with Landscape |
| Small isolated terrain prop | Static mesh |
| Road that raises/lowers and paints terrain | Landscape Spline on a Spline Edit Layer |
| Local procedural height/weight stamp | Landscape Patch on a Patch Edit Layer |
| Runtime deformable arbitrary surface | A dedicated runtime deformation/mesh solution; Landscape authoring is not the default |

Prototype the transition between Landscape and meshes. Hide seams through placement, material/RVT blending, decals, rocks, or vegetation; do not rely on a single shading trick.

## Before creation/import

Record:

- playable XY extent and non-playable vista extent;
- minimum and maximum elevation, including depth below datum;
- desired XY vertex spacing and smallest shape the heightfield must express;
- valid heightmap resolution and component topology;
- World Partition use and tiled-import convention;
- coordinate origin, tile naming/order, Y-axis orientation, units, and Z-scale formula;
- source heightmap version and checksum/path for reproducibility.

## Supported heightmap paths

UE 5.8 supports 16-bit grayscale PNG, 8-bit `.r8`, 16-bit `.r16`, and RAW with a JSON sidecar. Prefer 16-bit source data for smooth elevation precision. Target-layer weightmaps are normally single-channel 8-bit data.

For a new Landscape:

1. Enter Landscape mode (`Shift+2`).
2. Choose **Import from File** or **Create New**.
3. Enable Edit Layers.
4. Select the material only if its Target Layer contract is already known.
5. For World Partition tiled import, set and record partition grid/region settings and accept the tiled path prompt.
6. Confirm heightmap resolution, component topology, XY scale, Z scale, and `Flip Y Axis` before import.
7. Import, then immediately verify seams, orientation, elevation extrema, and world size.

## Z-scale calculation

Epic documents:

```text
Z scale = elevation range in meters × 100 × 0.001953125
```

The source range must include the full desired vertical span, not merely the height above sea level. Document where the source zero/datum maps into the UE height range.

## Existing Landscape import modes

- `Original`: original resolution at gizmo location.
- `Expand`: expand data to fit.
- `Resample`: resample to the existing Landscape.
- `Subregion`: import without resolution checks; used for World Partition subregions.

Resampling changes data. Keep the source and export a verification copy after the operation.

## Acceptance

- no tile rotation/flip/seam mismatch;
- known world points match source coordinates and elevations;
- slopes and plateaus support intended movement/camera;
- a round-trip export records the blended result or selected Edit Layer intentionally;
- the import can be repeated from a clean checkout with the same result.

UE 5.8 primary sources

# UE 5.8 primary sources

Checked against Epic's Unreal Engine 5.8 documentation on 2026-07-19.

## Landscape core

- [Landscape Overview](https://dev.epicgames.com/documentation/unreal-engine/landscape-overview?lang=en-US)
- [Creating Landscapes](https://dev.epicgames.com/documentation/en-us/unreal-engine/creating-landscapes-in-unreal-engine)
- [Landscape Technical Guide](https://dev.epicgames.com/documentation/unreal-engine/landscape-technical-guide-in-unreal-engine?lang=en-US)
- [Importing and Exporting Landscape Heightmaps](https://dev.epicgames.com/documentation/unreal-engine/importing-and-exporting-landscape-heightmaps-in-unreal-engine?lang=en-US)
- [Editing Landscapes](https://dev.epicgames.com/documentation/unreal-engine/editing-landscapes-in-unreal-engine?lang=en-US)
- [Landscape Edit Layers](https://dev.epicgames.com/documentation/unreal-engine/landscape-edit-layers-in-unreal-engine?lang=en-US)
- [Landscape Patch System](https://dev.epicgames.com/documentation/en-us/unreal-engine/landscape-patch-system)
- [Landscape Splines](https://dev.epicgames.com/documentation/unreal-engine/landscape-splines-in-unreal-engine?lang=en-US)

## Shading and population

- [Landscape Materials](https://dev.epicgames.com/documentation/en-us/unreal-engine/landscape-materials-in-unreal-engine)
- [Landscape Paint Mode](https://dev.epicgames.com/documentation/en-us/unreal-engine/landscape-paint-mode-in-unreal-engine)
- [Foliage Mode](https://dev.epicgames.com/documentation/en-us/unreal-engine/foliage-mode-in-unreal-engine)
- [Procedural Foliage Tool](https://dev.epicgames.com/documentation/unreal-engine/procedural-foliage-tool-in-unreal-engine)
- [Runtime Virtual Texturing](https://dev.epicgames.com/documentation/en-us/unreal-engine/runtime-virtual-texturing-in-unreal-engine)
- [Water System](https://dev.epicgames.com/documentation/unreal-engine/water-system-in-unreal-engine?lang=en-US)

## Runtime and performance

- [Using Nanite with Landscapes](https://dev.epicgames.com/documentation/unreal-engine/using-nanite-with-landscapes-in-unreal-engine?lang=en-US)
- [Landscape Collision Guide](https://dev.epicgames.com/documentation/unreal-engine/landscape-collision-guide-in-unreal-engine?lang=en-US)
- [World Partition](https://dev.epicgames.com/documentation/en-us/unreal-engine/world-partition-in-unreal-engine)
- [UE 5.8 Release Notes](https://dev.epicgames.com/documentation/unreal-engine/unreal-engine-5-8-release-notes?lang=en-US)

## Maturity notes

- Core Landscape, Edit Layers, materials, splines, foliage, collision, and World Partition integration are documented production workflows.
- `Landscape.Nanite.LiveRebuildOnModification` is Experimental.
- Procedural Foliage remains under Experimental editor settings in the current guide.
- Procedural Vegetation Editor is Experimental and is intentionally not a default workflow in this skill.

Prefer the current 5.8 page and installed-engine console help over remembered behavior from earlier releases.

Landscape Splines, water, and RVT

# Landscape Splines, water, and RVT

## Landscape Spline workflow

Use when a road, path, riverbed, or embankment must deform and optionally paint the Landscape.

1. Create a dedicated **Spline Edit Layer**.
2. Author control points and segments in Landscape Manage mode.
3. Set width, side falloff, end falloff, tangent/rotation, and segment direction.
4. Enable `Raise Terrain` and/or `Lower Terrain` only where the segment should deform height.
5. Assign `Layer Name` when the spline should paint a Target Layer.
6. Assign spline meshes with consistent forward axis, collision, LOD/Nanite, and material policy.
7. Inspect intersections, sharp curvature, component boundaries, landscape seams, and navigation.

Landscape Splines do not affect height until a Spline Edit Layer exists. Route general spline motion or spline mesh implementation to `$unreal-splines`.

## Water integration boundary

The Water plugin supplies spline-driven oceans, lakes, and rivers integrated with Landscape. Establish before authoring:

- water body type and spline ownership;
- Landscape deformation/Edit Layer ownership;
- water surface height and terrain datum;
- shore/riverbank material transition;
- collision, swimming/boat physics, nav, and gameplay volumes;
- World Partition loading and distant representation.

Do not let a Water Body, Landscape Spline, manual sculpt, and Patch all deform the same bank without a documented stack order. Verify the terrain with each layer isolated.

## RVT selector

Use Runtime Virtual Texturing when it materially helps:

- cache expensive Landscape shading;
- blend static meshes/spline roads into terrain;
- add decal-like static surface contributions;
- provide a common terrain/object material-data surface.

RVT is a GPU-generated cache, not durable gameplay data. Writers are expected to be static; skeletal, movable, or animated components are poor writers.

## RVT workflow

1. Enable Virtual Texture support and restart.
2. Create an RVT Asset with a material type and memory/resolution plan.
3. Make the Landscape material write through `RuntimeVirtualTextureOutput` and sample/fallback intentionally.
4. Place an RVT Volume and set bounds from the Landscape/required writers.
5. Add the RVT asset to writer components and choose Main Pass behavior.
6. Use world-space normals for consistent blending.
7. Define sort priority when multiple alpha writers overlap; equal-priority order is undefined.
8. Validate a fallback path for feature levels without RVT when the content must remain visible.

## RVT performance/debug

```text
stat virtualtexturing
stat virtualtexturememory
```

- Larger/more detailed RVTs consume more pool memory and uploads.
- YCoCg base-color encoding reduces banding but uses about 25% more memory and adds decode cost.
- A writer rendered only to RVT may still have collision; disable it when not needed.
- Diagnose missing writers by checking volume bounds, asset/material type match, Render to Virtual Textures, Main Pass setting, and sort priority.

World Partition and Landscape streaming

# World Partition and Landscape streaming

Use with [`../../unreal-world-partition/SKILL.md`](../../unreal-world-partition/SKILL.md). Landscape defines terrain topology; World Partition defines cell residency and streaming sources.

## Large-world setup

1. Choose Landscape topology and source tile convention before World Partition import.
2. Import tiled heightmaps with recorded `World Partition Grid Size`, `World Partition Region Size`, `Flip Y Axis`, XY scale, and Z scale.
3. Verify all Landscape Streaming Proxies, component boundaries, edit ownership, and source-control files.
4. Establish streaming sources/ranges from maximum traversal speed and target-device readiness.
5. Build and validate Landscape-related HLOD/distant content where applicable.
6. Rebuild navigation, PCG, foliage, RVT streaming low mips, and Nanite data after relevant Landscape changes.

Do not assume Landscape component, Landscape Streaming Proxy, World Partition cell, HLOD cell, PCG grid, and navigation tile are the same unit. Name each size explicitly.

## Editor workflow

- Load only the region required for an edit, but check seams with neighboring regions loaded.
- Keep broad import/re-tile operations reproducible and coordinated; they can touch many external actor/proxy files.
- Disable automatic expensive derived rebuilds while making broad edits only when a deliberate final-build step exists.
- Use location/region loading and source control to prevent invisible work on unloaded neighbors.

## Seam validation

At each tile/proxy boundary inspect:

- height continuity and normals;
- Target Layer/weightmap continuity;
- material/RVT and virtual-texture behavior;
- Landscape Spline and Water deformation;
- collision and physical surface;
- NavMesh connectivity;
- PCG/grass/foliage density and exclusion;
- Nanite proxy freshness and skirt behavior.

## Runtime acceptance

- fastest traversal cannot reach missing terrain collision;
- camera vistas do not expose unloaded holes or unacceptable LOD changes;
- returning across cells does not grow memory indefinitely;
- Runtime Data Layer transitions do not leave terrain-dependent content inconsistent;
- server and clients have compatible collision/navigation/world state;
- cooked target traces show streaming, material, and Landscape work inside budgets.

Route streaming-source, cell, Data Layer, HLOD, and commandlet diagnosis to `$unreal-world-partition`.

Use with [`../../unreal-world-partition/SKILL.md`](/unreal/unreal-world-partition/). Landscape defines terrain topology; World Partition defines cell residency and streaming sources.

## Large-world setup

1. Choose Landscape topology and source tile convention before World Partition import.
2. Import tiled heightmaps with recorded `World Partition Grid Size`, `World Partition Region Size`, `Flip Y Axis`, XY scale, and Z scale.
3. Verify all Landscape Streaming Proxies, component boundaries, edit ownership, and source-control files.
4. Establish streaming sources/ranges from maximum traversal speed and target-device readiness.
5. Build and validate Landscape-related HLOD/distant content where applicable.
6. Rebuild navigation, PCG, foliage, RVT streaming low mips, and Nanite data after relevant Landscape changes.

Do not assume Landscape component, Landscape Streaming Proxy, World Partition cell, HLOD cell, PCG grid, and navigation tile are the same unit. Name each size explicitly.

## Editor workflow

- Load only the region required for an edit, but check seams with neighboring regions loaded.
- Keep broad import/re-tile operations reproducible and coordinated; they can touch many external actor/proxy files.
- Disable automatic expensive derived rebuilds while making broad edits only when a deliberate final-build step exists.
- Use location/region loading and source control to prevent invisible work on unloaded neighbors.

## Seam validation

At each tile/proxy boundary inspect:

- height continuity and normals;
- Target Layer/weightmap continuity;
- material/RVT and virtual-texture behavior;
- Landscape Spline and Water deformation;
- collision and physical surface;
- NavMesh connectivity;
- PCG/grass/foliage density and exclusion;
- Nanite proxy freshness and skirt behavior.

## Runtime acceptance

- fastest traversal cannot reach missing terrain collision;
- camera vistas do not expose unloaded holes or unacceptable LOD changes;
- returning across cells does not grow memory indefinitely;
- Runtime Data Layer transitions do not leave terrain-dependent content inconsistent;
- server and clients have compatible collision/navigation/world state;
- cooked target traces show streaming, material, and Landscape work inside budgets.

Route streaming-source, cell, Data Layer, HLOD, and commandlet diagnosis to `$unreal-world-partition`.