🔸Animation Modifiers

In this page you will find general information about modifiers.

Overview

An Animation Modifier defines procedural animation settings and logic. Modifiers reside in the Procedural Animation Settings and are placed in a list. You can add multiple modifiers of the same type to the settings:

Animation Modifiers.

Each modifier has a Gizmo-toggle button—use it to enable or disable the UI. This is useful for making adjustments and debugging.

Tip: Modifiers are applied at runtime in the same order as their position in the list.

All modifiers consist of 2 parts:

1. Settings: a ScriptableObject that contains data (e.g., bone references).

2. Animation Job: a runtime-only struct that executes the logic (e.g., applies inverse kinematics).

IK modifiers example.

Weight Overrides

This feature provides more granular control over how modifiers are applied at runtime, using custom float properties:

Weight Override.

• Weight — a float property to control the influence of this modifier.

• Is Mask — if enabled, the final value is computed as 1f - Weight.

• In Range Min and Max — used to remap the Weight value. For example, if the Weight value is in a range other than [0, 1], specify the min and max values of the Weight range.

Tip: You can add multiple overrides to the same modifier. In this case, their outputs are multiplied. If one of the overrides is zero, the final value is zero.

Animation Modifier Settings

AnimationModifierSettings is a base class for all modifier settings in the system:

Inheritance and Interfaces

public class AnimationModifierSettings : ScriptableObject, IRigProvider, IBindableContext

• IRigProvider: This interface is used to provide a skeleton hierarchy for editor widgets (e.g., bone or bone chain selection).

• IBindableContext: This interface provides a GameObject context for https://kinemation.gitbook.io/character-animation-system-docs/character-animation-system/property-bindings.

Fields

[ShowStandalone] public GameObject characterPrefab;
[Range(0f, 1f)] public float alpha = 1f;
[Unfold] public List<WeightOverride> weightOverrides = new List<WeightOverride>();

• characterPrefab: A reference to the player prefab.

• alpha: A value that controls the influence of this modifier.

• weightOverrides: Additional float parameters to adjust alpha at runtime. This section is useful when multiple values should affect the influence of a modifier (e.g., blending it out when playing a specific animation).

Methods

public virtual void InitializeOnLoad();
public virtual IAnimationModifierJob CreateAnimationJob();
public GameObject GetContext();
public KRigElement[] GetHierarchy();

• InitializeOnLoad(): Called when the game starts. This callback is used to build Property Bindings.

• CreateAnimationJob(): Called when Procedural Animation Settings are initialized and returns an instance of an Animation Job that executes the logic.

• GetContext(): Returns a context GameObject for Property Bindings.

• GetHierarchy(): Returns an array of all bones in the skeleton.

Although the Modifier Settings class is derived from a ScriptableObject, it is not typically instantiated as an asset in the project.

By default, all modifiers exist only in the Procedural Animation Settings and shouldn't be accessed from the outside.

Note: Animation Jobs run their logic on the animation thread, so modifying their data at runtime may result in unexpected behaviors.

Animation Modifier Job

An Animation Modifier Job is a struct that executes animation logic. All jobs in the Character Animation System implement 2 interfaces:

1. IAnimationJob: an interface provided by Unity's Playables API.

2. IAnimationModifierJob: an interface provided by the Character Animation System.

IAnimationModifierJob

IAnimationModifierJob.cs

public interface IAnimationModifierJob
{
    /// <summary>
    /// Sets up a job. Called on the main thread when a new profile is linked.
    /// </summary>
    /// <param name="jobData">General job data.</param>
    /// <param name="settings">Procedural animation asset.</param>
    public void Initialize(ModifierJobData jobData, AnimationModifierSettings settings);
    
    /// <summary>
    /// Creates a new AnimationScriptPlayable based on the Animation Job.
    /// </summary>
    /// <param name="graph">Main Playable Graph.</param>
    /// <param name="source">Source Playable.</param>
    /// <returns></returns>
    public AnimationScriptPlayable CreatePlayable(PlayableGraph graph);
    
    /// <summary>
    /// Returns active Animator Layer Settings.
    /// </summary>
    /// <returns></returns>
    public AnimationModifierSettings GetModifierSettings();
    
    /// <summary>
    /// Standard game thread update.
    /// </summary>
    /// <param name="playable">Playable to update.</param>
    /// <param name="weight">General feature weight.</param>
    public void UpdateJobData(AnimationScriptPlayable playable, float weight);
    
    /// <summary>
    /// Called after the pose is finalized.
    /// </summary>
    public void LateUpdate();
    
    /// <summary>
    /// Destroys this job and disposes its data.
    /// </summary>
    public void Dispose();
    
    /// <summary>
    /// Draws the modifier's Gizmos.
    /// </summary>
    public void OnDrawGizmos();
}

Animation Modifier Pooling

CAS reuses already allocated modifiers when updating animation settings. When this occurs, the system calls Initialize() and recreates the AnimationScriptPlayable linked to this Animation Modifier.