OrreryTerrainCore

A std::shared_ptr<T> behind a std::mutex, with the member names and call shapes of std::atomic<std::shared_ptr<T>>.

The smallest side of a brush mask, in samples.

The largest side of a brush mask, in samples (a 16-bit mask of this side holds 8 MiB of samples).

The canonical bytes' format version, written after the magic.

Bytes of the canonical header: the magic 'TSBM', the format version (1 byte), the bits (1 byte) and the side (2 bytes, little-endian).

A mask value of 1 (a white sample) in Q16: every sample becomes M in [0, kBrushMaskOne].

The largest FBrush::Radius_mm a mask is sampled at, 2^30 mm (about 1,074 km), so the sampler's products fit 64 bits; a larger masked brush writes nothing.

Why bytes or samples were refused as a brush mask.

One brush mask: a square grid of 8- or 16-bit samples, one channel, row-major, that scales a brush's falloff weight per post.

A dab's rotation: cos and sin of FBrush::MaskAngle in Q30 (2^30 is 1).

Cos and sin of an angle in 1/65536 of a turn (FBrush::MaskAngle), by an integer CORDIC (Volder 1959).

The fixed-point shift of FBrushMaskDab::ScaleX and ScaleY (samples per Q16 millimetre).

The fixed-point shift of FBrushMaskDab::InvHalfX and InvHalfY (1 over a half-side in mm).

One dab's sampler state, prepared once per dab by PrepareBrushMaskDab and read per post.

Prepare one dab of Brush over Mask: its rotation (BrushMaskRotation), mirror, half-sides (BrushMaskHalfSides), level (FBrushMask::LevelFor with the longer half-side) and scales.

M at a local position (FBrushMaskDab::Local), in Q16 from 0 to kBrushMaskOne: the one sampler entry point, which dispatches on the dab's flags.

What SampleBrushMaskRow writes for a post off the mask's rectangle (where FBrushMaskDab::Local answers false).

Sample one row of posts: post i lies at offset (Dx_mm + i × Step_mm, Dy_mm) from the brush centre.

FBrushMaskRegistry's default byte budget, 64 MiB: six 2048² masks with their mips, or about 380 of 256² (samples are held as 16-bit unorm).

How FBrushMaskRegistry::Add ended.

How FBrushMaskRegistry::Remove ended.

A pin on one held mask: while any pin on it lives, FBrushMaskRegistry::Remove refuses it.

The brush masks one terrain holds, by content hash.

What the ground under a station suggests building, before the owner's own thresholds.

Why a formation edge holds a vertical step: a retaining wall the terrain reports.

Cross-section at one corridor station: per-station areas for a mass-haul diagram and pricing.

A run of retaining wall along consecutive stations of one side of one feature.

What a feature does to the ground, from FTerrainWorld::Evaluate (preview) or Commit.

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

The rules of one followed type (a foliage type, a tagged component, an actor).

How an instance's registration or evaluation ended.

The result of registering one instance.

The result of evaluating one tracked instance on a snapshot.

One followed instance: 12 bytes.

The edit tile key (Y high, X low) of a world position, metres; tiles beyond +-16384 saturate.

The tile coordinate a key stands for (the inverse of FollowTileKey, for keys that did not saturate).

The followed items of one component, kept as a few sorted runs so an edit finds the items under it without a scan and adding a million items never re-sorts them all at once.

The changes of a journal pull, folded into a few edit-tile rectangles in canonical order.

One segment of a corridor's or channel's formation band, with its half widths and bounds, for a batch.

One plate polygon for a batch.

Scratch a caller keeps between batches, so the steady state allocates nothing.

Whether a point stands in a feature's footprint (plus a margin): a plate's polygon, or a corridor's or channel's formation band (the wider half width at each station, interpolated along the segment).

Register Count instances: their reference offsets and whether each stands cleared already.

Evaluate Count tracked instances against a snapshot.

The rotation that takes the unit normal From to the unit normal To, its angle clamped.

A thread-safe handle a terrain world publishes into: every snapshot the world publishes, it also hands to its handle, and when the world is destroyed it closes the handle.

What a journal entry may have changed (FGroundChange::What), as bits: a may-have-changed set, so a reader that caches one kind of data skips the entries without its bit.

The union of two sets of bits.

The bits two sets share.

Whether Bits holds any of Test's bits.

The bit of far level Level in FGroundChange::Levels; levels 15 and deeper share bit 15.

Every far level: FGroundChange::Levels of a change to the truth.

Entries the ground journal keeps: a reader more entries behind than this resets (FGroundQuery::ChangesSince).

Far entries (Levels != 0) FTerrainWorld::FarChanges keeps: a far reader more far entries behind than this resets.

Far rectangles one publish adds at most; more changed tiles coalesce into bounding rectangles.

One entry of the ground change journal: a rectangle of edit tiles whose ground, or the answers about it, may have changed in one publish.

The far journal's entry: the ground journal's entries with Levels != 0.

How exact a sampler request must be.

The (layer, weight) pairs of one post's paint, heaviest first (ties by ascending layer id), weights summing to 255.

The weights of one canonical post (FPaintSlots): its used pairs, zero weights dropped.

What to sample: positions in, in metres, and which ground at what accuracy.

Where the answers go: one array per column, each Count long (Normal and SmoothNormal 3·Count, SurfaceState 4·Count).

Sample many positions on one snapshot.

Rise over run of the ground along a horizontal direction, a central difference one edit cell either side of the point.

The field of a SyncHash leaf: a paint channel is its own FChannelId (below 0x10000); the sculpt layer is kSyncFieldSculpt.

One leaf of the SyncHash tree: a field's tiles in one 32 × 32-tile chunk of the edit extent.

The incremental SyncHash of one world.

Stroke contexts a batch stream keeps: a switch back to one of these costs one byte.

One stroke context of a batch stream: the stroke, its author and the reference its next brush step is coded against.

The state a batch stream carries from one batch to the next, the same on the writer and the reader.

Packs a run of records into one batch payload (ClientRecords, and upstream requests), for one link.

Reads the batches of one stream that FNetBatchWriter wrote, in order.

Version of the join stream's framing and head.

The most canonical brush mask bytes one join carries (FJoinHead::Masks), 32 MiB: three 16-bit 2048² masks (8 MiB and 8 bytes each), or 512 8-bit 256² ones.

The most save bytes one frame carries; the transport cuts the stream wherever it likes (ClientJoinChunk, at most 32 KB).

The largest head a reader accepts, bytes.

The largest start chunk a reader accepts, bytes: its stroke and tile index, then the tile's kTilePosts² posts as zigzag varints of their residual from a plane through their neighbours.

One tile an open stroke touched, as the world's stroke keeps it (the rounding's pace).

One of the authority's open strokes at the join position: what a joiner needs to go on applying its steps and get the same posts.

One brush mask a join stream carries in a mask frame.

How a join stream uses the save a joiner kept from an earlier join (FJoinStreamConfig::JoinerSaveHash).

What the join stream's first frame says: the position S, the checkpoint there, and where the save's parts lie.

Where a join writer keeps the save it streams from: Prepare writes the save into it once, then the writer reads its frames back through the file Finish returns, so the host holds a read-ahead per joiner rather than the save.

What the server knows of a joiner when its join starts (its hello).

How a join writer stands.

The server's half of one late join: a save pinned at S (PlanSave), cut into frames and reordered for the joiner.

Why a join reader stopped.

Why FJoinCache::Open refused a save.

A save a client kept from an earlier join, opened for a later join to take bytes from: its index by code hash.

How FJoinStreamReader::FillFromCache ended.

Where a joiner keeps the save it receives: a file the reader appends each arrived run of save bytes to, off the game thread (FJoinStreamReader::Drain), so the joiner holds the bytes on their way rather than the save, and the world loaded from the stream pages its codes from it.

Where a joiner keeps its stream's save.

The joiner's half: takes the stream in pieces of any size and keeps the save as a sparse file.

How LoadJoin ended.

Load the joiner's world from the stream's save at S (FTerrainSerialization::LoadFromFile: paged when the world has a page store, so codes still on their way stay cold), check StateHash and SyncHash against the head, hold the save's next feature id to the head's, then set the record position to S.

LoadJoin, then a replica that expects S + 1 with the head's digest, which continues the head's open strokes (FTerrainReplica::ResumeStrokes).

The heap every joiner's save file holds in this process, bytes: the runs in memory and their index, as FJoinStreamReader::ResidentBytes counts them, for as long as the file lives (the world loaded from it keeps it).

A cursor of FTerrainNetLog: one link or one open join.

The log's bounds.

The authority's ordered log of one terrain's net records.

A record's position in the authority's log (FTerrainNetLog): 1 for the first record, 0 for none.

Who authored a record: kTerrainServerAuthor for the server or host, then one id per connection, stable for the session.

The author of the server's or the listen host's own edits.

Version of the net record format: the envelope, the payloads below and the batch codec (NetBatch.h).

What a net record carries.

Whether this version knows a kind as a record of the authority's stream.

Whether a client's request batch may carry a kind: every known record kind, and MaskUpload.

Whether a kind takes a sequence number.

Why bytes were refused as a net record, a payload or a batch.

The largest payload a record may carry, 64 MiB.

Bytes of a record's envelope before its payload: version 2, kind 1, seq 8, author 4, payload size 4.

One record, borrowed: the payload bytes belong to whoever produced the view.

What one feature-stack op does, as FTerrainWorld's commit funnel applied it.

One stack op of a FeatureOps record: the result of a commit, not the call.

The stack ops one commit, undo, revert or reapply applied, in order, and the stack's NextFeatureId after it.

The hashes a replica compares when it reaches this position, so both sides compare at the same logical point.

Bytes of a Checkpoint payload.

Why the authority reset its replicas.

Every replica rejoins (control).

Bytes of a Reset payload.

The repair of one client after a checkpoint mismatch, placed at that client's position so ordering stays exact.

Bytes of a BrushMask payload that names its mask by hash only: U64 hash, U32 canonical size.

How a BrushMask payload codes its mask's canonical bytes.

One BrushMask record's content: the mask, or only its name.

Whether Bytes is the canonical size of some brush mask: kBrushMaskHeaderBytes + Side² × Bits / 8 for a legal side and bits.

Append the full BrushMask payload of Mask: its hash, its canonical size, then the smaller of the two codecs.

Append the hash-only BrushMask payload (kNetBrushMaskHashOnlyBytes) of the mask named Hash, CanonicalBytes long.

Read a BrushMask payload, all of Size.

The hash and canonical size a BrushMask payload starts with, unchecked.

Bytes of a MaskUpload payload before its chunk: U64 hash, U32 canonical size, U32 total, U32 offset.

The most upload bytes one MaskUpload part carries, 16 KiB: half of the largest transport part (kTerrainNetMaxPartBytes, 32 KiB), so a request batch part holds a chunk and the brush steps beside it.

One part of a client's brush mask upload (a MaskUpload request): the offer, or a chunk of the upload's bytes.

Append a MaskUpload payload: the header and Part's chunk.

Read a MaskUpload payload, all of Size.

Puts one brush mask upload back together on the server, in order.

Check a payload against its kind, touching nothing.

Check a request's payload against its kind: as CheckNetPayload, and a MaskUpload as DecodeMaskUpload checks it.

Append one record in its canonical, unbatched form: U16 kTerrainNetVersion, U8 kind, U64 seq, U32 author, U32 payload size, then the payload.

Read one record written by EncodeNetRecord, all of Size and nothing more.

Append a FeatureOps payload.

Read a FeatureOps payload, all of Size.

Append a Checkpoint payload, kNetCheckpointBytes; Checkpoint.Seq travels in the envelope.

Read a Checkpoint payload of the record at Seq.

Append a Reset payload, kNetResetBytes.

Read a Reset payload.

Append a Repair payload.

Read a Repair payload, all of Size.

The format versions two peers must share, compared at the Hello before anything else travels.

This build's versions.

Which version two peers disagree on, checked in this order.

Compare a peer's versions with this build's, as the Hello does; any mismatch is refused (VersionMismatch).

Version of the repair messages (leaves and request).

The server's SyncHash tree at one checkpoint: ServerRepairHashes.

One tile's content as the SyncHash reads it: a sculpt state's delta hash, a painted tile's content hash.

A chunk whose leaf differs, with every set tile the client holds in it, row then column.

The client's answer to the leaves: the chunks that differ, each with the client's tile hashes, so the server sends the tiles that differ at once.

Append the leaves message.

Read a leaves message, all of Size: leaves strictly in tree order, each with a tile.

Append the request message.

Read a request, all of Size: chunks strictly in tree order, tiles strictly row then column, at most 1,024 a chunk.

Compare the server's leaves with World's SyncHash tree and list the client's tiles in every chunk that differs (by count or sum, or present on one side only), and whether the stack differs.

How FTerrainRepairSource::Build ended.

The authority's truth at one checkpoint, kept to repair clients that disagreed there.

The FeatureOps record of one stack change, as the authority's commit listener hands it out (FTerrainWorld::SetCommitListener): each op with its id, anchor and feature bytes (EncodeFeature), and the next feature id.

How FTerrainReplica::Enqueue ended.

Why a replica stopped applying records.

How FTerrainReplica::Repair or Resync ended.

What one checkpoint compared on the replica.

Applies the authority's records to one world in the log's one total order: sculpt commands and patches through an FSculptReplayer, FeatureOps through FTerrainWorld::ApplyFeatureOps, and checks each Checkpoint against the world's SyncHash, the replayer's digest and the next feature id.

Version of the sculpt record format (commands and patches), written first on the wire.

The oldest record version a decoder still reads; it upgrades it to kSculptRecordVersion.

What a sculpt record carries.

One sculpt command, the unit that replicates a stroke.

Bytes of one encoded FSculptCommand: version 2, kind 1, brush kind 1, falloff 1, channel value 1, channel 2, stroke 8, step 4, centre 8 + 8, radius 4, strength 4, flatten-to 4, then (version 3 on) falloff start 2, flatten direction 1, paint layer 1, paint opacity 1, then (version 5) mask hash 8, mask angle 2, mask flags 1, stamp blend 1, mask aspect 2 and 5 zero bytes.

Bytes of a version 3 or 4 command: the first 53 of the version 5 layout, then 3 zero bytes.

Bytes of a version 2 command: the first 48 of the version 3 layout.

The sculpt layer's state after an undo or redo, replicated as tiles, never re-derived.

Why a sculpt record is refused before it touches the ground.

Largest |Brush.CentreX_mm| and |Brush.CentreY_mm| a record may carry: about 10^15 m, far beyond any terrain.

What the authority accepts from a player's brush.

What applying one sculpt record, or one brush step, did.

Whether a PaintChannel brush may never write Channel: the paint slot planes and the reserved id after them (16-31), and the retired v4 paint (Channels::PaintLayer, PaintWeight).

Check a command against the record format and the limits, touching nothing.

Write one command as kSculptCommandBytes little-endian bytes.

Read one command written by EncodeSculptCommand, of this version or an older one it still reads.

Append a patch's bytes (version, kind, stroke, tile bytes) to Out.

Read a patch written by EncodeSculptPatch.

The kind of an encoded record, from its first three bytes, so a receiver can dispatch.

Fold one command into a running digest: authority and replica compare it to find the first command they disagree on, before StateHash differs.

What one stroke moved, for pricing.

Applies sculpt records to one terrain in the authority's order, never skipping one.

Ground classes a cell can carry: the rows of FBatterTable and of the shell's physical material table.

Ground-class value that marks a hole: a cell under a mesh feature (portal, cut-and-cover), skipped by collision and navigation.

A per-cell channel the terrain knows by name.

FGroundClass per cell: batter row, physical material, cost; kHoleClass = hole.

Legacy paint (save versions 1-4): material layers per cell, two 4-bit indices, layer A in the low nibble, layer B in the high nibble (16 layers).

Legacy paint: weight of PaintLayer's layer B over layer A per cell, 0..255; 0 shows A alone.

Paint as slot planes (save version 5): a post holds up to kMaxPaintSlots (layer, weight) pairs, one u8 plane per field.

Weight plane of slot 1; slot s is PaintSlotWeightFirst + s - 1.

Last id of the paint planes (weight of slot 7).

Paint slots a post can hold in the format: the layer planes are ids 16-23 and the weight planes 24-30.

The channel id of slot Slot's layer plane.

The channel id of slot Slot's weight plane.

Whether Id is one of the paint slot planes (16-30).

The value an unpainted cell of a channel reads as.

The id of a named channel.

The parts of the terrain's CPU time, one counter each.

Number of counters, for arrays passed to DrainTerrainCosts.

Nonzero while the counters collect.

Start or stop collecting.

Add time to a counter.

Read every counter and reset it to zero.

Adds the time from construction to destruction to one counter, while collecting.

Outcome of staging one edit into a transaction.

Edits staged against the feature stack, not yet applied.

The exact inverse of one committed transaction: stack operations recorded at commit time, never a re-derivation from the owner's geometry.

What a sculpt brush does.

How a Stamp's target meets the ground (EBrushKind::Stamp).

FBrush::MaskFlags: the mask is mirrored left to right (its columns reversed) in the brush's own frame, before the rotation.

FBrush::MaskFlags: the footprint is the mask's own rectangle, rotated with it, corners included, instead of the disc that clips it.

FBrush::MaskFlags: the mask is sampled bicubically (fixed point, integer only) instead of bilinearly.

Every FBrush::MaskFlags bit record version 5 defines; a record with any other bit set is refused.

FBrush::MaskAspect_q8 of a square mask: width over height 1:1, in 1/256.

FBrush::MaskAngle of a whole turn: the angle counts 1/65536 of a turn (about 0.0055°).

Brush falloff.

Which way a Flatten brush may move the ground.

FBrush::FalloffStart_q16 of the whole radius: the start is a fraction of the radius in 1/65536.

The largest falloff start a brush carries, 65535/65536 of the radius.

A falloff start as a brush carries it: Start (a fraction of the radius) rounded to 1/65536.

The brush strength factor at a normalised distance, in floating point.

One brush application, in fixed point because strokes replicate as commands and must produce the same tiles on every machine.

Side slope as horizontal run per unit of rise, in thousandths (1500 = 1.5:1).

Batter per ground class.

Intermediate berms on deep cuttings and high embankments.

One sampled station of a corridor centreline.

A run of stations where the ground is left untouched: viaduct, bridge, tunnel bore.

Most openings one corridor may state (FTerrainWorld refuses more as InvalidFeature).

Most points one opening's outline may hold.

One tunnel mouth of a corridor: where the approach cutting folds to the portal, and where the face opens into a hole behind the portal's opening (Rail Earthworks Shoulders Skeleton, decisions 5 to 7).

A linear earthwork: railway, road, embankment, cutting, tunnel approach.

A vertex of a plate polygon, millimetres relative to the terrain origin.

An area earthwork: junction zone, platform, building pad, runway, apron.

A channel: canal, lock chamber, drainage cut.

Which payload a feature carries.

One entry of the feature stack: the semantic truth of the modified ground.

Sub-cells per chunk side: a 128-post chunk (127 quads) splits into 4 × 4 sub-cells of 32 quads (the last 31).

Quads per sub-cell side (the last sub-cell of a row or column takes the remainder).

Sub-cells per chunk; a dirty set is a uint16_t with bit SubY * 4 + SubX.

Paint layer ids a post can name (8-bit ids, PaintSlots.h).

Auto rules the material evaluates (the material's AutoRule0..4).

Keep-clear mask cells per sub-cell side: 0.5 m at 1 m posts.

Keep-clear distance unit, cm (FScatterKeepClear::MarginDistQ).

The material formula EffectiveLayerWeights ports: 64-bit FNV-1a of the UTF-8 bytes of MF_TerrainLayers' Custom node code from the first "float W0 = 1.0;" to the end of the first "EW[0] = W0 * Rem;", carriage returns removed (the painted bilinear of slots 0-1, the two noise fields, the five auto rules and RockMask; chunks holding texture 2 redo the bilinear with slots 2-3 in one branch after the block, which this hash does not cover).

A read-only view of one chunk's posts: FTerrainChunkPosts in plain C++.

One auto rule of the layer set, as the material reads it (MF_TerrainLayers, AutoRule{i}_Slope, _Altitude, _Noise).

The auto rules of a terrain's material: the one source of where layers show.

How a variety's three scales relate (ULandscapeGrassType's EGrassScaling).

One grass variety on one paint layer, in plain C++: the shell turns a ULandscapeGrassType variety plus a layer set entry (FOrreryTerrainLayerGrass) into this.

Per-run settings that are not part of a variety.

What a keep-clear footprint is (from FGroundQuery::FeaturesIn, or a buyer's shape).

One keep-clear footprint in world cm.

The keep-clear state of one sub-cell, rasterised once and tested per candidate (kScatterMaskSize² cells).

One placed instance, relative to the chunk: the shell's component sits at (OriginX, OriginY, OriginZ).

The seed of one variety: 64-bit FNV-1a over the grass type's package path (UTF-8 bytes, no terminator) followed by the four little-endian bytes of the variety index.

The key of candidate Index.

The quads of sub-cell (SubX, SubY), half-open: [OutQ0X, OutQ1X) × [OutQ0Y, OutQ1Y).

Candidates of one (sub-cell, variety): N = ceil(area m² × DensityPer100m2 / 100), at most 2^20.

The candidates density scaling leaves to be evaluated: ceil(Candidates × ThinScale) for Halton (a prefix, clamped to [0, Candidates]); every candidate for the grid, which thins per candidate instead (FScatterSettings::ThinScale).

The layer weights the material shows at one point (the material's MF_TerrainLayers formula, ported).

The auto rules alone: how a unit of layer-0 weight splits over the layers at world position (WorldXCm, WorldYCm).

Rasterise the footprints that touch sub-cell (SubX, SubY) into its keep-clear mask.

Place one (sub-cell, variety): every candidate in ascending Index, kept by holes, keep-clear, class, the slope and altitude bands, and W > Min && W <= Max && W >= u_keep.

The sub-cells whose instances can differ between two revisions of one chunk: heights (with OriginZ), paint and class over each sub-cell's posts, one post wider for the post normals.

The sub-cells of a chunk that a world rectangle (cm, inclusive) touches: what a footprint or keep-clear change dirties.

A height in integer millimetres: the authoritative, serialised and hashed unit.

Monotonic counter, bumped once per published change by FTerrainWorld only.

Identity of a feature in the stack.

Identity of a sculpt stroke, for the bounded undo ring.

Ground class of a cell (rock, soil, clay…).

Index of a typed per-cell channel registered on the terrain (paint weights, zoning, soil…).

Packs four characters into an owner domain, first character in the high byte (so 'RAIL' reads RAIL in a hex dump).

The owner domains Orrery reserves (FOwnerId::Domain).

Features authored in the terrain editor mode.

Who owns a feature: opaque to the terrain.

World position in metres, double precision (Large World Coordinates).

World point or direction in metres, double precision.

Which ground a query reads.

The surface a query actually reads: Top is Modified until an extension registers cover.

How exact a query answer is.

One ground answer.

Where a ray met the ground.

Integer address of a tile in one layer.

Inclusive rectangle of tiles.

Why the ground changed, as reported to listeners and in the change journal (FGroundChange::Cause).

Supplies natural ground: the cooked tile store in a game; a procedural, heightmap or imported-Landscape source in tests and the editor.

A place where the ground must be resident at full resolution: a camera, a player, or a simulation invoker (the construction cursor, a vehicle or agent that queries ground).

The residency radius of a view at Height_m above the ground under it: the ground within Radius_m of the camera horizontally and within Reach_m of it in 3D, so a view keeps its near set until that ground is far enough away for the far field to stand in for it, and has none once it is higher than Reach_m.

A tile FTerrainWorld wants loaded.