// Decompiled with JetBrains decompiler

// Type: UnityEngine.Animator

// Assembly: UnityEngine, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null

// MVID: A8FF7A2C-E4EE-4232-AB17-3FCABEC16496

// Assembly location: C:\Users\Blake\sandbox\unity\test-project\Library\UnityAssemblies\UnityEngine.dll

using System;

using System.ComponentModel;

using System.Runtime.CompilerServices;

using UnityEngine.Experimental.Director;

using UnityEngine.Internal;

using UnityEngine.Scripting;

namespace UnityEngine

{

/// <summary>

/// <para>Interface to control the Mecanim animation system.</para>

/// </summary>

[UsedByNativeCode]

public sealed class Animator : DirectorPlayer, IAnimatorControllerPlayable

{

/// <summary>

/// <para>Returns true if the current rig is optimizable with AnimatorUtility.OptimizeTransformHierarchy.</para>

/// </summary>

public bool isOptimizable { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; }

/// <summary>

/// <para>Returns true if the current rig is humanoid, false if it is generic.</para>

/// </summary>

public bool isHuman { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; }

/// <summary>

/// <para>Returns true if the current rig has root motion.</para>

/// </summary>

public bool hasRootMotion { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; }

internal bool isRootPositionOrRotationControlledByCurves { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; }

/// <summary>

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

/// </summary>

public float humanScale { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; }

/// <summary>

/// <para>Returns whether the animator is initialized successfully.</para>

/// </summary>

public bool isInitialized { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; }

/// <summary>

/// <para>Gets the avatar delta position for the last evaluated frame.</para>

/// </summary>

public Vector3 deltaPosition

{

get

{

Vector3 vector3;

this.INTERNAL_get_deltaPosition(out vector3);

return vector3;

}

}

/// <summary>

/// <para>Gets the avatar delta rotation for the last evaluated frame.</para>

/// </summary>

public Quaternion deltaRotation

{

get

{

Quaternion quaternion;

this.INTERNAL_get_deltaRotation(out quaternion);

return quaternion;

}

}

/// <summary>

/// <para>Gets the avatar velocity for the last evaluated frame.</para>

/// </summary>

public Vector3 velocity

{

get

{

Vector3 vector3;

this.INTERNAL_get_velocity(out vector3);

return vector3;

}

}

/// <summary>

/// <para>Gets the avatar angular velocity for the last evaluated frame.</para>

/// </summary>

public Vector3 angularVelocity

{

get

{

Vector3 vector3;

this.INTERNAL_get_angularVelocity(out vector3);

return vector3;

}

}

/// <summary>

/// <para>The root position, the position of the game object.</para>

/// </summary>

public Vector3 rootPosition

{

get

{

Vector3 vector3;

this.INTERNAL_get_rootPosition(out vector3);

return vector3;

}

set

{

this.INTERNAL_set_rootPosition(ref value);

}

}

/// <summary>

/// <para>The root rotation, the rotation of the game object.</para>

/// </summary>

public Quaternion rootRotation

{

get

{

Quaternion quaternion;

this.INTERNAL_get_rootRotation(out quaternion);

return quaternion;

}

set

{

this.INTERNAL_set_rootRotation(ref value);

}

}

/// <summary>

/// <para>Should root motion be applied?</para>

/// </summary>

public bool applyRootMotion { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] set; }

/// <summary>

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

/// </summary>

public bool linearVelocityBlending { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] set; }

/// <summary>

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

/// </summary>

[Obsolete("Use Animator.updateMode instead")]

public bool animatePhysics

{

get

{

return this.updateMode == AnimatorUpdateMode.AnimatePhysics;

}

set

{

this.updateMode = !value ? AnimatorUpdateMode.Normal : AnimatorUpdateMode.AnimatePhysics;

}

}

/// <summary>

/// <para>Specifies the update mode of the Animator.</para>

/// </summary>

public AnimatorUpdateMode updateMode { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] set; }

/// <summary>

/// <para>Returns true if the object has a transform hierarchy.</para>

/// </summary>

public bool hasTransformHierarchy { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; }

internal bool allowConstantClipSamplingOptimization { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] set; }

/// <summary>

/// <para>The current gravity weight based on current animations that are played.</para>

/// </summary>

public float gravityWeight { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; }

/// <summary>

/// <para>The position of the body center of mass.</para>

/// </summary>

public Vector3 bodyPosition

{

get

{

Vector3 vector3;

this.INTERNAL_get_bodyPosition(out vector3);

return vector3;

}

set

{

this.INTERNAL_set_bodyPosition(ref value);

}

}

/// <summary>

/// <para>The rotation of the body center of mass.</para>

/// </summary>

public Quaternion bodyRotation

{

get

{

Quaternion quaternion;

this.INTERNAL_get_bodyRotation(out quaternion);

return quaternion;

}

set

{

this.INTERNAL_set_bodyRotation(ref value);

}

}

/// <summary>

/// <para>Automatic stabilization of feet during transition and blending.</para>

/// </summary>

public bool stabilizeFeet { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] set; }

/// <summary>

/// <para>See IAnimatorControllerPlayable.layerCount.</para>

/// </summary>

public int layerCount { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; }

/// <summary>

/// <para>Read only acces to the AnimatorControllerParameters used by the animator.</para>

/// </summary>

public AnimatorControllerParameter[] parameters { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; }

/// <summary>

/// <para>See IAnimatorControllerPlayable.parameterCount.</para>

/// </summary>

public int parameterCount { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; }

/// <summary>

/// <para>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.</para>

/// </summary>

public float feetPivotActive { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] set; }

/// <summary>

/// <para>Gets the pivot weight.</para>

/// </summary>

public float pivotWeight { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; }

/// <summary>

/// <para>Get the current position of the pivot.</para>

/// </summary>

public Vector3 pivotPosition

{

get

{

Vector3 vector3;

this.INTERNAL_get_pivotPosition(out vector3);

return vector3;

}

}

/// <summary>

/// <para>If automatic matching is active.</para>

/// </summary>

public bool isMatchingTarget { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; }

/// <summary>

/// <para>The playback speed of the Animator. 1 is normal playback speed.</para>

/// </summary>

public float speed { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] set; }

/// <summary>

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

/// </summary>

public Vector3 targetPosition

{

get

{

Vector3 vector3;

this.INTERNAL_get_targetPosition(out vector3);

return vector3;

}

}

/// <summary>

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

/// </summary>

public Quaternion targetRotation

{

get

{

Quaternion quaternion;

this.INTERNAL_get_targetRotation(out quaternion);

return quaternion;

}

}

internal Transform avatarRoot { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; }

/// <summary>

/// <para>Controls culling of this Animator component.</para>

/// </summary>

public AnimatorCullingMode cullingMode { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] set; }

/// <summary>

/// <para>Sets the playback position in the recording buffer.</para>

/// </summary>

public float playbackTime { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] set; }

/// <summary>

/// <para>Start time of the first frame of the buffer relative to the frame at which StartRecording was called.</para>

/// </summary>

public float recorderStartTime { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] set; }

/// <summary>

/// <para>End time of the recorded clip relative to when StartRecording was called.</para>

/// </summary>

public float recorderStopTime { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] set; }

/// <summary>

/// <para>Gets the mode of the Animator recorder.</para>

/// </summary>

public AnimatorRecorderMode recorderMode { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; }

/// <summary>

/// <para>The runtime representation of AnimatorController that controls the Animator.</para>

/// </summary>

public RuntimeAnimatorController runtimeAnimatorController { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] set; }

/// <summary>

/// <para>Gets/Sets the current Avatar.</para>

/// </summary>

public Avatar avatar { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] set; }

/// <summary>

/// <para>Additional layers affects the center of mass.</para>

/// </summary>

public bool layersAffectMassCenter { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] set; }

/// <summary>

/// <para>Get left foot bottom height.</para>

/// </summary>

public float leftFeetBottomHeight { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; }

/// <summary>

/// <para>Get right foot bottom height.</para>

/// </summary>

public float rightFeetBottomHeight { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; }

internal bool supportsOnAnimatorMove { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; }

public bool logWarnings { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] set; }

public bool fireEvents { [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] get; [WrapperlessIcall, MethodImpl(MethodImplOptions.InternalCall)] set; }

/// <summary>

/// <para>See IAnimatorControllerPlayable.GetFloat.</para>

/// </summary>

/// <param name="name"></param>

/// <param name="id"></param>

public float GetFloat(string name)

{

return this.GetFloatString(name);

}

/// <summary>

/// <para>See IAnimatorControllerPlayable.GetFloat.</para>

/// </summary>

/// <param name="name"></param>

/// <param name="id"></param>

public float GetFloat(int id)

{

return this.GetFloatID(id);

}

/// <summary>

/// <para>See IAnimatorControllerPlayable.SetFloat.</para>

/// </summary>

/// <param name="name"></param>

/// <param name="value"></param>

/// <param name="dampTime"></param>

/// <param name="deltaTime"></param>

/// <param name="id"></param>

public void SetFloat(string name, float value)

{

this.SetFloatString(name, value);

}

/// <summary>

/// <para>See IAnimatorControllerPlayable.SetFloat.</para>

/// </summary>

/// <param name="name"></param>

/// <param name="value"></param>

/// <param name="dampTime"></param>

/// <param name="deltaTime"></param>

/// <param name="id"></param>

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

{

this.SetFloatStringDamp(name, value, dampTime, deltaTime);

}

/// <summary>

/// <para>See IAnimatorControllerPlayable.SetFloat.</para>

/// </summary>

/// <param name="name"></param>

/// <param name="value"></param>

/// <param name="dampTime"></param>

/// <param name="deltaTime"></param>

/// <param name="id"></param>

public void SetFloat(int id, float value)

{

this.SetFloatID(id, value);

}

/// <summary>

/// <para>See IAnimatorControllerPlayable.SetFloat.</para>

/// </summary>

/// <param name="name"></param>

/// <param name="value"></param>

/// <param name="dampTime"></param>

/// <param name="deltaTime"></param>

/// <param name="id"></param>

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

{

this.SetFloatIDDamp(id, value, dampTime, deltaTime);

}

/// <summary>

/// <para>See IAnimatorControllerPlayable.GetBool.</para>

/// </summary>

/// <param name="name"></param>

/// <param name="id"></param>

public bool GetBool(string name)

{

return this.GetBoolString(name);

}

/// <summary>

/// <para>See IAnimatorControllerPlayable.GetBool.</para>

/// </summary>

/// <param name="name"></param>

/// <param name="id"></param>

public bool GetBool(int id)

{

return this.GetBoolID(id);

}

/// <summary>

/// <para>See IAnimatorControllerPlayable.SetBool.</para>

/// </summary>

/// <param name="name"></param>

/// <param name="value"></param>

/// <param name="id"></param>

public void SetBool(string name, bool value)

{

this.SetBoolString(name, value);

}

/// <summary>

/// <para>See IAnimatorControllerPlayable.SetBool.</para>

/// </summary>

/// <param name="name"></param>

/// <param name="value"></param>

/// <param name="id"></param>

public void SetBool(int id, bool value)

{

this.SetBoolID(id, value);

}

/// <summary>

/// <para>See IAnimatorControllerPlayable.GetInteger.</para>

/// </summary>

/// <param name="name"></param>

/// <param name="id"></param>

public int GetInteger(string name)

{

return this.GetIntegerString(name);

}

/// <summary>

/// <para>See IAnimatorControllerPlayable.GetInteger.</para>

/// </summary>

/// <param name="name"></param>

/// <param name="id"></param>

public int GetInteger(int id)

{

return this.GetIntegerID(id);

}

/// <summary>

/// <para>See IAnimatorControllerPlayable.SetInteger.</para>

/// </summary>

/// <param name="name"></param>

/// <param name="value"></param>

/// <param name="id"></param>

public void SetInteger(string name, int value)

{

this.SetIntegerString(name, value);

}

/// <summary>

/// <para>See IAnimatorControllerPlayable.SetInteger.</para>

/// </summary>

/// <param name="name"></param>

/// <param name="value"></param>

/// <param name="id"></param>

public void SetInteger(int id, int value)

{

this.SetIntegerID(id, value);

}

/// <summary>

/// <para>See IAnimatorControllerPlayable.SetTrigger.</para>

/// </summary>

/// <param name="name"></param>

/// <param name="id"></param>

public void SetTrigger(string name)

{

this.SetTriggerString(name);

}

/// <summary>

/// <para>See IAnimatorControllerPlayable.SetTrigger.</para>

/// </summary>

/// <param name="name"></param>

/// <param name="id"></param>

public void SetTrigger(int id)

{

this.SetTriggerID(id);

}

/// <summary>

/// <para>See IAnimatorControllerPlayable.ResetTrigger.</para>

/// </summary>

/// <param name="name"></param>

/// <param name="id"></param>

public void ResetTrigger(string name)

{

this.ResetTriggerString(name);

}

/// <summary>

/// <para>See IAnimatorControllerPlayable.ResetTrigger.</para>

/// </summary>

/// <param name="name"></param>

/// <param name="id"></param>

public void ResetTrigger(int id)

{

this.ResetTriggerID(id);

}

/// <summary>

/// <para>See IAnimatorControllerPlayable.IsParameterControlledByCurve.</para>

/// </summary>

/// <param name="name"></param>

/// <param name="id"></param>

public bool IsParameterControlledByCurve(string name)

{

return this.IsParameterControlledByCurveString(name);

}

/// <summary>

/// <para>See IAnimatorControllerPlayable.IsParameterControlledByCurve.</para>

/// </summary>

/// <param name="name"></param>

/// <param name="id"></param>

public bool IsParameterControlledByCurve(int id)

{

return this.IsParameterControlledByCurveID(id);

}

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

private void INTERNAL_get_deltaPosition(out Vector3 value);

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

private void INTERNAL_get_deltaRotation(out Quaternion value);

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

private void INTERNAL_get_velocity(out Vector3 value);

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

private void INTERNAL_get_angularVelocity(out Vector3 value);

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

private void INTERNAL_get_rootPosition(out Vector3 value);

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

private void INTERNAL_set_rootPosition(ref Vector3 value);

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

private void INTERNAL_get_rootRotation(out Quaternion value);

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

private void INTERNAL_set_rootRotation(ref Quaternion value);

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

private void INTERNAL_get_bodyPosition(out Vector3 value);

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

private void INTERNAL_set_bodyPosition(ref Vector3 value);

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

private void INTERNAL_get_bodyRotation(out Quaternion value);

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

private void INTERNAL_set_bodyRotation(ref Quaternion value);

/// <summary>

/// <para>Gets the position of an IK goal.</para>

/// </summary>

/// <param name="goal">The AvatarIKGoal that is queried.</param>

/// <returns>

/// <para>Return the current position of this IK goal in world space.</para>

/// </returns>

public Vector3 GetIKPosition(AvatarIKGoal goal)

{

this.CheckIfInIKPass();

return this.GetIKPositionInternal(goal);

}

internal Vector3 GetIKPositionInternal(AvatarIKGoal goal)

{

Vector3 vector3;

Animator.INTERNAL_CALL_GetIKPositionInternal(this, goal, out vector3);

return vector3;

}

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

private static extern void INTERNAL_CALL_GetIKPositionInternal(Animator self, AvatarIKGoal goal, out Vector3 value);

/// <summary>

/// <para>Sets the position of an IK goal.</para>

/// </summary>

/// <param name="goal">The AvatarIKGoal that is set.</param>

/// <param name="goalPosition">The position in world space.</param>

public void SetIKPosition(AvatarIKGoal goal, Vector3 goalPosition)

{

this.CheckIfInIKPass();

this.SetIKPositionInternal(goal, goalPosition);

}

internal void SetIKPositionInternal(AvatarIKGoal goal, Vector3 goalPosition)

{

Animator.INTERNAL_CALL_SetIKPositionInternal(this, goal, ref goalPosition);

}

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

private static extern void INTERNAL_CALL_SetIKPositionInternal(Animator self, AvatarIKGoal goal, ref Vector3 goalPosition);

/// <summary>

/// <para>Gets the rotation of an IK goal.</para>

/// </summary>

/// <param name="goal">The AvatarIKGoal that is is queried.</param>

public Quaternion GetIKRotation(AvatarIKGoal goal)

{

this.CheckIfInIKPass();

return this.GetIKRotationInternal(goal);

}

internal Quaternion GetIKRotationInternal(AvatarIKGoal goal)

{

Quaternion quaternion;

Animator.INTERNAL_CALL_GetIKRotationInternal(this, goal, out quaternion);

return quaternion;

}

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

private static extern void INTERNAL_CALL_GetIKRotationInternal(Animator self, AvatarIKGoal goal, out Quaternion value);

/// <summary>

/// <para>Sets the rotation of an IK goal.</para>

/// </summary>

/// <param name="goal">The AvatarIKGoal that is set.</param>

/// <param name="goalRotation">The rotation in world space.</param>

public void SetIKRotation(AvatarIKGoal goal, Quaternion goalRotation)

{

this.CheckIfInIKPass();

this.SetIKRotationInternal(goal, goalRotation);

}

internal void SetIKRotationInternal(AvatarIKGoal goal, Quaternion goalRotation)

{

Animator.INTERNAL_CALL_SetIKRotationInternal(this, goal, ref goalRotation);

}

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

private static extern void INTERNAL_CALL_SetIKRotationInternal(Animator self, AvatarIKGoal goal, ref Quaternion goalRotation);

/// <summary>

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

/// </summary>

/// <param name="goal">The AvatarIKGoal that is queried.</param>

public float GetIKPositionWeight(AvatarIKGoal goal)

{

this.CheckIfInIKPass();

return this.GetIKPositionWeightInternal(goal);

}

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

internal float GetIKPositionWeightInternal(AvatarIKGoal goal);

/// <summary>

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

/// </summary>

/// <param name="goal">The AvatarIKGoal that is set.</param>

/// <param name="value">The translative weight.</param>

public void SetIKPositionWeight(AvatarIKGoal goal, float value)

{

this.CheckIfInIKPass();

this.SetIKPositionWeightInternal(goal, value);

}

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

internal void SetIKPositionWeightInternal(AvatarIKGoal goal, float value);

/// <summary>

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

/// </summary>

/// <param name="goal">The AvatarIKGoal that is queried.</param>

public float GetIKRotationWeight(AvatarIKGoal goal)

{

this.CheckIfInIKPass();

return this.GetIKRotationWeightInternal(goal);

}

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

internal float GetIKRotationWeightInternal(AvatarIKGoal goal);

/// <summary>

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

/// </summary>

/// <param name="goal">The AvatarIKGoal that is set.</param>

/// <param name="value">The rotational weight.</param>

public void SetIKRotationWeight(AvatarIKGoal goal, float value)

{

this.CheckIfInIKPass();

this.SetIKRotationWeightInternal(goal, value);

}

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

internal void SetIKRotationWeightInternal(AvatarIKGoal goal, float value);

/// <summary>

/// <para>Gets the position of an IK hint.</para>

/// </summary>

/// <param name="hint">The AvatarIKHint that is queried.</param>

/// <returns>

/// <para>Return the current position of this IK hint in world space.</para>

/// </returns>

public Vector3 GetIKHintPosition(AvatarIKHint hint)

{

this.CheckIfInIKPass();

return this.GetIKHintPositionInternal(hint);

}

internal Vector3 GetIKHintPositionInternal(AvatarIKHint hint)

{

Vector3 vector3;

Animator.INTERNAL_CALL_GetIKHintPositionInternal(this, hint, out vector3);

return vector3;

}

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

private static extern void INTERNAL_CALL_GetIKHintPositionInternal(Animator self, AvatarIKHint hint, out Vector3 value);

/// <summary>

/// <para>Sets the position of an IK hint.</para>

/// </summary>

/// <param name="hint">The AvatarIKHint that is set.</param>

/// <param name="hintPosition">The position in world space.</param>

public void SetIKHintPosition(AvatarIKHint hint, Vector3 hintPosition)

{

this.CheckIfInIKPass();

this.SetIKHintPositionInternal(hint, hintPosition);

}

internal void SetIKHintPositionInternal(AvatarIKHint hint, Vector3 hintPosition)

{

Animator.INTERNAL_CALL_SetIKHintPositionInternal(this, hint, ref hintPosition);

}

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

private static extern void INTERNAL_CALL_SetIKHintPositionInternal(Animator self, AvatarIKHint hint, ref Vector3 hintPosition);

/// <summary>

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

/// </summary>

/// <param name="hint">The AvatarIKHint that is queried.</param>

/// <returns>

/// <para>Return translative weight.</para>

/// </returns>

public float GetIKHintPositionWeight(AvatarIKHint hint)

{

this.CheckIfInIKPass();

return this.GetHintWeightPositionInternal(hint);

}

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

internal float GetHintWeightPositionInternal(AvatarIKHint hint);

/// <summary>

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

/// </summary>

/// <param name="hint">The AvatarIKHint that is set.</param>

/// <param name="value">The translative weight.</param>

public void SetIKHintPositionWeight(AvatarIKHint hint, float value)

{

this.CheckIfInIKPass();

this.SetIKHintPositionWeightInternal(hint, value);

}

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

internal void SetIKHintPositionWeightInternal(AvatarIKHint hint, float value);

/// <summary>

/// <para>Sets the look at position.</para>

/// </summary>

/// <param name="lookAtPosition">The position to lookAt.</param>

public void SetLookAtPosition(Vector3 lookAtPosition)

{

this.CheckIfInIKPass();

this.SetLookAtPositionInternal(lookAtPosition);

}

internal void SetLookAtPositionInternal(Vector3 lookAtPosition)

{

Animator.INTERNAL_CALL_SetLookAtPositionInternal(this, ref lookAtPosition);

}

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

private static extern void INTERNAL_CALL_SetLookAtPositionInternal(Animator self, ref Vector3 lookAtPosition);

/// <summary>

/// <para>Set look at weights.</para>

/// </summary>

/// <param name="weight">(0-1) the global weight of the LookAt, multiplier for other parameters.</param>

/// <param name="bodyWeight">(0-1) determines how much the body is involved in the LookAt.</param>

/// <param name="headWeight">(0-1) determines how much the head is involved in the LookAt.</param>

/// <param name="eyesWeight">(0-1) determines how much the eyes are involved in the LookAt.</param>

/// <param name="clampWeight">(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).</param>

[ExcludeFromDocs]

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

{

float clampWeight = 0.5f;

this.SetLookAtWeight(weight, bodyWeight, headWeight, eyesWeight, clampWeight);

}

/// <summary>

/// <para>Set look at weights.</para>

/// </summary>

/// <param name="weight">(0-1) the global weight of the LookAt, multiplier for other parameters.</param>

/// <param name="bodyWeight">(0-1) determines how much the body is involved in the LookAt.</param>

/// <param name="headWeight">(0-1) determines how much the head is involved in the LookAt.</param>

/// <param name="eyesWeight">(0-1) determines how much the eyes are involved in the LookAt.</param>

/// <param name="clampWeight">(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).</param>

[ExcludeFromDocs]

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

{

float clampWeight = 0.5f;

float eyesWeight = 0.0f;

this.SetLookAtWeight(weight, bodyWeight, headWeight, eyesWeight, clampWeight);

}

/// <summary>

/// <para>Set look at weights.</para>

/// </summary>

/// <param name="weight">(0-1) the global weight of the LookAt, multiplier for other parameters.</param>

/// <param name="bodyWeight">(0-1) determines how much the body is involved in the LookAt.</param>

/// <param name="headWeight">(0-1) determines how much the head is involved in the LookAt.</param>

/// <param name="eyesWeight">(0-1) determines how much the eyes are involved in the LookAt.</param>

/// <param name="clampWeight">(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).</param>

[ExcludeFromDocs]

public void SetLookAtWeight(float weight, float bodyWeight)

{

float clampWeight = 0.5f;

float eyesWeight = 0.0f;

float headWeight = 1f;

this.SetLookAtWeight(weight, bodyWeight, headWeight, eyesWeight, clampWeight);

}

/// <summary>

/// <para>Set look at weights.</para>

/// </summary>

/// <param name="weight">(0-1) the global weight of the LookAt, multiplier for other parameters.</param>

/// <param name="bodyWeight">(0-1) determines how much the body is involved in the LookAt.</param>

/// <param name="headWeight">(0-1) determines how much the head is involved in the LookAt.</param>

/// <param name="eyesWeight">(0-1) determines how much the eyes are involved in the LookAt.</param>

/// <param name="clampWeight">(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).</param>

[ExcludeFromDocs]

public void SetLookAtWeight(float weight)

{

float clampWeight = 0.5f;

float eyesWeight = 0.0f;

float headWeight = 1f;

float bodyWeight = 0.0f;

this.SetLookAtWeight(weight, bodyWeight, headWeight, eyesWeight, clampWeight);

}

/// <summary>

/// <para>Set look at weights.</para>

/// </summary>

/// <param name="weight">(0-1) the global weight of the LookAt, multiplier for other parameters.</param>

/// <param name="bodyWeight">(0-1) determines how much the body is involved in the LookAt.</param>

/// <param name="headWeight">(0-1) determines how much the head is involved in the LookAt.</param>

/// <param name="eyesWeight">(0-1) determines how much the eyes are involved in the LookAt.</param>

/// <param name="clampWeight">(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).</param>

public void SetLookAtWeight(float weight, [DefaultValue("0.00f")] float bodyWeight, [DefaultValue("1.00f")] float headWeight, [DefaultValue("0.00f")] float eyesWeight, [DefaultValue("0.50f")] float clampWeight)

{

this.CheckIfInIKPass();

this.SetLookAtWeightInternal(weight, bodyWeight, headWeight, eyesWeight, clampWeight);

}

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

internal void SetLookAtWeightInternal(float weight, [DefaultValue("0.00f")] float bodyWeight, [DefaultValue("1.00f")] float headWeight, [DefaultValue("0.00f")] float eyesWeight, [DefaultValue("0.50f")] float clampWeight);

[ExcludeFromDocs]

internal void SetLookAtWeightInternal(float weight, float bodyWeight, float headWeight, float eyesWeight)

{

float clampWeight = 0.5f;

this.SetLookAtWeightInternal(weight, bodyWeight, headWeight, eyesWeight, clampWeight);

}

[ExcludeFromDocs]

internal void SetLookAtWeightInternal(float weight, float bodyWeight, float headWeight)

{

float clampWeight = 0.5f;

float eyesWeight = 0.0f;

this.SetLookAtWeightInternal(weight, bodyWeight, headWeight, eyesWeight, clampWeight);

}

[ExcludeFromDocs]

internal void SetLookAtWeightInternal(float weight, float bodyWeight)

{

float clampWeight = 0.5f;

float eyesWeight = 0.0f;

float headWeight = 1f;

this.SetLookAtWeightInternal(weight, bodyWeight, headWeight, eyesWeight, clampWeight);

}

[ExcludeFromDocs]

internal void SetLookAtWeightInternal(float weight)

{

float clampWeight = 0.5f;

float eyesWeight = 0.0f;

float headWeight = 1f;

float bodyWeight = 0.0f;

this.SetLookAtWeightInternal(weight, bodyWeight, headWeight, eyesWeight, clampWeight);

}

/// <summary>

/// <para>Sets local rotation of a human bone during a IK pass.</para>

/// </summary>

/// <param name="humanBoneId">The human bone Id.</param>

/// <param name="rotation">The local rotation.</param>

public void SetBoneLocalRotation(HumanBodyBones humanBoneId, Quaternion rotation)

{

this.CheckIfInIKPass();

this.SetBoneLocalRotationInternal(humanBoneId, rotation);

}

internal void SetBoneLocalRotationInternal(HumanBodyBones humanBoneId, Quaternion rotation)

{

Animator.INTERNAL_CALL_SetBoneLocalRotationInternal(this, humanBoneId, ref rotation);

}

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

private static extern void INTERNAL_CALL_SetBoneLocalRotationInternal(Animator self, HumanBodyBones humanBoneId, ref Quaternion rotation);

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

internal ScriptableObject GetBehaviour(System.Type type);

public T GetBehaviour<T>() where T : StateMachineBehaviour

{

return this.GetBehaviour(typeof (T)) as T;

}

[WrapperlessIcall]

[MethodImpl(MethodImplOptions.InternalCall)]

internal ScriptableObject[] GetBehaviours(System.Type type);