UnityEngine.AnimationModule

The animation component is used to play back animations.

When turned on, Unity might stop animating if it thinks that the results of the animation won't be visible to the user.

When turned on, animations will be executed in the physics loop. This is only useful in conjunction with kinematic rigidbodies.

The default animation.

Controls culling of this Animation component.

Are we playing any animations?

AABB of this Animation animation component in local space.

Should the default animation clip (the Animation.clip property) automatically start playing on startup?

How should time beyond the playback range of the clip be treated?

Adds a clip to the animation with name newName.

Adds clip to the only play between firstFrame and lastFrame. The new clip will also be added to the animation with name newName.

Should an extra frame be inserted at the end that matches the first frame? Turn this on if you are making a looping animation.

Adds clip to the only play between firstFrame and lastFrame. The new clip will also be added to the animation with name newName.

Should an extra frame be inserted at the end that matches the first frame? Turn this on if you are making a looping animation.

Blends the animation named animation towards targetWeight over the next time seconds.

Blends the animation named animation towards targetWeight over the next time seconds.

Blends the animation named animation towards targetWeight over the next time seconds.

Fades the animation with name animation in over a period of time seconds and fades other animations out.

Fades the animation with name animation in over a period of time seconds and fades other animations out.

Fades the animation with name animation in over a period of time seconds and fades other animations out.

Cross fades an animation after previous animations has finished playing.

Cross fades an animation after previous animations has finished playing.

Cross fades an animation after previous animations has finished playing.

Cross fades an animation after previous animations has finished playing.

Get the number of clips currently assigned to this animation.

Is the animation named name playing?

Plays an animation without any blending.

Plays an animation without any blending.

Plays an animation without any blending.

Plays an animation without any blending.

Plays an animation after previous animations has finished playing.

Plays an animation after previous animations has finished playing.

Plays an animation after previous animations has finished playing.

Remove clip from the animation list.

Remove clip from the animation list.

Rewinds the animation named name.

Rewinds all animations.

Samples animations at the current state.

Stops all playing animations that were started with this Animation.

Stops an animation named name.

Returns the animation state named name.

Used by Animation.Play function.

Animations will be added.

Animations will be blended.

Stores keyframe based animations.

Returns true if the animation clip has no curves and no events.

Animation Events for this animation clip.

Frame rate at which keyframes are sampled. (Read Only)

Returns true if the animation contains curve that drives a humanoid rig.

Set to true if the AnimationClip will be used with the Legacy Animation component ( instead of the Animator ).

Animation length in seconds. (Read Only)

AABB of this Animation Clip in local space of Animation component that it is attached too.

Sets the default wrap mode used in the animation state.

Adds an animation event to the clip.

AnimationEvent to add.

Clears all curves from the clip.

Creates a new animation clip.

Realigns quaternion keys to ensure shortest interpolation paths.

Samples an animation at a given time for any animated properties.

The animated game object. The time to sample an animation.

Assigns the curve to animate a specific property.

Path to the game object this curve applies to. The relativePath is formatted similar to a pathname, e.g. "rootspineleftArm". If relativePath is empty it refers to the game object the animation clip is attached to. The class type of the component that is animated. The name or path to the property being animated. The animation curve.

This class defines a pair of clips used by AnimatorOverrideController.

The original clip from the controller.

The override animation clip.

This enum controlls culling of Animation component.

Animation culling is disabled - object is animated even when offscreen.

Animation is disabled when renderers are not visible.

AnimationEvent lets you call a script function similar to SendMessage as part of playing back an animation.

The animation state that fired this event (Read Only).

The animator clip info related to this event (Read Only).

The animator state info related to this event (Read Only).

Float parameter that is stored in the event and will be sent to the function.

The name of the function that will be called.

Int parameter that is stored in the event and will be sent to the function.

Returns true if this Animation event has been fired by an Animator component.

Returns true if this Animation event has been fired by an Animation component.

Function call options.

Object reference parameter that is stored in the event and will be sent to the function.

String parameter that is stored in the event and will be sent to the function.

The time at which the event will be fired off.

Creates a new animation event.

A Playable that controls an AnimationClip.

Creates an AnimationClipPlayable in the PlayableGraph.

The PlayableGraph object that will own the AnimationClipPlayable. The AnimationClip that will be added in the PlayableGraph. A AnimationClipPlayable linked to the PlayableGraph.

Returns the AnimationClip stored in the AnimationClipPlayable.

Returns the state of the ApplyFootIK flag.

Sets the value of the ApplyFootIK flag.

The new value of the ApplyFootIK flag.

An implementation of IPlayable that controls an animation layer mixer.

Creates an AnimationLayerMixerPlayable in the PlayableGraph.

The PlayableGraph that will contain the new AnimationLayerMixerPlayable. The number of layers. A new AnimationLayerMixerPlayable linked to the PlayableGraph.

Returns true if the layer is additive, false otherwise.

The layer index. True if the layer is additive, false otherwise.

Returns an invalid AnimationLayerMixerPlayable.

Specifies whether a layer is additive or not. Additive layers blend with previous layers.

The layer index. Whether the layer is additive or not. Set to true for an additive blend, or false for a regular blend.

Sets the mask for the current layer.

The layer index. The AvatarMask used to create the new LayerMask.

An implementation of IPlayable that controls an animation mixer.

Creates an AnimationMixerPlayable in the PlayableGraph.

The PlayableGraph that will contain the new AnimationMixerPlayable. The number of inputs that the mixer will update. True to force a weight normalization of the inputs. A new AnimationMixerPlayable linked to the PlayableGraph.

A IPlayableOutput implementation that connects the PlayableGraph to an Animator in the scene.

Creates an AnimationPlayableOutput in the PlayableGraph.

The PlayableGraph that will contain the AnimationPlayableOutput. The name of the output. The Animator that will process the PlayableGraph. A new AnimationPlayableOutput attached to the PlayableGraph.

Returns the Animator that plays the animation graph.

The targeted Animator.

Sets the Animator that plays the animation graph.

The targeted Animator.

An implementation of IPlayable that controls an animation RuntimeAnimatorController.

Creates an AnimatorControllerPlayable in the PlayableGraph.

The PlayableGraph object that will own the AnimatorControllerPlayable. The RuntimeAnimatorController that will be added in the graph. A AnimatorControllerPlayable.

Returns an invalid AnimatorControllerPlayable.

The AnimationState gives full control over animation blending.

Which blend mode should be used?

The clip that is being played by this animation state.

Enables / disables the animation.

The length of the animation clip in seconds.

The name of the animation.

The normalized playback speed.

The normalized time of the animation.

The playback speed of the animation. 1 is normal playback speed.

The current time of the animation.

The weight of animation.

Wrapping mode of the animation.

Adds a transform which should be animated. This allows you to reduce the number of animations you have to create.

The transform to animate. Whether to also animate all children of the specified transform.

Adds a transform which should be animated. This allows you to reduce the number of animations you have to create.

The transform to animate. Whether to also animate all children of the specified transform.

Removes a transform which should be animated.

Interface to control the Mecanim animation system.

Gets the avatar angular velocity for the last evaluated frame.

When turned on, animations will be executed in the physics loop. This is only useful in conjunction with kinematic rigidbodies.

Should root motion be applied?

Gets/Sets the current Avatar.

The position of the body center of mass.

The rotation of the body center of mass.

Controls culling of this Animator component.

Gets the avatar delta position for the last evaluated frame.

Gets the avatar delta rotation for the last evaluated frame.

Blends pivot point between body center of mass and feet pivot. At 0%, the blending point is body center of mass. At 100%, the blending point is feet pivot.

The current gravity weight based on current animations that are played.

Returns true if Animator has any playables assigned to it.

Returns true if the current rig has root motion.

Returns true if the object has a transform hierarchy.

Returns the scale of the current Avatar for a humanoid rig, (1 by default if the rig is generic).

Returns true if the current rig is humanoid, false if it is generic.

Returns whether the animator is initialized successfully.

If automatic matching is active.

Returns true if the current rig is optimizable with AnimatorUtility.OptimizeTransformHierarchy.

See IAnimatorControllerPlayable.layerCount.

Additional layers affects the center of mass.

Get left foot bottom height.

When linearVelocityBlending is set to true, the root motion velocity and angular velocity will be blended linearly.

See IAnimatorControllerPlayable.parameterCount.

Read only acces to the AnimatorControllerParameters used by the animator.

Get the current position of the pivot.

Gets the pivot weight.

The PlayableGraph created by the Animator.

Sets the playback position in the recording buffer.

Gets the mode of the Animator recorder.

Start time of the first frame of the buffer relative to the frame at which StartRecording was called.

End time of the recorded clip relative to when StartRecording was called.

Get right foot bottom height.

The root position, the position of the game object.

The root rotation, the rotation of the game object.

The runtime representation of AnimatorController that controls the Animator.

The playback speed of the Animator. 1 is normal playback speed.

Automatic stabilization of feet during transition and blending.

Returns the position of the target specified by SetTarget(AvatarTarget targetIndex, float targetNormalizedTime)).

Returns the rotation of the target specified by SetTarget(AvatarTarget targetIndex, float targetNormalizedTime)).

Specifies the update mode of the Animator.

Gets the avatar velocity for the last evaluated frame.

Apply the default Root Motion.

Creates a crossfade from the current state to any other state using normalized times.

The name of the state. The hash name of the state. The duration of the transition (normalized). The layer where the crossfade occurs. The time of the state (normalized). The time of the transition (normalized).

Creates a crossfade from the current state to any other state using normalized times.

The name of the state. The hash name of the state. The duration of the transition (normalized). The layer where the crossfade occurs. The time of the state (normalized). The time of the transition (normalized).

Creates a crossfade from the current state to any other state using times in seconds.

The name of the state. The hash name of the state. The duration of the transition (in seconds). The layer where the crossfade occurs. The time of the state (in seconds). The time of the transition (normalized).

Creates a crossfade from the current state to any other state using times in seconds.

The name of the state. The hash name of the state. The duration of the transition (in seconds). The layer where the crossfade occurs. The time of the state (in seconds). The time of the transition (normalized).

See IAnimatorControllerPlayable.GetAnimatorTransitionInfo.

Return the first StateMachineBehaviour that match type T or derived from T. Return null if none are found.

Returns all StateMachineBehaviour that match type T or are derived from T. Returns null if none are found.

Returns transform mapped to this human bone id.

The human bone that is queried, see enum HumanBodyBones for a list of possible values.

See IAnimatorControllerPlayable.GetBool.

See IAnimatorControllerPlayable.GetBool.

Access the current Animation clip’s information from the Animator.

Get a list of AnimatorClipInfo from the Animator.

See IAnimatorControllerPlayable.GetCurrentAnimatorClipInfoCount.

See IAnimatorControllerPlayable.GetCurrentAnimatorStateInfo.

See IAnimatorControllerPlayable.GetFloat.

See IAnimatorControllerPlayable.GetFloat.

Gets the position of an IK hint.

The AvatarIKHint that is queried. Return the current position of this IK hint in world space.

Gets the translative weight of an IK Hint (0 = at the original animation before IK, 1 = at the hint).

The AvatarIKHint that is queried. Return translative weight.

Gets the position of an IK goal.

The AvatarIKGoal that is queried. Return the current position of this IK goal in world space.

Gets the translative weight of an IK goal (0 = at the original animation before IK, 1 = at the goal).

The AvatarIKGoal that is queried.

Gets the rotation of an IK goal.

The AvatarIKGoal that is is queried.

Gets the rotational weight of an IK goal (0 = rotation before IK, 1 = rotation at the IK goal).

The AvatarIKGoal that is queried.

See IAnimatorControllerPlayable.GetInteger.

See IAnimatorControllerPlayable.GetInteger.

See IAnimatorControllerPlayable.GetLayerIndex.

See IAnimatorControllerPlayable.GetLayerName.

See IAnimatorControllerPlayable.GetLayerWeight.

See IAnimatorControllerPlayable.GetNextAnimatorClipInfo.

See IAnimatorControllerPlayable.GetNextAnimatorClipInfo.

See IAnimatorControllerPlayable.GetNextAnimatorClipInfoCount.

See IAnimatorControllerPlayable.GetNextAnimatorStateInfo.

See AnimatorController.GetParameter.

Gets the value of a quaternion parameter.

The name of the parameter.

Gets the value of a quaternion parameter.

The id of the parameter. The id is generated using Animator::StringToHash.

Gets the value of a vector parameter.

The name of the parameter.

Gets the value of a vector parameter.

The id of the parameter. The id is generated using Animator::StringToHash.

See IAnimatorControllerPlayable.HasState.

Interrupts the automatic target matching.

Interrupts the automatic target matching.

Returns true if the transform is controlled by the Animator\.

The transform that is queried.

See IAnimatorControllerPlayable.IsInTransition.

See IAnimatorControllerPlayable.IsParameterControlledByCurve.

See IAnimatorControllerPlayable.IsParameterControlledByCurve.

Automatically adjust the gameobject position and rotation so that the AvatarTarget reaches the matchPosition when the current state is at the specified progress.

The position we want the body part to reach. The rotation in which we want the body part to be. The body part that is involved in the match. Structure that contains weights for matching position and rotation. Start time within the animation clip (0 - beginning of clip, 1 - end of clip). End time within the animation clip (0 - beginning of clip, 1 - end of clip), values greater than 1 can be set to trigger a match after a certain number of loops. Ex: 2.3 means at 30% of 2nd loop.

See IAnimatorControllerPlayable.Play.

See IAnimatorControllerPlayable.Play.

See IAnimatorControllerPlayable.PlayInFixedTime.

See IAnimatorControllerPlayable.PlayInFixedTime.

Rebind all the animated properties and mesh data with the Animator.

See IAnimatorControllerPlayable.ResetTrigger.

See IAnimatorControllerPlayable.ResetTrigger.

Sets local rotation of a human bone during a IK pass.

The human bone Id. The local rotation.

Sets an Animator bool parameter.

Sets an Animator bool parameter.

Send float values to the Animator to affect transitions.

Send float values to the Animator to affect transitions.

Send float values to the Animator to affect transitions.

Send float values to the Animator to affect transitions.

Sets the position of an IK hint.

The AvatarIKHint that is set. The position in world space.

Sets the translative weight of an IK hint (0 = at the original animation before IK, 1 = at the hint).

The AvatarIKHint that is set. The translative weight.

Sets the position of an IK goal.

The AvatarIKGoal that is set. The position in world space.

Sets the translative weight of an IK goal (0 = at the original animation before IK, 1 = at the goal).

The AvatarIKGoal that is set. The translative weight.

Sets the rotation of an IK goal.

The AvatarIKGoal that is set. The rotation in world space.

Sets the rotational weight of an IK goal (0 = rotation before IK, 1 = rotation at the IK goal).

The AvatarIKGoal that is set. The rotational weight.

See IAnimatorControllerPlayable.SetInteger.

See IAnimatorControllerPlayable.SetInteger.

See IAnimatorControllerPlayable.SetLayerWeight.

Sets the look at position.

The position to lookAt.

Set look at weights.

(0-1) the global weight of the LookAt, multiplier for other parameters. (0-1) determines how much the body is involved in the LookAt. (0-1) determines how much the head is involved in the LookAt. (0-1) determines how much the eyes are involved in the LookAt. (0-1) 0.0 means the character is completely unrestrained in motion, 1.0 means he's completely clamped (look at becomes impossible), and 0.5 means he'll be able to move on half of the possible range (180 degrees).

Set look at weights.

(0-1) the global weight of the LookAt, multiplier for other parameters. (0-1) determines how much the body is involved in the LookAt. (0-1) determines how much the head is involved in the LookAt. (0-1) determines how much the eyes are involved in the LookAt. (0-1) 0.0 means the character is completely unrestrained in motion, 1.0 means he's completely clamped (look at becomes impossible), and 0.5 means he'll be able to move on half of the possible range (180 degrees).

Set look at weights.

(0-1) the global weight of the LookAt, multiplier for other parameters. (0-1) determines how much the body is involved in the LookAt. (0-1) determines how much the head is involved in the LookAt. (0-1) determines how much the eyes are involved in the LookAt. (0-1) 0.0 means the character is completely unrestrained in motion, 1.0 means he's completely clamped (look at becomes impossible), and 0.5 means he'll be able to move on half of the possible range (180 degrees).

Set look at weights.

(0-1) the global weight of the LookAt, multiplier for other parameters. (0-1) determines how much the body is involved in the LookAt. (0-1) determines how much the head is involved in the LookAt. (0-1) determines how much the eyes are involved in the LookAt. (0-1) 0.0 means the character is completely unrestrained in motion, 1.0 means he's completely clamped (look at becomes impossible), and 0.5 means he'll be able to move on half of the possible range (180 degrees).

Set look at weights.

(0-1) the global weight of the LookAt, multiplier for other parameters. (0-1) determines how much the body is involved in the LookAt. (0-1) determines how much the head is involved in the LookAt. (0-1) determines how much the eyes are involved in the LookAt. (0-1) 0.0 means the character is completely unrestrained in motion, 1.0 means he's completely clamped (look at becomes impossible), and 0.5 means he'll be able to move on half of the possible range (180 degrees).

Sets the value of a quaternion parameter.

The name of the parameter. The new value for the parameter.

Sets the value of a quaternion parameter.

Of the parameter. The id is generated using Animator::StringToHash. The new value for the parameter.

Sets an AvatarTarget and a targetNormalizedTime for the current state.

The avatar body part that is queried. The current state Time that is queried.

See IAnimatorControllerPlayable.SetTrigger.

See IAnimatorControllerPlayable.SetTrigger.

Sets the value of a vector parameter.

The name of the parameter. The new value for the parameter.

Sets the value of a vector parameter.

The id of the parameter. The id is generated using Animator::StringToHash. The new value for the parameter.

Sets the animator in playback mode.

Sets the animator in recording mode, and allocates a circular buffer of size frameCount.

The number of frames (updates) that will be recorded. If frameCount is 0, the recording will continue until the user calls StopRecording. The maximum value for frameCount is 10000.

Stops the animator playback mode. When playback stops, the avatar resumes getting control from game logic.

Stops animator record mode.

Generates an parameter id from a string.

The string to convert to Id.

Evaluates the animator based on deltaTime.

The time delta.

Information about clip being played and blended by the Animator.

Returns the animation clip played by the Animator.

Returns the blending weight used by the Animator to blend this clip.

Used to communicate between scripting and the controller. Some parameters can be set in scripting and used by the controller, while other parameters are based on Custom Curves in Animation Clips and can be sampled using the scripting API.

The default bool value for the parameter.

The default float value for the parameter.

The default int value for the parameter.

The name of the parameter.

Returns the hash of the parameter based on its name.

The type of the parameter.

The type of the parameter.

Boolean type parameter.

Float type parameter.

Int type parameter.

Trigger type parameter.

Culling mode for the Animator.

Always animate the entire character. Object is animated even when offscreen.

Animation is completely disabled when renderers are not visible.

Retarget, IK and write of Transforms are disabled when renderers are not visible.

Interface to control Animator Override Controller.

Returns the list of orignal Animation Clip from the controller and their override Animation Clip.

Returns the count of overrides.

The Runtime Animator Controller that the Animator Override Controller overrides.

Applies the list of overrides on this Animator Override Controller.

Overrides list to apply.

Creates an empty Animator Override Controller.

Creates an Animator Override Controller that overrides controller.

Runtime Animator Controller to override.

Gets the list of Animation Clip overrides currently defined in this Animator Override Controller.

Array to receive results.

Returns either the overriding Animation Clip if set or the original Animation Clip named name.

Returns either the overriding Animation Clip if set or the original Animation Clip named name.

The mode of the Animator's recorder.

The Animator recorder is offline.

The Animator recorder is in Playback.

The Animator recorder is in Record.

Information about the current or next state.

The full path hash for this state.

Current duration of the state.

Is the state looping.

The hashed name of the State.

Normalized time of the State.

The hash is generated using Animator::StringToHash. The string to pass doest not include the parent layer's name.

The playback speed of the animation. 1 is the normal playback speed.

The speed multiplier for this state.

The Tag of the State.

Does name match the name of the active state in the statemachine?

Does tag match the tag of the active state in the statemachine.

Information about the current transition.

Returns true if the transition is from an AnyState node, or from Animator.CrossFade().

Duration of the transition.

The unit of the transition duration.

The unique name of the Transition.

The simplified name of the Transition.

Normalized time of the Transition.

The user-specified name of the Transition.

Does name match the name of the active Transition.

Does userName match the name of the active Transition.

The update mode of the Animator.

Updates the animator during the physic loop in order to have the animation system synchronized with the physics engine.

Normal update of the animator.

Animator updates independently of Time.timeScale.

Various utilities for animator manipulation.

This function will recreate all transform hierarchy under GameObject.

GameObject to Deoptimize.

This function will remove all transform hierarchy under GameObject, the animator will write directly transform matrices into the skin mesh matrices saving alot of CPU cycles.

GameObject to Optimize. List of transform name to expose.

Avatar definition.

Return true if this avatar is a valid human avatar.

Return true if this avatar is a valid mecanim avatar. It can be a generic avatar or a human avatar.

Class to build avatars from user scripts.

Create a new generic avatar.

Root object of your transform hierarchy. Transform name of the root motion transform. If empty no root motion is defined and you must take care of avatar movement yourself.

Create a humanoid avatar.

Root object of your transform hierachy. It must be the top most gameobject when you create the avatar. Humanoid description of the avatar. Returns the Avatar, you must always always check the avatar is valid before using it with Avatar.isValid.

IK Goal.

The left foot.

The left hand.

The right foot.

The right hand.

IK Hint.

The left elbow IK hint.

The left knee IK hint.

The right elbow IK hint.

The right knee IK hint.

AvatarMask are used to mask out humanoid body parts and transforms.

Number of transforms.

Adds a transform path into the AvatarMask.

The transform to add into the AvatarMask. Whether to also add all children of the specified transform.

Creates a new AvatarMask.

Returns true if the humanoid body part at the given index is active.

The index of the humanoid body part.

Returns true if the transform at the given index is active.

The index of the transform.

Returns the path of the transform at the given index.

The index of the transform.

Removes a transform path from the AvatarMask.

The Transform that should be removed from the AvatarMask. Whether to also remove all children of the specified transform.

Sets the humanoid body part at the given index to active or not.

The index of the humanoid body part. Active or not.

Sets the tranform at the given index to active or not.

The index of the transform. Active or not.

Sets the path of the transform at the given index.

The index of the transform. The path of the transform.

Avatar body part.

The Body.

The Head.

Total number of body parts.

The Left Arm.

Left Fingers.

Left Foot IK.

Left Hand IK.

The Left Leg.

The Right Arm.

Right Fingers.

Right Foot IK.

Right Hand IK.

The Right Leg.

The Root.

Target.

The body, center of mass.

The left foot.

The left hand.

The right foot.

The right hand.

The root, the position of the game object.

Describe the unit of a duration.

A fixed duration is a duration expressed in seconds.

A normalized duration is a duration expressed in percentage.

Human Body Bones.

This is the Chest bone.

This is the Head bone.

This is the Hips bone.

This is the Jaw bone.

This is the Last bone index delimiter.

This is the Left Eye bone.

This is the Left Ankle bone.

This is the Left Wrist bone.

This is the left index 3rd phalange.

This is the left index 2nd phalange.

This is the left index 1st phalange.

This is the left little 3rd phalange.

This is the left little 2nd phalange.

This is the left little 1st phalange.

This is the Left Elbow bone.

This is the Left Knee bone.

This is the left middle 3rd phalange.

This is the left middle 2nd phalange.

This is the left middle 1st phalange.

This is the left ring 3rd phalange.

This is the left ring 2nd phalange.

This is the left ring 1st phalange.

This is the Left Shoulder bone.

This is the left thumb 3rd phalange.

This is the left thumb 2nd phalange.

This is the left thumb 1st phalange.

This is the Left Toes bone.

This is the Left Upper Arm bone.

This is the Left Upper Leg bone.

This is the Neck bone.

This is the Right Eye bone.

This is the Right Ankle bone.

This is the Right Wrist bone.

This is the right index 3rd phalange.

This is the right index 2nd phalange.

This is the right index 1st phalange.

This is the right little 3rd phalange.

This is the right little 2nd phalange.

This is the right little 1st phalange.

This is the Right Elbow bone.

This is the Right Knee bone.

This is the right middle 3rd phalange.

This is the right middle 2nd phalange.

This is the right middle 1st phalange.

This is the right ring 3rd phalange.

This is the right ring 2nd phalange.

This is the right ring 1st phalange.

This is the Right Shoulder bone.

This is the right thumb 3rd phalange.

This is the right thumb 2nd phalange.

This is the right thumb 1st phalange.

This is the Right Toes bone.

This is the Right Upper Arm bone.

This is the Right Upper Leg bone.

This is the first Spine bone.

This is the Upper Chest bone.

The mapping between a bone in the model and the conceptual bone in the Mecanim human anatomy.

The name of the bone to which the Mecanim human bone is mapped.

The name of the Mecanim human bone to which the bone from the model is mapped.

The rotation limits that define the muscle for this bone.

Class that holds humanoid avatar parameters to pass to the AvatarBuilder.BuildHumanAvatar function.

Amount by which the arm's length is allowed to stretch when using IK.

Modification to the minimum distance between the feet of a humanoid model.

True for any human that has a translation Degree of Freedom (DoF). It is set to false by default.

Mapping between Mecanim bone names and bone names in the rig.

Amount by which the leg's length is allowed to stretch when using IK.

Defines how the lower arm's roll/twisting is distributed between the elbow and wrist joints.

Defines how the lower leg's roll/twisting is distributed between the knee and ankle.

List of bone Transforms to include in the model.

Defines how the lower arm's roll/twisting is distributed between the shoulder and elbow joints.

Defines how the upper leg's roll/twisting is distributed between the thigh and knee joints.

This class stores the rotation limits that define the muscle for a single human bone.

Length of the bone to which the limit is applied.

The default orientation of a bone when no muscle action is applied.

The maximum rotation away from the initial value that this muscle can apply.

The maximum negative rotation away from the initial value that this muscle can apply.

Should this limit use the default values?

Retargetable humanoid pose.

The human body position for that pose.

The human body orientation for that pose.

The array of muscle values for that pose.

A handler that lets you read or write a HumanPose from or to a humanoid avatar skeleton hierarchy.

Creates a human pose handler from an avatar and a root transform.

The avatar that defines the humanoid rig on skeleton hierarchy with root as the top most parent. The top most node of the skeleton hierarchy defined in humanoid avatar.

Gets a human pose from the handled avatar skeleton.

The output human pose.

Sets a human pose on the handled avatar skeleton.

The human pose to be set.

Details of all the human bone and muscle types defined by Mecanim.

The number of human bone types defined by Mecanim.

Return the bone to which a particular muscle is connected.

Muscle index.

Array of the names of all human bone types defined by Mecanim.

Get the default maximum value of rotation for a muscle in degrees.

Muscle index.

Get the default minimum value of rotation for a muscle in degrees.

Muscle index.

Returns parent humanoid bone index of a bone.

Humanoid bone index to get parent from. Humanoid bone index of parent.

The number of human muscle types defined by Mecanim.

Obtain the muscle index for a particular bone index and "degree of freedom".

Bone index. Number representing a "degree of freedom": 0 for X-Axis, 1 for Y-Axis, 2 for Z-Axis.

Array of the names of all human muscle types defined by Mecanim.

Is the bone a member of the minimal set of bones that Mecanim requires for a human model?

Index of the bone to test.

The number of bone types that are required by Mecanim for any human model.

To specify position and rotation weight mask for Animator::MatchTarget.

Position XYZ weight.

Rotation weight.

MatchTargetWeightMask contructor.

Position XYZ weight. Rotation weight.

Base class for AnimationClips and BlendTrees.

Implements high-level utility methods to simplify use of the Playable API with Animations.

Plays the Playable on the given Animator.

Target Animator. The Playable that will be played. The Graph that owns the Playable.

Creates a PlayableGraph to be played on the given Animator. An AnimatorControllerPlayable is also created for the given RuntimeAnimatorController.

Target Animator. The RuntimeAnimatorController to create an AnimatorControllerPlayable for. The created PlayableGraph. A handle to the newly-created AnimatorControllerPlayable.

Creates a PlayableGraph to be played on the given Animator. An AnimationClipPlayable is also created for the given AnimationClip.

Target Animator. The AnimationClip to create an AnimationClipPlayable for. The created PlayableGraph. A handle to the newly-created AnimationClipPlayable.

Creates a PlayableGraph to be played on the given Animator. An AnimationLayerMixerPlayable is also created.

Target Animator. The input count for the AnimationLayerMixerPlayable. Defines the number of layers. The created PlayableGraph. A handle to the newly-created AnimationLayerMixerPlayable.

Creates a PlayableGraph to be played on the given Animator. An AnimationMixerPlayable is also created.

Target Animator. The input count for the AnimationMixerPlayable. The created PlayableGraph. A handle to the newly-created AnimationMixerPlayable.

Used by Animation.Play function.

Will stop all animations that were started with this component before playing.

Will stop all animations that were started in the same layer. This is the default when playing animations.

Used by Animation.Play function.

Will start playing after all other animations have stopped playing.

Starts playing immediately. This can be used if you just want to quickly create a duplicate animation.

Runtime representation of the AnimatorController. It can be used to change the Animator's controller during runtime.

Retrieves all AnimationClip used by the controller.

SharedBetweenAnimatorsAttribute is an attribute that specify that this StateMachineBehaviour should be instantiate only once and shared among all Animator instance. This attribute reduce the memory footprint for each controller instance.

Details of the Transform name mapped to a model's skeleton bone and its default position and rotation in the T-pose.

The name of the Transform mapped to the bone.

The T-pose position of the bone in local space.

The T-pose rotation of the bone in local space.

The T-pose scaling of the bone in local space.

StateMachineBehaviour is a component that can be added to a state machine state. It's the base class every script on a state derives from.

Called on the first Update frame when a statemachine evaluate this state.

Called on the last update frame when a statemachine evaluate this state.

Called right after MonoBehaviour.OnAnimatorIK.

Called on the first Update frame when making a transition to a StateMachine. This is not called when making a transition into a StateMachine sub-state.

The Animator playing this state machine. The full path hash for this state machine.

Called on the last Update frame when making a transition out of a StateMachine. This is not called when making a transition into a StateMachine sub-state.

The Animator playing this state machine. The full path hash for this state machine.

Called right after MonoBehaviour.OnAnimatorMove.

Called at each Update frame except for the first and last frame.