OrbdaleTerrain

The feature a client's Replace or Remove request names, as the server knows it.

A brush mask a client offers to upload, as CanAddBrushMask sees it: the mask's size from the offer, and what this player has uploaded so far.

Decides whether a player may make an edit: the place for ownership, zoning and money (Tier 3).

One client's terrain link: its own actor channel, so terrain traffic never fills the PlayerController's reliable window.

A request's outcome, as OnRequestResultBP gives it, for C++.

Replicates one world's terrain edits: the server keeps one ordered log of authoritative records and serves a link per client; each client applies the records as a replica and sends its edits as requests.

The server's side of one link: what it sends that client.

A client's side of its link: what it sends the server.

No RPC carries more than this, half of net.MaxConstructedPartialBunchSizeBytes.

What a terrain record carries.

One record of the authority's ordered stream: what a game with its own transport relays from OnTerrainRecordBP on the authority to ApplyTerrainRecord on every replica, in Seq order.

What ApplyTerrainRecord did with a record.

Why the server refused a join or a request.

What a request asks for, as the edit policy sees it.

This side's role in terrain replication.

How a client's last checkpoint compared, as its ack reports it.

The client's first message (ServerHello): what both sides must share before anything else travels.

The server's answer to an accepted Hello (ClientWelcome): the client's author id and its join.

The client's acknowledgement (ServerAck, unreliable, 4 Hz): a lost one is replaced by the next.

The outcome of one request, sent to its client only (ClientRequestResults).

The network settings (Project Settings, Orbdale Terrain, Network): built-in replication, request rules, pacing and checkpoints.

What the net hub has done so far, for a debug overlay and for tests.

A terrain in a level: names its natural-ground source, its material and its runtime settings, and hosts the chunk components (Tier 3).

The outputs of Wait For Terrain Ground and Wait For Terrain Editable: Reason is None on OnReady, why on OnFailed.

The outputs of Sample Ground Exact (Async): the sample and None on OnCompleted; an empty sample and why on OnFailed.

The outputs of Sample Ground Batch (Async): the samples and None on OnCompleted; no samples and why on OnFailed.

The outputs of the commit, rebuild and undo nodes: the committed result (bOk true) and None on OnCompleted; on OnFailed a refused result (bOk false, its Reason text when the terrain gave one) and why the node gave up.

The outputs of Save Terrain To Slot (Async), the fields of FOrbdaleTerrainSlotSaveResult: Ref is the save on OnCompleted (Result Ok); on OnFailed Ref is empty and Result, LostCodes and Message say why.

The outputs of Load Terrain From Slot (Async): Result is Ok on OnCompleted, why on OnFailed.

The outputs of Stamp Terrain (Async).

Common machinery of the latent terrain nodes: a game-thread ticker that polls once per frame, a timeout in real seconds, and a root reference that keeps the node alive until it finishes.

Wait until the full-resolution ground around some locations is resident and its collision is built.

Wait until a brush over one circle would be applied: the answer to "can I edit here now?" after a load, a teleport or a spawn in a streamed or paged world, without polling.

Sample one position exactly, waiting for its ground to stream in first.

Sample a large batch off the game thread: the snapshot is taken now, the work runs on the task system, and the samples arrive on the game thread.

Commit a plate or a corridor as soon as the ground under it is resident: streams the footprint plus 300 m around it (the terrain bakes in blocks wider than the footprint), tries every frame, and gives up at the timeout.

Rebuild a spline feature as soon as the ground under it is resident: the spline is sampled once, when the node starts; the node streams the footprint plus 300 m, tries every frame, and gives up at the timeout, as Commit Corridor (Async) does.

Undo or redo a construction.

Save the terrain beside a game's save slot (UOrbdaleTerrainSubsystem::SaveTerrainAsync): fires OnCompleted with the reference to keep in the game's USaveGame, or OnFailed with the result, the lost-code count and a message.

Load the terrain from a save a reference names (UOrbdaleTerrainSubsystem::LoadTerrainAsync): fires OnCompleted, or OnFailed with why (NotFound for a missing file, Corrupt for a file that is not the recorded save).

Wait until the ground under one brush is editable, then apply it once as a one-dab stroke: a stamp.

What the author made in the terrain editor, kept beside the map until a bake folds it into a tile store (Tier 3).

Which channel of a source texture becomes the mask.

What a mask is for.

The bit depth of a baked mask.

How a bake ended.

Source image sizes above this many pixels a side are refused (BadSize).

What the bake does to its pixels; the asset's bake settings.

The nearest power of two to Side in 8 to 2048 (a tie goes up).

The side a spec bakes to: Side rounded by NearestSide, or 256 (Strength) or 1024 (Height) when Side is 0.

The bits a spec bakes to: 8 or 16.

Bake one 16-bit plane: resample to the spec's side, invert, quantise to its depth and make the mask.

Bake raw single-channel pixels from game code.

Bake a 16-bit (or 8-bit or floating point) single-band TIFF.

Bake a texture.

Channels a splat image holds: red, green, blue, alpha, in that order.

Bake an RGBA image into up to four step masks, one per used channel (splat paint).

Bake raw 8-bit RGBA pixels from game code, as FromSplatRgba16 does.

Bake a texture's four channels, as FromSplatRgba16 does; the texture is read as FromTexture reads it (the editor's untouched source, else a CPU copy; never a GPU readback).

A brush mask as an asset: a baked, content-hashed grid that scales a brush per post or shapes a height Stamp.

A group of brush assets: a palette a game or the editor lists, and registers in one call (UOrbdaleTerrainSubsystem::RegisterBrushSet).

A splat brush as an asset: one RGBA image that paints up to four terrain paint layers in one dab.

Turns Blueprint-unit descriptions into Tier 1 features through the terrain's contract frame.

What a followed foliage type does when the ground under it changes.

Project settings for ground-following foliage (Project Settings, Plugins, Orbdale Terrain Follow).

An instance was hidden or restored and so changed id: NewId is INDEX_NONE while it is hidden; OldId is the id it had before it was hidden.

What the follow subsystem is tracking and has queued.

Keeps placed foliage and actors on the ground.

What an actor does when the ground under it changes.

The ground under an actor moved or cleared it: OldZ and NewZ are the actor's world heights (cm) before and after, bCleared is whether the ground no longer admits it.

Keeps the owning actor on the ground it was placed on.

One grass entry of a paint layer: which ULandscapeGrassType grows where.

One paint layer: what the player calls it and which slice of the material's layer textures it draws.

The paint layer table of a terrain (Tier 3 data asset): entry N is paint layer N, up to 256.

Static Blueprint API over the world terrain: read the ground, preview and commit earthworks, undo them.

How exact a ground read must be.

Which columns a ground sample fills besides the height, which is always computed.

One paint layer at a point and its weight: an entry of FOrbdaleTerrainGroundSample::Paint.

One ground answer in Unreal units.

Where along a corridor a keep-out run lies, and whether its ends get a tunnel opening.

Where a corridor's formation height comes from.

A linear earthwork (road, rail, canal bank) as Blueprint states it, in cm.

What an earthwork does to the ground, in Unreal units: the preview and the committed numbers.

The inverse of one committed construction, to give back to UndoConstruction.

The answer to a construction call.

What a feature is.

What the stack knows about one feature.

Why an async node gave up; None on the node's success outputs, which share the failure output's pins.

A terrain quality profile, one per engine scalability level: the value is the sg.LandscapeQuality level it follows and r.OrbdaleTerrain.Quality's value for it.

Where the project's terrain quality profile comes from (Project Settings, Plugins, Orbdale Terrain, Quality Profile).

One console variable the profiles write, with its value under each profile.

The profile for an engine scalability level (sg.LandscapeQuality): 0 Low, 1 Medium, 2 High, 3 Epic, 4 Cinematic; below 0 Low, above 4 Cinematic.

The far ring preset a profile brings: Balanced from Low to Epic, High at Cinematic.

The normal-only far level a profile brings: none at Low (the preset's own), level 2 to 4 km at Medium, level 2 to 8 km at High and Epic, level 1 to 8 km at Cinematic.

The profile source a project stored by earlier versions, under the key QualityProfile, read in the five-level scheme: Scalability, Low and Manual keep their meaning, Balanced becomes High and High becomes Cinematic, so a project keeps the far ring, sub-post detail and grass it had (UOrbdaleTerrainSettings reads the old key when the new one is absent).

The rows every profile writes, in a fixed order.

The profile in force.

Sets r.OrbdaleTerrain.Quality to Profile and applies it at once.

Sets r.OrbdaleTerrain.Quality to -1, so the project's Quality Profile is in force again.

Writes Profile's rows at SetBy, skipping each row whose variable was set at a stronger priority or does not exist (its module is not loaded).

Whether Profile is in force and every row that exists holds its value.

The far detail a terrain with these render settings draws: its own FarDetail when bOverrideFarDetail is on or when no profile is in force, else the profile's.

The normal-only far level in force: the profile's (FarNormalsOf), or the preset's own (Level -1) when no profile is in force.

Re-reads the profile's sources and writes its rows when the profile or its priority changed, or always with bForce.

Hooks the console variables and engine init; the OrbdaleTerrain module calls it at startup.

Unhooks what Startup hooked; the module calls it at shutdown.

How a dragged brush times its steps.

How a dab turns its mask (FOrbdaleTerrainBrushBP::MaskAngle is the base angle in every mode).

Turns a player's pointer into sculpt strokes: the sample input component for player sculpting, shaped like rail's URailConstructionInputComponent.

Where the sculpt cursor comes from (Tier 3).

Why ground near a plate or corridor is not baked yet.

What applying one sculpt record did.

The sculpt tool's state, for a HUD and for tests (Tier 3 value, no object references).

What one finished stroke moved, in cubic metres, for a costed game (a sculpt beneath a feature is a sculpt cost, never re-charged to construction).

The authority's sculpt rules, edited with the terrain's runtime settings (Tier 3 config).

A sculpt record the authority applied, as bytes for the game's replication (a command or an undo/redo patch).

A stroke ended with these volumes.

A stroke opened (bActive) or closed, with the world bounds (cm) it has touched so far.

The project's defaults for every terrain: the material, the quality profile, the residency radius, the sculpt undo depth and whether to register the ground provider (Tier 3 configuration).

Broadcast when a source asset's own properties were edited; the argument is the edited asset.

Where a terrain's natural ground comes from, as an asset (Tier 3).

Natural ground flat at one height: the simplest source, for tests and empty maps.

Deterministic procedural hills (integer value noise, no transcendental functions), so every machine, test and scenario sees the same ground.

Natural ground from a 16-bit heightmap stored inside the asset: one sample per base post.

What a spline feature builds.

Where a spline feature stands against the terrain.

A terrain feature that follows a spline: a corridor along an open spline or a plate inside a closed one, owned by this component and replaced in place (same id, same stack position) by each Rebuild.

The ground changed (a struct, so it can grow without breaking a binding).

The ground changed.

A terrain was created in, or is being removed from, this world.

Blueprint form of FOnTerrainLifecycle: the host actor of the terrain.

A save to a slot ended, on the game thread, exactly once (UOrbdaleTerrainSubsystem::SaveTerrainAsync).

A load from a slot ended, on the game thread, exactly once (UOrbdaleTerrainSubsystem::LoadTerrainAsync).

The native form of OnTerrainRecordBP: each record the authority applied, as a view valid during the call only.

The streamer's counters and queue depths at one moment; see UOrbdaleTerrainSubsystem::GetStreamingStats.

What a file save did: the game's own save keeps Path, Bytes, FileHash, StateHash and NaturalHash beside each other, so a mismatched pair is refused at load (FOrbdaleTerrainSaveRef wraps them).

A file save landed, on the game thread (UOrbdaleTerrainSubsystem::SaveTerrainToFile).

The pager's view of paging: the world's counters and the session page file's.

A place, other than a streaming source, that needs full-resolution ground around it (Voxel Plugin's term).

What the terrain's colour runtime virtual texture is doing (UOrbdaleTerrainSubsystem::GetRvtStatus).

The terrain of one world: owns its FTerrainWorld and everything that keeps the engine in step with it (Tier 2.5 owner + Tier 3 shell).

The packed index of a tile store: where each stored tile's bytes sit in the payload.

What kind of input a tile store was imported from, for the importers' staleness checks.

Where a tile store's ground sits on the earth: metadata only, never read by the terrain.

What a tile store was built from, so an importer can tell whether the host changed since (see IsImportCurrent).

The cooked tile store: natural ground for large worlds, streamed per tile.

The one conversion between Unreal units and the terrain's (the Tier 3 boundary).

Centimetres to metres.

Metres to centimetres.

Centimetres to whole millimetres, rounded half away from zero (as Native::MetresToMm rounds metres).

Whole millimetres to centimetres.

A world position, cm, as Tier-1 world metres.

A Tier-1 world position, metres, as an Unreal world position, cm.

Which ground a query reads.

How exact a ground answer is.

Why the ground changed.

The ground changed under Bounds.

Whether an edit would be accepted now, and if not why.

What a sculpt brush does.

How a Stamp's target meets the ground.

A brush mask named by its content hash: the 64-bit hash of its canonical bytes, which is what a sculpt record carries.

How registering a brush mask with a terrain ended.

What a terrain's registry says about one mask.

Brush falloff, all polynomial.

Which way a Flatten brush may move the ground.

Outcome of loading terrain bytes.

Outcome of writing a terrain save file.

What a terrain save keeps (editor authoring layer).

A terrain save beside a game's save slot, as the game keeps it in its own USaveGame: the file the terrain wrote and the hashes that pair it with this game save.

What saving the terrain to a slot did.

One brush application, in Unreal units, for Blueprint and game input.

One channel of a registered splat: a paint layer and the mask that weights it.

A splat brush as a terrain holds it: up to four channels, each a paint layer and a registered mask, in the fixed order red, green, blue, alpha.

The Paint steps of one splat dab: Dab with its Kind set to Paint, and each used channel's layer and mask, in channel order (red, green, blue, alpha).

A Blueprint brush as Tier 1 states it: fixed point, millimetres relative to the terrain origin.

The sculpt limits, cm, as the authority's millimetre rules.

The authority's millimetre rules in cm: the inverse of ToSculptLimits, exact for whole millimetres.

An area earthwork as Blueprint states it: a building pad, yard or apron.

Runtime settings of one terrain, edited on AOrbdaleTerrainActor.

Ground-class value that marks a hole in Channels::GroundClass (collision and navigation skip it): Chaos skips the cell (TNumericLimits<uint8>::Max()).

The heights of one chunk, read once from a published snapshot and shared, immutable, by everything downstream of the ground: the chunk's collision field and its render chunk.

A chunk's heights are ready, or changed.

A chunk left the residency set; drop everything built for it.

Which renderer draws a terrain.

How much terrain detail the far field keeps between the near chunks and the distant atlases.

The far ring's normal-only level and its radius: finer slopes for the lighting of the distant ground, on top of the far detail preset, without more triangles.

How the heightfield tier's near chunks get their colour: the layer blend per pixel, or a runtime virtual texture.

How a terrain renders: tier, LOD, far field and shadow invalidation (Tier 3 authoring data).

Brush strength factor at a normalised distance, 0 to 1.

Normalised distance at which the brush strength factor falls to Level.

One contour of the falloff on the ground.

The radii of the strength contours inside a brush.

The brush tool's state, for a HUD and for tests (Tier 3 value, no object references).

A brush tool a game drops onto a player controller: Enhanced Input for the verbs, a text HUD and a cursor ring drawn on the terrain, over UOrbdaleTerrainSculptComponent.