Animation and Rigging Capabilities

Animation and rigging capabilities in Unity and Unreal Engine represent the foundational technical systems that enable developers to create lifelike character movements, object behaviors, and interactive performances within real-time 3D environments. These capabilities encompass the tools, workflows, and architectural frameworks for constructing skeletal hierarchies, managing motion data, implementing procedural behaviors, and optimizing character performance across diverse platforms ¹². The comparison between these two dominant game engines matters critically because animation systems directly influence production efficiency, visual fidelity, performance optimization, and ultimately the quality of player experience ⁹. As modern interactive experiences demand increasingly sophisticated character performances with realistic deformations, responsive interactions, and seamless transitions, understanding the distinct strengths and limitations of each engine's animation architecture becomes essential for technical artists, animators, and development teams making strategic platform decisions ⁵⁶.

Overview

The evolution of animation and rigging capabilities in Unity and Unreal Engine reflects the broader maturation of real-time 3D development over the past two decades. Unity introduced its Mecanim animation system to provide a unified workflow with state machines, blend trees, and humanoid retargeting capabilities, addressing the fundamental challenge of creating scalable, reusable animation systems accessible to teams of varying technical expertise ¹⁷. Unreal Engine developed its node-based Animation Blueprint system built on visual scripting frameworks, prioritizing real-time procedural animation capabilities and deep integration with gameplay programming ⁴⁸.

The fundamental challenge both engines address is the complex relationship between skeletal rig structures and animation data—enabling artists to create believable character motion while maintaining performance efficiency across platforms ranging from mobile devices to high-end PCs ²¹². Historically, game animation required extensive programming knowledge and engine-specific implementations. Modern systems have evolved to separate animation data from skeletal structures, enabling animation reuse, retargeting across different character models, and sophisticated blending between multiple animation sources ¹⁸. This evolution has democratized character animation, allowing smaller teams to achieve visual quality previously reserved for AAA studios while providing enterprise-scale productions with the flexibility to implement highly customized animation solutions ⁵⁹.

Key Concepts

Skeletal Rigging and Avatar Systems

Skeletal rigging defines the hierarchical bone structure that controls mesh deformation, establishing parent-child relationships that determine how character geometry responds to animation ¹⁸. Unity's humanoid avatar system automatically maps imported skeletal structures to a standardized rig definition, enabling animation sharing across different character models with varying proportions ¹⁷. For example, a third-person action game developer creating multiple playable characters with different body types can animate a single "run cycle" and apply it to a muscular warrior, slender rogue, and stocky dwarf character through Unity's retargeting system, significantly reducing animation production time while maintaining unique character silhouettes.

State Machines and Animation Controllers

State machines manage the logical flow between different animation states based on gameplay conditions, parameters, and transitions ⁴⁷. Unity's Animator Controller serves as a visual state machine where developers define states (idle, walk, run, jump) and configure transitions with conditional parameters ⁷. Consider a stealth game where a character transitions from "crouch_idle" to "crouch_walk" when the player inputs movement while crouched, then to "crouch_to_stand" when releasing the crouch button, and finally to "alert_run" if an enemy detects them—each transition governed by specific boolean, float, or trigger parameters that gameplay code manipulates in real-time.

Blend Spaces and Animation Blending

Blend spaces enable smooth interpolation between multiple animations based on one or two input parameters, creating fluid directional movement without discrete animation switching ¹⁴. Unreal Engine's blend spaces typically use 2D configurations with horizontal and vertical axes representing movement direction and speed ⁴⁸. For instance, a racing game character standing in a victory podium might use a 2D blend space where the horizontal axis represents left-right weight shifting (-1.0 to 1.0) and the vertical axis represents excitement level (0.0 to 1.0), blending between four corner animations: calm-left-lean, calm-right-lean, excited-left-lean, and excited-right-lean, with the system automatically interpolating intermediate poses based on dynamic crowd noise levels and random variation timers.

Animation Rigging and Procedural Constraints

Animation rigging systems apply procedural modifications to skeletal poses at runtime using constraint-based systems similar to those in digital content creation (DCC) applications ³⁶. Unity's Animation Rigging package provides constraints like Two Bone IK (inverse kinematics), Multi-Parent, and Damped Transform that modify animation playback procedurally ³. A practical application appears in a first-person shooter where a character's left hand position on a rifle must adjust based on weapon type—a constraint system procedurally positions the hand on the weapon's foregrip regardless of whether the player equips an assault rifle, shotgun, or sniper rifle, eliminating the need for separate animations for each weapon while maintaining proper hand placement.

Animation Blueprints and Visual Scripting

Animation Blueprints in Unreal Engine combine visual node-based programming with animation logic, containing both AnimGraph (for pose generation and blending) and EventGraph (for logic and state management) components ⁴⁸. The AnimGraph constructs the final character pose through a node network that processes animation sequences, applies blending, and outputs the result ⁴. For example, a multiplayer battle royale game might implement an Animation Blueprint where the EventGraph calculates the character's current velocity, aim offset angles, and injury state, then feeds these values into the AnimGraph where a locomotion state machine blends directional movement animations, a layered blend node adds upper-body aiming adjustments, and a final blend applies injury-based limping modifications before outputting the composite pose.

Root Motion and Animation-Driven Movement

Root motion extracts positional and rotational movement data from animations themselves rather than relying solely on code-driven character controllers, ensuring visual motion matches actual displacement ¹⁸. Unity's "Apply Root Motion" setting on the Animator component enables this behavior, while Unreal's Character Movement Component integrates root motion through animation montages ¹⁸. In a fighting game, a character performing a lunging sword attack uses root motion to move forward precisely the distance animated by the artist—if the animation shows a 2-meter forward lunge, the character physically moves 2 meters in game space, ensuring the attack's visual presentation perfectly matches its mechanical hitbox positioning and creating satisfying, grounded combat feedback.

Animation Compression and Optimization

Animation compression reduces memory footprint and streaming bandwidth by removing redundant keyframe data while maintaining visual quality within acceptable thresholds ¹¹². Unity offers Keyframe Reduction and Optimal compression settings, while Unreal provides an Animation Compression Library with various codec options ¹². A mobile RPG targeting devices with limited memory might apply aggressive compression to background NPC animations (reducing a 60fps mocap walk cycle to 15fps with keyframe reduction), moderate compression to player character locomotion (30fps with curve simplification), and minimal compression to cinematic facial animations, balancing the 200MB animation budget across 50+ characters while maintaining visual quality where players focus attention.

Applications in Game Development

Character Locomotion Systems

Both engines excel at implementing sophisticated locomotion systems that blend directional movement, speed variations, and terrain adaptation ¹⁴. Unity's blend tree approach typically creates hierarchical structures where a root blend tree separates idle from movement, then nested blend trees handle directional variations ⁷. A third-person adventure game might implement a locomotion system where the base layer contains a blend tree transitioning between idle and movement based on speed (0-6 m/s), the movement state contains a 2D blend space blending walk-forward, walk-backward, walk-left, and walk-right animations based on input direction, while an additive layer applies slope-leaning adjustments when traversing hills, and an Animation Rigging constraint system procedurally adjusts foot placement on uneven terrain using raycasts ³⁷.

Combat and Action Systems

Combat animation systems require precise timing, cancellable states, and integration with hitbox detection and damage calculation ⁴⁸. Unreal's Animation Montage system provides sections, slots, and notify events specifically designed for gameplay integration ⁸. Consider a souls-like action RPG where light attacks use animation montages with three sections (windup, strike, recovery), each containing notify events—the windup section triggers a "CanCancel" notify allowing dodge-rolling, the strike section spawns hitbox collision and triggers weapon trail VFX, and the recovery section gradually re-enables movement. The montage uses blend-out overrides to ensure smooth transitions if the player chains attacks, while the Animation Blueprint's state machine handles transitions to hit-reaction, dodge, or death states based on gameplay events ⁴⁸.

Facial Animation and Cinematic Sequences

Modern narrative-driven games demand cinematic-quality facial performances synchronized with voice acting and camera work ²⁵. Unity's Timeline system provides multi-track sequencing for coordinating animations, audio, cameras, and events, while Unreal's Sequencer offers similar capabilities with deeper integration into the Animation Blueprint workflow ⁵⁸. A story-driven adventure game might create a dialogue scene where Timeline controls a 90-second conversation: track one plays the full-body idle animation with subtle breathing and weight-shifting, track two drives facial animation using blend shape clips synchronized to phoneme data extracted from voice recordings, track three controls eye-look targets as characters shift attention between each other and environmental elements, track four manages camera cuts between over-shoulder and close-up angles, and track five triggers subtitle display and lip-sync adjustments for localized language versions ⁵.

Multiplayer Animation Synchronization

Network-replicated animation presents unique challenges requiring efficient data transmission and client-side prediction ⁸¹². Unity typically replicates Animator parameters rather than full animation states, allowing clients to independently evaluate state machines based on synchronized parameters ⁷. In a competitive multiplayer shooter, the server authoritative character controller sends compressed movement data (velocity vector, rotation, jump state) at 20Hz, which clients use to update local Animator parameters (Speed, Direction, IsGrounded, IsSprinting). The client-side Animator Controller evaluates state transitions and blend trees locally at 60fps, providing smooth animation while minimizing network bandwidth. Animation events for footstep sounds and particle effects trigger locally without network calls, while critical gameplay events like firing weapons or taking damage use reliable RPC calls to ensure synchronization ⁷⁸.

Best Practices

Modular Animation Architecture

Organizing animation systems with modular, reusable components reduces duplication and facilitates iteration across multiple characters ⁷⁸. The principle involves creating base animation controllers or blueprints with core functionality, then using inheritance or override mechanisms for character-specific variations. For implementation, a team developing an RPG with five playable classes might create a base Animator Controller containing universal states (idle, walk, run, jump, fall, land, death) with transitions and blend trees, then create Animation Override Controllers for each class that replace specific animation clips while maintaining the state machine structure—the warrior uses heavy, armored movement animations while the rogue uses light, agile animations, but both share the same logical flow and parameter structure ⁷. This approach reduces the complexity of maintaining five separate state machines and ensures consistent behavior across characters.

Performance-Conscious Bone Hierarchies

Limiting skeletal complexity directly impacts CPU performance, particularly when rendering multiple characters simultaneously ¹². The rationale centers on the computational cost of transforming bone matrices and updating skinned mesh vertices each frame. A best practice implementation establishes tiered bone budgets: hero characters (player-controlled, always visible) use 75-100 bones enabling detailed finger articulation and facial rigs; secondary characters (important NPCs, bosses) use 50-75 bones with simplified hands and faces; background NPCs use 30-50 bones with unified hand bones and no facial articulation; and distant crowd characters use 15-30 bones with simplified limbs ¹². Additionally, implementing LOD (Level of Detail) systems automatically reduces bone counts and animation update rates based on camera distance—a crowd character 50 meters away updates at 15fps with 20 active bones rather than 60fps with 45 bones, significantly reducing CPU overhead in scenes with dozens of visible characters.

Strategic Animation Compression

Applying appropriate compression settings balances memory usage against visual quality based on animation importance and visibility ¹¹². The rationale recognizes that not all animations warrant identical quality thresholds—subtle background animations tolerate more compression than focal character performances. Implementation involves categorizing animations by importance: cinematic facial animations use minimal compression (Keyframe Reduction with 0.5mm position tolerance, 0.5-degree rotation tolerance); player character locomotion uses moderate compression (Optimal compression with 1mm position, 1-degree rotation tolerance); NPC ambient animations use aggressive compression (Keyframe Reduction with 5mm position, 2-degree rotation tolerance, reduced to 20fps sampling) ¹¹². A 10GB animation dataset might compress to 3.5GB through strategic application, with imperceptible quality loss on high-priority animations while significantly reducing memory footprint and streaming requirements for platform deployment.

Comprehensive Animation Event Integration

Leveraging animation notify events creates tight synchronization between visual animation and gameplay systems, audio, and VFX ⁴⁸. The principle ensures that footstep sounds occur precisely when feet contact ground, weapon impacts trigger at the moment of collision, and particle effects spawn synchronized with character actions. Implementation in a character action game places notify events at specific animation frames: a sword swing animation contains notifies at frame 8 ("SwordWhoosh_Start" triggering wind VFX and swoosh sound), frame 15 ("EnableHitbox" activating weapon collision detection), frame 18 ("DisableHitbox" deactivating collision), and frame 22 ("SwordWhoosh_End" stopping wind VFX) ⁴⁸. These events call functions in gameplay scripts that handle the actual logic, maintaining separation between animation data and game code while ensuring perfect synchronization that would be impossible with time-based polling approaches.

Implementation Considerations

Engine-Specific Tooling and Workflow Integration

Choosing between Unity and Unreal significantly impacts the technical artist pipeline and required skill sets ⁹. Unity's component-based architecture with inspector-driven workflows suits teams familiar with traditional game development patterns and C# scripting, offering rapid prototyping and iteration through its immediate play-mode testing ¹⁷. Teams with strong programming backgrounds often prefer Unity's code-centric approach where animation behavior extends through custom scripts. Conversely, Unreal's node-based visual scripting in Animation Blueprints appeals to technical artists with limited programming experience, providing powerful animation logic without writing code ⁴⁸. A small indie team with artist-heavy composition might choose Unreal to leverage Blueprint visual scripting, while a team with experienced programmers might prefer Unity's C# ecosystem for implementing custom animation systems and tools.

Platform-Specific Performance Optimization

Target platform capabilities dramatically influence animation system design, requiring different optimization strategies for mobile, console, and PC deployment ¹². Mobile platforms demand aggressive optimization: reduced bone counts (20-40 bones maximum), simplified blend trees (avoiding deeply nested structures), compressed animation data, and lower update frequencies (30fps animation evaluation) ¹². A mobile action game might implement a simplified animation system using direct state transitions rather than blend trees, limit simultaneous animated characters to 10-15, and use sprite-based VFX rather than skeletal mesh effects. Console and PC platforms support more complex systems: 75-100 bone characters, sophisticated blend spaces, layered animation with multiple additive layers, and 60fps evaluation ¹². Cross-platform projects require scalability systems that automatically adjust animation complexity based on detected hardware, using Unity's quality settings or Unreal's scalability configurations to maintain performance targets across diverse devices.

Team Expertise and Learning Curve

The existing skill set of the development team significantly influences which engine's animation system proves more productive ⁹. Unity's Mecanim system presents a gentler learning curve for teams transitioning from other engines or with limited animation programming experience, offering intuitive visual state machines and straightforward parameter-based control ¹⁷. However, implementing advanced procedural animation or custom retargeting solutions requires C# programming knowledge. Unreal's Animation Blueprint system offers greater out-of-box power for complex procedural systems but demands understanding of node-based programming paradigms and the relationship between AnimGraph and EventGraph ⁴⁸. A team with Maya technical directors familiar with node-based rigging might adapt quickly to Unreal's Control Rig system, while a team with Unity experience on previous projects would maintain productivity by continuing with Unity's ecosystem. Training time and documentation availability also factor into decisions—Unity's extensive community tutorials and Unreal's comprehensive official documentation both provide learning resources, but team-specific learning styles influence effectiveness.

Project Scope and Animation Complexity Requirements

The scale and complexity of animation requirements should align with engine capabilities and project timelines ⁵⁹. Small-to-medium projects with straightforward animation needs (2D games, simple 3D characters, limited character variety) benefit from Unity's streamlined workflow and rapid iteration capabilities ⁵. Large-scale projects requiring sophisticated procedural animation, extensive character customization, or AAA-quality cinematic sequences leverage Unreal's advanced Control Rig system and Sequencer integration ⁶⁸. A narrative adventure game with 20 unique characters, each requiring 50-100 animations, benefits from Unity's humanoid retargeting to share base locomotion across characters while using Animation Override Controllers for personality variations ⁷. Conversely, a multiplayer hero shooter with 30 characters, each requiring unique movement styles, complex ability animations, and extensive customization options, justifies Unreal's more complex but flexible Animation Blueprint inheritance system and modular animation montage approach ⁴⁸.

Common Challenges and Solutions

Challenge: Root Motion and Character Controller Conflicts

Root motion implementation frequently creates conflicts between animation-driven movement and code-driven character controllers, resulting in characters sliding across terrain, movement feeling unresponsive, or animations not matching actual displacement ¹⁸. This challenge manifests particularly in action games where precise positioning matters for combat mechanics—a character's attack animation shows them lunging forward two meters, but the character controller's collision detection prevents the movement, causing the character to animate in place while their weapon swings through empty space where an enemy should be.

Solution:

Implement hybrid movement systems that strategically blend root motion and controller-driven movement based on animation context ¹⁸. In Unity, configure the Animator component's "Apply Root Motion" setting and implement the OnAnimatorMove() callback in character controller scripts to selectively apply or override root motion ¹. For a fighting game, enable root motion during attack animations (allowing the lunge animation to drive actual movement), but disable it during locomotion (using player input to drive movement while animations provide visual feedback). The implementation checks the current animation state: if in an attack state, OnAnimatorMove() applies the animator's delta position directly to the character controller; if in locomotion, it ignores root motion and uses input-driven movement while the animation system responds to the resulting velocity ¹⁷. In Unreal, configure Animation Montages with appropriate root motion settings and use the Character Movement Component's root motion modes to control when animation drives movement versus code-driven physics ⁸.

Challenge: Animation Retargeting Artifacts

Retargeting animations between characters with different skeletal proportions produces visual artifacts including unnatural poses, floating feet, intersecting geometry, and broken joint rotations ¹⁸. A common scenario occurs when retargeting a walk cycle from a human character to a creature with different leg proportions—the foot placement timing designed for human stride length causes the creature's feet to slide or hover above ground because its legs are 30% shorter.

Solution:

Implement multi-layered retargeting strategies combining automated systems with procedural corrections ¹³. In Unity, use the humanoid avatar system for base retargeting, then apply Animation Rigging constraints to correct specific issues ³. For the walk cycle example, configure the humanoid avatar with proper T-pose alignment and bone mapping, enable "Feet IK" in the Animator component to automatically adjust foot placement, then add Two Bone IK constraints from the Animation Rigging package targeting ground-aligned positions detected through raycasts ³. This ensures feet contact terrain regardless of proportion differences. In Unreal, configure retarget bases carefully, use the Retarget Manager to adjust bone chain mappings, and implement IK solutions within Animation Blueprints using Two Bone IK or FBIK (Full Body IK) nodes to correct foot placement, hand positioning, and spine alignment ⁶⁸. Additionally, create proportion-specific animation variations for extreme differences—if a character's proportions differ by more than 20% from the source, invest in custom animations rather than relying solely on retargeting.

Challenge: Performance Degradation with Multiple Animated Characters

Scenes containing numerous simultaneously animated characters experience significant CPU performance degradation as animation evaluation, bone transformations, and skinned mesh updates compound ¹². This challenge critically impacts games with crowd systems, RTS titles, or multiplayer environments—a battle scene with 50 visible characters, each with 60-bone skeletons updating at 60fps, consumes excessive CPU resources causing frame rate drops below acceptable thresholds.

Solution:

Implement comprehensive LOD (Level of Detail) and optimization systems that scale animation complexity based on visibility and importance ¹². Configure distance-based LOD tiers: characters within 10 meters use full-quality skeletons (60-75 bones) updating at 60fps with complex blend trees; characters 10-30 meters away reduce to medium-quality skeletons (40 bones) updating at 30fps with simplified state machines; characters 30-50 meters away use low-quality skeletons (25 bones) updating at 15fps with direct animation playback; characters beyond 50 meters switch to static poses or simple two-frame idle animations ¹². In Unity, implement this through custom scripts that adjust Animator update modes (AnimatorUpdateMode.Normal, AnimatorUpdateMode.AnimatePhysics, AnimatorUpdateMode.UnscaledTime) and culling modes based on camera distance ⁷. In Unreal, use the Animation LOD system and configure Update Rate Optimizations (URO) that automatically reduce update frequencies for distant characters ¹². Additionally, implement animation sharing systems where multiple similar characters (crowd NPCs) share animation evaluation results, and use GPU skinning techniques to offload bone transformation calculations from CPU to GPU for background characters.

Challenge: Complex State Machine Maintenance

As projects evolve, animation state machines grow increasingly complex with hundreds of states, transitions, and parameters, becoming difficult to maintain, debug, and extend ⁷⁸. A character action game that begins with simple locomotion (idle, walk, run) expands to include combat states (light attack 1-3, heavy attack 1-2, dodge, block), traversal states (climb, vault, slide), and contextual interactions (open door, pull lever, pickup item), resulting in a state machine with 50+ states and 200+ transitions that becomes a tangled web of connections.

Solution:

Implement hierarchical state machine organization using sub-state machines and modular layer architecture ⁴⁷. In Unity, organize the Animator Controller into multiple layers: a base layer handles locomotion, a combat layer manages attack states using avatar masks to affect only upper body, a traversal layer handles climbing and vaulting, and an interaction layer manages contextual actions ⁷. Within each layer, use sub-state machines to group related states—the combat layer contains a "LightAttacks" sub-state machine with the three-hit combo sequence, a "HeavyAttacks" sub-state machine with heavy attack variations, and a "Defense" sub-state machine with block and dodge states. This hierarchical organization makes the state machine visually comprehensible and logically segmented. In Unreal, create modular Animation Blueprint components using the Animation Layer Interface system, allowing different animation logic modules to be swapped or combined ⁴⁸. Implement a naming convention for states, transitions, and parameters (e.g., "LOCO_Idle", "CMB_LightAttack01", "TRV_ClimbUp") that clearly indicates which system owns each element. Use state machine comments and color-coding to visually organize related states, and regularly refactor by consolidating similar transitions using blend spaces or shared transition logic.

Challenge: Animation-Gameplay Synchronization Issues

Maintaining tight synchronization between animation timing and gameplay mechanics proves challenging, particularly for combat systems, platforming, and interactive sequences where timing mismatches create poor player experience ⁴⁸. A common manifestation occurs in melee combat where the visual sword swing animation completes before or after the hitbox detection window, causing players to see their weapon pass through enemies without registering hits, or hits registering before the weapon visually reaches the target.

Solution:

Implement animation-driven gameplay timing using notify events and frame-accurate synchronization systems ⁴⁸. Rather than using time-based delays in gameplay code, place Animation Notify events at precise frames where gameplay events should occur ⁸. For the sword swing example, the animation contains notifies: frame 12 triggers "WindupComplete" (earliest point player can cancel into dodge), frame 18 triggers "HitboxEnable" (activates weapon collision detection), frame 24 triggers "HitboxDisable" (deactivates collision), and frame 30 triggers "RecoveryStart" (allows transition to next attack) ⁴⁸. The gameplay code responds to these events rather than estimating timing, ensuring perfect synchronization regardless of animation speed modifications or frame rate variations. In Unity, implement this using Animation Events in the Animation window, creating callback functions in MonoBehaviour scripts attached to the character ¹. In Unreal, use Animation Notifies and Notify States in Animation Sequences, with corresponding event handlers in Animation Blueprints or gameplay code ⁸. For complex timing requirements, use Animation Montages (Unreal) or Playables API (Unity) to programmatically control animation playback with frame-accurate precision, enabling features like hit-stop (freezing animation for impact frames) or dynamic speed adjustments based on gameplay state.

References

1. Unity Technologies. (2025). Animation Overview. https://docs.unity3d.com/Manual/AnimationOverview.html
2. Epic Games. (2020). Animation Features in Unreal Engine. https://docs.unrealengine.com/5.0/en-US/animation-features-in-unreal-engine/
3. Unity Technologies. (2019). Animation Rigging Package Manual. https://docs.unity3d.com/Packages/com.unity.animation.rigging@1.0/manual/index.html
4. Epic Games. (2020). Animation Blueprints in Unreal Engine. https://docs.unrealengine.com/5.0/en-US/animation-blueprints-in-unreal-engine/
5. Unity Technologies. (2025). Animation Solutions. https://unity.com/solutions/animation
6. Epic Games. (2021). Control Rig in Unreal Engine 5. https://www.unrealengine.com/en-US/tech-blog/control-rig-in-unreal-engine-5
7. Unity Technologies. (2025). Animator Controller Class Reference. https://docs.unity3d.com/Manual/class-AnimatorController.html
8. Epic Games. (2020). Skeletal Mesh Animation System in Unreal Engine. https://docs.unrealengine.com/5.0/en-US/skeletal-mesh-animation-system-in-unreal-engine/
9. Game Developer. (2024). Unity vs Unreal Engine: Choosing the Right Game Engine. https://www.gamedeveloper.com/programming/unity-vs-unreal-engine-choosing-the-right-game-engine
10. Stack Overflow. (2025). Unity3D Animation Questions. https://stackoverflow.com/questions/tagged/unity3d+animation
11. Reddit. (2023). Unity vs Unreal for Animation Discussion. https://www.reddit.com/r/gamedev/comments/10x8y9z/unity_vs_unreal_for_animation/
12. Epic Games. (2020). Animation Optimization in Unreal Engine. https://docs.unrealengine.com/5.0/en-US/animation-optimization-in-unreal-engine/