Animator

More information can be found in the Unity API Reference

Constructors

Constructor	Description
`Animator()`

Members

Member	Description
`angularVelocity`
`applyRootMotion`
`bodyPosition`
`bodyRotation`
`cullingMode`
`deltaPosition`
`deltaRotation`
`enabled`
`feetPivotActive`
`fireEvents`
`gameObject`
`gravityWeight`
`hasBoundPlayables`
`hasRootMotion`
`hasTransformHierarchy`
`humanScale`
`isActiveAndEnabled`
`isHuman`
`isInitialized`
`isMatchingTarget`
`isOptimizable`
`keepAnimatorStateOnDisable`
`layerCount`
`layersAffectMassCenter`
`leftFeetBottomHeight`
`logWarnings`
`name`
`parameterCount`
`pivotPosition`
`pivotWeight`
`playbackTime`
`recorderStartTime`
`recorderStopTime`
`rightFeetBottomHeight`
`rootPosition`
`rootRotation`
`runtimeAnimatorController`
`speed`
`stabilizeFeet`
`tag`
`targetPosition`
`targetRotation`
`transform`
`updateMode`
`velocity`
`writeDefaultValuesOnDisable`

Methods

Method	Description
`ApplyBuiltinRootMotion()`
`CompareTag(tag)`
`CrossFade(stateName, normalizedTransitionDuration)`
`CrossFade(stateHashName, normalizedTransitionDuration)`
`CrossFade(stateName, normalizedTransitionDuration, layer)`
`CrossFade(stateHashName, normalizedTransitionDuration, layer)`
`CrossFade(stateName, normalizedTransitionDuration, layer, normalizedTimeOffset)`
`CrossFade(stateHashName, normalizedTransitionDuration, layer, normalizedTimeOffset)`
`CrossFade(stateName, normalizedTransitionDuration, layer, normalizedTimeOffset, normalizedTransitionTime)`
`CrossFade(stateHashName, normalizedTransitionDuration, layer, normalizedTimeOffset, normalizedTransitionTime)`
`CrossFadeInFixedTime(stateName, fixedTransitionDuration)`
`CrossFadeInFixedTime(stateHashName, fixedTransitionDuration)`
`CrossFadeInFixedTime(stateName, fixedTransitionDuration, layer)`
`CrossFadeInFixedTime(stateHashName, fixedTransitionDuration, layer)`
`CrossFadeInFixedTime(stateName, fixedTransitionDuration, layer, fixedTimeOffset)`
`CrossFadeInFixedTime(stateHashName, fixedTransitionDuration, layer, fixedTimeOffset)`
`CrossFadeInFixedTime(stateName, fixedTransitionDuration, layer, fixedTimeOffset, normalizedTransitionTime)`
`CrossFadeInFixedTime(stateHashName, fixedTransitionDuration, layer, fixedTimeOffset, normalizedTransitionTime)`
`GetBoneTransform(humanBoneId)`
`GetBool(name)`
`GetBool(id)`
`GetCurrentAnimatorClipInfoCount(layerIndex)`
`GetFloat(name)`
`GetFloat(id)`
`GetHashCode()`
`GetIKHintPosition(hint)`
`GetIKHintPositionWeight(hint)`
`GetIKPosition(goal)`
`GetIKPositionWeight(goal)`
`GetIKRotation(goal)`
`GetIKRotationWeight(goal)`
`GetInteger(name)`
`GetInteger(id)`
`GetLayerIndex(layerName)`
`GetLayerName(layerIndex)`
`GetLayerWeight(layerIndex)`
`GetNextAnimatorClipInfoCount(layerIndex)`
`HasState(layerIndex, stateID)`
`InterruptMatchTarget()`
`InterruptMatchTarget(completeMatch)`
`IsInTransition(layerIndex)`
`IsParameterControlledByCurve(name)`
`IsParameterControlledByCurve(id)`
`Play(stateName)`
`Play(stateNameHash)`
`Play(stateName, layer)`
`Play(stateNameHash, layer)`
`Play(stateName, layer, normalizedTime)`
`Play(stateNameHash, layer, normalizedTime)`
`PlayInFixedTime(stateName)`
`PlayInFixedTime(stateNameHash)`
`PlayInFixedTime(stateName, layer)`
`PlayInFixedTime(stateNameHash, layer)`
`PlayInFixedTime(stateName, layer, fixedTime)`
`PlayInFixedTime(stateNameHash, layer, fixedTime)`
`Rebind()`
`ResetTrigger(name)`
`ResetTrigger(id)`
`SetBoneLocalRotation(humanBoneId, rotation)`
`SetBool(name, value)`
`SetBool(id, value)`
`SetFloat(name, value)`
`SetFloat(id, value)`
`SetFloat(name, value, dampTime, deltaTime)`
`SetFloat(id, value, dampTime, deltaTime)`
`SetIKHintPosition(hint, hintPosition)`
`SetIKHintPositionWeight(hint, value)`
`SetIKPosition(goal, goalPosition)`
`SetIKPositionWeight(goal, value)`
`SetIKRotation(goal, goalRotation)`
`SetIKRotationWeight(goal, value)`
`SetInteger(name, value)`
`SetInteger(id, value)`
`SetLayerWeight(layerIndex, weight)`
`SetLookAtPosition(lookAtPosition)`
`SetLookAtWeight(weight)`
`SetLookAtWeight(weight, bodyWeight)`
`SetLookAtWeight(weight, bodyWeight, headWeight)`
`SetLookAtWeight(weight, bodyWeight, headWeight, eyesWeight)`
`SetLookAtWeight(weight, bodyWeight, headWeight, eyesWeight, clampWeight)`
`SetTrigger(name)`
`SetTrigger(id)`
`StartPlayback()`
`StartRecording(frameCount)`
`StopPlayback()`
`StopRecording()`
`ToString()`
`Update(deltaTime)`
`WriteDefaultValues()`

Static methods

Method	Description
`StringToHash(name)`

Details

class Animator

Animator Animator()

const Vector3 angularVelocity

bool applyRootMotion

Vector3 bodyPosition

Quaternion bodyRotation

AnimatorCullingMode cullingMode

const Vector3 deltaPosition

const Quaternion deltaRotation

bool enabled

float feetPivotActive

bool fireEvents

const GameObject gameObject

const float gravityWeight

const bool hasBoundPlayables

const bool hasRootMotion

const bool hasTransformHierarchy

const float humanScale

const bool isActiveAndEnabled

const bool isHuman

const bool isInitialized

const bool isMatchingTarget

const bool isOptimizable

bool keepAnimatorStateOnDisable

const int layerCount

bool layersAffectMassCenter

const float leftFeetBottomHeight

bool logWarnings

string name

const int parameterCount

const Vector3 pivotPosition

const float pivotWeight

float playbackTime

float recorderStartTime

float recorderStopTime

const float rightFeetBottomHeight

Vector3 rootPosition

Quaternion rootRotation

RuntimeAnimatorController runtimeAnimatorController

float speed

bool stabilizeFeet

string tag

const Vector3 targetPosition

const Quaternion targetRotation

const Transform transform

AnimatorUpdateMode updateMode

const Vector3 velocity

bool writeDefaultValuesOnDisable

void ApplyBuiltinRootMotion()

bool CompareTag(string tag)

void CrossFade(string stateName, float normalizedTransitionDuration)

void CrossFade(int stateHashName, float normalizedTransitionDuration)

void CrossFade(string stateName, float normalizedTransitionDuration, int layer)

void CrossFade(int stateHashName, float normalizedTransitionDuration, int layer)

void CrossFade(string stateName, float normalizedTransitionDuration, int layer, float normalizedTimeOffset)

void CrossFade(int stateHashName, float normalizedTransitionDuration, int layer, float normalizedTimeOffset)

void CrossFade(string stateName, float normalizedTransitionDuration, int layer, float normalizedTimeOffset, float normalizedTransitionTime)

void CrossFade(int stateHashName, float normalizedTransitionDuration, int layer, float normalizedTimeOffset, float normalizedTransitionTime)

void CrossFadeInFixedTime(string stateName, float fixedTransitionDuration)

void CrossFadeInFixedTime(int stateHashName, float fixedTransitionDuration)

void CrossFadeInFixedTime(string stateName, float fixedTransitionDuration, int layer)

void CrossFadeInFixedTime(int stateHashName, float fixedTransitionDuration, int layer)

void CrossFadeInFixedTime(string stateName, float fixedTransitionDuration, int layer, float fixedTimeOffset)

void CrossFadeInFixedTime(int stateHashName, float fixedTransitionDuration, int layer, float fixedTimeOffset)

void CrossFadeInFixedTime(string stateName, float fixedTransitionDuration, int layer, float fixedTimeOffset, float normalizedTransitionTime)

void CrossFadeInFixedTime(int stateHashName, float fixedTransitionDuration, int layer, float fixedTimeOffset, float normalizedTransitionTime)

Transform GetBoneTransform(HumanBodyBones humanBoneId)

bool GetBool(string name)

bool GetBool(int id)

int GetCurrentAnimatorClipInfoCount(int layerIndex)

float GetFloat(string name)

float GetFloat(int id)

int GetHashCode()

Vector3 GetIKHintPosition(AvatarIKHint hint)

float GetIKHintPositionWeight(AvatarIKHint hint)

Vector3 GetIKPosition(AvatarIKGoal goal)

float GetIKPositionWeight(AvatarIKGoal goal)

Quaternion GetIKRotation(AvatarIKGoal goal)

float GetIKRotationWeight(AvatarIKGoal goal)

int GetInteger(string name)

int GetInteger(int id)

int GetLayerIndex(string layerName)

string GetLayerName(int layerIndex)

float GetLayerWeight(int layerIndex)

int GetNextAnimatorClipInfoCount(int layerIndex)

bool HasState(int layerIndex, int stateID)

void InterruptMatchTarget()

void InterruptMatchTarget(bool completeMatch)

bool IsInTransition(int layerIndex)

bool IsParameterControlledByCurve(string name)

bool IsParameterControlledByCurve(int id)

void Play(string stateName)

void Play(int stateNameHash)

void Play(string stateName, int layer)

void Play(int stateNameHash, int layer)

void Play(string stateName, int layer, float normalizedTime)

void Play(int stateNameHash, int layer, float normalizedTime)

void PlayInFixedTime(string stateName)

void PlayInFixedTime(int stateNameHash)

void PlayInFixedTime(string stateName, int layer)

void PlayInFixedTime(int stateNameHash, int layer)

void PlayInFixedTime(string stateName, int layer, float fixedTime)

void PlayInFixedTime(int stateNameHash, int layer, float fixedTime)

void Rebind()

void ResetTrigger(string name)

void ResetTrigger(int id)

void SetBoneLocalRotation(HumanBodyBones humanBoneId, Quaternion rotation)

void SetBool(string name, bool value)

void SetBool(int id, bool value)

void SetFloat(string name, float value)

void SetFloat(int id, float value)

void SetFloat(string name, float value, float dampTime, float deltaTime)

void SetFloat(int id, float value, float dampTime, float deltaTime)

void SetIKHintPosition(AvatarIKHint hint, Vector3 hintPosition)

void SetIKHintPositionWeight(AvatarIKHint hint, float value)

void SetIKPosition(AvatarIKGoal goal, Vector3 goalPosition)

void SetIKPositionWeight(AvatarIKGoal goal, float value)

void SetIKRotation(AvatarIKGoal goal, Quaternion goalRotation)

void SetIKRotationWeight(AvatarIKGoal goal, float value)

void SetInteger(string name, int value)

void SetInteger(int id, int value)

void SetLayerWeight(int layerIndex, float weight)

void SetLookAtPosition(Vector3 lookAtPosition)

void SetLookAtWeight(float weight)

void SetLookAtWeight(float weight, float bodyWeight)

void SetLookAtWeight(float weight, float bodyWeight, float headWeight)

void SetLookAtWeight(float weight, float bodyWeight, float headWeight, float eyesWeight)

void SetLookAtWeight(float weight, float bodyWeight, float headWeight, float eyesWeight, float clampWeight)

void SetTrigger(string name)

void SetTrigger(int id)

void StartPlayback()

void StartRecording(int frameCount)

void StopPlayback()

void StopRecording()

string ToString()

void Update(float deltaTime)

void WriteDefaultValues()

static int StringToHash(string name)