TerraDyne Manual
Persistent runtime world framework for authored Unreal Landscapes
TerraDyne converts a shipped-quality Unreal Landscape into a chunked, persistent, runtime-editable world without moving your game to a voxel stack. It keeps authored terrain workflows, adds runtime sculpting and paint, preserves world state, and exposes gameplay hooks for procedural extension, AI, building rules, and PCG.
This manual targets TerraDyne 0.4.1. It covers the new first-run Survival Framework defaults, packaged sample meshes/presets/profiles, Blueprint and C++ integration examples, demo-map warning cleanup, and Fab-ready packaging for UE 5.5, 5.6, and 5.7.
-
Authored world conversion first
Import height, paint layers, placed foliage, and actor foliage from existing landscape content, then continue editing at runtime. -
Gameplay-facing persistence
Save terrain, migrated foliage state, procedural metadata, persistent actors, build permissions, AI zones, and runtime population rules. -
Sample-backed first run
The recommended first-run path now applies packaged TerraDyne sample content instead of relying on project-local placeholder meshes or legacy /Game/... assets.
Convert authored Unreal Landscapes into a persistent runtime world layer for sandbox, survival, and open-world gameplay.
Important usage disclaimer
TerraDyne is not a beginner-friendly, drop-in asset. Productive use assumes a good grasp of UE5 project structure, actors, materials, input, runtime systems, and some C++ familiarity, especially when integrating custom survival, PCG, replication, persistence, or world-partition workflows. Exposure to the FOSS GitHub version is recommended before deep production integration.
System map
TerraDyne sits between authored landscape content and the runtime systems that need reliable terrain ownership.
Keep the landscape workflow
The practical value is not replacing Unreal Landscape with a brand-new editor. It is taking a landscape you already trust and handing runtime ownership to TerraDyne.
Manager owns the world state
Chunk lookup, edit replication, save/load, gameplay metadata, and population management are centralized on ATerraDyneManager.
Terrain is only the base layer
The product now includes presets, spawn rules, biome metadata, AI zones, build permissions, runtime notifications, and PCG-facing queries.
Samples are packaged with the plugin
/TerraDyne/Samples now contains sample grass meshes, a grass material, a grass profile, and a showcase world preset that the wizard, scene setup, and demo map can use directly.
Small examples show project wiring
Survival setup, PCG seed export, and authoritative replication bridges now exist as C++ example actors and Blueprint assets under /TerraDyne/Examples.
Best fit
Survival games, sandbox builders, persistent open-world projects, authored maps that need runtime deformation, and hybrid worlds that extend beyond the original footprint.
Install and Setup
Install the plugin as a world framework, not as a loose utility
TerraDyne ships as a runtime plugin with content, resources, shaders, and editor tools. Treat it like a proper plugin dependency in your project structure.
Requirements
- Current source branch targets Unreal Engine 5.7.
- Fab-ready 0.4.1 packages are maintained for UE 5.7, UE 5.6, and UE 5.5.
- The plugin descriptor enables GeometryScripting and VirtualHeightfieldMesh.
- Runtime module allow list: Win64, Mac, Linux, Android, IOS.
- Official support URL: https://discord.gg/nqYQ5mtmHb.
- Official docs URL: https://gregorigin.com/Terradyne.
Recommended project shape
MyProject/
Plugins/
TerraDyne/
Config/FilterPlugin.ini
Content/
Examples/
Maps/
Samples/
Scripts/
Resources/
Icon128.png
Shaders/
Source/
docs/
TerraDyne.uplugin
If your gameplay code needs TerraDyne APIs, add the dependency in your module build rules:
PublicDependencyModuleNames.AddRange(new string[] { "TerraDyne" });
Global defaults live in developer settings
Open Edit > Project Settings > TerraDyne Settings to configure master material path, HUD widget path, default chunk size, default resolution, LOD threshold, collision debounce, streaming radii, undo depth, and runtime notifications.
Editing controller expects TerraDyne actions
The runtime edit controller validates the action TerraDyneClick at startup. If you use TerraDyne editing in your own game mode, make input mappings part of your setup checklist rather than an afterthought.
Do not point defaults at project-only content unless intended
The current plugin branch is built to avoid depending on /Game/... defaults. Preserve that if you extend it, especially for Fab or reusable project templates.
Fab package shape
The submitted zip is source-first and isolated. It contains a host-project folder only as a plugin container; it deliberately omits HostProject.uproject, Binaries, and Intermediate.
| Settings category | Key fields | Why it matters |
|---|---|---|
| Asset Paths | MasterMaterialPath, HeightBrushMaterialPath, HUDWidgetPath | Sets the default runtime material and UI surfaces the manager and edit controller will try to use. |
| Defaults | DefaultChunkSize, DefaultResolution | Defines the baseline chunk footprint and per-chunk fidelity before any landscape import overrides. |
| Performance | LODDistanceThreshold, CollisionDebounceTime, GrassDebounceTime | Controls runtime cost after edits, especially in maps where players sculpt continuously. |
| Streaming | ChunkLoadRadius, ChunkUnloadRadius, MaxChunkOpsPerTick, GridExtent | These settings define the active chunk envelope and the rate at which the manager is allowed to mutate the world. |
| Notifications | bShowRuntimeNotifications | Lets runtime builds suppress on-screen notifications while editor builds still surface toasts for errors and warnings. |
| Descriptor field | 0.4.1 value | Reason |
|---|---|---|
| Version / VersionName | 401 / 0.4.1 | Matches the Fab package name and changelog heading. |
| CreatedBy / CreatedByURL | GregOrigin / www.gregorigin.com | Publisher metadata expected in the installed plugin descriptor. |
| DocsURL / SupportURL | https://gregorigin.com/Terradyne / Discord support | Points users to the product documentation and live support channel. |
| EngineVersion | 5.5.0, 5.6.0, or 5.7.0 | Stamped per engine package during the clean BuildPlugin pass. |
| CanContainContent | true | Required because TerraDyne ships maps, Blueprints, sample meshes, profiles, presets, scripts, resources, and shaders. |
| PlatformAllowList | Win64, Mac, Linux, Android, IOS | Applied to both runtime and editor modules for descriptor consistency. |
Setup Wizard
Use the setup wizard to bootstrap the right kind of world
Open Window > TerraDyne Setup Wizard. In 0.4.1 the wizard opens on Survival Framework (Recommended First Run) so a new user gets a packaged preset, grass profile, sample meshes, streaming defaults, biome overlays, AI zones, build zones, lighting, manager, and orchestrator without hunting for missing assets.
Survival Framework
The default first-run path. It applies the packaged showcase world preset and grass profile, sets up practical streaming/procedural defaults, and seeds biome, AI-zone, and build-zone metadata that survival and sandbox projects naturally need.
Full Feature Showcase
Demo-oriented setup with a guided tour of sculpting, painting, persistence, foliage, population, AI zones, build permissions, and PCG-relevant metadata. Use this for validation recordings and feature presentations.
Authored World Conversion
The most important template for real projects. It scans the level for landscape actors, exposes migration options, and converts the selected landscape into TerraDyne chunks.
Sandbox
Minimal startup for testing edit flow, materials, chunk settings, and low-friction experimentation. Good when you want TerraDyne actors present without importing a landscape or applying the survival-oriented defaults.
Landscape detection stays in sync
The wizard refreshes its landscape list when maps open or change. If the authored conversion dropdown looks wrong, use Refresh after loading the correct level.
Initialize World is opinionated
The wizard is designed to create or update TerraDyne bootstrap actors for the selected template. For first-run use, leave the Survival Framework defaults alone and validate the packaged sample profile before swapping in project-specific assets.
Wizard decision flow
Pick the template based on whether you already trust the source landscape or want TerraDyne to own the world from the beginning.
What the recommended first run wires together
The stronger defaults are intentionally concrete: new users should see terrain ownership, grass, sample meshes, gameplay metadata, and framework hooks on the first clean map.
Practical recommendation
For a first run, use Survival Framework. For a production map that already has authored terrain, switch to Authored World Conversion after you have inspected the sample-backed defaults and understand what TerraDyne actors and assets are being created.
Landscape Conversion
Authored World Conversion is the core production workflow
The conversion path imports loaded landscape components into TerraDyne chunks, captures weight-layer mappings, transfers placed foliage and actor foliage, optionally hides the source hierarchy, and preserves migration metadata on the manager for later save/load and gameplay queries.
Conversion pipeline
The current pipeline is deliberately defensive. It resolves the full landscape group, imports loaded components, warns when something critical is missing, and refuses obviously incompatible material adoption.
Recommended import sequence
-
1
Open the level that contains the source landscape and make sure the components you want are loaded.
-
2
Open Window > TerraDyne Setup Wizard, choose Authored World Conversion, and confirm the target landscape.
-
3
Start with the safe defaults: hide source on, clear existing chunks on, weight import on, layer mapping capture on, foliage transfer on, material adoption off.
-
4
Initialize the world, then inspect the spawned TerraDyne chunks in the Outliner before entering play.
-
5
Press Play and validate terrain visibility, material behavior, foliage transfer, and any play-mode UI settings for that map.
Material adoption caveat
Leave "Adopt Landscape Material As Master Material" off unless you have a specific reason to test it. Most landscape graphs rely on landscape-only expressions and are not valid chunk master materials on TerraDyne dynamic meshes.
The current branch now refuses clearly incompatible landscape materials and keeps the existing TerraDyne material instead of blindly applying a broken graph. That is a safety net, not a recommendation to turn the option on casually.
| Import option | Recommended default | What it actually does |
|---|---|---|
| Hide Source Landscape | On | Hides the full source landscape proxy hierarchy after import, not just the one actor you selected. |
| Clear Existing Chunks | On | Destroys existing TerraDyne chunk actors before import so you do not merge new authored data into stale chunk state. |
| Pause Streaming During Import | On | Temporarily freezes chunk streaming while conversion is building authored chunk state. |
| Import Weight Layers | On | Resamples supported painted landscape layers into TerraDyne's four weight layers. |
| Capture Layer Mappings | On | Records source landscape layer names to TerraDyne weight layer indices in migration state for later tooling and debugging. |
| Regenerate Grass From Imported Layers | Usually on | Rebuilds TerraDyne grass using the imported paint data once chunks are active. |
| Adopt Landscape Material As Master Material | Off | Attempts to replace the TerraDyne chunk master material with the source landscape material. Safe only for compatible non-landscape-only graphs. |
| Transfer Placed Foliage | On | Transfers both instanced static mesh foliage and actor foliage types found on the imported landscape components. |
| Foliage Follows Terrain | On for deformable worlds | Keeps transferred foliage placement aligned to terrain changes after import by refreshing placement after edits. |
Proxy-aware import
Current conversion resolves the landscape through ULandscapeInfo and imports all loaded components instead of only the selected proxy actor. This is what you want for streaming-proxy and partitioned landscape setups.
Clear import failure messages
The manager now surfaces explicit user-facing errors when the selected landscape has no loaded components or when no TerraDyne chunks were created from the import.
Import metadata stays on the manager
Source landscape name, path, scale, imported component count, layer mappings, unmapped layer names, foliage counts, and adoption flags are stored in LandscapeMigrationState.
What conversion does not do for you
Converting the landscape does not automatically solve gameplay camera placement, player starts, or map-specific material design. If PIE launches to mostly sky after a successful import, chunk creation may already be fine and the next suspect is your map bootstrap or camera placement, not the import itself.
Runtime Editing
Editing can be a real gameplay mode or safely turned off
TerraDyne's edit controller can either run as a true runtime terrain editor or behave like a normal gameplay controller. The current branch adds a safe switch for disabling the TerraDyne play-mode UI without leaving invisible edit input active.
Editing feature surface
The edit controller supports raise, lower, smooth, flatten, and paint, with live brush preview and undo/redo coordination on the manager.
Editing controls
- Tools: Raise, Lower, Smooth, Flatten, Paint.
- Paint layers: Four runtime weight layers indexed 0-3.
- Flatten behavior: The controller locks the flatten height when the stroke begins, then reuses it until release.
- Brush preview: The decal shows radius and mode. Current branch uses blue for sculpt and orange for paint.
- Notifications: Critical problems surface via editor toasts or runtime messages through UTerraDyneSubsystem::ShowNotification.
- Input: The edit controller validates TerraDyneClick. Panel buttons remain the safest user-facing path when UI is enabled.
Play Mode Tool UI switch
The property Enable Play Mode Tool UI on ATerraDyneEditController is a safety switch, not a cosmetic toggle. When it is off, TerraDyne deliberately stops behaving like an editing controller.
When enabled
- Spawns or reconnects to the TerraDyne tool widget.
- Uses GameAndUI input mode.
- Shows the mouse cursor and click / mouse-over behavior.
- Creates the brush preview decal dynamic material.
- Binds edit input and sends brush / undo / redo RPCs.
When disabled
- Removes the TerraDyne widget if one exists.
- Uses GameOnly input mode.
- Hides the cursor and disables click / mouse-over events.
- Hides the brush preview decal.
- Skips input binding and blocks sculpt / undo / redo edit paths.
Gameplay maps without terrain UI
Use the edit controller with Enable Play Mode Tool UI unchecked when you want TerraDyne present in the map but do not want the runtime editing UX to be available to the player.
Dedicated edit maps
Keep the switch on for edit/demo maps, showcase scenes, internal terrain tools, or games where terrain sculpting is an actual player-facing mechanic.
PIE harness exists for the no-UI branch
The branch now includes dedicated PIE automation that boots a real TerraDyne edit controller with UI disabled and asserts that the no-UI path is inert end to end.
Persistence
Terrain persistence and world persistence are part of the same model
TerraDyne does not just serialize sculpted height changes. Save/load captures terrain buffers, migrated foliage state, procedural settings, authored chunk coordinates, persistent population entries, and world metadata needed to restore the runtime world shape.
Save / load flow
Core save calls
Manager->SaveWorld("TerraDyneSave");
Manager->LoadWorld("TerraDyneSave");
The default slot name in the current branch is TerraDyneSave. Chunk cache data is stored under the configured save directory, defaulting to Saved/SaveGames/TerraDyneCache/.
Persistent actor model
Use RegisterPersistentActor for already-placed gameplay actors or PlacePersistentActor / PlacePersistentActorFromDescriptor for TerraDyne-owned runtime placement. This is the right layer for props, harvestables, destroyables, and regrowth loops.
Transferred foliage persists too
The save payload includes migrated instanced foliage definitions, override materials, actor foliage classes, per-instance local transforms, and terrain offsets.
Brush state replicates separately from save state
Runtime editing uses brush RPCs and multicast sync for live play. Save/load is the persistence layer for long-lived world state, not a replacement for replication.
Subsystem owns task flushing
The world subsystem is the place to flush pending TerraDyne tasks before teardown. That matters for background IO safety and orderly shutdown.
World Framework
TerraDyne now layers gameplay framework systems on top of terrain ownership
This is the part that changes TerraDyne from a narrow runtime terrain plugin into a broader world framework. Presets, procedural outskirts, biome overlays, persistent population, AI zones, build permissions, terrain events, and PCG seed points all live on the runtime manager.
Framework stack
Think of TerraDyne as layered world state, not just editable mesh.
| Framework element | Where it lives | What it is for |
|---|---|---|
| World preset | UTerraDyneWorldPreset | Packages procedural settings, biome overlays, population rules, AI zones, and build permission zones into one reusable asset. |
| Procedural settings | FTerraDyneProceduralWorldSettings | Controls seeded outskirts, infinite edge growth, procedural extent, and whether population rules generate instances on procedural chunks. |
| Biome overlay | FTerraDyneBiomeOverlay | Maps paint weights or procedural noise windows to biome tags for authored and procedural chunks. |
| Population rules | FTerraDynePopulationSpawnRule | Deterministic rule set for runtime population on procedural and optionally authored chunks. |
| AI zones | FTerraDyneAISpawnZone | Gameplay query surface for zone-aware spawning filtered by biome, chunk provenance, and enabled state. |
| Build permissions | FTerraDyneBuildPermissionZone | Allows or blocks building with explicit reasons and slope checks. |
| PCG points | GetPCGSeedPointsForChunk | Exposes TerraDyne-managed metadata into secondary world generation workflows without expensive landscape raycasts. |
Biome queries
Use GetBiomeTagAtLocation to ask what biome a world position currently belongs to. That gives gameplay systems a stable answer after both authored import and runtime edits.
Build permissions
Use CanBuildAtLocation to gate building systems against zone rules and slope policy, with a reason string when the answer is no.
AI spawn zones
Use GetAISpawnZonesAtLocation to query zone metadata that can drive encounter spawning, biome-specific AI, or authored combat regions.
Terrain, foliage, and population delegates
The manager broadcasts change delegates so your project can react to sculpting, foliage movement, or persistent population state changes without polling.
Navmesh refresh policy is configurable
The manager can refresh navigation for terrain and population changes with a configurable dirty-bounds padding value. This matters for AI-heavy games that let players reshape the ground.
Scene setup can apply presets
ATerraDyneSceneSetup lets you pair a preset with a template so the same level bootstrap can bring in terrain ownership and higher-level world metadata together.
Performance and Chunks
Chunk management is where TerraDyne stays practical at runtime
Chunk streaming, LOD throttling, delayed collision rebuilds, grass debounce, and debug overlays are what keep runtime terrain editing from collapsing under its own cost.
Chunk envelope
Load and unload radii form the manager's active world envelope, while imported chunks and procedural outskirts remain distinct pieces of state.
Current performance model
- Streaming: Load and unload regions are managed per tick from player positions.
- Collision: Complex collision is disabled on distant chunks based on the LOD distance threshold.
- Debounce: Collision rebuilds and grass regeneration wait briefly after edits to prevent frame spikes during continuous sculpting.
- Undo scope: Undo/redo is stored per player as a stroke-based history, with unloaded-chunk snapshots intentionally skipped.
- Debug overlay: Manager property bShowDebugOverlay visualizes chunk state in the world.
| Control | Typical use | Tradeoff |
|---|---|---|
| DefaultChunkSize | Larger chunks for fewer actors, smaller chunks for finer streaming. | Large chunks reduce actor count but increase rebuild blast radius for each edit. |
| DefaultResolution | Raise for more detailed terrain or imported component fidelity. | Higher resolution increases memory, mesh rebuild work, and save size. |
| ChunkLoadRadius / ChunkUnloadRadius | Control how much world is active around players. | Higher radii improve continuity but increase active chunk count. |
| MaxChunkOpsPerTick | Throttle how many chunk operations can happen per streaming tick. | Too low can make long-distance travel catch up slowly; too high can hitch. |
| LODDistanceThreshold | Turns off complex collision for distant chunks. | Improves physics cost but moves accuracy to the nearby playable area. |
| CollisionDebounceTime | Delays physics mesh rebuild until editing calms down. | Lower feels more immediate but can spike the CPU during fast sculpting. |
| GrassDebounceTime | Controls how long TerraDyne waits before regenerating grass after edits. | Low values update foliage quickly but can thrash on rapid edits. |
| MaxUndoHistory | Keeps more stroke snapshots per player. | Higher history depth retains more data in memory. |
About World Outliner clutter
Grouping chunk actors under a parent actor may clean up hierarchy visually, but it does not reduce runtime actor count or chunk cost. If you need Outliner organization, prefer folders or data-layer style organization unless you are deliberately changing attachment behavior in code and understand the transform implications.
API Reference
Core entry points for C++, Blueprint, and systems code
Most runtime integration should start with the world subsystem, then use the active manager as the authoritative world interface.
Get the active manager
if (UTerraDyneSubsystem* Sys = GetWorld()->GetSubsystem<UTerraDyneSubsystem>())
{
if (ATerraDyneManager* Manager = Sys->GetTerrainManager())
{
Manager->ApplyGlobalBrush(
HitLocation,
1200.0f,
1.0f,
ETerraDyneBrushMode::Lower,
0,
0.0f);
}
}
Query the world for gameplay
FString BuildReason;
const bool bCanBuild = Manager->CanBuildAtLocation(TestLocation, BuildReason);
const FName BiomeTag = Manager->GetBiomeTagAtLocation(TestLocation);
const TArray<FTerraDyneAISpawnZone> Zones =
Manager->GetAISpawnZonesAtLocation(TestLocation);
Save world state
Manager->SaveWorld("TerraDyneSave");
Manager->LoadWorld("TerraDyneSave");
Persistent actor placement
Manager->PlacePersistentActor(
SpawnClass,
SpawnTransform,
ETerraDynePopulationKind::RuntimePlaced,
true,
0.0f,
false,
0.0f);
Survival integration example
// Add BP_TerraDyne_SurvivalSetup to a startup level
// or subclass ATerraDyneSurvivalIntegrationExample.
SurvivalExample->ConfigureSurvivalWorld();
SurvivalExample->OnSurvivalWorldReady.AddDynamic(
this,
&AMyGameMode::HandleTerraDyneReady);
PCG seed export example
// BP_TerraDyne_PCGExporter wraps this call for Blueprint.
const TArray<FTerraDynePCGSeedPoint> Points =
Manager->GetPCGSeedPointsForChunk(ChunkCoord);
for (const FTerraDynePCGSeedPoint& Point : Points)
{
SpawnSecondaryContent(Point);
}
Replication bridge example
// BP_TerraDyne_ReplicationBridge is an owned replicated actor.
ReplicationBridge->ApplyBrushAuthoritatively(
HitLocation,
BrushRadius,
BrushStrength,
ETerraDyneBrushMode::Paint,
PaintLayer,
PaintValue);
Full terrain sync request
// Use after possession, reconnect, or late join. ReplicationBridge->RequestFullTerrainSync(EditController);
Real multiplayer games should own or spawn one replication bridge per editing player.
| API | Category | Use it for |
|---|---|---|
| ApplyGlobalBrush | Interaction | Runtime sculpting or painting on the terrain. |
| BeginStroke / CommitStroke / Undo / Redo | Interaction | Stroke-based history and player-specific edit reversal. |
| GetWorldHeightAtLocation | PCG | Read terrain height cheaply from TerraDyne state without relying on landscape traces. |
| ImportFromLandscapeWithOptions | Migration | Direct landscape import path when driving conversion from editor tools or utility code. |
| ApplyWorldPreset | Framework | Push a preset's procedural, biome, and gameplay metadata onto the manager. |
| GetPCGSeedPointsForChunk | PCG | Export TerraDyne-managed points for secondary generation or spawn logic. |
| ShowNotification | System | Surface actionable user-facing messages through editor toasts or runtime text. |
| ATerraDyneSurvivalIntegrationExample | Example | Small C++/Blueprint setup actor for applying packaged first-run defaults in survival-style projects. |
| ATerraDynePCGIntegrationExample | Example | Exports PCG seed points to Blueprint events and project-specific generation systems. |
| ATerraDyneReplicationIntegrationExample | Example | Shows authoritative brush routing and full terrain sync requests through an owned replicated actor. |
Blueprint-facing mindset
Use the manager as your single source of truth. Terrain, migrated foliage, biome state, build rules, AI zones, and persistent population are already co-located there. That is cleaner than scattering project-specific caches across unrelated systems.
Examples and Content
Shipped content is meant to shorten adoption time
TerraDyne 0.4.1 includes setup helpers, example Blueprints, C++ integration actors, packaged sample meshes, a sample grass profile, a sample world preset, a warning-clean showcase map, built-in UI content, and automation scripts that recreate supporting assets without repetitive editor work.
BP_TerraDyne_SurvivalSetup
Blueprint child of ATerraDyneSurvivalIntegrationExample. It finds or spawns a manager, applies the sample world preset and grass profile, enables practical survival defaults, and broadcasts when the TerraDyne world is ready.
BP_TerraDyne_PCGExporter
Blueprint child of ATerraDynePCGIntegrationExample. It refreshes chunk seed points and emits Blueprint events so project PCG graphs or secondary spawn systems can consume TerraDyne-managed metadata.
BP_TerraDyne_ReplicationBridge
Blueprint child of ATerraDyneReplicationIntegrationExample. It shows how an owned replicated actor can route brush edits to the server, multicast terrain changes, and request full terrain sync.
Save / biome / editor examples
Existing compact examples such as save/load, biome reactions, and runtime-editor setup remain useful as narrow references, but the 0.4.1 examples are the recommended entry points for new integrations.
Packaged sample content map
These assets are now part of the plugin payload and are referenced by the first-run defaults, scene setup, orchestrator, demo map, and validation tests.
Showcase map
Content/Maps/DemoMap_Showcase is the quickest way to see the broader framework in motion. The orchestrator walks through sculpting, paint, save/load, foliage, population, AI zones, build permissions, and PCG-relevant metadata. In 0.4.1 it prefers packaged samples and no longer depends on missing sample meshes or legacy project-local placeholder content.
Automation scripts
Scripts in Content/Scripts/ can create sample meshes/profiles/presets, example Blueprints, demo maps, brush preview material, and other supporting assets without repeating manual editor setup across projects.
Troubleshooting
Most failures are setup mistakes, import assumptions, or material mismatches
Current TerraDyne branches are better about surfacing errors to the user instead of only logging them, but it still helps to know which symptoms map to which category of problem.
No landscape detected in the wizard
Open the level that actually contains the landscape, then click Refresh. The authored conversion template only enables initialization when the selected landscape resolves to a real actor.
Import says no loaded components
The current import path uses the full landscape group but only imports loaded components. In streaming or partitioned setups, load the relevant cells or proxies first, then rerun the conversion.
Import created no chunks
That is now surfaced explicitly. Suspects are invalid target landscape state, unloaded source components, or a failed chunk spawn path. Inspect the manager, output log, and source level state before changing anything else.
Terrain is black or looks wrong after conversion
The most common cause is incompatible material adoption. Use a standard TerraDyne-compatible chunk material instead of a landscape-only graph. Leave the adopt-material option off unless you are intentionally validating a compatible material.
Only part of the landscape imported
In the current branch, partial imports usually mean only part of the source landscape was loaded, not that the system only understands a single proxy. Load the missing landscape components and retry.
Foliage did not transfer as expected
Confirm that Transfer Placed Foliage was enabled. That option now covers both instanced foliage and actor foliage capture for imported components, but it still depends on the source component state and supported foliage definitions.
First-run grass or preset assets are missing
Verify the plugin was packaged with Content/Samples, Content/Scripts, and Resources/Icon128.png. The 0.4.1 defaults expect DA_TerraDyne_ShowcaseWorld, DA_TerraDyne_ShowcaseGrass, and SM_TerraDyne_GrassA/B/C.
Example Blueprint generation warns on rerun
Use the current CreateExampleBlueprints.py. It preserves existing survival, PCG, and replication example Blueprints rather than repeatedly reparenting assets that already exist.
Terrain editing does nothing in play
Check whether your controller has Enable Play Mode Tool UI turned off. Also verify the input action TerraDyneClick exists if you expect edit mode to be active.
I want no editing UI in gameplay
Use the safe controller switch instead of simply hiding the widget. The switch also restores GameOnly input, hides the cursor, hides the brush preview, and blocks TerraDyne edit RPC paths.
Fab validator complains about stale output
Rebuild from a clean package root and ensure the final zip does not contain HostProject.uproject, Binaries, Intermediate, Saved, or DerivedDataCache. TerraDyne's validator now rejects those directories.
Read symptoms carefully
A map that boots to mostly sky after a conversion is not always an import failure. If chunk actors exist in the Outliner after conversion, look next at player start, camera placement, play-mode controller, and map bootstrap assumptions.
Support and Release Notes
Current manual status and release-facing notes
This manual is now aligned with TerraDyne 0.4.1 and the current Fab-facing source packages. It documents the sample-backed first run, integration examples, demo-map cleanup, descriptor metadata, FilterPlugin policy, and clean BuildPlugin output for UE 5.5, 5.6, and 5.7.
| Validation gate | 0.4.1 result | What was checked |
|---|---|---|
| C++ build | Passed | UE 5.7 editor build completed successfully before release packaging. |
| Automation | 23/23 passed | Runtime, rendering, persistence, migration, first-run default, sample asset, and integration-example checks. |
| Blueprint generation | 0 error(s), 0 warning(s) | Survival, PCG, and replication example Blueprints preserve cleanly on rerun. |
| Showcase map | No TerraDyne/map diagnostics | Live-load smoke test against /TerraDyne/Maps/DemoMap_Showcase. |
| Fab package isolation | Passed | No HostProject.uproject, no Binaries, no Intermediate, required content/resources/scripts/shaders included. |