What actually produced this frame's pose, for the wrap seam. A single clip is one entry at weight 1; a blend space is the 2 or 3 clips it blended, with the same weights, in the same order.
A reflected object as a package's payload (ROADMAP §23.2): a root node <Class> "<Name>" { ... } carrying the MPROPERTY values that differ from the class's default object — a new field is absent and reads at its default
The first consumer of surface types, and the one that most obviously has to answer "what am I standing on". Runs after PhysicsSystem so the character's ground surface is the one from this tick's step.
Tick ordering inside a frame — UE5's ETickingGroup analog. Scene::OnUpdateRuntime dispatches in this order: PrePhysics → DuringPhysics → [ECS system update, which is where the physics step and TransformSystem live] → Pos
UE's PostProcessVolume. AVolumeActor already is one (its volume component blends a profile by priority and distance); the named class is what the Place actors palette and the Outliner's Type column show, so an author rea
Where a captured object reference pointed, in terms that survive the destroy/respawn: an address does not, but "the component of this actor named X" and "the actor named Y of class Z" both do.
One clip of the composition the pose was built from, at the weight the pose blend used. Blend-space clips are sampled phase-matched, so the stepper's clock is a phase and the representative clip gives it a length in seco
UE5's ExponentialHeightFog: distance fog whose density falls off exponentially with height. Density and falloff use UE's authoring scale (density 0.02 thins to a third over a kilometre at the fog height), and the in-scat
A local volumetric-fog volume. The froxel fog pass injects this volume's density (scaled by its albedo/emissive) into the light grid wherever a froxel falls inside it, on top of the global height fog — so a room fills wi
One row of the painted-foliage palette — UE5's UFoliageType, kept on the scene instead of as an asset: a type only means something together with the instances painted with it, and a scene that loses either half is broken
Hand-painted foliage: the palette and every instance the Foliage viewport mode placed with it. UE5's AInstancedFoliageActor. Instances are stored in WORLD space inside one packed field (see FFoliageInstanceCodec) rather
A strand groom (.mhair guide curves) on a character. Put it on the entity with the skeletal mesh: the guides ride the named bone of that mesh's posed skeleton (or the entity itself when the bone is empty or missing), sim
Gradient key for color interpolation along the line — reflected so LineRenderer's colorGradient array serializes through the array-of-struct path (descriptor emitted locally into the component's .refl.cpp, not registered
How the mouth is driven: by the level of the entity's own audio source (jaw opens with loudness), by the text of what is being said (visemes paced over the clip), or both layered.
Lip-sync over morph targets. Sits next to a Morph component and the entity's AudioSource: while the source plays, the jaw target follows the signal's envelope and, in Text mode, one of five viseme targets is held for eac
Off-mesh connection — a manual traversal link between two points on the nav mesh. Agents take it when its endpoints are on the planned route; useful for jumps, teleports, ladders, drop-down ledges, doors that aren't on t
Per-entity nav-mesh area override. Attach to an entity that also has a MeshRenderer to tag every triangle that mesh contributes to the bake with a custom area type.
Runtime obstacle that re-cuts the nav mesh through dtTileCache. Place on an entity (closed door, fallen tree, deployable barricade) — the system removes its volume from agents' walkable surface within a frame or two, and
One runtime look-at goal. The AnimationSystem runs it after IK, before the final FK, aiming constraint.bone's forward axis at targetPosition. Set targetInWorldSpace when gameplay supplies a world target (the common
One spring-bone chain plus its persistent dynamic state. The state carries tip positions/velocities across frames; the solver (re)initializes it from the animated pose on first use.
Secondary/procedural motion for a skeletal actor — look-at aiming and spring-bone chains (ponytails, tails, cloth straps). Attach it next to an AnimatorComponent; the AnimationSystem applies both after IK so they layer o
UE's ProjectileMovementComponent: kinematic flight for anything thrown, fired or launched, without a rigid body. FGameplayMovementSystem integrates the velocity each frame, sweeps the step so a fast projectile cannot tun
Retargets the animator's clips — authored against sourceSkeleton — onto the entity's own (target) skeleton at runtime. When enabled and a source skeleton is set, the AnimationSystem samples the active clip against the
The entity a rollback player drives: each simulated frame the session writes that player's input here (confirmed or predicted) before the rollback steps run, and a rollback rewinds it with the rest of the world.
UE's RotatingMovementComponent: spins the entity at a fixed rate — pickups, fans, turbines, a radar dish — with no graph ticking it. A pivot offset swings the entity around a point instead of its own origin.
UE's SceneCaptureComponent2D: a camera that renders the world into a RenderTargetAsset instead of the screen — a security monitor, a portal, a rear-view mirror, a minimap. The entity's transform is the camera and looks d
UE5's SkyAtmosphere: the physical atmosphere the sky, the sky light capture, aerial perspective and the sun's colour are all computed from. Coefficients are authored the UE way, as a colour times a scale per kilometre; t
UE's SpringArmComponent: holds its CHILD entities at the end of an arm that trails behind the entity, pulls in when the world is in the way, and can lag behind the motion it follows. Parent a camera entity (or a light, a
World-partition opt-in (UE's "Is Spatially Loaded"). Entities carrying this marker are bucketed into streaming sectors by the editor's Build Streaming Sectors pass and spawned/despawned at runtime by FSectorEntityStreame
A point the world streams around (UE's WorldPartitionStreamingSourceComponent). Streaming used to follow the main camera alone, which is wrong the moment a world has more than one viewer: on a listen server the sectors a
A control point of a landscape spline. position.y is the target height the corridor is graded to, in the same terrain-local meters the heightfield uses.
A grass type authored on the TERRAIN's layer palette rather than as a sibling FoliageComponent. UE5 hangs a grass type off the landscape layer info, and for the same reason: "sand does not grow grass" is a property of th
A sparse volume from a NanoVDB file — smoke, fire, a cloud — ray-marched over the lit scene after the volumetric fog (FVdbVolume, the VDB pass). The grid sits in the entity's space: its voxel coordinates map to world thr
A water zone: the authored object that says which stretch of world the water system is responsible for. UE's WaterZone does three jobs and so does this one — it bounds which bodies participate, it fixes the water info te
The engine-wide seam a plugin's InitializeModule hook writes into so its systems and asset serializers join the running engine without any core edit. Scene consults the registered systems alongside its built-in table; ev
Save/travel-carried world state as data: a system that owns durable gameplay state (quest log, faction standings) registers a fragment; SaveGame writes every fragment with state into the save root and FTravelManager carr
Template-character gameplay extensions: a plugin that adds a character-driven mode (base building was the first) registers input binding + a per-frame camera aim feed instead of the template naming its system. Plain func
What a provider is asked about. Actors is null for an ECS world that has no MWorld (a bare simulation); Ecs is null only for an MWorld with no ECS world.
The placeholder body of anything whose origin is its feet: a character controller (its Jolt capsule is lifted by half its height), a nav agent (Detour writes the navmesh surface point into its position). The built-in "ca
Returns false when the unload or the load failed (load failure leaves the module unloaded — snapshots are lost; the caller should surface that loudly). A module that was never loaded just loads. world may be null (no a
Plugin hook for hot reload: code that caches per-module artifacts (native behavior-tree tasks were the first) registers a purge handler called with the module handle right before it unloads. Rides the FModuleManager unlo
One active effect as a client sees it: identity, stacks and the clock, which is what a buff bar needs. Remaining time counts down locally between updates; the server only resends on apply, stack, refresh or inhibition.
Visual Scripting's view of geometric acoustics: click and read the echoes back (an echolocation mechanic is a click on a button, then what came back drawn or voiced), ask how a path between two points sounds, and read th
Visual Scripting's view of Attention: read the stage and value on any machine (a client shows what the host last sent), and on the host add to it or load the profile.
Blueprint's Print String and Draw Debug family for Visual Scripting and C++ gameplay. Every call is a no-op in release and profile: the timed list is drained by the world tick, so a shape drawn for two seconds is re-issu
The one object that outlives every world: UE's UGameInstance. A scene load or a map travel tears the actor world down with everything in it, so a value that must cross that boundary — the chosen difficulty, the lobby the
Input queries for scripting. The Visual Script node catalogue is built by walking MClassRegistry, so these MFUNCTIONs are the visual-scripting input surface — before this class existed, Visual Script graphs could not rea
Visual Scripting's live-ops: read remote-config values (defaults, the cached document or the fetched one, A/B variant values on top), ask which variant of an experiment this player is in (recording the exposure once), re
Visual Scripting's view of the mods: what loaded, in which order, what was refused and why, and the switches a mod menu needs (enable, reorder, apply).
The replicated player records (PlayerStateComponent) for Visual Scripting and gameplay: a scoreboard, a ready list, team colours. Reads work on every machine; the setters run on the host only and return false elsewhere.
Reflected façade over the renderer's backend selection, so Visual Script graphs can read the active graphics API and request a different one. A request never switches the live device — it writes the persisted rendering.g
Visual Scripting's time rewind (game.Rewind): "Rewind Seconds" takes the world back that far — to the newest captured moment at least that old — at the start of the next frame. False when rewind is off or nothing is held
Visual Scripting's view of rollback netcode (net.Rollback): feed this machine's input each frame, read the frame and the session's health. Inputs a rollback step reads come from each player's RollbackPlayer component.
UE's USaveGame: the player's progress, saved apart from the world. Unlocks, a crew dossier, the trophy record, settings that follow a profile — what a world-state slot has no place for, and what must survive a patch that
Blueprint's string library for Visual Scripting and C++ gameplay. Every function is a pure, side-effect-free operation on std::string values (UTF-8 bytes; the index-based ones count bytes, which is what a graph indexing
The water queries as Visual Script nodes and gameplay verbs. FWaterQuery is the C++ surface and stays authoritative; this is the reflected face of it, so a graph or an audio trigger can ask where the water is without a C
The pose a spawn verb asked for, applied during registration so it is in place before OnConstruct and BeginPlay run: a graph that reads its own location from its first event must see where it was put, not the origin. Eac
What the world is for. Game: a standalone game or server (and any world nobody told otherwise). Editor: the level being authored, ticked in edit mode. PIE: the disposable copy a Play In Editor session runs.
MWorld is a GC root: the mark phase reaches every spawned actor through the MPROPERTY m_actors list (and from there components via the actors' own MPROPERTY fields). An actor's Outer pointing at the world does NOT keep t
Pin wiring (Glacier model) Level-authored connections between instances: firing srcPin on the actor backing srcEntity runs dstPin as an event on every wired target (payload lands in the target's "PinPayload" variab
Backing-entity creation hooks. Without them, backing entities are raw ECS entities — fine for tests, but INVISIBLE to the renderer/editor, which iterate Scene's entity metadata (name/layer/active), not the raw World. A S
A key carries the SDL scancode, keycode and modifier state the editor received; a mouse event its position as a fraction of the window body (the two processes need not agree on DPI) and the relative motion in pixels; a b
Steam Input (or any platform with action-based controller input) as the gamepad half of InputActionSystem. Input contexts are action sets: the bottom enabled context is the active set and every context above it a layer,
What the game does while the platform overlay is up. Ducking and muting are separate flags because in a game whose audio carries the threat, silence is information the overlay was never meant to hand the player — so duck
An inspector event's listeners and the call that fires them. A listener is an actor (by stable id, so it follows the actor into the PIE copy) and one of its class's reflected functions taking nothing or one bool, number
Per-instance structure a module keeps on the actor's MDF node beside the variable values: the script components a designer added in Details. Writers run after the actor's own properties; readers run on load before any ho
One player's pane, both normalized (0..1, what a CameraComponent stores) and in pixels (what a swapchain-region blit takes). Adjacent panes tile exactly — the pixel edges are computed so neighbours share a boundary with
What kind of thing a stimulus is — the AI side's senses key off it. Sound and ScanPulse are heard through the room/portal graph, Sight is seen along a line of sight inside a view cone, Damage lands on its victim.
One thing that happened, as gameplay reports it. radius is the reach in metres when the emitter knows it (a scanner's range, a flare's visibility); 0 means the perceiver's own sense radius scaled by strength.
Core gameplay → AI notifications, as a lock-free game-thread multicast (same shape and rules as FInteractionDelegates): footsteps and gunshots report noise, weapons raise named situations — without core systems naming th
A recorded client-side prediction: the full pre-activation core state of the ASC, kept until the server confirms or rejects the activation the client ran locally. On reject the state is restored wholesale from here, whic
A clamp rule: keep attr within [minValue, current value of maxAttr]. maxAttr empty = no upper bound. Applied after every base change and every recompute, which is the pre/post-modifier clamp hook the default attribute
The one source of truth for Attention's numbers (audit C6/C8/C9/C10): band weights, stage thresholds, the Fill and tripod multipliers, decay and the per-stage "breathing" of the Substrate (P13). Host computes with it, th
Attention (AJAX's threat meter): how much the Substrate has noticed the crew's scanning. The HOST owns the number. Every scan any player fires adds its band weight — times the Fill multiplier for a full-sphere Fill, time
Where a hit landed. Filled by a trace/overlap and carried through the damage event so cues can play at the impact point and armour can read the surface.
The responsibility chain behind a hit (UE: DamageCauser + Instigator + EventInstigator). causer is the thing that physically dealt it (projectile, trap, the swinging weapon actor); instigator is the pawn/actor respon
Radial damage with distance falloff (UE FRadialDamageParams). Full baseDamage within innerRadius, interpolating down to minimumDamage at outerRadius along an exponent curve, zero beyond.
Process-wide, data-driven cue dispatch. HandleCue routes a fired cue to the most specific installed handler whose tag is an ancestor-or-equal of the cue tag (so a handler on "GameplayCue" catches everything under it, whi
The scene's geometric acoustics. On its first tick it builds the acoustic geometry — its own scan hierarchy over the level when the ScanHierarchy plugin is loaded, else the physics scene — and installs the scan hierarchy
Broadcast synchronously when a pawn interacts with an actor — AFTER the interactable's own reaction, BEFORE the Visual Script OnInteract pins (the order the old direct QuestSystem call had). Consumers (quest objectives,
Writes lip-sync weights into MorphComponent from the entity's playing AudioSource: the jaw from the source's envelope follower (enabled on demand), the visemes from the text paced over the clip. Runs before MorphSystem i
Guide dynamics, per placed groom. Verlet with follow-the-leader length constraints (every segment keeps its rest length exactly, root outward), a shape-matching pull toward the rest pose carried by the root transform, an
Loaded grooms by VFS path. Hair files are small (guides, not strands), so a load is synchronous; a file that fails is remembered and not retried each frame.
The engine's start and end of live-ops: remote config configured from the project (liveops.ConfigUrl, the host's registered signing key, a cache under Saved/LiveOps) with its cached document applied at once and a fresh o
FRemoteConfig — values a live game can change without a patch: defaults in code (or a defaults file), overridden by a signed document fetched over HTTP and cached for the next offline start, overridden again per A/B vari
FTelemetry — the analytics events a game records (FAnalytics::RecordEvent and Record here), stamped with time, session, user and the A/B variants in force, appended to a local journal and sent in batches. Nothing is reco
Mods for a shipped game: content paks found under the mod roots, an enable list the player owns, a load order from dependencies and loadAfter, every pak's signature checked, and a report of everything that does not fit —
Where the collider a fresh placement gets came from. Reported so the caller (and the test) can tell an artist's authored setup from a shape the engine measured, which are the two answers that must never be confused: one
What collider a freshly placed mesh should get. Nothing in the engine used to create one at all: every instantiation site added a MeshRenderer and stopped, so a placed prop either had no collision or — once a human added
The scale path for the trace. A grenade is thousands of rays in one frame, which is a dispatch, not a loop of physics queries — but it is the SAME pattern the CPU trace walks, so a shot fired here and a shot re-traced on
The scan loop between a scanner and the clouds. Every machine holds its OWN cloud (what this player scanned, owner slot 0) and a SHARED cloud (what the others scanned, re-traced locally from their shots, tinted by a per-
Wire channels mirrored from Networking's NetworkChannel BY VALUE — the journal is transport-agnostic (only the sink installer touches a real transport) and must stay includable in a NoOnline closure that has no Networkin
How a shot distributes its rays. Every scanner variant in the game is one of these plus numbers — a wide sweep, a tight long-range beam and a grenade that floods a room differ only in cone width, ray count, range and fal
One trigger pull, and the entire replication payload for it. A shot is re-traceable from these bytes alone: every ray direction is a pure function of (seed, tick, rayIndex) and the shot's frame, with no RNG state carried
The deterministic ray pattern, and the single definition of it. LidarTrace.comp.hlsl mirrors these four functions instruction for instruction; the GPU trace and the CPU trace must agree or a client re-tracing a replicate
What happens when the cloud is full, stated as data rather than left to a clamp somewhere. Pages are the resource that actually runs out: the GPU pool is maxPoints / kPageCapacity pages and a chunk holds one page per k
Points are ordered by a rank that is a pure function of the dedup cell they occupy, so "draw at half density" is "draw the first half" and "thin this chunk" is "drop the tail" — both stable under insertion order, which i
The persistent half of a scanned world: every point that landed on something that cannot move, held chunked by sector so it can be culled, thinned, evicted and written to disk a piece at a time.
Points that landed on something that can move. They are kept apart from the persistent cloud because they are wrong the moment the body moves — and because that wrongness is the game: scan, see a silhouette standing in t
Float math whose result is the same bit pattern on every machine the game ships to. The C runtime's sin/cos/pow are free to differ in the last ulp between MSVC, glibc and Apple's libm, and one ulp in a ray direction move
The deterministic scan hierarchy (§29 A2). Shots replicate, not points, so every client re-traces every shot — and the cloud a player sees is only shared if every client's trace returns the same hits bit for bit. Jolt an
A static and a dynamic hierarchy traced as one, plus the shot loop with the scan-response table in it. This is the trace every client runs on a replicated shot.
What a level author said about one entity's scan geometry. The scanner's ScanMeshComponent lives above Game, so it reaches the gather through this rule rather than by type.
The level's triangles gathered into an FScanBvhScene: every enabled mesh renderer, static bodies into the static hierarchy once, moving bodies and one tessellated capsule per animated bone into the dynamic hierarchy on e
The deterministic scan hierarchy as acoustic geometry: the walls the players scan are the walls sound is stopped by and bounces off. Bone capsules are passed through — a body in a doorway does not wall the room off, and
FScanBvhWorld as a scan trace backend, with no level-author rules (those live above Game, in the PointCloud module's tracer, which derives from this). Sound reaches it when the ScanHierarchy plugin is not enabled, so a l
Free functions
Signature
Description
using FScanBvhRuleFn = std::function<bool(World& world, EntityID id, FScanBvhGatherRule& rule)>
Fills rule for an entity that has one and returns true; false = defaults.
Gaussian splats grown from the accumulated scan (§29 A6). Each chunk of the persistent cloud is binned into cells; a cell with enough points becomes one splat fitted to them: mean position, covariance from the points' sp
A trace the LiDAR scanner can cast shots against instead of the Jolt colliders. The Embree scan hierarchy is one, and it lives in an opt-in plugin (ScanHierarchy) so a game that does not enable it ships no Embree; with n
The one slot a backend plugin fills when its module loads. Lives in Game because both the scanner (PointCloud) and the plugin link Game and neither may link the other.
Gives a Gaussian splat instance a static collider built from its splats, so a captured room can be walked in rather than only looked at. Runs before the physics step and only when the settings or the asset changed.
Applies MorphComponent weights to the entity's mesh. Runs in all scene modes (facial poses must show while editing); the per-entity dirty check (weights vs lastWeights) makes idle frames free.
Q16.16 fixed point for gameplay state that must come out the same bits on every machine and every build: the float rules a compiler may follow (contraction into FMA, x87 vs SSE, reassociation under fast-math) differ acro
PCG32 (O'Neill): small, fast and a fixed algorithm, so a seed gives the same sequence on every machine — std::uniform_*_distribution does not promise that across standard libraries. Copyable, which is how rollback saves
FRewindBuffer — time rewind as a gameplay feature: a ring of saved states, one every 1/captureHz seconds, holding the last seconds of play within a memory budget, any of which can be made the present again. It saves an
The play session's time rewind (game.Rewind): the scene's ECS world and physics scene are captured into a FRewindBuffer a few times a second, and a rewind asked for — from Visual Scripting, MRewindStatics::RewindSeconds
Moves session messages between players. Unreliable is fine: every message carries all the input the receiver has not acknowledged yet. Receive's outFromPlayer is the transport's word for who sent it — the connection, n
FRollbackSession — GGPO-style rollback for any number of players over any transport. Each frame the local input is filed inputDelay frames ahead and sent; inputs not yet heard from a peer are predicted (its last known
The project's rollback netcode in a play session (net.Rollback). With the switch on and an online session running, every player is a rollback player in player-id order; the scene's ECS world becomes the rollback simulati
Peers in one process joined by a simulated link: every message is held for a latency (plus jitter) counted in ticks and dropped at a loss rate, all from a seeded stream so a run is reproducible. What the rollback row dri
Session messages over a network transport (ENet or Steam), unreliable and unsequenced is enough: every message repeats what the peer has not acknowledged. Players map to transport peers one to one.
What a saved frame holds: the whole ECS world (deep-copied archetype columns, the same capture Play-In-Editor restores from) and the physics world's full state.
FRollbackWorld — an ECS world (and optionally a physics world) as the deterministic simulation a rollback session or the time rewind drives. Advance writes each player's input into its RollbackPlayerComponent, runs the r
Quick-look metadata for a save slot. Cheap to read without deserializing the full scene blob — used by the save-game browser to render the slot grid (player name, timestamp, scene name, playtime).
Key/value bag for the script-authored portion of a save. World state (entity positions, animator phase, physics) is handled by the Scene snapshot — Custom is for the player-progress contract: gold, quest flags, unlocked
An async SaveWorldState captures on the game thread (journal flush, the document tree, a copy of each cloud's chunk records) and leaves the rest — cloud compression, crcs, the binary encode and the writes — to the writer
GameObject wraps an Entity with metadata (name, tag, layer, active state). Every GameObject always has a TransformComponent. This provides a Unity-style OOP API on top of the ECS.
Data layers of a loaded One-File-Per-Actor level at runtime (UE's World Partition Data Layers, runtime state Loaded/Unloaded). The layers and each actor's membership live in the level's files (FExternalActorFiles); this
Level Instances of an open One-File-Per-Actor level, edited live (UE's Level Instance actor): placing, moving or removing an instance writes the level's World package as before and also brings the open scene to what the
The game-thread half of the persistent render scene: one proxy per entity that draws through a MeshRenderer, holding what the mesh gather used to look up again for every entity on every view — five hashed component looku
Turns an imported model's source node graph into an actor/entity tree, the UE analogue of dragging an FBX with several mesh objects: a model whose nodes carry more than one geometry object expands into a parent + one chi
Engine-side prefab → entity-tree instantiation. Operates on PrefabAsset (already parsed MDF nodes per entity) so it works in Runtime / dedicated server / any build without the editor.
What a scene serialization is for. A save game, the PIE snapshot and a deep copy capture the play session, runtime spawns included; saving the level writes only what was authored into it.
Which side of the authoring/Play line the frame being gathered is on. Latched by OnUpdateEditor / OnUpdateRuntime — they are the only callers that know, and OnRender runs after them.
Access to the actor world (UE-style gameplay layer). Lives as long as the scene does — created by Initialize, destroyed by Shutdown — so placed actors are visible while editing, not only between Play and Stop. Spawn game
A scene's Environment and PostProcess blocks, written through the reflection serializer instead of by hand: only fields that differ from the struct defaults are saved (UE's bOverride_* delta), enums are stored by NAME so
What a new level starts with, UE5's "Basic" template: a sun driven by a day-night cycle, a sky light that captures the atmosphere, the atmosphere itself, clouds and exponential height fog, plus the ground and the post pr
Residency of the mesh assets a host loaded for its scene follows the entities that use them, as a World Partition cell's packages do in UE: when a sector streams out, its entities drop their references, and an asset noth
Owns the proxy entities of one world. Bound to a World (raw entities) or through Scene hooks so the proxies carry scene metadata; either way a proxy is a Transform + a static Mesh collider and nothing else.
Texture2D adapter over a streamed texture: GetImage() resolves to the manager's CURRENT image, so whoever rebuilds a descriptor set after a mip swap picks up the new residency automatically. SceneRenderer's material DS c
A cell of one of the world's streaming grids. grid indexes StreamingManager::GetGrids() (0 = the default grid every manifest has); y is the vertical cell and stays 0 on a grid with no cell height.
One runtime grid (UE World Partition's runtime grids): its own cell size, optionally a cell height — a tower or a mine shaft streams by floor instead of loading every level above the player — and its own radii, so small
Serialized entity trees — the EntityTree node Scene::SerializeEntityTreeToNode produces at cook time, cooked into the manifest as a child node. FSectorEntityStreamer restores them on load (no text, no parse on the stre
The sector manifest cook, one sector at a time. Begin reads the manifest that is already there (layers, regions, always-loaded flags and hand-added assets survive a regenerate), collects the streamable roots and buckets
Texture mip-streaming (slice 1). A streamable texture is a cooked .mtex whose per-mip table lets us read ANY mip range without touching the rest of the file. Registration makes only the coarse TAIL resident; StreamTo(mip
Camera-distance mip prioritization on top of FTextureStreamer. Each tracked texture carries world-space bounds + the world extent one repeat of the texture covers; Update() projects that extent to screen pixels, picks th
Turns the driver's VRAM budget into a cap on a streaming pool (one governor per pool: textures, mesh LODs). The configured pool is a guess made at startup (half the card); the budget the OS grants shrinks when another pr
One hand-placed instance, in WORLD space. The normal is the surface it was painted on, kept so align-to-normal can be changed on the palette after the fact without repainting.
The packed form of FoliageInstancesComponent::instances: a magic, a version, a count and fixed 48-byte records, base64 for the text scene format. The version is what makes the field schema-tolerant — a newer record layou
The brush maths as pure functions, so the count a dab targets, the falloff that thins its rim and the filters that refuse a slope are measurable without a viewport, a scene or a device. The tool owns the gesture and the
One non-destructive sculpt layer. delta is the layer's contribution in meters and coverage records where the layer has authored anything at all — Alpha/Min/Max need to tell "authored 0" from "never touched", which a
The stack behind every height edit. Ops still run on a plain composited FEditableHeightfield — nothing downstream (mesh build, collision, GPU upload) knows layers exist — but the difference an op made is folded into the
Droplet-based hydraulic erosion. Offline by design: a full pass over a 1025² field is seconds of CPU, so it belongs behind an explicit "Erode" button, not on a brush dab.
How far a pass run a slice at a time has got. Stepping one to the end leaves the field exactly as one full call does: the droplet stream and the per-iteration jitter both carry on from here.
World-partition-style tiling: one oversized source heightmap cut into a grid of terrain entities. Tiles overlap by exactly one texel so neighbours share an edge row and StitchAdjacentTiles has nothing left to reconcile.
FTerrainNoiseAsset (.mnoise) — an authored procedural noise stack, the thing UE5 has no equivalent of: World Machine's layer list as a first-class asset. It stores the LAYERS, not a baked heightfield, so the same stack d
Per-texel XZ displacement of the render grid, in meters — UE5's landscape XY-offset map. The heightfield stays a regular grid; this says where each of its samples actually SITS in the world, which is the whole trick behi
Landscape splines: a polyline with a per-point width profile that flattens the heightfield into a corridor and paints a layer along it. Pure geometry — it never touches the component, the GPU or the collider, so the same
The RG16F payload the CDLOD vertex path samples, beside the R32F height texture: one half PAIR per texel (x then z) in terrain-local METERS, row-major over region. The shader adds the pair straight onto the sample's lo
Residency of one landscape tile. Deliberately NOT StreamingSector's state machine: a sector's cost is asset IO, so it has a Loading state to wait in. A terrain tile's cost is a synchronous CPU rebuild — mesh, quadtree bo
The tile half of world partition, sharing StreamingManager's policy rather than inventing a second one: the same three radii (load < keepAlive < unload), the same "closer is sooner" priority, the same per-frame budget. A
Builds and shades spline-driven water bodies (Ocean / Lake / River). Runs alongside the global WaterSystem: each WaterBodyComponent gets its own surface mesh regenerated when the spline changes, its own water material, a
One selected leaf of the water quadtree, in the body's LOCAL space. level counts down from the root: 0 is the whole ocean as one node, maxLevels is the finest.
A camera-following quadtree over one ocean body: the frustum's worth of the surface is meshed finely and the rest coarsely, so a 4 km ocean costs what is on screen rather than what exists. UE's WaterQuadTree has the same
One heightfield texel the carve wants to move, and how far it commits. weight 1 = the channel floor exactly, 0 = leave the terrain alone; the band between is the bank slope.
The texel window the carve touches, half-open, plus the edits inside it. The window is what a terrain rebuild and an undo snapshot are keyed on, which is why it is produced even when the edit list is short.
How a heightfield maps to the world. The carve is written against this rather than against the terrain module's own types on purpose: the terrain edit API is being reworked in parallel, and a spline-to-texel solve that t
Records are MDF nodes from capture to save to overlay. They were text, so a save wrote each entity's state as a string, a load parsed every string back, and a binary save carried text inside it — about six times the pars