Uranium-and-Waffles/Dec2017-Script-Dump
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

scripts

Browse Source
This commit is contained in:
niko
2026-06-04 11:42:34 +02:00
parent f39ba70a9f
commit e720b98cd1
7488 changed files with 2493818 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
UnityEngine/Animations/AnimationClipPlayable.cs
+171
View File
@@ -0,0 +1,171 @@
using System;
using System.Runtime.CompilerServices;
using UnityEngine.Playables;
using UnityEngine.Scripting;
namespace UnityEngine.Animations
{
// Token: 0x020001F2 RID: 498
[RequiredByNativeCode]
public struct AnimationClipPlayable : IPlayable, IEquatable<AnimationClipPlayable>
{
// Token: 0x060022D5 RID: 8917 RVA: 0x00028640 File Offset: 0x00026840
internal AnimationClipPlayable(PlayableHandle handle)
{
if (handle.IsValid())
{
if (!handle.IsPlayableOfType<AnimationClipPlayable>())
{
throw new InvalidCastException("Can't set handle: the playable is not an AnimationClipPlayable.");
}
}
this.m_Handle = handle;
}
// Token: 0x060022D6 RID: 8918 RVA: 0x00028670 File Offset: 0x00026870
public static AnimationClipPlayable Create(PlayableGraph graph, AnimationClip clip)
{
PlayableHandle playableHandle = AnimationClipPlayable.CreateHandle(graph, clip);
return new AnimationClipPlayable(playableHandle);
}
// Token: 0x060022D7 RID: 8919 RVA: 0x00028694 File Offset: 0x00026894
private static PlayableHandle CreateHandle(PlayableGraph graph, AnimationClip clip)
{
PlayableHandle @null = PlayableHandle.Null;
PlayableHandle playableHandle;
if (!AnimationClipPlayable.CreateHandleInternal(graph, clip, ref @null))
{
playableHandle = PlayableHandle.Null;
}
else
{
playableHandle = @null;
}
return playableHandle;
}
// Token: 0x060022D8 RID: 8920 RVA: 0x000286CC File Offset: 0x000268CC
public PlayableHandle GetHandle()
{
return this.m_Handle;
}
// Token: 0x060022D9 RID: 8921 RVA: 0x000286E8 File Offset: 0x000268E8
public static implicit operator Playable(AnimationClipPlayable playable)
{
return new Playable(playable.GetHandle());
}
// Token: 0x060022DA RID: 8922 RVA: 0x0002870C File Offset: 0x0002690C
public static explicit operator AnimationClipPlayable(Playable playable)
{
return new AnimationClipPlayable(playable.GetHandle());
}
// Token: 0x060022DB RID: 8923 RVA: 0x00028730 File Offset: 0x00026930
public bool Equals(AnimationClipPlayable other)
{
return this.GetHandle() == other.GetHandle();
}
// Token: 0x060022DC RID: 8924 RVA: 0x00028758 File Offset: 0x00026958
private static bool CreateHandleInternal(PlayableGraph graph, AnimationClip clip, ref PlayableHandle handle)
{
return AnimationClipPlayable.INTERNAL_CALL_CreateHandleInternal(ref graph, clip, ref handle);
}
// Token: 0x060022DD RID: 8925
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern bool INTERNAL_CALL_CreateHandleInternal(ref PlayableGraph graph, AnimationClip clip, ref PlayableHandle handle);
// Token: 0x060022DE RID: 8926 RVA: 0x00028778 File Offset: 0x00026978
public AnimationClip GetAnimationClip()
{
return AnimationClipPlayable.GetAnimationClipInternal(ref this.m_Handle);
}
// Token: 0x060022DF RID: 8927 RVA: 0x00028798 File Offset: 0x00026998
public bool GetApplyFootIK()
{
return AnimationClipPlayable.GetApplyFootIKInternal(ref this.m_Handle);
}
// Token: 0x060022E0 RID: 8928 RVA: 0x000287B8 File Offset: 0x000269B8
public void SetApplyFootIK(bool value)
{
AnimationClipPlayable.SetApplyFootIKInternal(ref this.m_Handle, value);
}
// Token: 0x060022E1 RID: 8929 RVA: 0x000287C8 File Offset: 0x000269C8
internal bool GetRemoveStartOffset()
{
return AnimationClipPlayable.GetRemoveStartOffsetInternal(ref this.m_Handle);
}
// Token: 0x060022E2 RID: 8930 RVA: 0x000287E8 File Offset: 0x000269E8
internal void SetRemoveStartOffset(bool value)
{
AnimationClipPlayable.SetRemoveStartOffsetInternal(ref this.m_Handle, value);
}
// Token: 0x060022E3 RID: 8931 RVA: 0x000287F8 File Offset: 0x000269F8
private static AnimationClip GetAnimationClipInternal(ref PlayableHandle handle)
{
return AnimationClipPlayable.INTERNAL_CALL_GetAnimationClipInternal(ref handle);
}
// Token: 0x060022E4 RID: 8932
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern AnimationClip INTERNAL_CALL_GetAnimationClipInternal(ref PlayableHandle handle);
// Token: 0x060022E5 RID: 8933 RVA: 0x00028814 File Offset: 0x00026A14
private static bool GetApplyFootIKInternal(ref PlayableHandle handle)
{
return AnimationClipPlayable.INTERNAL_CALL_GetApplyFootIKInternal(ref handle);
}
// Token: 0x060022E6 RID: 8934
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern bool INTERNAL_CALL_GetApplyFootIKInternal(ref PlayableHandle handle);
// Token: 0x060022E7 RID: 8935 RVA: 0x00028830 File Offset: 0x00026A30
private static void SetApplyFootIKInternal(ref PlayableHandle handle, bool value)
{
AnimationClipPlayable.INTERNAL_CALL_SetApplyFootIKInternal(ref handle, value);
}
// Token: 0x060022E8 RID: 8936
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_SetApplyFootIKInternal(ref PlayableHandle handle, bool value);
// Token: 0x060022E9 RID: 8937 RVA: 0x0002883C File Offset: 0x00026A3C
private static bool GetRemoveStartOffsetInternal(ref PlayableHandle handle)
{
return AnimationClipPlayable.INTERNAL_CALL_GetRemoveStartOffsetInternal(ref handle);
}
// Token: 0x060022EA RID: 8938
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern bool INTERNAL_CALL_GetRemoveStartOffsetInternal(ref PlayableHandle handle);
// Token: 0x060022EB RID: 8939 RVA: 0x00028858 File Offset: 0x00026A58
private static void SetRemoveStartOffsetInternal(ref PlayableHandle handle, bool value)
{
AnimationClipPlayable.INTERNAL_CALL_SetRemoveStartOffsetInternal(ref handle, value);
}
// Token: 0x060022EC RID: 8940
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_SetRemoveStartOffsetInternal(ref PlayableHandle handle, bool value);
// Token: 0x04000540 RID: 1344
private PlayableHandle m_Handle;
}
}
UnityEngine/Animations/AnimationLayerMixerPlayable.cs
+167
View File
@@ -0,0 +1,167 @@
using System;
using System.Runtime.CompilerServices;
using UnityEngine.Playables;
using UnityEngine.Scripting;
namespace UnityEngine.Animations
{
// Token: 0x020001F3 RID: 499
[RequiredByNativeCode]
public struct AnimationLayerMixerPlayable : IPlayable, IEquatable<AnimationLayerMixerPlayable>
{
// Token: 0x060022ED RID: 8941 RVA: 0x00028864 File Offset: 0x00026A64
internal AnimationLayerMixerPlayable(PlayableHandle handle)
{
if (handle.IsValid())
{
if (!handle.IsPlayableOfType<AnimationLayerMixerPlayable>())
{
throw new InvalidCastException("Can't set handle: the playable is not an AnimationLayerMixerPlayable.");
}
}
this.m_Handle = handle;
}
// Token: 0x17000837 RID: 2103
// (get) Token: 0x060022EE RID: 8942 RVA: 0x00028894 File Offset: 0x00026A94
public static AnimationLayerMixerPlayable Null
{
get
{
return AnimationLayerMixerPlayable.m_NullPlayable;
}
}
// Token: 0x060022EF RID: 8943 RVA: 0x000288B0 File Offset: 0x00026AB0
public static AnimationLayerMixerPlayable Create(PlayableGraph graph, int inputCount = 0)
{
PlayableHandle playableHandle = AnimationLayerMixerPlayable.CreateHandle(graph, inputCount);
return new AnimationLayerMixerPlayable(playableHandle);
}
// Token: 0x060022F0 RID: 8944 RVA: 0x000288D4 File Offset: 0x00026AD4
private static PlayableHandle CreateHandle(PlayableGraph graph, int inputCount = 0)
{
PlayableHandle @null = PlayableHandle.Null;
PlayableHandle playableHandle;
if (!AnimationLayerMixerPlayable.CreateHandleInternal(graph, ref @null))
{
playableHandle = PlayableHandle.Null;
}
else
{
@null.SetInputCount(inputCount);
playableHandle = @null;
}
return playableHandle;
}
// Token: 0x060022F1 RID: 8945 RVA: 0x00028910 File Offset: 0x00026B10
public PlayableHandle GetHandle()
{
return this.m_Handle;
}
// Token: 0x060022F2 RID: 8946 RVA: 0x0002892C File Offset: 0x00026B2C
public static implicit operator Playable(AnimationLayerMixerPlayable playable)
{
return new Playable(playable.GetHandle());
}
// Token: 0x060022F3 RID: 8947 RVA: 0x00028950 File Offset: 0x00026B50
public static explicit operator AnimationLayerMixerPlayable(Playable playable)
{
return new AnimationLayerMixerPlayable(playable.GetHandle());
}
// Token: 0x060022F4 RID: 8948 RVA: 0x00028974 File Offset: 0x00026B74
public bool Equals(AnimationLayerMixerPlayable other)
{
return this.GetHandle() == other.GetHandle();
}
// Token: 0x060022F5 RID: 8949 RVA: 0x0002899C File Offset: 0x00026B9C
private static bool CreateHandleInternal(PlayableGraph graph, ref PlayableHandle handle)
{
return AnimationLayerMixerPlayable.INTERNAL_CALL_CreateHandleInternal(ref graph, ref handle);
}
// Token: 0x060022F6 RID: 8950
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern bool INTERNAL_CALL_CreateHandleInternal(ref PlayableGraph graph, ref PlayableHandle handle);
// Token: 0x060022F7 RID: 8951 RVA: 0x000289BC File Offset: 0x00026BBC
public bool IsLayerAdditive(uint layerIndex)
{
if ((ulong)layerIndex >= (ulong)((long)this.m_Handle.GetInputCount()))
{
throw new ArgumentOutOfRangeException("layerIndex", string.Format("layerIndex {0} must be in the range of 0 to {1}.", layerIndex, this.m_Handle.GetInputCount() - 1));
}
return AnimationLayerMixerPlayable.IsLayerAdditiveInternal(ref this.m_Handle, layerIndex);
}
// Token: 0x060022F8 RID: 8952 RVA: 0x00028A20 File Offset: 0x00026C20
public void SetLayerAdditive(uint layerIndex, bool value)
{
if ((ulong)layerIndex >= (ulong)((long)this.m_Handle.GetInputCount()))
{
throw new ArgumentOutOfRangeException("layerIndex", string.Format("layerIndex {0} must be in the range of 0 to {1}.", layerIndex, this.m_Handle.GetInputCount() - 1));
}
AnimationLayerMixerPlayable.SetLayerAdditiveInternal(ref this.m_Handle, layerIndex, value);
}
// Token: 0x060022F9 RID: 8953 RVA: 0x00028A7C File Offset: 0x00026C7C
public void SetLayerMaskFromAvatarMask(uint layerIndex, AvatarMask mask)
{
if ((ulong)layerIndex >= (ulong)((long)this.m_Handle.GetInputCount()))
{
throw new ArgumentOutOfRangeException("layerIndex", string.Format("layerIndex {0} must be in the range of 0 to {1}.", layerIndex, this.m_Handle.GetInputCount() - 1));
}
if (mask == null)
{
throw new ArgumentNullException("mask");
}
AnimationLayerMixerPlayable.SetLayerMaskFromAvatarMaskInternal(ref this.m_Handle, layerIndex, mask);
}
// Token: 0x060022FA RID: 8954 RVA: 0x00028AF0 File Offset: 0x00026CF0
private static bool IsLayerAdditiveInternal(ref PlayableHandle handle, uint layerIndex)
{
return AnimationLayerMixerPlayable.INTERNAL_CALL_IsLayerAdditiveInternal(ref handle, layerIndex);
}
// Token: 0x060022FB RID: 8955
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern bool INTERNAL_CALL_IsLayerAdditiveInternal(ref PlayableHandle handle, uint layerIndex);
// Token: 0x060022FC RID: 8956 RVA: 0x00028B0C File Offset: 0x00026D0C
private static void SetLayerAdditiveInternal(ref PlayableHandle handle, uint layerIndex, bool value)
{
AnimationLayerMixerPlayable.INTERNAL_CALL_SetLayerAdditiveInternal(ref handle, layerIndex, value);
}
// Token: 0x060022FD RID: 8957
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_SetLayerAdditiveInternal(ref PlayableHandle handle, uint layerIndex, bool value);
// Token: 0x060022FE RID: 8958 RVA: 0x00028B18 File Offset: 0x00026D18
private static void SetLayerMaskFromAvatarMaskInternal(ref PlayableHandle handle, uint layerIndex, AvatarMask mask)
{
AnimationLayerMixerPlayable.INTERNAL_CALL_SetLayerMaskFromAvatarMaskInternal(ref handle, layerIndex, mask);
}
// Token: 0x060022FF RID: 8959
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_SetLayerMaskFromAvatarMaskInternal(ref PlayableHandle handle, uint layerIndex, AvatarMask mask);
// Token: 0x04000541 RID: 1345
private PlayableHandle m_Handle;
// Token: 0x04000542 RID: 1346
private static readonly AnimationLayerMixerPlayable m_NullPlayable = new AnimationLayerMixerPlayable(PlayableHandle.Null);
}
}
UnityEngine/Animations/AnimationMixerPlayable.cs
+87
View File
@@ -0,0 +1,87 @@
using System;
using System.Runtime.CompilerServices;
using UnityEngine.Playables;
using UnityEngine.Scripting;
namespace UnityEngine.Animations
{
// Token: 0x020001F4 RID: 500
[RequiredByNativeCode]
public struct AnimationMixerPlayable : IPlayable, IEquatable<AnimationMixerPlayable>
{
// Token: 0x06002301 RID: 8961 RVA: 0x00028B38 File Offset: 0x00026D38
internal AnimationMixerPlayable(PlayableHandle handle)
{
if (handle.IsValid())
{
if (!handle.IsPlayableOfType<AnimationMixerPlayable>())
{
throw new InvalidCastException("Can't set handle: the playable is not an AnimationMixerPlayable.");
}
}
this.m_Handle = handle;
}
// Token: 0x06002302 RID: 8962 RVA: 0x00028B68 File Offset: 0x00026D68
public static AnimationMixerPlayable Create(PlayableGraph graph, int inputCount = 0, bool normalizeWeights = false)
{
PlayableHandle playableHandle = AnimationMixerPlayable.CreateHandle(graph, inputCount, normalizeWeights);
return new AnimationMixerPlayable(playableHandle);
}
// Token: 0x06002303 RID: 8963 RVA: 0x00028B8C File Offset: 0x00026D8C
private static PlayableHandle CreateHandle(PlayableGraph graph, int inputCount = 0, bool normalizeWeights = false)
{
PlayableHandle @null = PlayableHandle.Null;
PlayableHandle playableHandle;
if (!AnimationMixerPlayable.CreateHandleInternal(graph, inputCount, normalizeWeights, ref @null))
{
playableHandle = PlayableHandle.Null;
}
else
{
@null.SetInputCount(inputCount);
playableHandle = @null;
}
return playableHandle;
}
// Token: 0x06002304 RID: 8964 RVA: 0x00028BCC File Offset: 0x00026DCC
public PlayableHandle GetHandle()
{
return this.m_Handle;
}
// Token: 0x06002305 RID: 8965 RVA: 0x00028BE8 File Offset: 0x00026DE8
public static implicit operator Playable(AnimationMixerPlayable playable)
{
return new Playable(playable.GetHandle());
}
// Token: 0x06002306 RID: 8966 RVA: 0x00028C0C File Offset: 0x00026E0C
public static explicit operator AnimationMixerPlayable(Playable playable)
{
return new AnimationMixerPlayable(playable.GetHandle());
}
// Token: 0x06002307 RID: 8967 RVA: 0x00028C30 File Offset: 0x00026E30
public bool Equals(AnimationMixerPlayable other)
{
return this.GetHandle() == other.GetHandle();
}
// Token: 0x06002308 RID: 8968 RVA: 0x00028C58 File Offset: 0x00026E58
private static bool CreateHandleInternal(PlayableGraph graph, int inputCount, bool normalizeWeights, ref PlayableHandle handle)
{
return AnimationMixerPlayable.INTERNAL_CALL_CreateHandleInternal(ref graph, inputCount, normalizeWeights, ref handle);
}
// Token: 0x06002309 RID: 8969
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern bool INTERNAL_CALL_CreateHandleInternal(ref PlayableGraph graph, int inputCount, bool normalizeWeights, ref PlayableHandle handle);
// Token: 0x04000543 RID: 1347
private PlayableHandle m_Handle;
}
}
UnityEngine/Animations/AnimationOffsetPlayable.cs
+172
View File
@@ -0,0 +1,172 @@
using System;
using System.Runtime.CompilerServices;
using UnityEngine.Playables;
using UnityEngine.Scripting;
namespace UnityEngine.Animations
{
// Token: 0x020001F5 RID: 501
[RequiredByNativeCode]
internal struct AnimationOffsetPlayable : IPlayable, IEquatable<AnimationOffsetPlayable>
{
// Token: 0x0600230A RID: 8970 RVA: 0x00028C78 File Offset: 0x00026E78
internal AnimationOffsetPlayable(PlayableHandle handle)
{
if (handle.IsValid())
{
if (!handle.IsPlayableOfType<AnimationOffsetPlayable>())
{
throw new InvalidCastException("Can't set handle: the playable is not an AnimationOffsetPlayable.");
}
}
this.m_Handle = handle;
}
// Token: 0x17000838 RID: 2104
// (get) Token: 0x0600230B RID: 8971 RVA: 0x00028CA8 File Offset: 0x00026EA8
public static AnimationOffsetPlayable Null
{
get
{
return AnimationOffsetPlayable.m_NullPlayable;
}
}
// Token: 0x0600230C RID: 8972 RVA: 0x00028CC4 File Offset: 0x00026EC4
public static AnimationOffsetPlayable Create(PlayableGraph graph, Vector3 position, Quaternion rotation, int inputCount)
{
PlayableHandle playableHandle = AnimationOffsetPlayable.CreateHandle(graph, position, rotation, inputCount);
return new AnimationOffsetPlayable(playableHandle);
}
// Token: 0x0600230D RID: 8973 RVA: 0x00028CEC File Offset: 0x00026EEC
private static PlayableHandle CreateHandle(PlayableGraph graph, Vector3 position, Quaternion rotation, int inputCount)
{
PlayableHandle @null = PlayableHandle.Null;
PlayableHandle playableHandle;
if (!AnimationOffsetPlayable.CreateHandleInternal(graph, position, rotation, ref @null))
{
playableHandle = PlayableHandle.Null;
}
else
{
@null.SetInputCount(inputCount);
playableHandle = @null;
}
return playableHandle;
}
// Token: 0x0600230E RID: 8974 RVA: 0x00028D2C File Offset: 0x00026F2C
public PlayableHandle GetHandle()
{
return this.m_Handle;
}
// Token: 0x0600230F RID: 8975 RVA: 0x00028D48 File Offset: 0x00026F48
public static implicit operator Playable(AnimationOffsetPlayable playable)
{
return new Playable(playable.GetHandle());
}
// Token: 0x06002310 RID: 8976 RVA: 0x00028D6C File Offset: 0x00026F6C
public static explicit operator AnimationOffsetPlayable(Playable playable)
{
return new AnimationOffsetPlayable(playable.GetHandle());
}
// Token: 0x06002311 RID: 8977 RVA: 0x00028D90 File Offset: 0x00026F90
public bool Equals(AnimationOffsetPlayable other)
{
return this.Equals(other.GetHandle());
}
// Token: 0x06002312 RID: 8978 RVA: 0x00028DC0 File Offset: 0x00026FC0
private static bool CreateHandleInternal(PlayableGraph graph, Vector3 position, Quaternion rotation, ref PlayableHandle handle)
{
return AnimationOffsetPlayable.INTERNAL_CALL_CreateHandleInternal(ref graph, ref position, ref rotation, ref handle);
}
// Token: 0x06002313 RID: 8979
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern bool INTERNAL_CALL_CreateHandleInternal(ref PlayableGraph graph, ref Vector3 position, ref Quaternion rotation, ref PlayableHandle handle);
// Token: 0x06002314 RID: 8980 RVA: 0x00028DE4 File Offset: 0x00026FE4
public Vector3 GetPosition()
{
return AnimationOffsetPlayable.GetPositionInternal(ref this.m_Handle);
}
// Token: 0x06002315 RID: 8981 RVA: 0x00028E04 File Offset: 0x00027004
public void SetPosition(Vector3 value)
{
AnimationOffsetPlayable.SetPositionInternal(ref this.m_Handle, value);
}
// Token: 0x06002316 RID: 8982 RVA: 0x00028E14 File Offset: 0x00027014
public Quaternion GetRotation()
{
return AnimationOffsetPlayable.GetRotationInternal(ref this.m_Handle);
}
// Token: 0x06002317 RID: 8983 RVA: 0x00028E34 File Offset: 0x00027034
public void SetRotation(Quaternion value)
{
AnimationOffsetPlayable.SetRotationInternal(ref this.m_Handle, value);
}
// Token: 0x06002318 RID: 8984 RVA: 0x00028E44 File Offset: 0x00027044
private static Vector3 GetPositionInternal(ref PlayableHandle handle)
{
Vector3 vector;
AnimationOffsetPlayable.INTERNAL_CALL_GetPositionInternal(ref handle, out vector);
return vector;
}
// Token: 0x06002319 RID: 8985
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_GetPositionInternal(ref PlayableHandle handle, out Vector3 value);
// Token: 0x0600231A RID: 8986 RVA: 0x00028E64 File Offset: 0x00027064
private static void SetPositionInternal(ref PlayableHandle handle, Vector3 value)
{
AnimationOffsetPlayable.INTERNAL_CALL_SetPositionInternal(ref handle, ref value);
}
// Token: 0x0600231B RID: 8987
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_SetPositionInternal(ref PlayableHandle handle, ref Vector3 value);
// Token: 0x0600231C RID: 8988 RVA: 0x00028E70 File Offset: 0x00027070
private static Quaternion GetRotationInternal(ref PlayableHandle handle)
{
Quaternion quaternion;
AnimationOffsetPlayable.INTERNAL_CALL_GetRotationInternal(ref handle, out quaternion);
return quaternion;
}
// Token: 0x0600231D RID: 8989
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_GetRotationInternal(ref PlayableHandle handle, out Quaternion value);
// Token: 0x0600231E RID: 8990 RVA: 0x00028E90 File Offset: 0x00027090
private static void SetRotationInternal(ref PlayableHandle handle, Quaternion value)
{
AnimationOffsetPlayable.INTERNAL_CALL_SetRotationInternal(ref handle, ref value);
}
// Token: 0x0600231F RID: 8991
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_SetRotationInternal(ref PlayableHandle handle, ref Quaternion value);
// Token: 0x04000544 RID: 1348
private PlayableHandle m_Handle;
// Token: 0x04000545 RID: 1349
private static readonly AnimationOffsetPlayable m_NullPlayable = new AnimationOffsetPlayable(PlayableHandle.Null);
}
}
UnityEngine/Animations/AnimationPlayableExtensions.cs
+29
View File
@@ -0,0 +1,29 @@
using System;
using System.Runtime.CompilerServices;
using UnityEngine.Playables;
using UnityEngine.Scripting;
namespace UnityEngine.Animations
{
// Token: 0x020001F6 RID: 502
public static class AnimationPlayableExtensions
{
// Token: 0x06002321 RID: 8993 RVA: 0x00028EB0 File Offset: 0x000270B0
public static void SetAnimatedProperties<U>(this U playable, AnimationClip clip) where U : struct, IPlayable
{
PlayableHandle handle = playable.GetHandle();
AnimationPlayableExtensions.SetAnimatedPropertiesInternal(ref handle, clip);
}
// Token: 0x06002322 RID: 8994 RVA: 0x00028ED4 File Offset: 0x000270D4
internal static void SetAnimatedPropertiesInternal(ref PlayableHandle playable, AnimationClip animatedProperties)
{
AnimationPlayableExtensions.INTERNAL_CALL_SetAnimatedPropertiesInternal(ref playable, animatedProperties);
}
// Token: 0x06002323 RID: 8995
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_SetAnimatedPropertiesInternal(ref PlayableHandle playable, AnimationClip animatedProperties);
}
}
UnityEngine/Animations/AnimationPlayableGraphExtensions.cs
+106
View File
@@ -0,0 +1,106 @@
using System;
using System.Runtime.CompilerServices;
using UnityEngine.Playables;
using UnityEngine.Scripting;
namespace UnityEngine.Animations
{
// Token: 0x020001F9 RID: 505
public static class AnimationPlayableGraphExtensions
{
// Token: 0x060023D2 RID: 9170 RVA: 0x00029D60 File Offset: 0x00027F60
internal static bool InternalCreateAnimationOutput(ref PlayableGraph graph, string name, out PlayableOutputHandle handle)
{
return AnimationPlayableGraphExtensions.INTERNAL_CALL_InternalCreateAnimationOutput(ref graph, name, out handle);
}
// Token: 0x060023D3 RID: 9171
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern bool INTERNAL_CALL_InternalCreateAnimationOutput(ref PlayableGraph graph, string name, out PlayableOutputHandle handle);
// Token: 0x060023D4 RID: 9172 RVA: 0x00029D80 File Offset: 0x00027F80
internal static void SyncUpdateAndTimeMode(this PlayableGraph graph, Animator animator)
{
AnimationPlayableGraphExtensions.InternalSyncUpdateAndTimeMode(ref graph, animator);
}
// Token: 0x060023D5 RID: 9173 RVA: 0x00029D8C File Offset: 0x00027F8C
internal static void InternalSyncUpdateAndTimeMode(ref PlayableGraph graph, Animator animator)
{
AnimationPlayableGraphExtensions.INTERNAL_CALL_InternalSyncUpdateAndTimeMode(ref graph, animator);
}
// Token: 0x060023D6 RID: 9174
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_InternalSyncUpdateAndTimeMode(ref PlayableGraph graph, Animator animator);
// Token: 0x060023D7 RID: 9175 RVA: 0x00029D98 File Offset: 0x00027F98
internal static PlayableHandle CreateAnimationMotionXToDeltaPlayable(this PlayableGraph graph)
{
PlayableHandle @null = PlayableHandle.Null;
PlayableHandle playableHandle;
if (!AnimationPlayableGraphExtensions.InternalCreateAnimationMotionXToDeltaPlayable(ref graph, ref @null))
{
playableHandle = PlayableHandle.Null;
}
else
{
@null.SetInputCount(1);
playableHandle = @null;
}
return playableHandle;
}
// Token: 0x060023D8 RID: 9176 RVA: 0x00029DD8 File Offset: 0x00027FD8
private static bool InternalCreateAnimationMotionXToDeltaPlayable(ref PlayableGraph graph, ref PlayableHandle handle)
{
return AnimationPlayableGraphExtensions.INTERNAL_CALL_InternalCreateAnimationMotionXToDeltaPlayable(ref graph, ref handle);
}
// Token: 0x060023D9 RID: 9177
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern bool INTERNAL_CALL_InternalCreateAnimationMotionXToDeltaPlayable(ref PlayableGraph graph, ref PlayableHandle handle);
// Token: 0x060023DA RID: 9178 RVA: 0x00029DF4 File Offset: 0x00027FF4
private static void InternalDestroyOutput(ref PlayableGraph graph, ref PlayableOutputHandle handle)
{
AnimationPlayableGraphExtensions.INTERNAL_CALL_InternalDestroyOutput(ref graph, ref handle);
}
// Token: 0x060023DB RID: 9179
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_InternalDestroyOutput(ref PlayableGraph graph, ref PlayableOutputHandle handle);
// Token: 0x060023DC RID: 9180 RVA: 0x00029E00 File Offset: 0x00028000
internal static void DestroyOutput(this PlayableGraph graph, PlayableOutputHandle handle)
{
AnimationPlayableGraphExtensions.InternalDestroyOutput(ref graph, ref handle);
}
// Token: 0x060023DD RID: 9181 RVA: 0x00029E0C File Offset: 0x0002800C
private static int InternalAnimationOutputCount(ref PlayableGraph graph)
{
return AnimationPlayableGraphExtensions.INTERNAL_CALL_InternalAnimationOutputCount(ref graph);
}
// Token: 0x060023DE RID: 9182
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern int INTERNAL_CALL_InternalAnimationOutputCount(ref PlayableGraph graph);
// Token: 0x060023DF RID: 9183 RVA: 0x00029E28 File Offset: 0x00028028
private static bool InternalGetAnimationOutput(ref PlayableGraph graph, int index, out PlayableOutputHandle handle)
{
return AnimationPlayableGraphExtensions.INTERNAL_CALL_InternalGetAnimationOutput(ref graph, index, out handle);
}
// Token: 0x060023E0 RID: 9184
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern bool INTERNAL_CALL_InternalGetAnimationOutput(ref PlayableGraph graph, int index, out PlayableOutputHandle handle);
}
}
UnityEngine/Animations/AnimationPlayableOutput.cs
+108
View File
@@ -0,0 +1,108 @@
using System;
using System.Runtime.CompilerServices;
using UnityEngine.Playables;
using UnityEngine.Scripting;
namespace UnityEngine.Animations
{
// Token: 0x020001F7 RID: 503
[RequiredByNativeCode]
public struct AnimationPlayableOutput : IPlayableOutput
{
// Token: 0x06002324 RID: 8996 RVA: 0x00028EE0 File Offset: 0x000270E0
internal AnimationPlayableOutput(PlayableOutputHandle handle)
{
if (handle.IsValid())
{
if (!handle.IsPlayableOutputOfType<AnimationPlayableOutput>())
{
throw new InvalidCastException("Can't set handle: the playable is not an AnimationPlayableOutput.");
}
}
this.m_Handle = handle;
}
// Token: 0x06002325 RID: 8997 RVA: 0x00028F10 File Offset: 0x00027110
public static AnimationPlayableOutput Create(PlayableGraph graph, string name, Animator target)
{
PlayableOutputHandle playableOutputHandle;
AnimationPlayableOutput animationPlayableOutput;
if (!AnimationPlayableGraphExtensions.InternalCreateAnimationOutput(ref graph, name, out playableOutputHandle))
{
animationPlayableOutput = AnimationPlayableOutput.Null;
}
else
{
AnimationPlayableOutput animationPlayableOutput2 = new AnimationPlayableOutput(playableOutputHandle);
animationPlayableOutput2.SetTarget(target);
animationPlayableOutput = animationPlayableOutput2;
}
return animationPlayableOutput;
}
// Token: 0x17000839 RID: 2105
// (get) Token: 0x06002326 RID: 8998 RVA: 0x00028F50 File Offset: 0x00027150
public static AnimationPlayableOutput Null
{
get
{
return new AnimationPlayableOutput(PlayableOutputHandle.Null);
}
}
// Token: 0x06002327 RID: 8999 RVA: 0x00028F70 File Offset: 0x00027170
public PlayableOutputHandle GetHandle()
{
return this.m_Handle;
}
// Token: 0x06002328 RID: 9000 RVA: 0x00028F8C File Offset: 0x0002718C
public static implicit operator PlayableOutput(AnimationPlayableOutput output)
{
return new PlayableOutput(output.GetHandle());
}
// Token: 0x06002329 RID: 9001 RVA: 0x00028FB0 File Offset: 0x000271B0
public static explicit operator AnimationPlayableOutput(PlayableOutput output)
{
return new AnimationPlayableOutput(output.GetHandle());
}
// Token: 0x0600232A RID: 9002 RVA: 0x00028FD4 File Offset: 0x000271D4
public Animator GetTarget()
{
return AnimationPlayableOutput.InternalGetTarget(ref this.m_Handle);
}
// Token: 0x0600232B RID: 9003 RVA: 0x00028FF4 File Offset: 0x000271F4
public void SetTarget(Animator value)
{
AnimationPlayableOutput.InternalSetTarget(ref this.m_Handle, value);
}
// Token: 0x0600232C RID: 9004 RVA: 0x00029004 File Offset: 0x00027204
private static Animator InternalGetTarget(ref PlayableOutputHandle handle)
{
return AnimationPlayableOutput.INTERNAL_CALL_InternalGetTarget(ref handle);
}
// Token: 0x0600232D RID: 9005
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern Animator INTERNAL_CALL_InternalGetTarget(ref PlayableOutputHandle handle);
// Token: 0x0600232E RID: 9006 RVA: 0x00029020 File Offset: 0x00027220
private static void InternalSetTarget(ref PlayableOutputHandle handle, Animator target)
{
AnimationPlayableOutput.INTERNAL_CALL_InternalSetTarget(ref handle, target);
}
// Token: 0x0600232F RID: 9007
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_InternalSetTarget(ref PlayableOutputHandle handle, Animator target);
// Token: 0x04000546 RID: 1350
private PlayableOutputHandle m_Handle;
}
}
UnityEngine/Animations/AnimatorControllerPlayable.cs
+1045
View File
@@ -0,0 +1,1045 @@
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using UnityEngine.Internal;
using UnityEngine.Playables;
using UnityEngine.Scripting;
namespace UnityEngine.Animations
{
// Token: 0x020001F8 RID: 504
[RequiredByNativeCode]
public struct AnimatorControllerPlayable : IPlayable, IEquatable<AnimatorControllerPlayable>
{
// Token: 0x06002330 RID: 9008 RVA: 0x0002902C File Offset: 0x0002722C
internal AnimatorControllerPlayable(PlayableHandle handle)
{
this.m_Handle = PlayableHandle.Null;
this.SetHandle(handle);
}
// Token: 0x1700083A RID: 2106
// (get) Token: 0x06002331 RID: 9009 RVA: 0x00029044 File Offset: 0x00027244
public static AnimatorControllerPlayable Null
{
get
{
return AnimatorControllerPlayable.m_NullPlayable;
}
}
// Token: 0x06002332 RID: 9010 RVA: 0x00029060 File Offset: 0x00027260
public static AnimatorControllerPlayable Create(PlayableGraph graph, RuntimeAnimatorController controller)
{
PlayableHandle playableHandle = AnimatorControllerPlayable.CreateHandle(graph, controller);
return new AnimatorControllerPlayable(playableHandle);
}
// Token: 0x06002333 RID: 9011 RVA: 0x00029084 File Offset: 0x00027284
private static PlayableHandle CreateHandle(PlayableGraph graph, RuntimeAnimatorController controller)
{
PlayableHandle @null = PlayableHandle.Null;
PlayableHandle playableHandle;
if (!AnimatorControllerPlayable.CreateHandleInternal(graph, controller, ref @null))
{
playableHandle = PlayableHandle.Null;
}
else
{
playableHandle = @null;
}
return playableHandle;
}
// Token: 0x06002334 RID: 9012 RVA: 0x000290BC File Offset: 0x000272BC
public PlayableHandle GetHandle()
{
return this.m_Handle;
}
// Token: 0x06002335 RID: 9013 RVA: 0x000290D8 File Offset: 0x000272D8
public void SetHandle(PlayableHandle handle)
{
if (this.m_Handle.IsValid())
{
throw new InvalidOperationException("Cannot call IPlayable.SetHandle on an instance that already contains a valid handle.");
}
if (handle.IsValid())
{
if (!handle.IsPlayableOfType<AnimatorControllerPlayable>())
{
throw new InvalidCastException("Can't set handle: the playable is not an AnimatorControllerPlayable.");
}
}
this.m_Handle = handle;
}
// Token: 0x06002336 RID: 9014 RVA: 0x00029130 File Offset: 0x00027330
public static implicit operator Playable(AnimatorControllerPlayable playable)
{
return new Playable(playable.GetHandle());
}
// Token: 0x06002337 RID: 9015 RVA: 0x00029154 File Offset: 0x00027354
public static explicit operator AnimatorControllerPlayable(Playable playable)
{
return new AnimatorControllerPlayable(playable.GetHandle());
}
// Token: 0x06002338 RID: 9016 RVA: 0x00029178 File Offset: 0x00027378
public bool Equals(AnimatorControllerPlayable other)
{
return this.GetHandle() == other.GetHandle();
}
// Token: 0x06002339 RID: 9017 RVA: 0x000291A0 File Offset: 0x000273A0
private static bool CreateHandleInternal(PlayableGraph graph, RuntimeAnimatorController controller, ref PlayableHandle handle)
{
return AnimatorControllerPlayable.INTERNAL_CALL_CreateHandleInternal(ref graph, controller, ref handle);
}
// Token: 0x0600233A RID: 9018
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern bool INTERNAL_CALL_CreateHandleInternal(ref PlayableGraph graph, RuntimeAnimatorController controller, ref PlayableHandle handle);
// Token: 0x0600233B RID: 9019 RVA: 0x000291C0 File Offset: 0x000273C0
private static RuntimeAnimatorController GetAnimatorControllerInternal(ref PlayableHandle handle)
{
return AnimatorControllerPlayable.INTERNAL_CALL_GetAnimatorControllerInternal(ref handle);
}
// Token: 0x0600233C RID: 9020
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern RuntimeAnimatorController INTERNAL_CALL_GetAnimatorControllerInternal(ref PlayableHandle handle);
// Token: 0x0600233D RID: 9021 RVA: 0x000291DC File Offset: 0x000273DC
public float GetFloat(string name)
{
return AnimatorControllerPlayable.GetFloatString(ref this.m_Handle, name);
}
// Token: 0x0600233E RID: 9022 RVA: 0x00029200 File Offset: 0x00027400
public float GetFloat(int id)
{
return AnimatorControllerPlayable.GetFloatID(ref this.m_Handle, id);
}
// Token: 0x0600233F RID: 9023 RVA: 0x00029224 File Offset: 0x00027424
public void SetFloat(string name, float value)
{
AnimatorControllerPlayable.SetFloatString(ref this.m_Handle, name, value);
}
// Token: 0x06002340 RID: 9024 RVA: 0x00029234 File Offset: 0x00027434
public void SetFloat(int id, float value)
{
AnimatorControllerPlayable.SetFloatID(ref this.m_Handle, id, value);
}
// Token: 0x06002341 RID: 9025 RVA: 0x00029244 File Offset: 0x00027444
public bool GetBool(string name)
{
return AnimatorControllerPlayable.GetBoolString(ref this.m_Handle, name);
}
// Token: 0x06002342 RID: 9026 RVA: 0x00029268 File Offset: 0x00027468
public bool GetBool(int id)
{
return AnimatorControllerPlayable.GetBoolID(ref this.m_Handle, id);
}
// Token: 0x06002343 RID: 9027 RVA: 0x0002928C File Offset: 0x0002748C
public void SetBool(string name, bool value)
{
AnimatorControllerPlayable.SetBoolString(ref this.m_Handle, name, value);
}
// Token: 0x06002344 RID: 9028 RVA: 0x0002929C File Offset: 0x0002749C
public void SetBool(int id, bool value)
{
AnimatorControllerPlayable.SetBoolID(ref this.m_Handle, id, value);
}
// Token: 0x06002345 RID: 9029 RVA: 0x000292AC File Offset: 0x000274AC
public int GetInteger(string name)
{
return AnimatorControllerPlayable.GetIntegerString(ref this.m_Handle, name);
}
// Token: 0x06002346 RID: 9030 RVA: 0x000292D0 File Offset: 0x000274D0
public int GetInteger(int id)
{
return AnimatorControllerPlayable.GetIntegerID(ref this.m_Handle, id);
}
// Token: 0x06002347 RID: 9031 RVA: 0x000292F4 File Offset: 0x000274F4
public void SetInteger(string name, int value)
{
AnimatorControllerPlayable.SetIntegerString(ref this.m_Handle, name, value);
}
// Token: 0x06002348 RID: 9032 RVA: 0x00029304 File Offset: 0x00027504
public void SetInteger(int id, int value)
{
AnimatorControllerPlayable.SetIntegerID(ref this.m_Handle, id, value);
}
// Token: 0x06002349 RID: 9033 RVA: 0x00029314 File Offset: 0x00027514
public void SetTrigger(string name)
{
AnimatorControllerPlayable.SetTriggerString(ref this.m_Handle, name);
}
// Token: 0x0600234A RID: 9034 RVA: 0x00029324 File Offset: 0x00027524
public void SetTrigger(int id)
{
AnimatorControllerPlayable.SetTriggerID(ref this.m_Handle, id);
}
// Token: 0x0600234B RID: 9035 RVA: 0x00029334 File Offset: 0x00027534
public void ResetTrigger(string name)
{
AnimatorControllerPlayable.ResetTriggerString(ref this.m_Handle, name);
}
// Token: 0x0600234C RID: 9036 RVA: 0x00029344 File Offset: 0x00027544
public void ResetTrigger(int id)
{
AnimatorControllerPlayable.ResetTriggerID(ref this.m_Handle, id);
}
// Token: 0x0600234D RID: 9037 RVA: 0x00029354 File Offset: 0x00027554
public bool IsParameterControlledByCurve(string name)
{
return AnimatorControllerPlayable.IsParameterControlledByCurveString(ref this.m_Handle, name);
}
// Token: 0x0600234E RID: 9038 RVA: 0x00029378 File Offset: 0x00027578
public bool IsParameterControlledByCurve(int id)
{
return AnimatorControllerPlayable.IsParameterControlledByCurveID(ref this.m_Handle, id);
}
// Token: 0x0600234F RID: 9039 RVA: 0x0002939C File Offset: 0x0002759C
public int GetLayerCount()
{
return AnimatorControllerPlayable.GetLayerCountInternal(ref this.m_Handle);
}
// Token: 0x06002350 RID: 9040 RVA: 0x000293BC File Offset: 0x000275BC
private static int GetLayerCountInternal(ref PlayableHandle handle)
{
return AnimatorControllerPlayable.INTERNAL_CALL_GetLayerCountInternal(ref handle);
}
// Token: 0x06002351 RID: 9041
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern int INTERNAL_CALL_GetLayerCountInternal(ref PlayableHandle handle);
// Token: 0x06002352 RID: 9042 RVA: 0x000293D8 File Offset: 0x000275D8
private static string GetLayerNameInternal(ref PlayableHandle handle, int layerIndex)
{
return AnimatorControllerPlayable.INTERNAL_CALL_GetLayerNameInternal(ref handle, layerIndex);
}
// Token: 0x06002353 RID: 9043
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern string INTERNAL_CALL_GetLayerNameInternal(ref PlayableHandle handle, int layerIndex);
// Token: 0x06002354 RID: 9044 RVA: 0x000293F4 File Offset: 0x000275F4
public string GetLayerName(int layerIndex)
{
return AnimatorControllerPlayable.GetLayerNameInternal(ref this.m_Handle, layerIndex);
}
// Token: 0x06002355 RID: 9045 RVA: 0x00029418 File Offset: 0x00027618
private static int GetLayerIndexInternal(ref PlayableHandle handle, string layerName)
{
return AnimatorControllerPlayable.INTERNAL_CALL_GetLayerIndexInternal(ref handle, layerName);
}
// Token: 0x06002356 RID: 9046
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern int INTERNAL_CALL_GetLayerIndexInternal(ref PlayableHandle handle, string layerName);
// Token: 0x06002357 RID: 9047 RVA: 0x00029434 File Offset: 0x00027634
public int GetLayerIndex(string layerName)
{
return AnimatorControllerPlayable.GetLayerIndexInternal(ref this.m_Handle, layerName);
}
// Token: 0x06002358 RID: 9048 RVA: 0x00029458 File Offset: 0x00027658
private static float GetLayerWeightInternal(ref PlayableHandle handle, int layerIndex)
{
return AnimatorControllerPlayable.INTERNAL_CALL_GetLayerWeightInternal(ref handle, layerIndex);
}
// Token: 0x06002359 RID: 9049
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern float INTERNAL_CALL_GetLayerWeightInternal(ref PlayableHandle handle, int layerIndex);
// Token: 0x0600235A RID: 9050 RVA: 0x00029474 File Offset: 0x00027674
public float GetLayerWeight(int layerIndex)
{
return AnimatorControllerPlayable.GetLayerWeightInternal(ref this.m_Handle, layerIndex);
}
// Token: 0x0600235B RID: 9051 RVA: 0x00029498 File Offset: 0x00027698
private static void SetLayerWeightInternal(ref PlayableHandle handle, int layerIndex, float weight)
{
AnimatorControllerPlayable.INTERNAL_CALL_SetLayerWeightInternal(ref handle, layerIndex, weight);
}
// Token: 0x0600235C RID: 9052
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_SetLayerWeightInternal(ref PlayableHandle handle, int layerIndex, float weight);
// Token: 0x0600235D RID: 9053 RVA: 0x000294A4 File Offset: 0x000276A4
public void SetLayerWeight(int layerIndex, float weight)
{
AnimatorControllerPlayable.SetLayerWeightInternal(ref this.m_Handle, layerIndex, weight);
}
// Token: 0x0600235E RID: 9054 RVA: 0x000294B4 File Offset: 0x000276B4
private static AnimatorStateInfo GetCurrentAnimatorStateInfoInternal(ref PlayableHandle handle, int layerIndex)
{
return AnimatorControllerPlayable.INTERNAL_CALL_GetCurrentAnimatorStateInfoInternal(ref handle, layerIndex);
}
// Token: 0x0600235F RID: 9055
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern AnimatorStateInfo INTERNAL_CALL_GetCurrentAnimatorStateInfoInternal(ref PlayableHandle handle, int layerIndex);
// Token: 0x06002360 RID: 9056 RVA: 0x000294D0 File Offset: 0x000276D0
public AnimatorStateInfo GetCurrentAnimatorStateInfo(int layerIndex)
{
return AnimatorControllerPlayable.GetCurrentAnimatorStateInfoInternal(ref this.m_Handle, layerIndex);
}
// Token: 0x06002361 RID: 9057 RVA: 0x000294F4 File Offset: 0x000276F4
private static AnimatorStateInfo GetNextAnimatorStateInfoInternal(ref PlayableHandle handle, int layerIndex)
{
return AnimatorControllerPlayable.INTERNAL_CALL_GetNextAnimatorStateInfoInternal(ref handle, layerIndex);
}
// Token: 0x06002362 RID: 9058
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern AnimatorStateInfo INTERNAL_CALL_GetNextAnimatorStateInfoInternal(ref PlayableHandle handle, int layerIndex);
// Token: 0x06002363 RID: 9059 RVA: 0x00029510 File Offset: 0x00027710
public AnimatorStateInfo GetNextAnimatorStateInfo(int layerIndex)
{
return AnimatorControllerPlayable.GetNextAnimatorStateInfoInternal(ref this.m_Handle, layerIndex);
}
// Token: 0x06002364 RID: 9060 RVA: 0x00029534 File Offset: 0x00027734
private static AnimatorTransitionInfo GetAnimatorTransitionInfoInternal(ref PlayableHandle handle, int layerIndex)
{
return AnimatorControllerPlayable.INTERNAL_CALL_GetAnimatorTransitionInfoInternal(ref handle, layerIndex);
}
// Token: 0x06002365 RID: 9061
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern AnimatorTransitionInfo INTERNAL_CALL_GetAnimatorTransitionInfoInternal(ref PlayableHandle handle, int layerIndex);
// Token: 0x06002366 RID: 9062 RVA: 0x00029550 File Offset: 0x00027750
public AnimatorTransitionInfo GetAnimatorTransitionInfo(int layerIndex)
{
return AnimatorControllerPlayable.GetAnimatorTransitionInfoInternal(ref this.m_Handle, layerIndex);
}
// Token: 0x06002367 RID: 9063 RVA: 0x00029574 File Offset: 0x00027774
private static AnimatorClipInfo[] GetCurrentAnimatorClipInfoInternal(ref PlayableHandle handle, int layerIndex)
{
return AnimatorControllerPlayable.INTERNAL_CALL_GetCurrentAnimatorClipInfoInternal(ref handle, layerIndex);
}
// Token: 0x06002368 RID: 9064
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern AnimatorClipInfo[] INTERNAL_CALL_GetCurrentAnimatorClipInfoInternal(ref PlayableHandle handle, int layerIndex);
// Token: 0x06002369 RID: 9065 RVA: 0x00029590 File Offset: 0x00027790
public AnimatorClipInfo[] GetCurrentAnimatorClipInfo(int layerIndex)
{
return AnimatorControllerPlayable.GetCurrentAnimatorClipInfoInternal(ref this.m_Handle, layerIndex);
}
// Token: 0x0600236A RID: 9066 RVA: 0x000295B4 File Offset: 0x000277B4
public void GetCurrentAnimatorClipInfo(int layerIndex, List<AnimatorClipInfo> clips)
{
if (clips == null)
{
throw new ArgumentNullException("clips");
}
AnimatorControllerPlayable.GetAnimatorClipInfoInternal(ref this.m_Handle, layerIndex, true, clips);
}
// Token: 0x0600236B RID: 9067 RVA: 0x000295D8 File Offset: 0x000277D8
public void GetNextAnimatorClipInfo(int layerIndex, List<AnimatorClipInfo> clips)
{
if (clips == null)
{
throw new ArgumentNullException("clips");
}
AnimatorControllerPlayable.GetAnimatorClipInfoInternal(ref this.m_Handle, layerIndex, false, clips);
}
// Token: 0x0600236C RID: 9068 RVA: 0x000295FC File Offset: 0x000277FC
private static void GetAnimatorClipInfoInternal(ref PlayableHandle handle, int layerIndex, bool isCurrent, object clips)
{
AnimatorControllerPlayable.INTERNAL_CALL_GetAnimatorClipInfoInternal(ref handle, layerIndex, isCurrent, clips);
}
// Token: 0x0600236D RID: 9069
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_GetAnimatorClipInfoInternal(ref PlayableHandle handle, int layerIndex, bool isCurrent, object clips);
// Token: 0x0600236E RID: 9070 RVA: 0x00029608 File Offset: 0x00027808
private static int GetAnimatorClipInfoCountInternal(ref PlayableHandle handle, int layerIndex, bool current)
{
return AnimatorControllerPlayable.INTERNAL_CALL_GetAnimatorClipInfoCountInternal(ref handle, layerIndex, current);
}
// Token: 0x0600236F RID: 9071
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern int INTERNAL_CALL_GetAnimatorClipInfoCountInternal(ref PlayableHandle handle, int layerIndex, bool current);
// Token: 0x06002370 RID: 9072 RVA: 0x00029628 File Offset: 0x00027828
public int GetCurrentAnimatorClipInfoCount(int layerIndex)
{
return AnimatorControllerPlayable.GetAnimatorClipInfoCountInternal(ref this.m_Handle, layerIndex, true);
}
// Token: 0x06002371 RID: 9073 RVA: 0x0002964C File Offset: 0x0002784C
public int GetNextAnimatorClipInfoCount(int layerIndex)
{
return AnimatorControllerPlayable.GetAnimatorClipInfoCountInternal(ref this.m_Handle, layerIndex, false);
}
// Token: 0x06002372 RID: 9074 RVA: 0x00029670 File Offset: 0x00027870
private static AnimatorClipInfo[] GetNextAnimatorClipInfoInternal(ref PlayableHandle handle, int layerIndex)
{
return AnimatorControllerPlayable.INTERNAL_CALL_GetNextAnimatorClipInfoInternal(ref handle, layerIndex);
}
// Token: 0x06002373 RID: 9075
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern AnimatorClipInfo[] INTERNAL_CALL_GetNextAnimatorClipInfoInternal(ref PlayableHandle handle, int layerIndex);
// Token: 0x06002374 RID: 9076 RVA: 0x0002968C File Offset: 0x0002788C
public AnimatorClipInfo[] GetNextAnimatorClipInfo(int layerIndex)
{
return AnimatorControllerPlayable.GetNextAnimatorClipInfoInternal(ref this.m_Handle, layerIndex);
}
// Token: 0x06002375 RID: 9077 RVA: 0x000296B0 File Offset: 0x000278B0
internal string ResolveHash(int hash)
{
return AnimatorControllerPlayable.ResolveHashInternal(ref this.m_Handle, hash);
}
// Token: 0x06002376 RID: 9078 RVA: 0x000296D4 File Offset: 0x000278D4
private static string ResolveHashInternal(ref PlayableHandle handle, int hash)
{
return AnimatorControllerPlayable.INTERNAL_CALL_ResolveHashInternal(ref handle, hash);
}
// Token: 0x06002377 RID: 9079
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern string INTERNAL_CALL_ResolveHashInternal(ref PlayableHandle handle, int hash);
// Token: 0x06002378 RID: 9080 RVA: 0x000296F0 File Offset: 0x000278F0
private static bool IsInTransitionInternal(ref PlayableHandle handle, int layerIndex)
{
return AnimatorControllerPlayable.INTERNAL_CALL_IsInTransitionInternal(ref handle, layerIndex);
}
// Token: 0x06002379 RID: 9081
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern bool INTERNAL_CALL_IsInTransitionInternal(ref PlayableHandle handle, int layerIndex);
// Token: 0x0600237A RID: 9082 RVA: 0x0002970C File Offset: 0x0002790C
public bool IsInTransition(int layerIndex)
{
return AnimatorControllerPlayable.IsInTransitionInternal(ref this.m_Handle, layerIndex);
}
// Token: 0x0600237B RID: 9083 RVA: 0x00029730 File Offset: 0x00027930
private static int GetParameterCountInternal(ref PlayableHandle handle)
{
return AnimatorControllerPlayable.INTERNAL_CALL_GetParameterCountInternal(ref handle);
}
// Token: 0x0600237C RID: 9084
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern int INTERNAL_CALL_GetParameterCountInternal(ref PlayableHandle handle);
// Token: 0x0600237D RID: 9085 RVA: 0x0002974C File Offset: 0x0002794C
public int GetParameterCount()
{
return AnimatorControllerPlayable.GetParameterCountInternal(ref this.m_Handle);
}
// Token: 0x0600237E RID: 9086 RVA: 0x0002976C File Offset: 0x0002796C
private static AnimatorControllerParameter[] GetParametersArrayInternal(ref PlayableHandle handle)
{
return AnimatorControllerPlayable.INTERNAL_CALL_GetParametersArrayInternal(ref handle);
}
// Token: 0x0600237F RID: 9087
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern AnimatorControllerParameter[] INTERNAL_CALL_GetParametersArrayInternal(ref PlayableHandle handle);
// Token: 0x06002380 RID: 9088 RVA: 0x00029788 File Offset: 0x00027988
public AnimatorControllerParameter GetParameter(int index)
{
AnimatorControllerParameter[] parametersArrayInternal = AnimatorControllerPlayable.GetParametersArrayInternal(ref this.m_Handle);
if (index < 0 && index >= parametersArrayInternal.Length)
{
throw new IndexOutOfRangeException("index");
}
return parametersArrayInternal[index];
}
// Token: 0x06002381 RID: 9089
[ThreadAndSerializationSafe]
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern int StringToHash(string name);
// Token: 0x06002382 RID: 9090 RVA: 0x000297C8 File Offset: 0x000279C8
[ExcludeFromDocs]
public void CrossFadeInFixedTime(string stateName, float transitionDuration, int layer)
{
float num = 0f;
this.CrossFadeInFixedTime(stateName, transitionDuration, layer, num);
}
// Token: 0x06002383 RID: 9091 RVA: 0x000297E8 File Offset: 0x000279E8
[ExcludeFromDocs]
public void CrossFadeInFixedTime(string stateName, float transitionDuration)
{
float num = 0f;
int num2 = -1;
this.CrossFadeInFixedTime(stateName, transitionDuration, num2, num);
}
// Token: 0x06002384 RID: 9092 RVA: 0x00029808 File Offset: 0x00027A08
public void CrossFadeInFixedTime(string stateName, float transitionDuration, [DefaultValue("-1")] int layer, [DefaultValue("0.0f")] float fixedTime)
{
AnimatorControllerPlayable.CrossFadeInFixedTimeInternal(ref this.m_Handle, AnimatorControllerPlayable.StringToHash(stateName), transitionDuration, layer, fixedTime);
}
// Token: 0x06002385 RID: 9093 RVA: 0x00029820 File Offset: 0x00027A20
[ExcludeFromDocs]
public void CrossFadeInFixedTime(int stateNameHash, float transitionDuration, int layer)
{
float num = 0f;
this.CrossFadeInFixedTime(stateNameHash, transitionDuration, layer, num);
}
// Token: 0x06002386 RID: 9094 RVA: 0x00029840 File Offset: 0x00027A40
[ExcludeFromDocs]
public void CrossFadeInFixedTime(int stateNameHash, float transitionDuration)
{
float num = 0f;
int num2 = -1;
this.CrossFadeInFixedTime(stateNameHash, transitionDuration, num2, num);
}
// Token: 0x06002387 RID: 9095 RVA: 0x00029860 File Offset: 0x00027A60
public void CrossFadeInFixedTime(int stateNameHash, float transitionDuration, [DefaultValue("-1")] int layer, [DefaultValue("0.0f")] float fixedTime)
{
AnimatorControllerPlayable.CrossFadeInFixedTimeInternal(ref this.m_Handle, stateNameHash, transitionDuration, layer, fixedTime);
}
// Token: 0x06002388 RID: 9096 RVA: 0x00029874 File Offset: 0x00027A74
private static void CrossFadeInFixedTimeInternal(ref PlayableHandle handle, int stateNameHash, float transitionDuration, [DefaultValue("-1")] int layer, [DefaultValue("0.0f")] float fixedTime)
{
AnimatorControllerPlayable.INTERNAL_CALL_CrossFadeInFixedTimeInternal(ref handle, stateNameHash, transitionDuration, layer, fixedTime);
}
// Token: 0x06002389 RID: 9097 RVA: 0x00029884 File Offset: 0x00027A84
[ExcludeFromDocs]
private static void CrossFadeInFixedTimeInternal(ref PlayableHandle handle, int stateNameHash, float transitionDuration, int layer)
{
float num = 0f;
AnimatorControllerPlayable.INTERNAL_CALL_CrossFadeInFixedTimeInternal(ref handle, stateNameHash, transitionDuration, layer, num);
}
// Token: 0x0600238A RID: 9098 RVA: 0x000298A4 File Offset: 0x00027AA4
[ExcludeFromDocs]
private static void CrossFadeInFixedTimeInternal(ref PlayableHandle handle, int stateNameHash, float transitionDuration)
{
float num = 0f;
int num2 = -1;
AnimatorControllerPlayable.INTERNAL_CALL_CrossFadeInFixedTimeInternal(ref handle, stateNameHash, transitionDuration, num2, num);
}
// Token: 0x0600238B RID: 9099
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_CrossFadeInFixedTimeInternal(ref PlayableHandle handle, int stateNameHash, float transitionDuration, int layer, float fixedTime);
// Token: 0x0600238C RID: 9100 RVA: 0x000298C4 File Offset: 0x00027AC4
[ExcludeFromDocs]
public void CrossFade(string stateName, float transitionDuration, int layer)
{
float negativeInfinity = float.NegativeInfinity;
this.CrossFade(stateName, transitionDuration, layer, negativeInfinity);
}
// Token: 0x0600238D RID: 9101 RVA: 0x000298E4 File Offset: 0x00027AE4
[ExcludeFromDocs]
public void CrossFade(string stateName, float transitionDuration)
{
float negativeInfinity = float.NegativeInfinity;
int num = -1;
this.CrossFade(stateName, transitionDuration, num, negativeInfinity);
}
// Token: 0x0600238E RID: 9102 RVA: 0x00029904 File Offset: 0x00027B04
public void CrossFade(string stateName, float transitionDuration, [DefaultValue("-1")] int layer, [DefaultValue("float.NegativeInfinity")] float normalizedTime)
{
AnimatorControllerPlayable.CrossFadeInternal(ref this.m_Handle, AnimatorControllerPlayable.StringToHash(stateName), transitionDuration, layer, normalizedTime);
}
// Token: 0x0600238F RID: 9103 RVA: 0x0002991C File Offset: 0x00027B1C
[ExcludeFromDocs]
public void CrossFade(int stateNameHash, float transitionDuration, int layer)
{
float negativeInfinity = float.NegativeInfinity;
this.CrossFade(stateNameHash, transitionDuration, layer, negativeInfinity);
}
// Token: 0x06002390 RID: 9104 RVA: 0x0002993C File Offset: 0x00027B3C
[ExcludeFromDocs]
public void CrossFade(int stateNameHash, float transitionDuration)
{
float negativeInfinity = float.NegativeInfinity;
int num = -1;
this.CrossFade(stateNameHash, transitionDuration, num, negativeInfinity);
}
// Token: 0x06002391 RID: 9105 RVA: 0x0002995C File Offset: 0x00027B5C
public void CrossFade(int stateNameHash, float transitionDuration, [DefaultValue("-1")] int layer, [DefaultValue("float.NegativeInfinity")] float normalizedTime)
{
AnimatorControllerPlayable.CrossFadeInternal(ref this.m_Handle, stateNameHash, transitionDuration, layer, normalizedTime);
}
// Token: 0x06002392 RID: 9106 RVA: 0x00029970 File Offset: 0x00027B70
private static void CrossFadeInternal(ref PlayableHandle handle, int stateNameHash, float transitionDuration, [DefaultValue("-1")] int layer, [DefaultValue("float.NegativeInfinity")] float normalizedTime)
{
AnimatorControllerPlayable.INTERNAL_CALL_CrossFadeInternal(ref handle, stateNameHash, transitionDuration, layer, normalizedTime);
}
// Token: 0x06002393 RID: 9107 RVA: 0x00029980 File Offset: 0x00027B80
[ExcludeFromDocs]
private static void CrossFadeInternal(ref PlayableHandle handle, int stateNameHash, float transitionDuration, int layer)
{
float negativeInfinity = float.NegativeInfinity;
AnimatorControllerPlayable.INTERNAL_CALL_CrossFadeInternal(ref handle, stateNameHash, transitionDuration, layer, negativeInfinity);
}
// Token: 0x06002394 RID: 9108 RVA: 0x000299A0 File Offset: 0x00027BA0
[ExcludeFromDocs]
private static void CrossFadeInternal(ref PlayableHandle handle, int stateNameHash, float transitionDuration)
{
float negativeInfinity = float.NegativeInfinity;
int num = -1;
AnimatorControllerPlayable.INTERNAL_CALL_CrossFadeInternal(ref handle, stateNameHash, transitionDuration, num, negativeInfinity);
}
// Token: 0x06002395 RID: 9109
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_CrossFadeInternal(ref PlayableHandle handle, int stateNameHash, float transitionDuration, int layer, float normalizedTime);
// Token: 0x06002396 RID: 9110 RVA: 0x000299C0 File Offset: 0x00027BC0
[ExcludeFromDocs]
public void PlayInFixedTime(string stateName, int layer)
{
float negativeInfinity = float.NegativeInfinity;
this.PlayInFixedTime(stateName, layer, negativeInfinity);
}
// Token: 0x06002397 RID: 9111 RVA: 0x000299E0 File Offset: 0x00027BE0
[ExcludeFromDocs]
public void PlayInFixedTime(string stateName)
{
float negativeInfinity = float.NegativeInfinity;
int num = -1;
this.PlayInFixedTime(stateName, num, negativeInfinity);
}
// Token: 0x06002398 RID: 9112 RVA: 0x00029A00 File Offset: 0x00027C00
public void PlayInFixedTime(string stateName, [DefaultValue("-1")] int layer, [DefaultValue("float.NegativeInfinity")] float fixedTime)
{
AnimatorControllerPlayable.PlayInFixedTimeInternal(ref this.m_Handle, AnimatorControllerPlayable.StringToHash(stateName), layer, fixedTime);
}
// Token: 0x06002399 RID: 9113 RVA: 0x00029A18 File Offset: 0x00027C18
[ExcludeFromDocs]
public void PlayInFixedTime(int stateNameHash, int layer)
{
float negativeInfinity = float.NegativeInfinity;
this.PlayInFixedTime(stateNameHash, layer, negativeInfinity);
}
// Token: 0x0600239A RID: 9114 RVA: 0x00029A38 File Offset: 0x00027C38
[ExcludeFromDocs]
public void PlayInFixedTime(int stateNameHash)
{
float negativeInfinity = float.NegativeInfinity;
int num = -1;
this.PlayInFixedTime(stateNameHash, num, negativeInfinity);
}
// Token: 0x0600239B RID: 9115 RVA: 0x00029A58 File Offset: 0x00027C58
public void PlayInFixedTime(int stateNameHash, [DefaultValue("-1")] int layer, [DefaultValue("float.NegativeInfinity")] float fixedTime)
{
AnimatorControllerPlayable.PlayInFixedTimeInternal(ref this.m_Handle, stateNameHash, layer, fixedTime);
}
// Token: 0x0600239C RID: 9116 RVA: 0x00029A6C File Offset: 0x00027C6C
private static void PlayInFixedTimeInternal(ref PlayableHandle handle, int stateNameHash, [DefaultValue("-1")] int layer, [DefaultValue("float.NegativeInfinity")] float fixedTime)
{
AnimatorControllerPlayable.INTERNAL_CALL_PlayInFixedTimeInternal(ref handle, stateNameHash, layer, fixedTime);
}
// Token: 0x0600239D RID: 9117 RVA: 0x00029A78 File Offset: 0x00027C78
[ExcludeFromDocs]
private static void PlayInFixedTimeInternal(ref PlayableHandle handle, int stateNameHash, int layer)
{
float negativeInfinity = float.NegativeInfinity;
AnimatorControllerPlayable.INTERNAL_CALL_PlayInFixedTimeInternal(ref handle, stateNameHash, layer, negativeInfinity);
}
// Token: 0x0600239E RID: 9118 RVA: 0x00029A98 File Offset: 0x00027C98
[ExcludeFromDocs]
private static void PlayInFixedTimeInternal(ref PlayableHandle handle, int stateNameHash)
{
float negativeInfinity = float.NegativeInfinity;
int num = -1;
AnimatorControllerPlayable.INTERNAL_CALL_PlayInFixedTimeInternal(ref handle, stateNameHash, num, negativeInfinity);
}
// Token: 0x0600239F RID: 9119
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_PlayInFixedTimeInternal(ref PlayableHandle handle, int stateNameHash, int layer, float fixedTime);
// Token: 0x060023A0 RID: 9120 RVA: 0x00029AB8 File Offset: 0x00027CB8
[ExcludeFromDocs]
public void Play(string stateName, int layer)
{
float negativeInfinity = float.NegativeInfinity;
this.Play(stateName, layer, negativeInfinity);
}
// Token: 0x060023A1 RID: 9121 RVA: 0x00029AD8 File Offset: 0x00027CD8
[ExcludeFromDocs]
public void Play(string stateName)
{
float negativeInfinity = float.NegativeInfinity;
int num = -1;
this.Play(stateName, num, negativeInfinity);
}
// Token: 0x060023A2 RID: 9122 RVA: 0x00029AF8 File Offset: 0x00027CF8
public void Play(string stateName, [DefaultValue("-1")] int layer, [DefaultValue("float.NegativeInfinity")] float normalizedTime)
{
AnimatorControllerPlayable.PlayInternal(ref this.m_Handle, AnimatorControllerPlayable.StringToHash(stateName), layer, normalizedTime);
}
// Token: 0x060023A3 RID: 9123 RVA: 0x00029B10 File Offset: 0x00027D10
[ExcludeFromDocs]
public void Play(int stateNameHash, int layer)
{
float negativeInfinity = float.NegativeInfinity;
this.Play(stateNameHash, layer, negativeInfinity);
}
// Token: 0x060023A4 RID: 9124 RVA: 0x00029B30 File Offset: 0x00027D30
[ExcludeFromDocs]
public void Play(int stateNameHash)
{
float negativeInfinity = float.NegativeInfinity;
int num = -1;
this.Play(stateNameHash, num, negativeInfinity);
}
// Token: 0x060023A5 RID: 9125 RVA: 0x00029B50 File Offset: 0x00027D50
public void Play(int stateNameHash, [DefaultValue("-1")] int layer, [DefaultValue("float.NegativeInfinity")] float normalizedTime)
{
AnimatorControllerPlayable.PlayInternal(ref this.m_Handle, stateNameHash, layer, normalizedTime);
}
// Token: 0x060023A6 RID: 9126 RVA: 0x00029B64 File Offset: 0x00027D64
private static void PlayInternal(ref PlayableHandle handle, int stateNameHash, [DefaultValue("-1")] int layer, [DefaultValue("float.NegativeInfinity")] float normalizedTime)
{
AnimatorControllerPlayable.INTERNAL_CALL_PlayInternal(ref handle, stateNameHash, layer, normalizedTime);
}
// Token: 0x060023A7 RID: 9127 RVA: 0x00029B70 File Offset: 0x00027D70
[ExcludeFromDocs]
private static void PlayInternal(ref PlayableHandle handle, int stateNameHash, int layer)
{
float negativeInfinity = float.NegativeInfinity;
AnimatorControllerPlayable.INTERNAL_CALL_PlayInternal(ref handle, stateNameHash, layer, negativeInfinity);
}
// Token: 0x060023A8 RID: 9128 RVA: 0x00029B90 File Offset: 0x00027D90
[ExcludeFromDocs]
private static void PlayInternal(ref PlayableHandle handle, int stateNameHash)
{
float negativeInfinity = float.NegativeInfinity;
int num = -1;
AnimatorControllerPlayable.INTERNAL_CALL_PlayInternal(ref handle, stateNameHash, num, negativeInfinity);
}
// Token: 0x060023A9 RID: 9129
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_PlayInternal(ref PlayableHandle handle, int stateNameHash, int layer, float normalizedTime);
// Token: 0x060023AA RID: 9130 RVA: 0x00029BB0 File Offset: 0x00027DB0
public bool HasState(int layerIndex, int stateID)
{
return AnimatorControllerPlayable.HasStateInternal(ref this.m_Handle, layerIndex, stateID);
}
// Token: 0x060023AB RID: 9131 RVA: 0x00029BD4 File Offset: 0x00027DD4
private static bool HasStateInternal(ref PlayableHandle handle, int layerIndex, int stateID)
{
return AnimatorControllerPlayable.INTERNAL_CALL_HasStateInternal(ref handle, layerIndex, stateID);
}
// Token: 0x060023AC RID: 9132
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern bool INTERNAL_CALL_HasStateInternal(ref PlayableHandle handle, int layerIndex, int stateID);
// Token: 0x060023AD RID: 9133 RVA: 0x00029BF4 File Offset: 0x00027DF4
private static void SetFloatString(ref PlayableHandle handle, string name, float value)
{
AnimatorControllerPlayable.INTERNAL_CALL_SetFloatString(ref handle, name, value);
}
// Token: 0x060023AE RID: 9134
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_SetFloatString(ref PlayableHandle handle, string name, float value);
// Token: 0x060023AF RID: 9135 RVA: 0x00029C00 File Offset: 0x00027E00
private static void SetFloatID(ref PlayableHandle handle, int id, float value)
{
AnimatorControllerPlayable.INTERNAL_CALL_SetFloatID(ref handle, id, value);
}
// Token: 0x060023B0 RID: 9136
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_SetFloatID(ref PlayableHandle handle, int id, float value);
// Token: 0x060023B1 RID: 9137 RVA: 0x00029C0C File Offset: 0x00027E0C
private static float GetFloatString(ref PlayableHandle handle, string name)
{
return AnimatorControllerPlayable.INTERNAL_CALL_GetFloatString(ref handle, name);
}
// Token: 0x060023B2 RID: 9138
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern float INTERNAL_CALL_GetFloatString(ref PlayableHandle handle, string name);
// Token: 0x060023B3 RID: 9139 RVA: 0x00029C28 File Offset: 0x00027E28
private static float GetFloatID(ref PlayableHandle handle, int id)
{
return AnimatorControllerPlayable.INTERNAL_CALL_GetFloatID(ref handle, id);
}
// Token: 0x060023B4 RID: 9140
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern float INTERNAL_CALL_GetFloatID(ref PlayableHandle handle, int id);
// Token: 0x060023B5 RID: 9141 RVA: 0x00029C44 File Offset: 0x00027E44
private static void SetBoolString(ref PlayableHandle handle, string name, bool value)
{
AnimatorControllerPlayable.INTERNAL_CALL_SetBoolString(ref handle, name, value);
}
// Token: 0x060023B6 RID: 9142
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_SetBoolString(ref PlayableHandle handle, string name, bool value);
// Token: 0x060023B7 RID: 9143 RVA: 0x00029C50 File Offset: 0x00027E50
private static void SetBoolID(ref PlayableHandle handle, int id, bool value)
{
AnimatorControllerPlayable.INTERNAL_CALL_SetBoolID(ref handle, id, value);
}
// Token: 0x060023B8 RID: 9144
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_SetBoolID(ref PlayableHandle handle, int id, bool value);
// Token: 0x060023B9 RID: 9145 RVA: 0x00029C5C File Offset: 0x00027E5C
private static bool GetBoolString(ref PlayableHandle handle, string name)
{
return AnimatorControllerPlayable.INTERNAL_CALL_GetBoolString(ref handle, name);
}
// Token: 0x060023BA RID: 9146
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern bool INTERNAL_CALL_GetBoolString(ref PlayableHandle handle, string name);
// Token: 0x060023BB RID: 9147 RVA: 0x00029C78 File Offset: 0x00027E78
private static bool GetBoolID(ref PlayableHandle handle, int id)
{
return AnimatorControllerPlayable.INTERNAL_CALL_GetBoolID(ref handle, id);
}
// Token: 0x060023BC RID: 9148
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern bool INTERNAL_CALL_GetBoolID(ref PlayableHandle handle, int id);
// Token: 0x060023BD RID: 9149 RVA: 0x00029C94 File Offset: 0x00027E94
private static void SetIntegerString(ref PlayableHandle handle, string name, int value)
{
AnimatorControllerPlayable.INTERNAL_CALL_SetIntegerString(ref handle, name, value);
}
// Token: 0x060023BE RID: 9150
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_SetIntegerString(ref PlayableHandle handle, string name, int value);
// Token: 0x060023BF RID: 9151 RVA: 0x00029CA0 File Offset: 0x00027EA0
private static void SetIntegerID(ref PlayableHandle handle, int id, int value)
{
AnimatorControllerPlayable.INTERNAL_CALL_SetIntegerID(ref handle, id, value);
}
// Token: 0x060023C0 RID: 9152
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_SetIntegerID(ref PlayableHandle handle, int id, int value);
// Token: 0x060023C1 RID: 9153 RVA: 0x00029CAC File Offset: 0x00027EAC
private static int GetIntegerString(ref PlayableHandle handle, string name)
{
return AnimatorControllerPlayable.INTERNAL_CALL_GetIntegerString(ref handle, name);
}
// Token: 0x060023C2 RID: 9154
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern int INTERNAL_CALL_GetIntegerString(ref PlayableHandle handle, string name);
// Token: 0x060023C3 RID: 9155 RVA: 0x00029CC8 File Offset: 0x00027EC8
private static int GetIntegerID(ref PlayableHandle handle, int id)
{
return AnimatorControllerPlayable.INTERNAL_CALL_GetIntegerID(ref handle, id);
}
// Token: 0x060023C4 RID: 9156
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern int INTERNAL_CALL_GetIntegerID(ref PlayableHandle handle, int id);
// Token: 0x060023C5 RID: 9157 RVA: 0x00029CE4 File Offset: 0x00027EE4
private static void SetTriggerString(ref PlayableHandle handle, string name)
{
AnimatorControllerPlayable.INTERNAL_CALL_SetTriggerString(ref handle, name);
}
// Token: 0x060023C6 RID: 9158
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_SetTriggerString(ref PlayableHandle handle, string name);
// Token: 0x060023C7 RID: 9159 RVA: 0x00029CF0 File Offset: 0x00027EF0
private static void SetTriggerID(ref PlayableHandle handle, int id)
{
AnimatorControllerPlayable.INTERNAL_CALL_SetTriggerID(ref handle, id);
}
// Token: 0x060023C8 RID: 9160
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_SetTriggerID(ref PlayableHandle handle, int id);
// Token: 0x060023C9 RID: 9161 RVA: 0x00029CFC File Offset: 0x00027EFC
private static void ResetTriggerString(ref PlayableHandle handle, string name)
{
AnimatorControllerPlayable.INTERNAL_CALL_ResetTriggerString(ref handle, name);
}
// Token: 0x060023CA RID: 9162
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_ResetTriggerString(ref PlayableHandle handle, string name);
// Token: 0x060023CB RID: 9163 RVA: 0x00029D08 File Offset: 0x00027F08
private static void ResetTriggerID(ref PlayableHandle handle, int id)
{
AnimatorControllerPlayable.INTERNAL_CALL_ResetTriggerID(ref handle, id);
}
// Token: 0x060023CC RID: 9164
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern void INTERNAL_CALL_ResetTriggerID(ref PlayableHandle handle, int id);
// Token: 0x060023CD RID: 9165 RVA: 0x00029D14 File Offset: 0x00027F14
private static bool IsParameterControlledByCurveString(ref PlayableHandle handle, string name)
{
return AnimatorControllerPlayable.INTERNAL_CALL_IsParameterControlledByCurveString(ref handle, name);
}
// Token: 0x060023CE RID: 9166
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern bool INTERNAL_CALL_IsParameterControlledByCurveString(ref PlayableHandle handle, string name);
// Token: 0x060023CF RID: 9167 RVA: 0x00029D30 File Offset: 0x00027F30
private static bool IsParameterControlledByCurveID(ref PlayableHandle handle, int id)
{
return AnimatorControllerPlayable.INTERNAL_CALL_IsParameterControlledByCurveID(ref handle, id);
}
// Token: 0x060023D0 RID: 9168
[GeneratedByOldBindingsGenerator]
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern bool INTERNAL_CALL_IsParameterControlledByCurveID(ref PlayableHandle handle, int id);
// Token: 0x04000547 RID: 1351
private PlayableHandle m_Handle;
// Token: 0x04000548 RID: 1352
private static readonly AnimatorControllerPlayable m_NullPlayable = new AnimatorControllerPlayable(PlayableHandle.Null);
}
}
UnityEngine/Animations/IAnimatorControllerPlayable.cs
+141
View File
@@ -0,0 +1,141 @@
using System;
using System.Collections.Generic;
namespace UnityEngine.Animations
{
// Token: 0x02000213 RID: 531
public interface IAnimatorControllerPlayable
{
// Token: 0x0600259D RID: 9629
float GetFloat(string name);
// Token: 0x0600259E RID: 9630
float GetFloat(int id);
// Token: 0x0600259F RID: 9631
void SetFloat(string name, float value);
// Token: 0x060025A0 RID: 9632
void SetFloat(int id, float value);
// Token: 0x060025A1 RID: 9633
bool GetBool(string name);
// Token: 0x060025A2 RID: 9634
bool GetBool(int id);
// Token: 0x060025A3 RID: 9635
void SetBool(string name, bool value);
// Token: 0x060025A4 RID: 9636
void SetBool(int id, bool value);
// Token: 0x060025A5 RID: 9637
int GetInteger(string name);
// Token: 0x060025A6 RID: 9638
int GetInteger(int id);
// Token: 0x060025A7 RID: 9639
void SetInteger(string name, int value);
// Token: 0x060025A8 RID: 9640
void SetInteger(int id, int value);
// Token: 0x060025A9 RID: 9641
void SetTrigger(string name);
// Token: 0x060025AA RID: 9642
void SetTrigger(int id);
// Token: 0x060025AB RID: 9643
void ResetTrigger(string name);
// Token: 0x060025AC RID: 9644
void ResetTrigger(int id);
// Token: 0x060025AD RID: 9645
bool IsParameterControlledByCurve(string name);
// Token: 0x060025AE RID: 9646
bool IsParameterControlledByCurve(int id);
// Token: 0x060025AF RID: 9647
int GetLayerCount();
// Token: 0x060025B0 RID: 9648
string GetLayerName(int layerIndex);
// Token: 0x060025B1 RID: 9649
int GetLayerIndex(string layerName);
// Token: 0x060025B2 RID: 9650
float GetLayerWeight(int layerIndex);
// Token: 0x060025B3 RID: 9651
void SetLayerWeight(int layerIndex, float weight);
// Token: 0x060025B4 RID: 9652
AnimatorStateInfo GetCurrentAnimatorStateInfo(int layerIndex);
// Token: 0x060025B5 RID: 9653
AnimatorStateInfo GetNextAnimatorStateInfo(int layerIndex);
// Token: 0x060025B6 RID: 9654
AnimatorTransitionInfo GetAnimatorTransitionInfo(int layerIndex);
// Token: 0x060025B7 RID: 9655
AnimatorClipInfo[] GetCurrentAnimatorClipInfo(int layerIndex);
// Token: 0x060025B8 RID: 9656
AnimatorClipInfo[] GetNextAnimatorClipInfo(int layerIndex);
// Token: 0x060025B9 RID: 9657
int GetCurrentAnimatorClipInfoCount(int layerIndex);
// Token: 0x060025BA RID: 9658
void GetCurrentAnimatorClipInfo(int layerIndex, List<AnimatorClipInfo> clips);
// Token: 0x060025BB RID: 9659
int GetNextAnimatorClipInfoCount(int layerIndex);
// Token: 0x060025BC RID: 9660
void GetNextAnimatorClipInfo(int layerIndex, List<AnimatorClipInfo> clips);
// Token: 0x060025BD RID: 9661
bool IsInTransition(int layerIndex);
// Token: 0x060025BE RID: 9662
int GetParameterCount();
// Token: 0x060025BF RID: 9663
AnimatorControllerParameter GetParameter(int index);
// Token: 0x060025C0 RID: 9664
void CrossFadeInFixedTime(string stateName, float transitionDuration, int layer, float fixedTime);
// Token: 0x060025C1 RID: 9665
void CrossFadeInFixedTime(int stateNameHash, float transitionDuration, int layer, float fixedTime);
// Token: 0x060025C2 RID: 9666
void CrossFade(string stateName, float transitionDuration, int layer, float normalizedTime);
// Token: 0x060025C3 RID: 9667
void CrossFade(int stateNameHash, float transitionDuration, int layer, float normalizedTime);
// Token: 0x060025C4 RID: 9668
void PlayInFixedTime(string stateName, int layer, float fixedTime);
// Token: 0x060025C5 RID: 9669
void PlayInFixedTime(int stateNameHash, int layer, float fixedTime);
// Token: 0x060025C6 RID: 9670
void Play(string stateName, int layer, float normalizedTime);
// Token: 0x060025C7 RID: 9671
void Play(int stateNameHash, int layer, float normalizedTime);
// Token: 0x060025C8 RID: 9672
bool HasState(int layerIndex, int stateID);
}
}