The array of corresponding blend positions for each animation clip. Used for 1D blending. Not used if the layer has only one animation clip.

The start and end range used during blending. For 1D blending, this value is ignored if the Blend Positions has been set.

Get the root motion angular velocity of the animations played by that layer. Should be typically accessed from an OnAnimatorMove callback.

The number of AnimationClips being played by the FlexMotionLayer.

The state of the FlexMotionLayer.

Determines if the FlexMotionLayer is currently posing. Posing a layer can be seen as a pause that doesn't prevent transitions to occur.

Checks the current state of the layer to determine if it's in or out transition.

Determines whether or not the pose should be mirrored.

Determines if the underlying FlexMotionMaskLayer is paused or not. It's important to note that if paused, transitions will be paused as well.

Determines whether the FlexMotionLayer is playing (including transitions).

The scaled length in seconds of the longest AnimationClip.

Computes the current animation progress ratio using the longest AnimationClip. The returns value is not clamped and will eventually be above 1.0f even if the clip doesn't loop.

The speed multiplier of the Layer.

Gets the layer's current animation time.

The unscaled length in seconds of the FlexMotionLayer based on the longest AnimationClip.

Should the layer recompute every clip speed value using their weights? This will be done every frame to achieve a consistent length.

Get the root motion velocity of the animations played by that layer. Should be typically accessed from an OnAnimatorMove callback.

The weight of the motion layer used for blending.

Clear root motion data by reapplying the current time to the playable.

Computes 1D blend weights based on the given value and previously provided blend positions.

Computes 2D blend weights based on the given value.

Ensures that the AnimationClips have the same playback length by computing the speed of their respective AnimationClipPlayable using the average clip length.

Computes 1D blend weights based on the given value.

Delete the AnimationScriptPlayable from a previously inserted animation job.

The reference to the FlexMotion or AnimationClip asset that was lastly used on that layer. An inactive layer will still reference its last used asset.

Determines the currently shown animation clip based on the layer's weights. Playing an animation clip or a FlexMotion asset with only one clip will skip the weight check.

Insert an Animation Job that will only affect that animation layer. This will create an AnimationScriptPlayable and insert it into the PlayableGraph.

Determines if the layer is reusable without having to create and connect new Playables.

Subscribes a callback to the completed event which is triggered when the time crosses the current length. The callback will be invoked once per loop even if the animation is visually not looping. Please consider using OnComplete<T>(T, Action<T, FlexMotionLayer>) instead to prevent possible closure allocations.

Register a callback that will be invoked when the time crosses the current length. The callback will be invoked once per loop even if the animation is visually not looping.

Registers a callback that will be invoked once when the provided normalized time is reached. Please consider using OnNormalizedTime<T>(T, float, Action<T, FlexMotionLayer>) instead to prevent possible closure allocations.

Registers a callback that will be invoked when the provided normalized time is reached. Please consider using OnNormalizedTime<T>(T, float, Action<T, FlexMotionLayer>) instead to prevent possible closure allocations.

Registers a callback that will be invoked once when the provided normalized time is reached.

Registers a callback that will be invoked when the provided normalized time is reached.

Registers a callback that will be invoked when the provided normalized time is reached. The process will be repeated for every subsequent loop (e.g.: 0.25 => 1.25 => 2.25...). Please consider using OnNormalizedTimeLoop<T>(T, float, Action<T, FlexMotionLayer>) instead to prevent possible closure allocations.

Registers a callback that will be invoked when the provided normalized time is reached. The process will be repeated for every subsequent loop (e.g.: 0.25 => 1.25 => 2.25...).

Registers a callback that will be invoked when the provided normalized time is reached. The process will be repeated for every subsequent added target time (e.g.: 0.25 => 0.50 => 0.75...). Please consider using OnNormalizedTimeRepeat<T>(T, float, Action<T, FlexMotionLayer>) instead to prevent possible closure allocations.

Registers a callback that will be invoked when the provided normalized time is reached. The process will be repeated for every subsequent added target time (e.g.: 0.25 => 0.50 => 0.75...).

Subscribes a callback to the stopped event which is triggered when the layer starts its "out" transition. Please consider using OnStopped<T>(T, Action<T, FlexMotionLayer>) instead to prevent possible closure allocations.

Register a callback that will be invoked when the layer starts its "out" transition.

Registers a callback that will be invoked once when the provided time is reached. Please consider using OnTime<T>(T, float, Action<T, FlexMotionLayer>) instead to prevent possible closure allocations.

Registers a callback that will be invoked when the provided time is reached. Please consider using OnTime<T>(T, float, Action<T, FlexMotionLayer>) instead to prevent possible closure allocations.

Registers a callback that will be invoked once when the provided time is reached.

Registers a callback that will be invoked when the provided time is reached.

Registers a callback that will be invoked when the provided time is reached. The process will be repeated for every subsequent loop (e.g.: 0.25 => 1.25 => 2.25...). Please consider using OnTimeLoop<T>(T, float, Action<T, FlexMotionLayer>) instead to prevent possible closure allocations.

Registers a callback that will be invoked when the provided time is reached. The process will be repeated for every subsequent loop (e.g.: 0.25 => 1.25 => 2.25...).

Registers a callback that will be invoked when the provided time is reached. The process will be repeated for every subsequent added target time (e.g.: 0.25 => 0.50 => 0.75...). Please consider using OnTimeRepeat<T>(T, float, Action<T, FlexMotionLayer>) instead to prevent possible closure allocations.

Registers a callback that will be invoked when the provided time is reached. The process will be repeated for every subsequent added target time (e.g.: 0.25 => 0.50 => 0.75...).

Registers a callback that will be invoked once every update. Please consider using OnUpdate<T>(T, Action<T, FlexMotionLayer>) instead to prevent possible closure allocations.

Registers a callback that will be invoked once every update.

Pause the the underlying FlexMotionMaskLayer. It's important to note that if paused, transitions will be paused as well.

Play the layer, starting its in transition.

Re-initializes the speed of every AnimationClipPlayables to 1f. Thus the animation clips will have their original lengths restored. Only useful to revert the effect of the method EqualizeClipsLength.

Restores all the settings to their default values as if the FlexMotionLayer has just been created or reused.

Sets the foot IK on or off for all AnimationClips.

Sets the playable IK on or off for all AnimationClips. Setting it to turn enables the usage of the OnAnimatorIk messages in MonoBehavior scripts.

Sets the array of corresponding blend positions for each animation clip. Used for 1D blending. Not used if the layer has only one animation clip.

Sets the start and end range used during blending. For 1D blending, this value is ignored if the Blend Positions has been set.

Changes the blending weight value of an animation clip based on its index. Obviously this has no effect on layers containing only one animation clip.

Sets the layer's current animation frame time. Every animation clip will be affected. The computation is based on the animation clip with the highest weight. As retrieving the AnimationClip from a playable is slow, avoid using this method in an update loop.

Sets if the pose should be mirrored or not.

Sets the layer's current animation normalized time (from 0f to 1f). Every animation clip will be affected.

Sets the layer to a pose by pausing it and applying a normalized time on every animation clips. The normalized time to apply on the animation clips.

Sets the speed multiplier of the Layer.

Sets the layer's current animation time (in seconds). Every animation clip will be affected.

Sets the transition to apply when the FlexMotionLayer transitions from one state to another. If that layer is currently in a in transition, the other layers in a out transition will also use that new transition settings. Not doing so will lead to disjointed transitions as it the time and weights will not match.

Sets the easing function to use during the transition. It will impacts current and future transitions for every layers on the same mask layer.

Sets the duration of the transition. It will impacts current and future transitions for every layers on the same mask layer.

Should the layer recompute every clip speed value using their weights? This will be done every frame to achieve a consistent length.

Skips the current transition for every motion layers on the same mask layer. Do nothing if no transition is currently occuring.

Stops the layer, starting its out transition.

Switches the pause state of the underlying FlexMotionMaskLayer. If it's currently playing, this method will pause it. If it is paused, calling the method will unpause it. It's important to note that if paused, transitions will be paused as well.

Switches the pose state. It can be used as a pause that doesn't impact transitions.

Unpause the the underlying FlexMotionMaskLayer if it was paused.

Event that is signalled when the FlexMotionLayer motion time crosses its current length. You don't need to manually unsubscribe from this event. Please consider using OnComplete<T>(T, Action<T, FlexMotionLayer>) instead to prevent possible closure allocations.

Event that is signalled when the FlexMotionLayer has been stopped thus starting its out transition. You don't need to manually unsubscribe from this event. Please consider using OnStopped<T>(T, Action<T, FlexMotionLayer>) instead to prevent possible closure allocations.