Animation

Animation module API reference: 37 headers · 190 types · 1705 symbols.

Generated from animation.json · Oct 26, 2026Version 1.0.0
Build name
MowoEngine.Animation
Source
Engine/Source/Runtime/Animation/Public
Category
Runtime
Contents
37 headers · 190 types · 1705 symbols

Animation/AnimClipMetadata.h

KindTypeSummary
structFAnimNotifyDef
structFAnimCurveKeyDefOne key of an authored scalar curve. Times are SECONDS in the sidecar (like notify times) and convert to ticks at ApplyToClips.
structFAnimCurveDef
structFAnimClipMetaEntry
structFAnimMontageSectionDef
structFAnimMontageNotifyDefA 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.
structFAnimMontageDef
classFAnimClipMetadata

Animation/AnimCompressionAuthoring.h

KindTypeSummary
classFAnimCompressionAuthoring

Animation/AnimGraph.h

KindTypeSummary
enumEAnimGraphNodeTypeThe 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
enumEBoneModifyModeWhat 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.
enumEAnimBoneSpaceThe 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
structFAnimGraphNode
structFAnimGraphLink
structFAnimGraphCompiledNodeOne 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
structFAnimGraphCompiled
structFAnimGraphEvalScratchEvery 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
structFAnimGraphInstancePer-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.
structFAnimGraphInstance::FClipState
structFAnimGraphContext
classFAnimGraph

Animation/AnimGraphNodes.h

KindTypeSummary
enumEAnimLayerBlendType
enumEAdditiveTypeHow 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 —
enumEAdditiveBasePoseModeWhere 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
structFMontageSlotPoseOne 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
structFBoneGroup
structFLayeredBlendInput
classFLayeredBlendPerBone
classFBlendPosesByValue
classFPoseCache

Animation/AnimGraphRegistry.h

KindTypeSummary
enumEAnimGraphPropTypeHow 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
enumEAnimGraphNodeStyleWhat 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.
classTAnimGraphEnumAccessA 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.
structFAnimGraphNodePropOne 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.
structFAnimGraphNodeDescEverything 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
classFAnimGraphNodeRegistry

Animation/AnimNotify.h

KindTypeSummary
enumAnimNotifyKindWhat 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.
structAnimNotifyInstantaneous notify — fires once when playback crosses time.
structAnimNotifyStateRanged notify — fires a Begin edge when playback enters [beginTime, endTime] and an End edge when it leaves.
enumAnimNotifyPhase
structFFiredAnimNotifyThe resolved context handed to a notify handler at fire time.
classFAnimNotifyDispatcherProcess-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

SignatureDescription
using AnimNotifyParam = std::variant<float, int32_t, bool, std::string>

Animation/AnimationBlender.h

KindTypeSummary
classAnimationBlenderBlends between two animation clips, producing interpolated local transforms Used for crossfading between animations (e.g., Walk -> Run transition)

Animation/AnimationClip.h

KindTypeSummary
structPositionKey
structRotationKey
structScaleKey
structAnimationEvent
structAnimSyncMarkerA 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
structAnimMarkerSegmentWhere 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
structAnimationChannelAnimation channel — keyframes for a single bone
structMorphKey
structMorphChannel
structFAnimCurveNamed 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).
classAnimationClipA complete animation clip (e.g. "Walk", "Run", "Idle")
structAnimationClip::FFiredNotifyStateEdgeA begin/end edge of a ranged notify state, produced by GetFiredNotifyStateEdges.

Free functions

SignatureDescription
using AnimEventParam = std::variant<float, int, bool, std::string>Animation event — fires at a specific time in the clip

Animation/AnimationCompression.h

KindTypeSummary
enumEAnimTrackFormatHow 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
structFAnimQuantizedVectorKeyQuantized 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.
structFAnimQuantizedRotationKeyQuantized rotation key: time plus a 48-bit smallest-three quaternion. 8 bytes against the 20 a raw RotationKey costs.
structFAnimVectorKeyInLossless 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.
structFAnimRotationKeyIn
structFCompressedAnimTrackEverything 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.
structFCompressedAnimChannel
structFAnimBoneToleranceOne 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
structFAnimCompressionSettings
structFAnimCompressionStats
classFAnimTrackCodec

Free functions

SignatureDescription
static_assert(sizeof(FAnimQuantizedVectorKey) == 8, "quantized vector key must stay 8 bytes — it is written to disk")
static_assert(sizeof(FAnimQuantizedRotationKey) == 8, "quantized rotation key must stay 8 bytes — it is written to disk")

Animation/AnimationController.h

KindTypeSummary
enumTransitionCompareOp
enumTransitionParamType
enumEAnimSyncRole
structTransitionConditionA single serializable condition for a transition
structAnimationTransitionTransition between animation states
structAnimationStateA single animation state in the controller
classAnimationControllerState machine for managing animation transitions and blending Designed to work with AnimatorComponent and AnimationBlender
structAnimationController::UpdateResultUpdate 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

Animation/AnimationControllerSerializer.h

KindTypeSummary
structAnimationControllerSerializerMDF 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

Animation/AnimationKeyReduction.h

KindTypeSummary
structFKeyReductionStats
classAnimationKeyReduction

Animation/AnimationSampler.h

KindTypeSummary
classAnimationSamplerSamples an AnimationClip at a given time, producing per-bone local transforms

Animation/BlendProfile.h

KindTypeSummary
enumEBlendProfileModeWhat 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
structFBlendProfileEntryOne 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
structFBlendProfileResolvedA 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
classFBlendProfileThe 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

Animation/BlendSpace.h

KindTypeSummary
structBlendSample1DOne 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
classBlendSpace1D
structBlendSpace1D::Result
structBlendSample2DOne clip placed at a position in 2D parameter space. See BlendSample1D for the clipName/clipIndex split.
classBlendSpace2D
structBlendSpace2D::Weighted

Animation/Components/AnimatorComponent.h

KindTypeSummary
enumAnimLayerBlendModeNo MOWO_API — dllexport doesn't apply to enums
enumESkinningMethodHow 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
structAnimationLayerAnimation layer for additive/override blending
structFMontageSlot
structFAnimPoseClipContributionOne 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
structAnimatorComponent

Free functions

SignatureDescription
using AnimEventCallback = std::function<void(const std::string&, const std::unordered_map<std::string, AnimEventParam>&)>Animation event callback: (eventName, params)

Animation/Components/ControlRigComponent.h

KindTypeSummary
structControlRigComponentAttaches 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

Animation/Components/MotionMatchingComponent.h

KindTypeSummary
structFMotionDatabaseSlotOne named database of a character's set (UE's chooser picking a database by gameplay state: "Stand", "Crouch", "Carry").
structMotionMatchingComponent

Animation/ControlRig.h

KindTypeSummary
enumEControlRigNodeType
enumEControlRigEventTypeWhich 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
enumEControlRigSpaceThe 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
enumEControlRigValueType
enumEControlRigMathOp
structFControlRigTransform
structFControlRigValue
structFControlRigControl
structFControlRigNode
structFControlRigConnection
structFControlRigPin
classFControlRigA 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

Animation/DualQuatSkinning.h

KindTypeSummary
structFDualQuatOne 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
classFDualQuatSkinningThe 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

Animation/IK/FABRIK.h

KindTypeSummary
enumEIKJointConstraintDescription of an N-bone chain solved iteratively by FABRIK (Forward And Backward Reaching Inverse Kinematics).
structFIKJointLimitAngles 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
enumEIKChainSolverHow an N-bone chain reaches its target.
structFABRIKChain
classFABRIKFABRIK solver. Iterative, positions-only, then converts to bone rotations.

Animation/IK/FullBodyIK.h

KindTypeSummary
structFFullBodyIKEffectorOne 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
structFFullBodyIKBoneSettingPer-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
structFFullBodyIKSetup
classFFullBodyIKUE's Full Body IK, as a multi-effector FABRIK over the skeleton TREE rather than over one chain.

Animation/IK/TwoBoneIK.h

KindTypeSummary
structTwoBoneIKChainDescription of a three-bone chain that gets solved analytically.
classTwoBoneIKTwo-bone IK solver. Analytical, single-iteration, runs in O(1).

Animation/Inertialization.h

KindTypeSummary
classPoseMath
classFInertializer

Animation/MirrorTable.h

KindTypeSummary
enumEMirrorAxisWhich 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.
structFMirrorBonePair
structFMirrorNameRuleOne 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_
structFMirrorResolvedA 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
classFMirrorTableThe .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

Animation/Montage.h

KindTypeSummary
structMontageSection
structMontageNotifyA 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
structMontageCurveKey
structMontageCurveA 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
classMontage
classMontagePlayer
enumMontagePlayer::Phase

Animation/MontageDocument.h

KindTypeSummary
classFMontageDocumentA 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

Animation/MotionBricksBake.h

KindTypeSummary
structFMotionBricksWaypoint
structFMotionBricksBakeRequestWhat 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.
structFMotionBricksStreamBone
structFMotionBricksStreamFrameOne frame of LOCAL transforms, index-parallel with the bone table.
structFMotionBricksPoseStream
structFMotionBricksToolConfig<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.
structFMotionBricksBakeStats
classFMotionBricksBake

Animation/MotionMatching.h

KindTypeSummary
structFMotionFeatureBone
structFMotionFeatureSchema
structFMotionTimeRange
structFMotionTagRange
structFMotionClipEntry
structFMotionFrame
structFMotionSearchFilterWhich frames a search may pick: all of requiredTags, none of excludedTags (database tag masks). Blocked frames are never picked.
classFMotionMatchingDatabase
classFMotionPoseHistoryThe 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
classFMotionQueryBuilderAssembles 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
classFTrajectoryPredictorSpring-damper projection of the character's desired velocity into the future trajectory the search asks for. Also keeps the past window the schema needs.
structFMotionMatchResult
classFMotionMatcherPlayback 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

Animation/MotionWarping.h

KindTypeSummary
structFMotionWarpTarget
structFMotionWarpWindow
classMotionWarping

Animation/PoseAsset.h

KindTypeSummary
structFPoseAssetPoseOne 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
structFPoseAssetResolvedA 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
classFPoseAssetThe .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.
enumEPoseDriverKernelWhich 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
classFPoseDriverUE'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.
classFPoseAssetLibraryProcess-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

Animation/PoseProvider.h

KindTypeSummary
classIPoseProvider
classFPoseProviderRegistryProcess-wide name → provider table. Registration does NOT transfer ownership — the registering module (plugin, tool, test) keeps the provider alive and unregisters before unloading.

Animation/Procedural/ProceduralBones.h

KindTypeSummary
structLookAtConstraintProcedural 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
classLookAt
structSpringBoneChainSpring-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
structSpringBoneStatePersistent dynamic state — keep one per chain instance across frames; Step() (re)initializes it from the animated pose on first use.
classSpringBoneSolver

Animation/RetargetAsset.h

KindTypeSummary
enumERetargetRootModeWhat 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
structFRetargetBonePair
structFRetargetBoneTranslation
structFRetargetRootSettings
structFRetargetChainMappingOne 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
structFRetargetPoseAdjustmentA 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
structFRetargetEvaluationThe 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
classFRetargetAssetThe 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

Animation/RetargetSerializer.h

KindTypeSummary
structFRetargetSerializerMDF serialization for the retargeter asset (.retarget) — UE's IK Retargeter minus the IK chains.

Animation/Retargeting.h

KindTypeSummary
enumERetargetTranslationModeHow 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
structFRetargetChainName-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
structFRetargetOptions
classFRetargetMapAnimation retargeting — replays a pose authored on one skeleton onto another with the same (or partially matching) bone NAMES but different proportions and rest orientations.

Animation/Skeleton.h

KindTypeSummary
structBone
structFVirtualBoneA bone the rig did not ship with (UE's Virtual Bone): parented to Source and driven onto Target's pose every frame. Indices are into the skeleton.
classSkeleton

Free functions

SignatureDescription
static constexpr uint32_t MAX_BONES = Animation::MaxBones
static constexpr int32_t BONE_NO_PARENT = Animation::BoneNoParent

Page feedback

Was this page helpful?