A mark on the montage timeline (see MontageNotify). Branching points are dispatched at their exact time mid-tick so a jump decided from one lands on the authored frame.
The pose-composition graph (UE's AnimGraph): a node network that composes the runtime pieces that already exist — the state machine's inertialized result, standalone clip players, per-bone layered blends, value-driven po
What a skeletal-control node does to one transform channel. Ignore leaves the incoming pose alone, which is why it is the default: a freshly added ModifyBone must be a no-op until something is authored on it.
The space a skeletal control reads and writes in. Component is the rig's own accumulated space (the skeleton root transform excluded) — a bone written there keeps its result no matter what its parents did, and its childr
One node's resolved wiring: input node INDICES per pin, its fan-out, and every bone name it authored turned into a bone index. Resolved once per (graph structure, skeleton) instead of per frame, so the evaluator never co
Every buffer an evaluation needs, kept across frames so the capacity is paid once per entity: the per-node pose slots (the memo), the bind pose, and the rig / reference / weight scratch the node bodies used to allocate o
Per-entity runtime state. Lives on the AnimatorComponent so a controller asset shared across entities never shares clocks; keyed by node id so an editor graph edit (add/remove nodes) leaves surviving nodes' state alone.
How an additive delta composes onto the base (UE's EAdditiveAnimationType). LocalSpace multiplies the delta rotation into each bone's local rotation. MeshSpace measures and applies the ROTATION delta in component space —
Where the additive reference (base) pose comes from (UE's EAdditiveBasePoseType). ReferencePose ignores any reference clip and measures the delta from the skeleton bind pose. AnimationFrame samples the reference clip at
One montage slot's overlay for THIS frame: its playhead already advanced and its pose already sampled, BEFORE the pose graph runs, so a Slot node can compose it at the point in the graph the author put it. consumed is
How one authored field of FAnimGraphNode is stored. The set is deliberately small: everything a pose node exposes is a number, a flag, a name, a list of names, a vector or a fixed choice — plus the one blend grid, which
What ROLE a node kind plays. The registry lives in the runtime module and must never name an editor colour, so it names the role and the panel maps roles onto Arc style tokens exactly once instead of once per kind.
A pointer-to-member per storage kind rather than one byte offset: FAnimGraphNode holds std::vector and std::string members and so is not standard-layout, which makes offsetof on it only conditionally supported.
One authored property of one node kind: what it is called in the MDF, what the editor labels it, how it is stored, what it defaults to, and when it is worth showing at all.
Everything the rest of the engine needs to know about one node kind. Adding a kind is this table row plus its evaluator — the serializer, the editor palette, the inspector rows and the document comparison all read it fro
What a data-driven notify does when it fires. The engine resolves the kind to an action at fire time through FAnimNotifyDispatcher — the designer authors only the data, no per-notify code callback.
Process-wide, data-driven notify dispatch. AnimationSystem fires every clip notify through here; the engine installs one handler per kind (sound, particle, Visual Scripting) and the editor / tests can add an observer tha
Free functions
Signature
Description
using AnimNotifyParam = std::variant<float, int32_t, bool, std::string>
A named point sync groups align ON. Pinning normalized time makes two clips agree on "40% through"; pinning a marker makes them agree on the FOOTFALL, which is the thing that has to line up when a walk of one length blen
Where a time sits in the marker ring: the ordered PAIR names the segment, alpha is the fraction through it. A follower reproduces this position in its OWN marker list, so the segment means the same thing in both clips ho
Named scalar curve track (UE's anim curves): per-clip float data that is NOT a bone or a morph — material parameters, graph parameters, metadata. Keys share MorphKey's shape (time in TICKS, linear interpolation).
How one track (translation / rotation / scale of one bone) is stored. Quantized is the normal case; Raw is the lossless fallback taken when the measured error of the quantized form exceeds the caller's tolerance — a long
Quantized vector key: time as a fraction of the track's own time span, each axis as a fraction of that axis's own range. 8 bytes against the 16 a raw PositionKey costs.
Lossless input/output form. The codec speaks these rather than AnimationClip's PositionKey/RotationKey so the cook side can call it without including a dllexported runtime header.
Everything needed to decode one track without touching any other track: the format, the key count, where the keys start in the owning blob, and the two affine ranges (time, value) the quantized words are fractions of.
One per-bone budget: bones whose name matches bone compress at these tolerances instead of the clip's. bone is an exact name or a pattern with a leading and/or trailing * ("*Finger*", "jaw*", "*_end"). A negative t
Update the controller — evaluates transitions, advances the state clock. Transitions no longer cross-fade two clips here; they switch the current state instantly and flag transitionStarted, and the AnimationSystem inerti
MDF serialization for AnimationController assets (.animgraph). The controller is the animation-graph asset the editor authors: states, transitions, conditions, blend spaces and parameters all round-trip through here so t
What the per-bone number in a blend profile MEANS. The three modes are UE's, and they are genuinely different questions: TimeFactor stretches the blend WINDOW per bone (the legs finish a transition while the torso is sti
One authored row. includeChildren is the branch-root form the layered-blend bone filter already uses: naming a spine and taking the subtree is how a rig is actually authored, and spelling out every finger is how that a
A profile resolved against one skeleton. Kept per ANIMATOR INSTANCE for the same reason FMirrorResolved is: a controller asset is shared by every entity playing it and animation evaluates on job workers, so a cache hangi
The blend profile (UE's UBlendProfile): a named per-bone scale that a transition, a layered blend or a value blend applies on top of its own weight. Pure data — resolution against a skeleton is a static, so one profile c
One clip placed at a position in 1D parameter space. clipName is the durable reference (robust to a model reordering its clips); clipIndex is the resolved cache the AnimationSystem samples, filled from the name at bi
How the GPU blends a vertex's bone influences. Linear (LBS) averages matrices and pinches a twisted joint into a candy wrapper; DualQuaternion blends rigid motions on the rotation manifold and keeps the volume, at the co
One clip's share of the frame's final pose, published by the animation system after evaluation. Base contributions accumulate at weight (blend-space weighting); montage overlays lerp over the accumulated base by `weigh
Attaches a procedural .controlrig rig to a skeletal-mesh actor. After the AnimGraph produces the frame pose, AnimationSystem feeds that pose plus the component's control values through the rig graph and uses the output
Which chain a Begin node heads. Forward is the per-frame post-process every rig has always run. Construction runs ONCE when the rig is bound to a skeleton and writes control values (a control snapped to a bone at bind ti
The space a control's authored value is expressed in. Component is the rig's own accumulated space and is the only thing that existed before — a target authored there is a raw component-space point, so it detaches the mo
A procedural rigging node graph (.controlrig, MDF). It reads an input bone pose plus a set of named control inputs and writes an output pose, mutating bones through IK / aim / offset nodes wired off an execution chain
One bone's skinning transform as a unit dual quaternion (rigid part) plus the scale a dual quaternion cannot carry. Dual-quaternion skinning blends rigid motions on the rotation manifold, so a wrist twisted 180° keeps it
The CPU half of the GPU dual-quaternion path. The bone arena keeps its Mat4 slots: a DQ palette is PACKED into the same 64-byte records (row 0 = real, row 1 = dual, row 2 = scale, row 3 = 0,0,0,1) and the draw's bone bas
Angles are measured against the direction ARRIVING at the joint (the previous segment), except at the chain root, where the reference is the root's own outgoing direction in the pre-solve animated pose — there is no prev
One thing the body is being asked to reach. Unlike an IKGoal or a FABRIKGoal this does NOT name a chain: the chain is whatever lies between the solver's root and this bone, which is the entire point — two effectors shari
Per-bone resistance. 0 leaves the joint free, 1 pins it where the animation put it. A stiff chest is how a reach reads as a reach and not as a character folding in half — a positions-only solver has no other way to say t
Which plane the pose is reflected through, named by the axis the plane is normal to. X (the YZ plane) is the correct answer for every rig authored with the character facing down +Z or -Z, which is all of ours.
One find/replace used to discover pairs by name. from is looked for at every position in the bone name and the first substitution that names a real, still-unpaired bone wins — a rule of "_l"→"_r" must not claim "spine_
A mirror table resolved against one skeleton. Kept per ANIMATOR INSTANCE, never on the table itself: a controller asset is shared across every entity playing it and animation evaluates on job workers, so a cache hanging
The .mirror asset (UE's UMirrorDataTable): the left/right bone pairing and the plane a pose is reflected through. It is pure data — resolution against a skeleton and the reflection itself are statics, so the same table
A mark on the MONTAGE's own timeline rather than on a source clip's notify track. A montage assembled from several clips needs marks that belong to the assembly — "the combo window opens here" is a property of the montag
A scalar curve on the montage timeline, sampled at the playhead and lerped over the base curve values by the montage weight. Clip curves cannot cover this: a montage that chains two clips has no single clip timeline to k
A montage as a FILE of its own (.montage) instead of a row inside the model's .manimmeta sidecar. The payload is the same FAnimMontageDef the sidecar has always carried — sections, slot, blend in/out, play rate, mo
What the model is asked for. The prompt, reference clip and constraints are conditioning a model may or may not honour; a bake script that ignores a key still produces a stream, so every one is optional on the read side.
<project>/Config/MotionBricks.ini: the command that turns a request file into a stream file, and where to run it. Kept in project config rather than in the engine because the Python environment is per machine.
The pose block of a query taken from the pose the character actually showed last frame — after montages, IK, ragdoll recovery and blends — not from the database frame that happens to be playing (UE's pose history collect
Assembles a query in RAW feature units; the matcher normalizes it before the search. The pose block normally comes from the database frame currently playing (CopyPoseFromFrame) — the cheapest exact answer to "what is the
Spring-damper projection of the character's desired velocity into the future trajectory the search asks for. Also keeps the past window the schema needs.
Playback head over the database: advances the current clip, and every searchInterval seconds re-searches. It only switches when the best candidate beats simply CONTINUING the current animation by switchBias — without
One named pose: a local transform per TRACKED bone, index-parallel with FPoseAsset::bones rather than with the skeleton. A corrective pose touches a handful of joints, and storing the whole rig per pose would cost two or
A pose asset resolved against ONE skeleton. Kept per animator instance for the reason FMirrorResolved and FBlendProfileResolved are: an asset is shared by every entity that names it and animation evaluates on job workers
The .pose asset (UE's UPoseAsset): a set of named poses over a shared bone list, applied either as deltas from a base pose (the normal case — a corrective, a facial shape, a hand grip) or as full local transforms.
Which radial basis turns "how far is this joint from the target pose" into a weight. Gaussian is UE's default and the one that reads as a soft corrective; Linear falls off to exactly zero at the radius, which is what an
UE's AnimNode_PoseDriver: a joint's own rotation picks which stored poses fire, so a shoulder lifted to 90 degrees pulls in the corrective authored at 90 degrees without anything in gameplay knowing the pose exists.
Process-wide path → pose asset table, the shape FPoseProviderRegistry already established for the ExternalPose node. The graph addresses a pose asset by its .pose path and the evaluator runs on job workers, so the load
Process-wide name → provider table. Registration does NOT transfer ownership — the registering module (plugin, tool, test) keeps the provider alive and unregisters before unloading.
Procedural look-at: aims one bone's local forwardAxis at a world target, clamped to a cone of maxAngleDegrees around the ANIMATED orientation so heads don't owl-turn. weight slerps between the animated and solved p
Spring-bone chain — secondary motion for ponytails, tails, cloth straps, antennae. bones is parent→child order where bones[i+1] is the child of bones[i]; each driven bone's "tip" is its child's animated position, simul
What the retargeted ROOT's translation does (UE's root settings): None the target root stays at its rest position — the animation plays in place. GloballyScaled the source root's travel, scaled by the rigs' h
One chain row of the mapping table: a limb on the source rig paired with the limb on the target rig that should follow it. FK is the rotation replay every matched bone in the chain gets; IK is the end-effector placement
A rotation (degrees, engine euler order) and translation offset applied to one bone's REST pose before the retarget is built — UE's retarget pose. The deltas are re-expressed against the adjusted rest, so an A-pose sourc
The two skeletons the asset was prepared against, with the pose adjustments already folded into their rest poses, and the map built over them. Callers keep this across frames and re-Prepare only when the asset or a skele
The authored .retarget — UE's IK Retargeter asset. It carries what the runtime FRetargetOptions carries (the name map, the prefix strips, the translation modes and the chains) plus what only an authoring surface can ho
How a matched bone's TRANSLATION retargets (UE's per-bone modes): Skeleton target rest position — bone lengths belong to the target rig (the safe default for humanoids). Animation the source's animated loc
Name-matching rules applied before exact-name lookup, in order: 1. explicit nameMap (source bone name → target bone name), 2. prefix strips on BOTH sides ("mixamorig:" → ""), then exact match. Per-bone translation mode
Animation retargeting — replays a pose authored on one skeleton onto another with the same (or partially matching) bone NAMES but different proportions and rest orientations.