scripts

2026-06-04 11:42:34 +02:00
parent f39ba70a9f
commit e720b98cd1
7488 changed files with 2493818 additions and 0 deletions
@@ -0,0 +1,67 @@
+using System;
+using UnityEngine.Animations;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020001EF RID: 495
+	public static class AnimationPlayableUtilities
+	{
+		// Token: 0x060022C0 RID: 8896 RVA: 0x00028450 File Offset: 0x00026650
+		public static void Play(Animator animator, Playable playable, PlayableGraph graph)
+		{
+			AnimationPlayableOutput animationPlayableOutput = AnimationPlayableOutput.Create(graph, "AnimationClip", animator);
+			animationPlayableOutput.SetSourcePlayable(playable);
+			animationPlayableOutput.SetSourceInputPort(0);
+			graph.SyncUpdateAndTimeMode(animator);
+			graph.Play();
+		}
+
+		// Token: 0x060022C1 RID: 8897 RVA: 0x00028488 File Offset: 0x00026688
+		public static AnimationClipPlayable PlayClip(Animator animator, AnimationClip clip, out PlayableGraph graph)
+		{
+			graph = PlayableGraph.Create();
+			AnimationPlayableOutput animationPlayableOutput = AnimationPlayableOutput.Create(graph, "AnimationClip", animator);
+			AnimationClipPlayable animationClipPlayable = AnimationClipPlayable.Create(graph, clip);
+			animationPlayableOutput.SetSourcePlayable(animationClipPlayable);
+			graph.SyncUpdateAndTimeMode(animator);
+			graph.Play();
+			return animationClipPlayable;
+		}
+
+		// Token: 0x060022C2 RID: 8898 RVA: 0x000284E4 File Offset: 0x000266E4
+		public static AnimationMixerPlayable PlayMixer(Animator animator, int inputCount, out PlayableGraph graph)
+		{
+			graph = PlayableGraph.Create();
+			AnimationPlayableOutput animationPlayableOutput = AnimationPlayableOutput.Create(graph, "Mixer", animator);
+			AnimationMixerPlayable animationMixerPlayable = AnimationMixerPlayable.Create(graph, inputCount, false);
+			animationPlayableOutput.SetSourcePlayable(animationMixerPlayable);
+			graph.SyncUpdateAndTimeMode(animator);
+			graph.Play();
+			return animationMixerPlayable;
+		}
+
+		// Token: 0x060022C3 RID: 8899 RVA: 0x00028540 File Offset: 0x00026740
+		public static AnimationLayerMixerPlayable PlayLayerMixer(Animator animator, int inputCount, out PlayableGraph graph)
+		{
+			graph = PlayableGraph.Create();
+			AnimationPlayableOutput animationPlayableOutput = AnimationPlayableOutput.Create(graph, "Mixer", animator);
+			AnimationLayerMixerPlayable animationLayerMixerPlayable = AnimationLayerMixerPlayable.Create(graph, inputCount);
+			animationPlayableOutput.SetSourcePlayable(animationLayerMixerPlayable);
+			graph.SyncUpdateAndTimeMode(animator);
+			graph.Play();
+			return animationLayerMixerPlayable;
+		}
+
+		// Token: 0x060022C4 RID: 8900 RVA: 0x0002859C File Offset: 0x0002679C
+		public static AnimatorControllerPlayable PlayAnimatorController(Animator animator, RuntimeAnimatorController controller, out PlayableGraph graph)
+		{
+			graph = PlayableGraph.Create();
+			AnimationPlayableOutput animationPlayableOutput = AnimationPlayableOutput.Create(graph, "AnimatorControllerPlayable", animator);
+			AnimatorControllerPlayable animatorControllerPlayable = AnimatorControllerPlayable.Create(graph, controller);
+			animationPlayableOutput.SetSourcePlayable(animatorControllerPlayable);
+			graph.SyncUpdateAndTimeMode(animator);
+			graph.Play();
+			return animatorControllerPlayable;
+		}
+	}
+}
@@ -0,0 +1,21 @@
+using System;
+using System.Runtime.CompilerServices;
+using UnityEngine.Scripting;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020001EA RID: 490
+	public static class AudioPlayableGraphExtensions
+	{
+		// Token: 0x0600228F RID: 8847 RVA: 0x000282B4 File Offset: 0x000264B4
+		internal static bool InternalCreateAudioOutput(ref PlayableGraph graph, string name, out PlayableOutputHandle handle)
+		{
+			return AudioPlayableGraphExtensions.INTERNAL_CALL_InternalCreateAudioOutput(ref graph, name, out handle);
+		}
+
+		// Token: 0x06002290 RID: 8848
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool INTERNAL_CALL_InternalCreateAudioOutput(ref PlayableGraph graph, string name, out PlayableOutputHandle handle);
+	}
+}
@@ -0,0 +1,17 @@
+using System;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020000E3 RID: 227
+	public enum DataStreamType
+	{
+		// Token: 0x04000214 RID: 532
+		Animation,
+		// Token: 0x04000215 RID: 533
+		Audio,
+		// Token: 0x04000216 RID: 534
+		Video,
+		// Token: 0x04000217 RID: 535
+		None
+	}
+}
@@ -0,0 +1,17 @@
+using System;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020000E2 RID: 226
+	public enum DirectorUpdateMode
+	{
+		// Token: 0x0400020F RID: 527
+		DSPClock,
+		// Token: 0x04000210 RID: 528
+		GameTime,
+		// Token: 0x04000211 RID: 529
+		UnscaledGameTime,
+		// Token: 0x04000212 RID: 530
+		Manual
+	}
+}
@@ -0,0 +1,15 @@
+using System;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020002D4 RID: 724
+	public enum DirectorWrapMode
+	{
+		// Token: 0x0400097C RID: 2428
+		Hold,
+		// Token: 0x0400097D RID: 2429
+		Loop,
+		// Token: 0x0400097E RID: 2430
+		None
+	}
+}
@@ -0,0 +1,139 @@
+using System;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020004B4 RID: 1204
+	public struct FrameData
+	{
+		// Token: 0x17000D6B RID: 3435
+		// (get) Token: 0x06003B15 RID: 15125 RVA: 0x00067B54 File Offset: 0x00065D54
+		public ulong frameId
+		{
+			get
+			{
+				return this.m_FrameID;
+			}
+		}
+
+		// Token: 0x17000D6C RID: 3436
+		// (get) Token: 0x06003B16 RID: 15126 RVA: 0x00067B70 File Offset: 0x00065D70
+		public float deltaTime
+		{
+			get
+			{
+				return (float)this.m_DeltaTime;
+			}
+		}
+
+		// Token: 0x17000D6D RID: 3437
+		// (get) Token: 0x06003B17 RID: 15127 RVA: 0x00067B8C File Offset: 0x00065D8C
+		public float weight
+		{
+			get
+			{
+				return this.m_Weight;
+			}
+		}
+
+		// Token: 0x17000D6E RID: 3438
+		// (get) Token: 0x06003B18 RID: 15128 RVA: 0x00067BA8 File Offset: 0x00065DA8
+		public float effectiveWeight
+		{
+			get
+			{
+				return this.m_EffectiveWeight;
+			}
+		}
+
+		// Token: 0x17000D6F RID: 3439
+		// (get) Token: 0x06003B19 RID: 15129 RVA: 0x00067BC4 File Offset: 0x00065DC4
+		public float effectiveSpeed
+		{
+			get
+			{
+				return this.m_EffectiveSpeed;
+			}
+		}
+
+		// Token: 0x17000D70 RID: 3440
+		// (get) Token: 0x06003B1A RID: 15130 RVA: 0x00067BE0 File Offset: 0x00065DE0
+		public FrameData.EvaluationType evaluationType
+		{
+			get
+			{
+				return ((this.m_Flags & FrameData.Flags.Evaluate) == (FrameData.Flags)0) ? FrameData.EvaluationType.Playback : FrameData.EvaluationType.Evaluate;
+			}
+		}
+
+		// Token: 0x17000D71 RID: 3441
+		// (get) Token: 0x06003B1B RID: 15131 RVA: 0x00067C0C File Offset: 0x00065E0C
+		public bool seekOccurred
+		{
+			get
+			{
+				return (this.m_Flags & FrameData.Flags.SeekOccured) != (FrameData.Flags)0;
+			}
+		}
+
+		// Token: 0x17000D72 RID: 3442
+		// (get) Token: 0x06003B1C RID: 15132 RVA: 0x00067C30 File Offset: 0x00065E30
+		public bool timeLooped
+		{
+			get
+			{
+				return (this.m_Flags & FrameData.Flags.Loop) != (FrameData.Flags)0;
+			}
+		}
+
+		// Token: 0x17000D73 RID: 3443
+		// (get) Token: 0x06003B1D RID: 15133 RVA: 0x00067C54 File Offset: 0x00065E54
+		public bool timeHeld
+		{
+			get
+			{
+				return (this.m_Flags & FrameData.Flags.Hold) != (FrameData.Flags)0;
+			}
+		}
+
+		// Token: 0x040011D2 RID: 4562
+		internal ulong m_FrameID;
+
+		// Token: 0x040011D3 RID: 4563
+		internal double m_DeltaTime;
+
+		// Token: 0x040011D4 RID: 4564
+		internal float m_Weight;
+
+		// Token: 0x040011D5 RID: 4565
+		internal float m_EffectiveWeight;
+
+		// Token: 0x040011D6 RID: 4566
+		internal float m_EffectiveSpeed;
+
+		// Token: 0x040011D7 RID: 4567
+		internal FrameData.Flags m_Flags;
+
+		// Token: 0x020004B5 RID: 1205
+		[Flags]
+		internal enum Flags
+		{
+			// Token: 0x040011D9 RID: 4569
+			Evaluate = 1,
+			// Token: 0x040011DA RID: 4570
+			SeekOccured = 2,
+			// Token: 0x040011DB RID: 4571
+			Loop = 4,
+			// Token: 0x040011DC RID: 4572
+			Hold = 8
+		}
+
+		// Token: 0x020004B6 RID: 1206
+		public enum EvaluationType
+		{
+			// Token: 0x040011DE RID: 4574
+			Evaluate,
+			// Token: 0x040011DF RID: 4575
+			Playback
+		}
+	}
+}
@@ -0,0 +1,11 @@
+using System;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020004B7 RID: 1207
+	public interface IPlayable
+	{
+		// Token: 0x06003B1E RID: 15134
+		PlayableHandle GetHandle();
+	}
+}
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020004BB RID: 1211
+	public interface IPlayableAsset
+	{
+		// Token: 0x06003B31 RID: 15153
+		Playable CreatePlayable(PlayableGraph graph, GameObject owner);
+
+		// Token: 0x17000D78 RID: 3448
+		// (get) Token: 0x06003B32 RID: 15154
+		double duration { get; }
+
+		// Token: 0x17000D79 RID: 3449
+		// (get) Token: 0x06003B33 RID: 15155
+		IEnumerable<PlayableBinding> outputs { get; }
+	}
+}
@@ -0,0 +1,32 @@
+using System;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020004B8 RID: 1208
+	public interface IPlayableBehaviour
+	{
+		// Token: 0x06003B1F RID: 15135
+		void OnGraphStart(Playable playable);
+
+		// Token: 0x06003B20 RID: 15136
+		void OnGraphStop(Playable playable);
+
+		// Token: 0x06003B21 RID: 15137
+		void OnPlayableCreate(Playable playable);
+
+		// Token: 0x06003B22 RID: 15138
+		void OnPlayableDestroy(Playable playable);
+
+		// Token: 0x06003B23 RID: 15139
+		void OnBehaviourPlay(Playable playable, FrameData info);
+
+		// Token: 0x06003B24 RID: 15140
+		void OnBehaviourPause(Playable playable, FrameData info);
+
+		// Token: 0x06003B25 RID: 15141
+		void PrepareFrame(Playable playable, FrameData info);
+
+		// Token: 0x06003B26 RID: 15142
+		void ProcessFrame(Playable playable, FrameData info, object playerData);
+	}
+}
@@ -0,0 +1,11 @@
+using System;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020004B9 RID: 1209
+	public interface IPlayableOutput
+	{
+		// Token: 0x06003B27 RID: 15143
+		PlayableOutputHandle GetHandle();
+	}
+}
@@ -0,0 +1,13 @@
+using System;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020000DF RID: 223
+	public enum PlayState
+	{
+		// Token: 0x04000208 RID: 520
+		Paused,
+		// Token: 0x04000209 RID: 521
+		Playing
+	}
+}
@@ -0,0 +1,64 @@
+using System;
+using UnityEngine.Scripting;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020000E1 RID: 225
+	[RequiredByNativeCode]
+	public struct Playable : IPlayable, IEquatable<Playable>
+	{
+		// Token: 0x060010AF RID: 4271 RVA: 0x00016694 File Offset: 0x00014894
+		internal Playable(PlayableHandle handle)
+		{
+			this.m_Handle = handle;
+		}
+
+		// Token: 0x1700036D RID: 877
+		// (get) Token: 0x060010B0 RID: 4272 RVA: 0x000166A0 File Offset: 0x000148A0
+		public static Playable Null
+		{
+			get
+			{
+				return Playable.m_NullPlayable;
+			}
+		}
+
+		// Token: 0x060010B1 RID: 4273 RVA: 0x000166BC File Offset: 0x000148BC
+		public static Playable Create(PlayableGraph graph, int inputCount = 0)
+		{
+			Playable playable = new Playable(graph.CreatePlayableHandle());
+			playable.SetInputCount(inputCount);
+			return playable;
+		}
+
+		// Token: 0x060010B2 RID: 4274 RVA: 0x000166E8 File Offset: 0x000148E8
+		public PlayableHandle GetHandle()
+		{
+			return this.m_Handle;
+		}
+
+		// Token: 0x060010B3 RID: 4275 RVA: 0x00016704 File Offset: 0x00014904
+		public bool IsPlayableOfType<T>() where T : struct, IPlayable
+		{
+			return this.GetHandle().IsPlayableOfType<T>();
+		}
+
+		// Token: 0x060010B4 RID: 4276 RVA: 0x00016728 File Offset: 0x00014928
+		public Type GetPlayableType()
+		{
+			return this.GetHandle().GetPlayableType();
+		}
+
+		// Token: 0x060010B5 RID: 4277 RVA: 0x0001674C File Offset: 0x0001494C
+		public bool Equals(Playable other)
+		{
+			return this.GetHandle() == other.GetHandle();
+		}
+
+		// Token: 0x0400020C RID: 524
+		private PlayableHandle m_Handle;
+
+		// Token: 0x0400020D RID: 525
+		private static readonly Playable m_NullPlayable = new Playable(PlayableHandle.Null);
+	}
+}
@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine.Scripting;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020004BC RID: 1212
+	[RequiredByNativeCode]
+	[Serializable]
+	public abstract class PlayableAsset : ScriptableObject, IPlayableAsset
+	{
+		// Token: 0x06003B35 RID: 15157
+		public abstract Playable CreatePlayable(PlayableGraph graph, GameObject owner);
+
+		// Token: 0x17000D7A RID: 3450
+		// (get) Token: 0x06003B36 RID: 15158 RVA: 0x00067D3C File Offset: 0x00065F3C
+		public virtual double duration
+		{
+			get
+			{
+				return PlayableBinding.DefaultDuration;
+			}
+		}
+
+		// Token: 0x17000D7B RID: 3451
+		// (get) Token: 0x06003B37 RID: 15159 RVA: 0x00067D58 File Offset: 0x00065F58
+		public virtual IEnumerable<PlayableBinding> outputs
+		{
+			get
+			{
+				return PlayableBinding.None;
+			}
+		}
+
+		// Token: 0x06003B38 RID: 15160 RVA: 0x00067D74 File Offset: 0x00065F74
+		[RequiredByNativeCode]
+		internal unsafe static void Internal_CreatePlayable(PlayableAsset asset, PlayableGraph graph, GameObject go, IntPtr ptr)
+		{
+			Playable playable;
+			if (asset == null)
+			{
+				playable = Playable.Null;
+			}
+			else
+			{
+				playable = asset.CreatePlayable(graph, go);
+			}
+			Playable* ptr2 = (Playable*)ptr.ToPointer();
+			*ptr2 = playable;
+		}
+
+		// Token: 0x06003B39 RID: 15161 RVA: 0x00067DB4 File Offset: 0x00065FB4
+		[RequiredByNativeCode]
+		internal unsafe static void Internal_GetPlayableAssetDuration(PlayableAsset asset, IntPtr ptrToDouble)
+		{
+			double duration = asset.duration;
+			double* ptr = (double*)ptrToDouble.ToPointer();
+			*ptr = duration;
+		}
+	}
+}
@@ -0,0 +1,62 @@
+using System;
+using UnityEngine.Scripting;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020004BD RID: 1213
+	[RequiredByNativeCode]
+	[Serializable]
+	public abstract class PlayableBehaviour : IPlayableBehaviour, ICloneable
+	{
+		// Token: 0x06003B3A RID: 15162 RVA: 0x00067DD8 File Offset: 0x00065FD8
+		public PlayableBehaviour()
+		{
+		}
+
+		// Token: 0x06003B3B RID: 15163 RVA: 0x00067DE4 File Offset: 0x00065FE4
+		public virtual void OnGraphStart(Playable playable)
+		{
+		}
+
+		// Token: 0x06003B3C RID: 15164 RVA: 0x00067DE8 File Offset: 0x00065FE8
+		public virtual void OnGraphStop(Playable playable)
+		{
+		}
+
+		// Token: 0x06003B3D RID: 15165 RVA: 0x00067DEC File Offset: 0x00065FEC
+		public virtual void OnPlayableCreate(Playable playable)
+		{
+		}
+
+		// Token: 0x06003B3E RID: 15166 RVA: 0x00067DF0 File Offset: 0x00065FF0
+		public virtual void OnPlayableDestroy(Playable playable)
+		{
+		}
+
+		// Token: 0x06003B3F RID: 15167 RVA: 0x00067DF4 File Offset: 0x00065FF4
+		public virtual void OnBehaviourPlay(Playable playable, FrameData info)
+		{
+		}
+
+		// Token: 0x06003B40 RID: 15168 RVA: 0x00067DF8 File Offset: 0x00065FF8
+		public virtual void OnBehaviourPause(Playable playable, FrameData info)
+		{
+		}
+
+		// Token: 0x06003B41 RID: 15169 RVA: 0x00067DFC File Offset: 0x00065FFC
+		public virtual void PrepareFrame(Playable playable, FrameData info)
+		{
+		}
+
+		// Token: 0x06003B42 RID: 15170 RVA: 0x00067E00 File Offset: 0x00066000
+		public virtual void ProcessFrame(Playable playable, FrameData info, object playerData)
+		{
+		}
+
+		// Token: 0x06003B43 RID: 15171 RVA: 0x00067E04 File Offset: 0x00066004
+		public virtual object Clone()
+		{
+			return base.MemberwiseClone();
+		}
+	}
+}
@@ -0,0 +1,36 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020004BA RID: 1210
+	[StructLayout(LayoutKind.Sequential, Size = 1)]
+	public struct PlayableBinding
+	{
+		// Token: 0x17000D74 RID: 3444
+		// (get) Token: 0x06003B28 RID: 15144 RVA: 0x00067C78 File Offset: 0x00065E78
+		// (set) Token: 0x06003B29 RID: 15145 RVA: 0x00067C94 File Offset: 0x00065E94
+		public string streamName { get; set; }
+
+		// Token: 0x17000D75 RID: 3445
+		// (get) Token: 0x06003B2A RID: 15146 RVA: 0x00067CA0 File Offset: 0x00065EA0
+		// (set) Token: 0x06003B2B RID: 15147 RVA: 0x00067CBC File Offset: 0x00065EBC
+		public DataStreamType streamType { get; set; }
+
+		// Token: 0x17000D76 RID: 3446
+		// (get) Token: 0x06003B2C RID: 15148 RVA: 0x00067CC8 File Offset: 0x00065EC8
+		// (set) Token: 0x06003B2D RID: 15149 RVA: 0x00067CE4 File Offset: 0x00065EE4
+		public Object sourceObject { get; set; }
+
+		// Token: 0x17000D77 RID: 3447
+		// (get) Token: 0x06003B2E RID: 15150 RVA: 0x00067CF0 File Offset: 0x00065EF0
+		// (set) Token: 0x06003B2F RID: 15151 RVA: 0x00067D0C File Offset: 0x00065F0C
+		public Type sourceBindingType { get; set; }
+
+		// Token: 0x040011E0 RID: 4576
+		public static readonly PlayableBinding[] None = new PlayableBinding[0];
+
+		// Token: 0x040011E1 RID: 4577
+		public static readonly double DefaultDuration = double.PositiveInfinity;
+	}
+}
@@ -0,0 +1,234 @@
+using System;
+using System.Runtime.CompilerServices;
+using UnityEngine.Scripting;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020002D5 RID: 725
+	[RequiredByNativeCode]
+	public class PlayableDirector : Behaviour, IExposedPropertyTable
+	{
+		// Token: 0x17000AE7 RID: 2791
+		// (get) Token: 0x06002FDF RID: 12255
+		public extern PlayState state
+		{
+			[GeneratedByOldBindingsGenerator]
+			[MethodImpl(MethodImplOptions.InternalCall)]
+			get;
+		}
+
+		// Token: 0x17000AE8 RID: 2792
+		// (get) Token: 0x06002FE0 RID: 12256 RVA: 0x00046000 File Offset: 0x00044200
+		// (set) Token: 0x06002FE1 RID: 12257 RVA: 0x00046020 File Offset: 0x00044220
+		public PlayableAsset playableAsset
+		{
+			get
+			{
+				return this.GetPlayableAssetInternal() as PlayableAsset;
+			}
+			set
+			{
+				this.SetPlayableAssetInternal(value);
+			}
+		}
+
+		// Token: 0x17000AE9 RID: 2793
+		// (get) Token: 0x06002FE2 RID: 12258
+		// (set) Token: 0x06002FE3 RID: 12259
+		public extern DirectorWrapMode extrapolationMode
+		{
+			[GeneratedByOldBindingsGenerator]
+			[MethodImpl(MethodImplOptions.InternalCall)]
+			get;
+			[GeneratedByOldBindingsGenerator]
+			[MethodImpl(MethodImplOptions.InternalCall)]
+			set;
+		}
+
+		// Token: 0x17000AEA RID: 2794
+		// (get) Token: 0x06002FE4 RID: 12260
+		// (set) Token: 0x06002FE5 RID: 12261
+		public extern DirectorUpdateMode timeUpdateMode
+		{
+			[GeneratedByOldBindingsGenerator]
+			[MethodImpl(MethodImplOptions.InternalCall)]
+			get;
+			[GeneratedByOldBindingsGenerator]
+			[MethodImpl(MethodImplOptions.InternalCall)]
+			set;
+		}
+
+		// Token: 0x17000AEB RID: 2795
+		// (get) Token: 0x06002FE6 RID: 12262
+		// (set) Token: 0x06002FE7 RID: 12263
+		public extern double time
+		{
+			[GeneratedByOldBindingsGenerator]
+			[MethodImpl(MethodImplOptions.InternalCall)]
+			get;
+			[GeneratedByOldBindingsGenerator]
+			[MethodImpl(MethodImplOptions.InternalCall)]
+			set;
+		}
+
+		// Token: 0x17000AEC RID: 2796
+		// (get) Token: 0x06002FE8 RID: 12264
+		// (set) Token: 0x06002FE9 RID: 12265
+		public extern double initialTime
+		{
+			[GeneratedByOldBindingsGenerator]
+			[MethodImpl(MethodImplOptions.InternalCall)]
+			get;
+			[GeneratedByOldBindingsGenerator]
+			[MethodImpl(MethodImplOptions.InternalCall)]
+			set;
+		}
+
+		// Token: 0x17000AED RID: 2797
+		// (get) Token: 0x06002FEA RID: 12266
+		public extern double duration
+		{
+			[GeneratedByOldBindingsGenerator]
+			[MethodImpl(MethodImplOptions.InternalCall)]
+			get;
+		}
+
+		// Token: 0x06002FEB RID: 12267
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public extern void Evaluate();
+
+		// Token: 0x06002FEC RID: 12268
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public extern void DeferredEvaluate();
+
+		// Token: 0x06002FED RID: 12269 RVA: 0x0004602C File Offset: 0x0004422C
+		public void Play(PlayableAsset asset)
+		{
+			if (asset == null)
+			{
+				throw new ArgumentNullException("asset");
+			}
+			this.Play(asset, this.extrapolationMode);
+		}
+
+		// Token: 0x06002FEE RID: 12270 RVA: 0x00046054 File Offset: 0x00044254
+		public void Play(PlayableAsset asset, DirectorWrapMode mode)
+		{
+			if (asset == null)
+			{
+				throw new ArgumentNullException("asset");
+			}
+			this.playableAsset = asset;
+			this.extrapolationMode = mode;
+			this.Play();
+		}
+
+		// Token: 0x06002FEF RID: 12271
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private extern void SetPlayableAssetInternal(ScriptableObject asset);
+
+		// Token: 0x06002FF0 RID: 12272
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private extern ScriptableObject GetPlayableAssetInternal();
+
+		// Token: 0x06002FF1 RID: 12273
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public extern void Play();
+
+		// Token: 0x06002FF2 RID: 12274
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public extern void Stop();
+
+		// Token: 0x06002FF3 RID: 12275
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		internal extern void StopImmediately();
+
+		// Token: 0x06002FF4 RID: 12276
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public extern void Pause();
+
+		// Token: 0x06002FF5 RID: 12277
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public extern void Resume();
+
+		// Token: 0x06002FF6 RID: 12278 RVA: 0x00046084 File Offset: 0x00044284
+		public void SetReferenceValue(PropertyName id, Object value)
+		{
+			PlayableDirector.INTERNAL_CALL_SetReferenceValue(this, ref id, value);
+		}
+
+		// Token: 0x06002FF7 RID: 12279
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_SetReferenceValue(PlayableDirector self, ref PropertyName id, Object value);
+
+		// Token: 0x06002FF8 RID: 12280 RVA: 0x00046090 File Offset: 0x00044290
+		public Object GetReferenceValue(PropertyName id, out bool idValid)
+		{
+			return PlayableDirector.INTERNAL_CALL_GetReferenceValue(this, ref id, out idValid);
+		}
+
+		// Token: 0x06002FF9 RID: 12281
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern Object INTERNAL_CALL_GetReferenceValue(PlayableDirector self, ref PropertyName id, out bool idValid);
+
+		// Token: 0x06002FFA RID: 12282 RVA: 0x000460B0 File Offset: 0x000442B0
+		public void ClearReferenceValue(PropertyName id)
+		{
+			PlayableDirector.INTERNAL_CALL_ClearReferenceValue(this, ref id);
+		}
+
+		// Token: 0x06002FFB RID: 12283
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_ClearReferenceValue(PlayableDirector self, ref PropertyName id);
+
+		// Token: 0x17000AEE RID: 2798
+		// (get) Token: 0x06002FFC RID: 12284 RVA: 0x000460BC File Offset: 0x000442BC
+		public PlayableGraph playableGraph
+		{
+			get
+			{
+				PlayableGraph playableGraph = default(PlayableGraph);
+				this.InternalGetCurrentGraph(ref playableGraph);
+				return playableGraph;
+			}
+		}
+
+		// Token: 0x06002FFD RID: 12285 RVA: 0x000460E4 File Offset: 0x000442E4
+		private void InternalGetCurrentGraph(ref PlayableGraph graph)
+		{
+			PlayableDirector.INTERNAL_CALL_InternalGetCurrentGraph(this, ref graph);
+		}
+
+		// Token: 0x06002FFE RID: 12286
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_InternalGetCurrentGraph(PlayableDirector self, ref PlayableGraph graph);
+
+		// Token: 0x06002FFF RID: 12287
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public extern void SetGenericBinding(Object key, Object value);
+
+		// Token: 0x06003000 RID: 12288
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public extern Object GetGenericBinding(Object key);
+
+		// Token: 0x06003001 RID: 12289
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		internal extern bool HasGenericBinding(Object key);
+	}
+}
@@ -0,0 +1,184 @@
+using System;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020004BE RID: 1214
+	public static class PlayableExtensions
+	{
+		// Token: 0x06003B44 RID: 15172 RVA: 0x00067E20 File Offset: 0x00066020
+		public static bool IsValid<U>(this U playable) where U : struct, IPlayable
+		{
+			return playable.GetHandle().IsValid();
+		}
+
+		// Token: 0x06003B45 RID: 15173 RVA: 0x00067E4C File Offset: 0x0006604C
+		public static void Destroy<U>(this U playable) where U : struct, IPlayable
+		{
+			playable.GetHandle().Destroy();
+		}
+
+		// Token: 0x06003B46 RID: 15174 RVA: 0x00067E70 File Offset: 0x00066070
+		public static PlayableGraph GetGraph<U>(this U playable) where U : struct, IPlayable
+		{
+			return playable.GetHandle().GetGraph();
+		}
+
+		// Token: 0x06003B47 RID: 15175 RVA: 0x00067E9C File Offset: 0x0006609C
+		public static void SetPlayState<U>(this U playable, PlayState value) where U : struct, IPlayable
+		{
+			playable.GetHandle().SetPlayState(value);
+		}
+
+		// Token: 0x06003B48 RID: 15176 RVA: 0x00067EC0 File Offset: 0x000660C0
+		public static PlayState GetPlayState<U>(this U playable) where U : struct, IPlayable
+		{
+			return playable.GetHandle().GetPlayState();
+		}
+
+		// Token: 0x06003B49 RID: 15177 RVA: 0x00067EEC File Offset: 0x000660EC
+		public static void SetSpeed<U>(this U playable, double value) where U : struct, IPlayable
+		{
+			playable.GetHandle().SetSpeed(value);
+		}
+
+		// Token: 0x06003B4A RID: 15178 RVA: 0x00067F10 File Offset: 0x00066110
+		public static double GetSpeed<U>(this U playable) where U : struct, IPlayable
+		{
+			return playable.GetHandle().GetSpeed();
+		}
+
+		// Token: 0x06003B4B RID: 15179 RVA: 0x00067F3C File Offset: 0x0006613C
+		public static void SetDuration<U>(this U playable, double value) where U : struct, IPlayable
+		{
+			playable.GetHandle().SetDuration(value);
+		}
+
+		// Token: 0x06003B4C RID: 15180 RVA: 0x00067F60 File Offset: 0x00066160
+		public static double GetDuration<U>(this U playable) where U : struct, IPlayable
+		{
+			return playable.GetHandle().GetDuration();
+		}
+
+		// Token: 0x06003B4D RID: 15181 RVA: 0x00067F8C File Offset: 0x0006618C
+		public static void SetTime<U>(this U playable, double value) where U : struct, IPlayable
+		{
+			playable.GetHandle().SetTime(value);
+		}
+
+		// Token: 0x06003B4E RID: 15182 RVA: 0x00067FB0 File Offset: 0x000661B0
+		public static double GetTime<U>(this U playable) where U : struct, IPlayable
+		{
+			return playable.GetHandle().GetTime();
+		}
+
+		// Token: 0x06003B4F RID: 15183 RVA: 0x00067FDC File Offset: 0x000661DC
+		public static void SetDone<U>(this U playable, bool value) where U : struct, IPlayable
+		{
+			playable.GetHandle().SetDone(value);
+		}
+
+		// Token: 0x06003B50 RID: 15184 RVA: 0x00068000 File Offset: 0x00066200
+		public static bool IsDone<U>(this U playable) where U : struct, IPlayable
+		{
+			return playable.GetHandle().IsDone();
+		}
+
+		// Token: 0x06003B51 RID: 15185 RVA: 0x0006802C File Offset: 0x0006622C
+		public static void SetPropagateSetTime<U>(this U playable, bool value) where U : struct, IPlayable
+		{
+			playable.GetHandle().SetPropagateSetTime(value);
+		}
+
+		// Token: 0x06003B52 RID: 15186 RVA: 0x00068050 File Offset: 0x00066250
+		public static bool GetPropagateSetTime<U>(this U playable) where U : struct, IPlayable
+		{
+			return playable.GetHandle().GetPropagateSetTime();
+		}
+
+		// Token: 0x06003B53 RID: 15187 RVA: 0x0006807C File Offset: 0x0006627C
+		public static bool CanChangeInputs<U>(this U playable) where U : struct, IPlayable
+		{
+			return playable.GetHandle().CanChangeInputs();
+		}
+
+		// Token: 0x06003B54 RID: 15188 RVA: 0x000680A8 File Offset: 0x000662A8
+		public static bool CanSetWeights<U>(this U playable) where U : struct, IPlayable
+		{
+			return playable.GetHandle().CanSetWeights();
+		}
+
+		// Token: 0x06003B55 RID: 15189 RVA: 0x000680D4 File Offset: 0x000662D4
+		public static bool CanDestroy<U>(this U playable) where U : struct, IPlayable
+		{
+			return playable.GetHandle().CanDestroy();
+		}
+
+		// Token: 0x06003B56 RID: 15190 RVA: 0x00068100 File Offset: 0x00066300
+		public static void SetInputCount<U>(this U playable, int value) where U : struct, IPlayable
+		{
+			playable.GetHandle().SetInputCount(value);
+		}
+
+		// Token: 0x06003B57 RID: 15191 RVA: 0x00068124 File Offset: 0x00066324
+		public static int GetInputCount<U>(this U playable) where U : struct, IPlayable
+		{
+			return playable.GetHandle().GetInputCount();
+		}
+
+		// Token: 0x06003B58 RID: 15192 RVA: 0x00068150 File Offset: 0x00066350
+		public static void SetOutputCount<U>(this U playable, int value) where U : struct, IPlayable
+		{
+			playable.GetHandle().SetOutputCount(value);
+		}
+
+		// Token: 0x06003B59 RID: 15193 RVA: 0x00068174 File Offset: 0x00066374
+		public static int GetOutputCount<U>(this U playable) where U : struct, IPlayable
+		{
+			return playable.GetHandle().GetOutputCount();
+		}
+
+		// Token: 0x06003B5A RID: 15194 RVA: 0x000681A0 File Offset: 0x000663A0
+		public static Playable GetInput<U>(this U playable, int inputPort) where U : struct, IPlayable
+		{
+			return playable.GetHandle().GetInput(inputPort);
+		}
+
+		// Token: 0x06003B5B RID: 15195 RVA: 0x000681CC File Offset: 0x000663CC
+		public static Playable GetOutput<U>(this U playable, int outputPort) where U : struct, IPlayable
+		{
+			return playable.GetHandle().GetOutput(outputPort);
+		}
+
+		// Token: 0x06003B5C RID: 15196 RVA: 0x000681F8 File Offset: 0x000663F8
+		public static void SetInputWeight<U>(this U playable, int inputIndex, float weight) where U : struct, IPlayable
+		{
+			playable.GetHandle().SetInputWeight(inputIndex, weight);
+		}
+
+		// Token: 0x06003B5D RID: 15197 RVA: 0x00068220 File Offset: 0x00066420
+		public static void SetInputWeight<U, V>(this U playable, V input, float weight) where U : struct, IPlayable where V : struct, IPlayable
+		{
+			playable.GetHandle().SetInputWeight(input.GetHandle(), weight);
+		}
+
+		// Token: 0x06003B5E RID: 15198 RVA: 0x00068254 File Offset: 0x00066454
+		public static float GetInputWeight<U>(this U playable, int inputIndex) where U : struct, IPlayable
+		{
+			return playable.GetHandle().GetInputWeight(inputIndex);
+		}
+
+		// Token: 0x06003B5F RID: 15199 RVA: 0x00068280 File Offset: 0x00066480
+		public static void ConnectInput<U, V>(this U playable, int inputIndex, V sourcePlayable, int sourceOutputIndex) where U : struct, IPlayable where V : struct, IPlayable
+		{
+			playable.GetGraph<U>().Connect<V, U>(sourcePlayable, sourceOutputIndex, playable, inputIndex);
+		}
+
+		// Token: 0x06003B60 RID: 15200 RVA: 0x000682A4 File Offset: 0x000664A4
+		public static void AddInput<U, V>(this U playable, V sourcePlayable, int sourceOutputIndex) where U : struct, IPlayable where V : struct, IPlayable
+		{
+			int inputCount = playable.GetInputCount<U>();
+			playable.SetInputCount(inputCount + 1);
+			playable.ConnectInput(inputCount, sourcePlayable, sourceOutputIndex);
+		}
+	}
+}
@@ -0,0 +1,496 @@
+using System;
+using System.Runtime.CompilerServices;
+using UnityEngine.Internal;
+using UnityEngine.Scripting;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020000E4 RID: 228
+	[UsedByNativeCode]
+	public struct PlayableGraph
+	{
+		// Token: 0x060010B7 RID: 4279 RVA: 0x00016788 File Offset: 0x00014988
+		public bool IsValid()
+		{
+			return PlayableGraph.IsValidInternal(ref this);
+		}
+
+		// Token: 0x060010B8 RID: 4280 RVA: 0x000167A4 File Offset: 0x000149A4
+		private static bool IsValidInternal(ref PlayableGraph graph)
+		{
+			return PlayableGraph.INTERNAL_CALL_IsValidInternal(ref graph);
+		}
+
+		// Token: 0x060010B9 RID: 4281
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool INTERNAL_CALL_IsValidInternal(ref PlayableGraph graph);
+
+		// Token: 0x060010BA RID: 4282 RVA: 0x000167C0 File Offset: 0x000149C0
+		public static PlayableGraph Create()
+		{
+			PlayableGraph playableGraph = default(PlayableGraph);
+			PlayableGraph.CreateInternal(ref playableGraph);
+			return playableGraph;
+		}
+
+		// Token: 0x060010BB RID: 4283 RVA: 0x000167E8 File Offset: 0x000149E8
+		internal static void CreateInternal(ref PlayableGraph graph)
+		{
+			PlayableGraph.INTERNAL_CALL_CreateInternal(ref graph);
+		}
+
+		// Token: 0x060010BC RID: 4284
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_CreateInternal(ref PlayableGraph graph);
+
+		// Token: 0x060010BD RID: 4285 RVA: 0x000167F4 File Offset: 0x000149F4
+		public bool IsDone()
+		{
+			return PlayableGraph.IsDoneInternal(ref this);
+		}
+
+		// Token: 0x060010BE RID: 4286 RVA: 0x00016810 File Offset: 0x00014A10
+		internal static bool IsDoneInternal(ref PlayableGraph graph)
+		{
+			return PlayableGraph.INTERNAL_CALL_IsDoneInternal(ref graph);
+		}
+
+		// Token: 0x060010BF RID: 4287
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool INTERNAL_CALL_IsDoneInternal(ref PlayableGraph graph);
+
+		// Token: 0x060010C0 RID: 4288 RVA: 0x0001682C File Offset: 0x00014A2C
+		public bool IsPlaying()
+		{
+			return PlayableGraph.IsPlayingInternal(ref this);
+		}
+
+		// Token: 0x060010C1 RID: 4289 RVA: 0x00016848 File Offset: 0x00014A48
+		internal static bool IsPlayingInternal(ref PlayableGraph graph)
+		{
+			return PlayableGraph.INTERNAL_CALL_IsPlayingInternal(ref graph);
+		}
+
+		// Token: 0x060010C2 RID: 4290
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool INTERNAL_CALL_IsPlayingInternal(ref PlayableGraph graph);
+
+		// Token: 0x060010C3 RID: 4291 RVA: 0x00016864 File Offset: 0x00014A64
+		public IExposedPropertyTable GetResolver()
+		{
+			return PlayableGraph.GetResolverInternal(ref this);
+		}
+
+		// Token: 0x060010C4 RID: 4292 RVA: 0x00016880 File Offset: 0x00014A80
+		public void SetResolver(IExposedPropertyTable value)
+		{
+			PlayableGraph.SetResolverInternal(ref this, value);
+		}
+
+		// Token: 0x060010C5 RID: 4293 RVA: 0x0001688C File Offset: 0x00014A8C
+		internal static IExposedPropertyTable GetResolverInternal(ref PlayableGraph graph)
+		{
+			return PlayableGraph.INTERNAL_CALL_GetResolverInternal(ref graph);
+		}
+
+		// Token: 0x060010C6 RID: 4294
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern IExposedPropertyTable INTERNAL_CALL_GetResolverInternal(ref PlayableGraph graph);
+
+		// Token: 0x060010C7 RID: 4295 RVA: 0x000168A8 File Offset: 0x00014AA8
+		internal static void SetResolverInternal(ref PlayableGraph graph, IExposedPropertyTable resolver)
+		{
+			PlayableGraph.INTERNAL_CALL_SetResolverInternal(ref graph, resolver);
+		}
+
+		// Token: 0x060010C8 RID: 4296
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_SetResolverInternal(ref PlayableGraph graph, IExposedPropertyTable resolver);
+
+		// Token: 0x060010C9 RID: 4297 RVA: 0x000168B4 File Offset: 0x00014AB4
+		public void Play()
+		{
+			PlayableGraph.PlayInternal(ref this);
+		}
+
+		// Token: 0x060010CA RID: 4298 RVA: 0x000168C0 File Offset: 0x00014AC0
+		internal static void PlayInternal(ref PlayableGraph graph)
+		{
+			PlayableGraph.INTERNAL_CALL_PlayInternal(ref graph);
+		}
+
+		// Token: 0x060010CB RID: 4299
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_PlayInternal(ref PlayableGraph graph);
+
+		// Token: 0x060010CC RID: 4300 RVA: 0x000168CC File Offset: 0x00014ACC
+		public void Stop()
+		{
+			PlayableGraph.StopInternal(ref this);
+		}
+
+		// Token: 0x060010CD RID: 4301 RVA: 0x000168D8 File Offset: 0x00014AD8
+		internal static void StopInternal(ref PlayableGraph graph)
+		{
+			PlayableGraph.INTERNAL_CALL_StopInternal(ref graph);
+		}
+
+		// Token: 0x060010CE RID: 4302
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_StopInternal(ref PlayableGraph graph);
+
+		// Token: 0x060010CF RID: 4303 RVA: 0x000168E4 File Offset: 0x00014AE4
+		public int GetPlayableCount()
+		{
+			return PlayableGraph.GetPlayableCountInternal(ref this);
+		}
+
+		// Token: 0x060010D0 RID: 4304 RVA: 0x00016900 File Offset: 0x00014B00
+		internal static int GetPlayableCountInternal(ref PlayableGraph graph)
+		{
+			return PlayableGraph.INTERNAL_CALL_GetPlayableCountInternal(ref graph);
+		}
+
+		// Token: 0x060010D1 RID: 4305
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern int INTERNAL_CALL_GetPlayableCountInternal(ref PlayableGraph graph);
+
+		// Token: 0x060010D2 RID: 4306 RVA: 0x0001691C File Offset: 0x00014B1C
+		public DirectorUpdateMode GetTimeUpdateMode()
+		{
+			return PlayableGraph.GetUpdateModeInternal(ref this);
+		}
+
+		// Token: 0x060010D3 RID: 4307 RVA: 0x00016938 File Offset: 0x00014B38
+		public void SetTimeUpdateMode(DirectorUpdateMode value)
+		{
+			PlayableGraph.SetUpdateModeInternal(ref this, value);
+		}
+
+		// Token: 0x060010D4 RID: 4308 RVA: 0x00016944 File Offset: 0x00014B44
+		private static DirectorUpdateMode GetUpdateModeInternal(ref PlayableGraph graph)
+		{
+			return PlayableGraph.INTERNAL_CALL_GetUpdateModeInternal(ref graph);
+		}
+
+		// Token: 0x060010D5 RID: 4309
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern DirectorUpdateMode INTERNAL_CALL_GetUpdateModeInternal(ref PlayableGraph graph);
+
+		// Token: 0x060010D6 RID: 4310 RVA: 0x00016960 File Offset: 0x00014B60
+		private static void SetUpdateModeInternal(ref PlayableGraph graph, DirectorUpdateMode mode)
+		{
+			PlayableGraph.INTERNAL_CALL_SetUpdateModeInternal(ref graph, mode);
+		}
+
+		// Token: 0x060010D7 RID: 4311
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_SetUpdateModeInternal(ref PlayableGraph graph, DirectorUpdateMode mode);
+
+		// Token: 0x060010D8 RID: 4312 RVA: 0x0001696C File Offset: 0x00014B6C
+		internal static bool CreateScriptOutputInternal(ref PlayableGraph graph, string name, out PlayableOutputHandle handle)
+		{
+			return PlayableGraph.INTERNAL_CALL_CreateScriptOutputInternal(ref graph, name, out handle);
+		}
+
+		// Token: 0x060010D9 RID: 4313
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool INTERNAL_CALL_CreateScriptOutputInternal(ref PlayableGraph graph, string name, out PlayableOutputHandle handle);
+
+		// Token: 0x060010DA RID: 4314 RVA: 0x0001698C File Offset: 0x00014B8C
+		internal PlayableHandle CreatePlayableHandle()
+		{
+			PlayableHandle @null = PlayableHandle.Null;
+			PlayableHandle playableHandle;
+			if (!PlayableGraph.CreatePlayableHandleInternal(ref this, ref @null))
+			{
+				playableHandle = PlayableHandle.Null;
+			}
+			else
+			{
+				playableHandle = @null;
+			}
+			return playableHandle;
+		}
+
+		// Token: 0x060010DB RID: 4315 RVA: 0x000169C0 File Offset: 0x00014BC0
+		private static bool CreatePlayableHandleInternal(ref PlayableGraph graph, ref PlayableHandle handle)
+		{
+			return PlayableGraph.INTERNAL_CALL_CreatePlayableHandleInternal(ref graph, ref handle);
+		}
+
+		// Token: 0x060010DC RID: 4316
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool INTERNAL_CALL_CreatePlayableHandleInternal(ref PlayableGraph graph, ref PlayableHandle handle);
+
+		// Token: 0x060010DD RID: 4317 RVA: 0x000169DC File Offset: 0x00014BDC
+		public void Destroy()
+		{
+			PlayableGraph.DestroyInternal(ref this);
+		}
+
+		// Token: 0x060010DE RID: 4318 RVA: 0x000169E8 File Offset: 0x00014BE8
+		private static void DestroyInternal(ref PlayableGraph graph)
+		{
+			PlayableGraph.INTERNAL_CALL_DestroyInternal(ref graph);
+		}
+
+		// Token: 0x060010DF RID: 4319
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_DestroyInternal(ref PlayableGraph graph);
+
+		// Token: 0x060010E0 RID: 4320 RVA: 0x000169F4 File Offset: 0x00014BF4
+		private static bool ConnectInternal(ref PlayableGraph graph, PlayableHandle source, int sourceOutputPort, PlayableHandle destination, int destinationInputPort)
+		{
+			return PlayableGraph.INTERNAL_CALL_ConnectInternal(ref graph, ref source, sourceOutputPort, ref destination, destinationInputPort);
+		}
+
+		// Token: 0x060010E1 RID: 4321
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool INTERNAL_CALL_ConnectInternal(ref PlayableGraph graph, ref PlayableHandle source, int sourceOutputPort, ref PlayableHandle destination, int destinationInputPort);
+
+		// Token: 0x060010E2 RID: 4322 RVA: 0x00016A18 File Offset: 0x00014C18
+		private static void DisconnectInternal(ref PlayableGraph graph, PlayableHandle playable, int inputPort)
+		{
+			PlayableGraph.INTERNAL_CALL_DisconnectInternal(ref graph, ref playable, inputPort);
+		}
+
+		// Token: 0x060010E3 RID: 4323
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_DisconnectInternal(ref PlayableGraph graph, ref PlayableHandle playable, int inputPort);
+
+		// Token: 0x060010E4 RID: 4324 RVA: 0x00016A24 File Offset: 0x00014C24
+		private static void DestroyPlayableInternal(ref PlayableGraph graph, PlayableHandle playable)
+		{
+			PlayableGraph.INTERNAL_CALL_DestroyPlayableInternal(ref graph, ref playable);
+		}
+
+		// Token: 0x060010E5 RID: 4325
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_DestroyPlayableInternal(ref PlayableGraph graph, ref PlayableHandle playable);
+
+		// Token: 0x060010E6 RID: 4326 RVA: 0x00016A30 File Offset: 0x00014C30
+		internal static void DestroyOutputInternal(ref PlayableGraph graph, PlayableOutputHandle handle)
+		{
+			PlayableGraph.INTERNAL_CALL_DestroyOutputInternal(ref graph, ref handle);
+		}
+
+		// Token: 0x060010E7 RID: 4327
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_DestroyOutputInternal(ref PlayableGraph graph, ref PlayableOutputHandle handle);
+
+		// Token: 0x060010E8 RID: 4328 RVA: 0x00016A3C File Offset: 0x00014C3C
+		private static void DestroySubgraphInternal(ref PlayableGraph graph, PlayableHandle playable)
+		{
+			PlayableGraph.INTERNAL_CALL_DestroySubgraphInternal(ref graph, ref playable);
+		}
+
+		// Token: 0x060010E9 RID: 4329
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_DestroySubgraphInternal(ref PlayableGraph graph, ref PlayableHandle playable);
+
+		// Token: 0x060010EA RID: 4330 RVA: 0x00016A48 File Offset: 0x00014C48
+		[ExcludeFromDocs]
+		public void Evaluate()
+		{
+			float num = 0f;
+			this.Evaluate(num);
+		}
+
+		// Token: 0x060010EB RID: 4331 RVA: 0x00016A64 File Offset: 0x00014C64
+		public void Evaluate([DefaultValue("0")] float deltaTime)
+		{
+			PlayableGraph.EvaluateInternal(ref this, deltaTime);
+		}
+
+		// Token: 0x060010EC RID: 4332 RVA: 0x00016A70 File Offset: 0x00014C70
+		internal static void EvaluateInternal(ref PlayableGraph graph, float deltaTime)
+		{
+			PlayableGraph.INTERNAL_CALL_EvaluateInternal(ref graph, deltaTime);
+		}
+
+		// Token: 0x060010ED RID: 4333
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_EvaluateInternal(ref PlayableGraph graph, float deltaTime);
+
+		// Token: 0x060010EE RID: 4334 RVA: 0x00016A7C File Offset: 0x00014C7C
+		public int GetRootPlayableCount()
+		{
+			return PlayableGraph.GetRootPlayableCountInternal(ref this);
+		}
+
+		// Token: 0x060010EF RID: 4335 RVA: 0x00016A98 File Offset: 0x00014C98
+		internal static int GetRootPlayableCountInternal(ref PlayableGraph graph)
+		{
+			return PlayableGraph.INTERNAL_CALL_GetRootPlayableCountInternal(ref graph);
+		}
+
+		// Token: 0x060010F0 RID: 4336
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern int INTERNAL_CALL_GetRootPlayableCountInternal(ref PlayableGraph graph);
+
+		// Token: 0x060010F1 RID: 4337 RVA: 0x00016AB4 File Offset: 0x00014CB4
+		public Playable GetRootPlayable(int index)
+		{
+			PlayableHandle @null = PlayableHandle.Null;
+			PlayableGraph.GetRootPlayableInternal(index, ref this, ref @null);
+			return new Playable(@null);
+		}
+
+		// Token: 0x060010F2 RID: 4338 RVA: 0x00016AE0 File Offset: 0x00014CE0
+		internal static void GetRootPlayableInternal(int index, ref PlayableGraph graph, ref PlayableHandle handle)
+		{
+			PlayableGraph.INTERNAL_CALL_GetRootPlayableInternal(index, ref graph, ref handle);
+		}
+
+		// Token: 0x060010F3 RID: 4339
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_GetRootPlayableInternal(int index, ref PlayableGraph graph, ref PlayableHandle handle);
+
+		// Token: 0x060010F4 RID: 4340 RVA: 0x00016AEC File Offset: 0x00014CEC
+		private static int GetOutputCountInternal(ref PlayableGraph graph)
+		{
+			return PlayableGraph.INTERNAL_CALL_GetOutputCountInternal(ref graph);
+		}
+
+		// Token: 0x060010F5 RID: 4341
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern int INTERNAL_CALL_GetOutputCountInternal(ref PlayableGraph graph);
+
+		// Token: 0x060010F6 RID: 4342 RVA: 0x00016B08 File Offset: 0x00014D08
+		private static bool GetOutputInternal(ref PlayableGraph graph, int index, out PlayableOutputHandle handle)
+		{
+			return PlayableGraph.INTERNAL_CALL_GetOutputInternal(ref graph, index, out handle);
+		}
+
+		// Token: 0x060010F7 RID: 4343
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool INTERNAL_CALL_GetOutputInternal(ref PlayableGraph graph, int index, out PlayableOutputHandle handle);
+
+		// Token: 0x060010F8 RID: 4344 RVA: 0x00016B28 File Offset: 0x00014D28
+		private static int GetOutputCountByTypeInternal(ref PlayableGraph graph, Type outputType)
+		{
+			return PlayableGraph.INTERNAL_CALL_GetOutputCountByTypeInternal(ref graph, outputType);
+		}
+
+		// Token: 0x060010F9 RID: 4345
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern int INTERNAL_CALL_GetOutputCountByTypeInternal(ref PlayableGraph graph, Type outputType);
+
+		// Token: 0x060010FA RID: 4346 RVA: 0x00016B44 File Offset: 0x00014D44
+		private static bool GetOutputByTypeInternal(ref PlayableGraph graph, Type outputType, int index, out PlayableOutputHandle handle)
+		{
+			return PlayableGraph.INTERNAL_CALL_GetOutputByTypeInternal(ref graph, outputType, index, out handle);
+		}
+
+		// Token: 0x060010FB RID: 4347
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool INTERNAL_CALL_GetOutputByTypeInternal(ref PlayableGraph graph, Type outputType, int index, out PlayableOutputHandle handle);
+
+		// Token: 0x060010FC RID: 4348 RVA: 0x00016B64 File Offset: 0x00014D64
+		public bool Connect<U, V>(U source, int sourceOutputPort, V destination, int destinationInputPort) where U : struct, IPlayable where V : struct, IPlayable
+		{
+			return PlayableGraph.ConnectInternal(ref this, source.GetHandle(), sourceOutputPort, destination.GetHandle(), destinationInputPort);
+		}
+
+		// Token: 0x060010FD RID: 4349 RVA: 0x00016B9C File Offset: 0x00014D9C
+		public void Disconnect<U>(U input, int inputPort) where U : struct, IPlayable
+		{
+			PlayableGraph.DisconnectInternal(ref this, input.GetHandle(), inputPort);
+		}
+
+		// Token: 0x060010FE RID: 4350 RVA: 0x00016BB4 File Offset: 0x00014DB4
+		public void DestroyPlayable<U>(U playable) where U : struct, IPlayable
+		{
+			PlayableGraph.DestroyPlayableInternal(ref this, playable.GetHandle());
+		}
+
+		// Token: 0x060010FF RID: 4351 RVA: 0x00016BCC File Offset: 0x00014DCC
+		public void DestroySubgraph<U>(U playable) where U : struct, IPlayable
+		{
+			PlayableGraph.DestroySubgraphInternal(ref this, playable.GetHandle());
+		}
+
+		// Token: 0x06001100 RID: 4352 RVA: 0x00016BE4 File Offset: 0x00014DE4
+		public void DestroyOutput<U>(U output) where U : struct, IPlayableOutput
+		{
+			PlayableGraph.DestroyOutputInternal(ref this, output.GetHandle());
+		}
+
+		// Token: 0x06001101 RID: 4353 RVA: 0x00016BFC File Offset: 0x00014DFC
+		public int GetOutputCount()
+		{
+			return PlayableGraph.GetOutputCountInternal(ref this);
+		}
+
+		// Token: 0x06001102 RID: 4354 RVA: 0x00016C18 File Offset: 0x00014E18
+		public int GetOutputCountByType<T>() where T : struct, IPlayableOutput
+		{
+			return PlayableGraph.GetOutputCountByTypeInternal(ref this, typeof(T));
+		}
+
+		// Token: 0x06001103 RID: 4355 RVA: 0x00016C40 File Offset: 0x00014E40
+		public PlayableOutput GetOutput(int index)
+		{
+			PlayableOutputHandle playableOutputHandle;
+			PlayableOutput playableOutput;
+			if (!PlayableGraph.GetOutputInternal(ref this, index, out playableOutputHandle))
+			{
+				playableOutput = PlayableOutput.Null;
+			}
+			else
+			{
+				playableOutput = new PlayableOutput(playableOutputHandle);
+			}
+			return playableOutput;
+		}
+
+		// Token: 0x06001104 RID: 4356 RVA: 0x00016C74 File Offset: 0x00014E74
+		public PlayableOutput GetOutputByType<T>(int index) where T : struct, IPlayableOutput
+		{
+			PlayableOutputHandle playableOutputHandle;
+			PlayableOutput playableOutput;
+			if (!PlayableGraph.GetOutputByTypeInternal(ref this, typeof(T), index, out playableOutputHandle))
+			{
+				playableOutput = PlayableOutput.Null;
+			}
+			else
+			{
+				playableOutput = new PlayableOutput(playableOutputHandle);
+			}
+			return playableOutput;
+		}
+
+		// Token: 0x04000218 RID: 536
+		internal IntPtr m_Handle;
+
+		// Token: 0x04000219 RID: 537
+		internal int m_Version;
+	}
+}
@@ -0,0 +1,643 @@
+using System;
+using System.Runtime.CompilerServices;
+using UnityEngine.Scripting;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020000E0 RID: 224
+	[UsedByNativeCode]
+	public struct PlayableHandle
+	{
+		// Token: 0x0600104E RID: 4174 RVA: 0x00015F08 File Offset: 0x00014108
+		internal T GetObject<T>() where T : class, IPlayableBehaviour
+		{
+			T t;
+			if (!this.IsValid())
+			{
+				t = (T)((object)null);
+			}
+			else
+			{
+				object scriptInstance = PlayableHandle.GetScriptInstance(ref this);
+				if (scriptInstance == null)
+				{
+					t = (T)((object)null);
+				}
+				else
+				{
+					t = (T)((object)scriptInstance);
+				}
+			}
+			return t;
+		}
+
+		// Token: 0x0600104F RID: 4175 RVA: 0x00015F54 File Offset: 0x00014154
+		private static object GetScriptInstance(ref PlayableHandle playable)
+		{
+			return PlayableHandle.INTERNAL_CALL_GetScriptInstance(ref playable);
+		}
+
+		// Token: 0x06001050 RID: 4176
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern object INTERNAL_CALL_GetScriptInstance(ref PlayableHandle playable);
+
+		// Token: 0x06001051 RID: 4177 RVA: 0x00015F70 File Offset: 0x00014170
+		internal void SetScriptInstance(object scriptInstance)
+		{
+			PlayableHandle.SetScriptInstance(ref this, scriptInstance);
+		}
+
+		// Token: 0x06001052 RID: 4178 RVA: 0x00015F7C File Offset: 0x0001417C
+		private static void SetScriptInstance(ref PlayableHandle playable, object scriptInstance)
+		{
+			PlayableHandle.INTERNAL_CALL_SetScriptInstance(ref playable, scriptInstance);
+		}
+
+		// Token: 0x06001053 RID: 4179
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_SetScriptInstance(ref PlayableHandle playable, object scriptInstance);
+
+		// Token: 0x06001054 RID: 4180 RVA: 0x00015F88 File Offset: 0x00014188
+		internal bool IsValid()
+		{
+			return PlayableHandle.IsValidInternal(ref this);
+		}
+
+		// Token: 0x06001055 RID: 4181 RVA: 0x00015FA4 File Offset: 0x000141A4
+		private static bool IsValidInternal(ref PlayableHandle playable)
+		{
+			return PlayableHandle.INTERNAL_CALL_IsValidInternal(ref playable);
+		}
+
+		// Token: 0x06001056 RID: 4182
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool INTERNAL_CALL_IsValidInternal(ref PlayableHandle playable);
+
+		// Token: 0x06001057 RID: 4183 RVA: 0x00015FC0 File Offset: 0x000141C0
+		private static Type GetPlayableTypeOf(ref PlayableHandle playable)
+		{
+			return PlayableHandle.INTERNAL_CALL_GetPlayableTypeOf(ref playable);
+		}
+
+		// Token: 0x06001058 RID: 4184
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern Type INTERNAL_CALL_GetPlayableTypeOf(ref PlayableHandle playable);
+
+		// Token: 0x06001059 RID: 4185 RVA: 0x00015FDC File Offset: 0x000141DC
+		internal Type GetPlayableType()
+		{
+			return PlayableHandle.GetPlayableTypeOf(ref this);
+		}
+
+		// Token: 0x0600105A RID: 4186 RVA: 0x00015FF8 File Offset: 0x000141F8
+		internal bool IsPlayableOfType<T>()
+		{
+			return PlayableHandle.GetPlayableTypeOf(ref this) == typeof(T);
+		}
+
+		// Token: 0x1700036C RID: 876
+		// (get) Token: 0x0600105B RID: 4187 RVA: 0x00016020 File Offset: 0x00014220
+		public static PlayableHandle Null
+		{
+			get
+			{
+				return new PlayableHandle
+				{
+					m_Version = 10
+				};
+			}
+		}
+
+		// Token: 0x0600105C RID: 4188 RVA: 0x00016048 File Offset: 0x00014248
+		internal PlayableGraph GetGraph()
+		{
+			PlayableGraph playableGraph = default(PlayableGraph);
+			PlayableHandle.GetGraphInternal(ref this, ref playableGraph);
+			return playableGraph;
+		}
+
+		// Token: 0x0600105D RID: 4189 RVA: 0x00016070 File Offset: 0x00014270
+		internal int GetInputCount()
+		{
+			return PlayableHandle.GetInputCountInternal(ref this);
+		}
+
+		// Token: 0x0600105E RID: 4190 RVA: 0x0001608C File Offset: 0x0001428C
+		internal void SetInputCount(int value)
+		{
+			PlayableHandle.SetInputCountInternal(ref this, value);
+		}
+
+		// Token: 0x0600105F RID: 4191 RVA: 0x00016098 File Offset: 0x00014298
+		internal int GetOutputCount()
+		{
+			return PlayableHandle.GetOutputCountInternal(ref this);
+		}
+
+		// Token: 0x06001060 RID: 4192 RVA: 0x000160B4 File Offset: 0x000142B4
+		internal void SetOutputCount(int value)
+		{
+			PlayableHandle.SetOutputCountInternal(ref this, value);
+		}
+
+		// Token: 0x06001061 RID: 4193 RVA: 0x000160C0 File Offset: 0x000142C0
+		internal PlayState GetPlayState()
+		{
+			return PlayableHandle.GetPlayStateInternal(ref this);
+		}
+
+		// Token: 0x06001062 RID: 4194 RVA: 0x000160DC File Offset: 0x000142DC
+		internal void SetPlayState(PlayState value)
+		{
+			PlayableHandle.SetPlayStateInternal(ref this, value);
+		}
+
+		// Token: 0x06001063 RID: 4195 RVA: 0x000160E8 File Offset: 0x000142E8
+		internal double GetSpeed()
+		{
+			return PlayableHandle.GetSpeedInternal(ref this);
+		}
+
+		// Token: 0x06001064 RID: 4196 RVA: 0x00016104 File Offset: 0x00014304
+		internal void SetSpeed(double value)
+		{
+			PlayableHandle.SetSpeedInternal(ref this, value);
+		}
+
+		// Token: 0x06001065 RID: 4197 RVA: 0x00016110 File Offset: 0x00014310
+		internal double GetTime()
+		{
+			return PlayableHandle.GetTimeInternal(ref this);
+		}
+
+		// Token: 0x06001066 RID: 4198 RVA: 0x0001612C File Offset: 0x0001432C
+		internal void SetTime(double value)
+		{
+			PlayableHandle.SetTimeInternal(ref this, value);
+		}
+
+		// Token: 0x06001067 RID: 4199 RVA: 0x00016138 File Offset: 0x00014338
+		internal bool IsDone()
+		{
+			return PlayableHandle.IsDoneInternal(ref this);
+		}
+
+		// Token: 0x06001068 RID: 4200 RVA: 0x00016154 File Offset: 0x00014354
+		internal void SetDone(bool value)
+		{
+			PlayableHandle.SetDoneInternal(ref this, value);
+		}
+
+		// Token: 0x06001069 RID: 4201 RVA: 0x00016160 File Offset: 0x00014360
+		internal bool GetPropagateSetTime()
+		{
+			return PlayableHandle.GetPropagateSetTimeInternal(ref this);
+		}
+
+		// Token: 0x0600106A RID: 4202 RVA: 0x0001617C File Offset: 0x0001437C
+		internal void SetPropagateSetTime(bool value)
+		{
+			PlayableHandle.SetPropagateSetTimeInternal(ref this, value);
+		}
+
+		// Token: 0x0600106B RID: 4203 RVA: 0x00016188 File Offset: 0x00014388
+		internal bool CanChangeInputs()
+		{
+			return PlayableHandle.CanChangeInputsInternal(ref this);
+		}
+
+		// Token: 0x0600106C RID: 4204 RVA: 0x000161A4 File Offset: 0x000143A4
+		internal bool CanSetWeights()
+		{
+			return PlayableHandle.CanSetWeightsInternal(ref this);
+		}
+
+		// Token: 0x0600106D RID: 4205 RVA: 0x000161C0 File Offset: 0x000143C0
+		internal bool CanDestroy()
+		{
+			return PlayableHandle.CanDestroyInternal(ref this);
+		}
+
+		// Token: 0x0600106E RID: 4206 RVA: 0x000161DC File Offset: 0x000143DC
+		private static bool CanChangeInputsInternal(ref PlayableHandle playable)
+		{
+			return PlayableHandle.INTERNAL_CALL_CanChangeInputsInternal(ref playable);
+		}
+
+		// Token: 0x0600106F RID: 4207
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool INTERNAL_CALL_CanChangeInputsInternal(ref PlayableHandle playable);
+
+		// Token: 0x06001070 RID: 4208 RVA: 0x000161F8 File Offset: 0x000143F8
+		private static bool CanSetWeightsInternal(ref PlayableHandle playable)
+		{
+			return PlayableHandle.INTERNAL_CALL_CanSetWeightsInternal(ref playable);
+		}
+
+		// Token: 0x06001071 RID: 4209
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool INTERNAL_CALL_CanSetWeightsInternal(ref PlayableHandle playable);
+
+		// Token: 0x06001072 RID: 4210 RVA: 0x00016214 File Offset: 0x00014414
+		private static bool CanDestroyInternal(ref PlayableHandle playable)
+		{
+			return PlayableHandle.INTERNAL_CALL_CanDestroyInternal(ref playable);
+		}
+
+		// Token: 0x06001073 RID: 4211
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool INTERNAL_CALL_CanDestroyInternal(ref PlayableHandle playable);
+
+		// Token: 0x06001074 RID: 4212 RVA: 0x00016230 File Offset: 0x00014430
+		private static PlayState GetPlayStateInternal(ref PlayableHandle playable)
+		{
+			return PlayableHandle.INTERNAL_CALL_GetPlayStateInternal(ref playable);
+		}
+
+		// Token: 0x06001075 RID: 4213
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern PlayState INTERNAL_CALL_GetPlayStateInternal(ref PlayableHandle playable);
+
+		// Token: 0x06001076 RID: 4214 RVA: 0x0001624C File Offset: 0x0001444C
+		private static void SetPlayStateInternal(ref PlayableHandle playable, PlayState playState)
+		{
+			PlayableHandle.INTERNAL_CALL_SetPlayStateInternal(ref playable, playState);
+		}
+
+		// Token: 0x06001077 RID: 4215
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_SetPlayStateInternal(ref PlayableHandle playable, PlayState playState);
+
+		// Token: 0x06001078 RID: 4216 RVA: 0x00016258 File Offset: 0x00014458
+		private static double GetSpeedInternal(ref PlayableHandle playable)
+		{
+			return PlayableHandle.INTERNAL_CALL_GetSpeedInternal(ref playable);
+		}
+
+		// Token: 0x06001079 RID: 4217
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern double INTERNAL_CALL_GetSpeedInternal(ref PlayableHandle playable);
+
+		// Token: 0x0600107A RID: 4218 RVA: 0x00016274 File Offset: 0x00014474
+		private static void SetSpeedInternal(ref PlayableHandle playable, double speed)
+		{
+			PlayableHandle.INTERNAL_CALL_SetSpeedInternal(ref playable, speed);
+		}
+
+		// Token: 0x0600107B RID: 4219
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_SetSpeedInternal(ref PlayableHandle playable, double speed);
+
+		// Token: 0x0600107C RID: 4220 RVA: 0x00016280 File Offset: 0x00014480
+		private static double GetTimeInternal(ref PlayableHandle playable)
+		{
+			return PlayableHandle.INTERNAL_CALL_GetTimeInternal(ref playable);
+		}
+
+		// Token: 0x0600107D RID: 4221
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern double INTERNAL_CALL_GetTimeInternal(ref PlayableHandle playable);
+
+		// Token: 0x0600107E RID: 4222 RVA: 0x0001629C File Offset: 0x0001449C
+		private static void SetTimeInternal(ref PlayableHandle playable, double time)
+		{
+			PlayableHandle.INTERNAL_CALL_SetTimeInternal(ref playable, time);
+		}
+
+		// Token: 0x0600107F RID: 4223
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_SetTimeInternal(ref PlayableHandle playable, double time);
+
+		// Token: 0x06001080 RID: 4224 RVA: 0x000162A8 File Offset: 0x000144A8
+		private static bool IsDoneInternal(ref PlayableHandle playable)
+		{
+			return PlayableHandle.INTERNAL_CALL_IsDoneInternal(ref playable);
+		}
+
+		// Token: 0x06001081 RID: 4225
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool INTERNAL_CALL_IsDoneInternal(ref PlayableHandle playable);
+
+		// Token: 0x06001082 RID: 4226 RVA: 0x000162C4 File Offset: 0x000144C4
+		private static void SetDoneInternal(ref PlayableHandle playable, bool isDone)
+		{
+			PlayableHandle.INTERNAL_CALL_SetDoneInternal(ref playable, isDone);
+		}
+
+		// Token: 0x06001083 RID: 4227
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_SetDoneInternal(ref PlayableHandle playable, bool isDone);
+
+		// Token: 0x06001084 RID: 4228 RVA: 0x000162D0 File Offset: 0x000144D0
+		internal double GetDuration()
+		{
+			return PlayableHandle.GetDurationInternal(ref this);
+		}
+
+		// Token: 0x06001085 RID: 4229 RVA: 0x000162EC File Offset: 0x000144EC
+		internal void SetDuration(double value)
+		{
+			PlayableHandle.SetDurationInternal(ref this, value);
+		}
+
+		// Token: 0x06001086 RID: 4230 RVA: 0x000162F8 File Offset: 0x000144F8
+		private static double GetDurationInternal(ref PlayableHandle playable)
+		{
+			return PlayableHandle.INTERNAL_CALL_GetDurationInternal(ref playable);
+		}
+
+		// Token: 0x06001087 RID: 4231
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern double INTERNAL_CALL_GetDurationInternal(ref PlayableHandle playable);
+
+		// Token: 0x06001088 RID: 4232 RVA: 0x00016314 File Offset: 0x00014514
+		private static void SetDurationInternal(ref PlayableHandle playable, double duration)
+		{
+			PlayableHandle.INTERNAL_CALL_SetDurationInternal(ref playable, duration);
+		}
+
+		// Token: 0x06001089 RID: 4233
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_SetDurationInternal(ref PlayableHandle playable, double duration);
+
+		// Token: 0x0600108A RID: 4234 RVA: 0x00016320 File Offset: 0x00014520
+		private static bool GetPropagateSetTimeInternal(ref PlayableHandle playable)
+		{
+			return PlayableHandle.INTERNAL_CALL_GetPropagateSetTimeInternal(ref playable);
+		}
+
+		// Token: 0x0600108B RID: 4235
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool INTERNAL_CALL_GetPropagateSetTimeInternal(ref PlayableHandle playable);
+
+		// Token: 0x0600108C RID: 4236 RVA: 0x0001633C File Offset: 0x0001453C
+		private static void SetPropagateSetTimeInternal(ref PlayableHandle playable, bool value)
+		{
+			PlayableHandle.INTERNAL_CALL_SetPropagateSetTimeInternal(ref playable, value);
+		}
+
+		// Token: 0x0600108D RID: 4237
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_SetPropagateSetTimeInternal(ref PlayableHandle playable, bool value);
+
+		// Token: 0x0600108E RID: 4238 RVA: 0x00016348 File Offset: 0x00014548
+		private static void GetGraphInternal(ref PlayableHandle playable, ref PlayableGraph graph)
+		{
+			PlayableHandle.INTERNAL_CALL_GetGraphInternal(ref playable, ref graph);
+		}
+
+		// Token: 0x0600108F RID: 4239
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_GetGraphInternal(ref PlayableHandle playable, ref PlayableGraph graph);
+
+		// Token: 0x06001090 RID: 4240 RVA: 0x00016354 File Offset: 0x00014554
+		private static int GetInputCountInternal(ref PlayableHandle playable)
+		{
+			return PlayableHandle.INTERNAL_CALL_GetInputCountInternal(ref playable);
+		}
+
+		// Token: 0x06001091 RID: 4241
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern int INTERNAL_CALL_GetInputCountInternal(ref PlayableHandle playable);
+
+		// Token: 0x06001092 RID: 4242 RVA: 0x00016370 File Offset: 0x00014570
+		private static void SetInputCountInternal(ref PlayableHandle playable, int count)
+		{
+			PlayableHandle.INTERNAL_CALL_SetInputCountInternal(ref playable, count);
+		}
+
+		// Token: 0x06001093 RID: 4243
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_SetInputCountInternal(ref PlayableHandle playable, int count);
+
+		// Token: 0x06001094 RID: 4244 RVA: 0x0001637C File Offset: 0x0001457C
+		private static int GetOutputCountInternal(ref PlayableHandle playable)
+		{
+			return PlayableHandle.INTERNAL_CALL_GetOutputCountInternal(ref playable);
+		}
+
+		// Token: 0x06001095 RID: 4245
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern int INTERNAL_CALL_GetOutputCountInternal(ref PlayableHandle playable);
+
+		// Token: 0x06001096 RID: 4246 RVA: 0x00016398 File Offset: 0x00014598
+		private static void SetOutputCountInternal(ref PlayableHandle playable, int count)
+		{
+			PlayableHandle.INTERNAL_CALL_SetOutputCountInternal(ref playable, count);
+		}
+
+		// Token: 0x06001097 RID: 4247
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_SetOutputCountInternal(ref PlayableHandle playable, int count);
+
+		// Token: 0x06001098 RID: 4248 RVA: 0x000163A4 File Offset: 0x000145A4
+		internal Playable GetInput(int inputPort)
+		{
+			return new Playable(PlayableHandle.GetInputInternal(ref this, inputPort));
+		}
+
+		// Token: 0x06001099 RID: 4249 RVA: 0x000163C8 File Offset: 0x000145C8
+		private static PlayableHandle GetInputInternal(ref PlayableHandle playable, int index)
+		{
+			PlayableHandle playableHandle;
+			PlayableHandle.INTERNAL_CALL_GetInputInternal(ref playable, index, out playableHandle);
+			return playableHandle;
+		}
+
+		// Token: 0x0600109A RID: 4250
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_GetInputInternal(ref PlayableHandle playable, int index, out PlayableHandle value);
+
+		// Token: 0x0600109B RID: 4251 RVA: 0x000163E8 File Offset: 0x000145E8
+		internal Playable GetOutput(int outputPort)
+		{
+			return new Playable(PlayableHandle.GetOutputInternal(ref this, outputPort));
+		}
+
+		// Token: 0x0600109C RID: 4252 RVA: 0x0001640C File Offset: 0x0001460C
+		private static PlayableHandle GetOutputInternal(ref PlayableHandle playable, int index)
+		{
+			PlayableHandle playableHandle;
+			PlayableHandle.INTERNAL_CALL_GetOutputInternal(ref playable, index, out playableHandle);
+			return playableHandle;
+		}
+
+		// Token: 0x0600109D RID: 4253
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_GetOutputInternal(ref PlayableHandle playable, int index, out PlayableHandle value);
+
+		// Token: 0x0600109E RID: 4254 RVA: 0x0001642C File Offset: 0x0001462C
+		private static void SetInputWeightFromIndexInternal(ref PlayableHandle playable, int index, float weight)
+		{
+			PlayableHandle.INTERNAL_CALL_SetInputWeightFromIndexInternal(ref playable, index, weight);
+		}
+
+		// Token: 0x0600109F RID: 4255
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_SetInputWeightFromIndexInternal(ref PlayableHandle playable, int index, float weight);
+
+		// Token: 0x060010A0 RID: 4256 RVA: 0x00016438 File Offset: 0x00014638
+		internal bool SetInputWeight(int inputIndex, float weight)
+		{
+			bool flag;
+			if (this.CheckInputBounds(inputIndex))
+			{
+				PlayableHandle.SetInputWeightFromIndexInternal(ref this, inputIndex, weight);
+				flag = true;
+			}
+			else
+			{
+				flag = false;
+			}
+			return flag;
+		}
+
+		// Token: 0x060010A1 RID: 4257 RVA: 0x0001646C File Offset: 0x0001466C
+		private static float GetInputWeightFromIndexInternal(ref PlayableHandle playable, int index)
+		{
+			return PlayableHandle.INTERNAL_CALL_GetInputWeightFromIndexInternal(ref playable, index);
+		}
+
+		// Token: 0x060010A2 RID: 4258
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float INTERNAL_CALL_GetInputWeightFromIndexInternal(ref PlayableHandle playable, int index);
+
+		// Token: 0x060010A3 RID: 4259 RVA: 0x00016488 File Offset: 0x00014688
+		internal void SetInputWeight(PlayableHandle input, float weight)
+		{
+			PlayableHandle.SetInputWeightInternal(ref this, ref input, weight);
+		}
+
+		// Token: 0x060010A4 RID: 4260 RVA: 0x00016494 File Offset: 0x00014694
+		private static void SetInputWeightInternal(ref PlayableHandle playable, ref PlayableHandle input, float weight)
+		{
+			PlayableHandle.INTERNAL_CALL_SetInputWeightInternal(ref playable, ref input, weight);
+		}
+
+		// Token: 0x060010A5 RID: 4261
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_SetInputWeightInternal(ref PlayableHandle playable, ref PlayableHandle input, float weight);
+
+		// Token: 0x060010A6 RID: 4262 RVA: 0x000164A0 File Offset: 0x000146A0
+		internal float GetInputWeight(int inputIndex)
+		{
+			float num;
+			if (this.CheckInputBounds(inputIndex))
+			{
+				num = PlayableHandle.GetInputWeightFromIndexInternal(ref this, inputIndex);
+			}
+			else
+			{
+				num = 0f;
+			}
+			return num;
+		}
+
+		// Token: 0x060010A7 RID: 4263 RVA: 0x000164D4 File Offset: 0x000146D4
+		internal void Destroy()
+		{
+			this.GetGraph().DestroyPlayable<Playable>(new Playable(this));
+		}
+
+		// Token: 0x060010A8 RID: 4264 RVA: 0x000164FC File Offset: 0x000146FC
+		public static bool operator ==(PlayableHandle x, PlayableHandle y)
+		{
+			return PlayableHandle.CompareVersion(x, y);
+		}
+
+		// Token: 0x060010A9 RID: 4265 RVA: 0x00016518 File Offset: 0x00014718
+		public static bool operator !=(PlayableHandle x, PlayableHandle y)
+		{
+			return !PlayableHandle.CompareVersion(x, y);
+		}
+
+		// Token: 0x060010AA RID: 4266 RVA: 0x00016538 File Offset: 0x00014738
+		public override bool Equals(object p)
+		{
+			return p is PlayableHandle && PlayableHandle.CompareVersion(this, (PlayableHandle)p);
+		}
+
+		// Token: 0x060010AB RID: 4267 RVA: 0x00016570 File Offset: 0x00014770
+		public override int GetHashCode()
+		{
+			return this.m_Handle.GetHashCode() ^ this.m_Version.GetHashCode();
+		}
+
+		// Token: 0x060010AC RID: 4268 RVA: 0x000165A8 File Offset: 0x000147A8
+		internal static bool CompareVersion(PlayableHandle lhs, PlayableHandle rhs)
+		{
+			return lhs.m_Handle == rhs.m_Handle && lhs.m_Version == rhs.m_Version;
+		}
+
+		// Token: 0x060010AD RID: 4269 RVA: 0x000165E8 File Offset: 0x000147E8
+		internal bool CheckInputBounds(int inputIndex)
+		{
+			return this.CheckInputBounds(inputIndex, false);
+		}
+
+		// Token: 0x060010AE RID: 4270 RVA: 0x00016608 File Offset: 0x00014808
+		internal bool CheckInputBounds(int inputIndex, bool acceptAny)
+		{
+			bool flag;
+			if (inputIndex == -1 && acceptAny)
+			{
+				flag = true;
+			}
+			else
+			{
+				if (inputIndex < 0)
+				{
+					throw new IndexOutOfRangeException("Index must be greater than 0");
+				}
+				if (this.GetInputCount() <= inputIndex)
+				{
+					throw new IndexOutOfRangeException(string.Concat(new object[]
+					{
+						"inputIndex ",
+						inputIndex,
+						" is greater than the number of available inputs (",
+						this.GetInputCount(),
+						")."
+					}));
+				}
+				flag = true;
+			}
+			return flag;
+		}
+
+		// Token: 0x0400020A RID: 522
+		internal IntPtr m_Handle;
+
+		// Token: 0x0400020B RID: 523
+		internal int m_Version;
+	}
+}
@@ -0,0 +1,56 @@
+using System;
+using UnityEngine.Scripting;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020000E6 RID: 230
+	[RequiredByNativeCode]
+	public struct PlayableOutput : IPlayableOutput, IEquatable<PlayableOutput>
+	{
+		// Token: 0x0600112F RID: 4399 RVA: 0x00016FD8 File Offset: 0x000151D8
+		internal PlayableOutput(PlayableOutputHandle handle)
+		{
+			this.m_Handle = handle;
+		}
+
+		// Token: 0x1700036F RID: 879
+		// (get) Token: 0x06001130 RID: 4400 RVA: 0x00016FE4 File Offset: 0x000151E4
+		public static PlayableOutput Null
+		{
+			get
+			{
+				return PlayableOutput.m_NullPlayableOutput;
+			}
+		}
+
+		// Token: 0x06001131 RID: 4401 RVA: 0x00017000 File Offset: 0x00015200
+		public PlayableOutputHandle GetHandle()
+		{
+			return this.m_Handle;
+		}
+
+		// Token: 0x06001132 RID: 4402 RVA: 0x0001701C File Offset: 0x0001521C
+		public bool IsPlayableOutputOfType<T>() where T : struct, IPlayableOutput
+		{
+			return this.GetHandle().IsPlayableOutputOfType<T>();
+		}
+
+		// Token: 0x06001133 RID: 4403 RVA: 0x00017040 File Offset: 0x00015240
+		public Type GetPlayableOutputType()
+		{
+			return PlayableOutputHandle.GetPlayableOutputTypeOf(ref this.m_Handle);
+		}
+
+		// Token: 0x06001134 RID: 4404 RVA: 0x00017060 File Offset: 0x00015260
+		public bool Equals(PlayableOutput other)
+		{
+			return this.GetHandle() == other.GetHandle();
+		}
+
+		// Token: 0x0400021C RID: 540
+		private PlayableOutputHandle m_Handle;
+
+		// Token: 0x0400021D RID: 541
+		private static readonly PlayableOutput m_NullPlayableOutput = new PlayableOutput(PlayableOutputHandle.Null);
+	}
+}
@@ -0,0 +1,74 @@
+using System;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020004BF RID: 1215
+	public static class PlayableOutputExtensions
+	{
+		// Token: 0x06003B61 RID: 15201 RVA: 0x000682CC File Offset: 0x000664CC
+		public static bool IsOutputValid<U>(this U output) where U : struct, IPlayableOutput
+		{
+			return output.GetHandle().IsValid();
+		}
+
+		// Token: 0x06003B62 RID: 15202 RVA: 0x000682F8 File Offset: 0x000664F8
+		public static Object GetReferenceObject<U>(this U output) where U : struct, IPlayableOutput
+		{
+			return output.GetHandle().GetReferenceObject();
+		}
+
+		// Token: 0x06003B63 RID: 15203 RVA: 0x00068324 File Offset: 0x00066524
+		public static void SetReferenceObject<U>(this U output, Object value) where U : struct, IPlayableOutput
+		{
+			output.GetHandle().SetReferenceObject(value);
+		}
+
+		// Token: 0x06003B64 RID: 15204 RVA: 0x00068348 File Offset: 0x00066548
+		public static Object GetUserData<U>(this U output) where U : struct, IPlayableOutput
+		{
+			return output.GetHandle().GetUserData();
+		}
+
+		// Token: 0x06003B65 RID: 15205 RVA: 0x00068374 File Offset: 0x00066574
+		public static void SetUserData<U>(this U output, Object value) where U : struct, IPlayableOutput
+		{
+			output.GetHandle().SetUserData(value);
+		}
+
+		// Token: 0x06003B66 RID: 15206 RVA: 0x00068398 File Offset: 0x00066598
+		public static Playable GetSourcePlayable<U>(this U output) where U : struct, IPlayableOutput
+		{
+			return new Playable(output.GetHandle().GetSourcePlayable());
+		}
+
+		// Token: 0x06003B67 RID: 15207 RVA: 0x000683C8 File Offset: 0x000665C8
+		public static void SetSourcePlayable<U, V>(this U output, V value) where U : struct, IPlayableOutput where V : struct, IPlayable
+		{
+			output.GetHandle().SetSourcePlayable(value.GetHandle());
+		}
+
+		// Token: 0x06003B68 RID: 15208 RVA: 0x000683F8 File Offset: 0x000665F8
+		public static int GetSourceInputPort<U>(this U output) where U : struct, IPlayableOutput
+		{
+			return output.GetHandle().GetSourceInputPort();
+		}
+
+		// Token: 0x06003B69 RID: 15209 RVA: 0x00068424 File Offset: 0x00066624
+		public static void SetSourceInputPort<U>(this U output, int value) where U : struct, IPlayableOutput
+		{
+			output.GetHandle().SetSourceInputPort(value);
+		}
+
+		// Token: 0x06003B6A RID: 15210 RVA: 0x00068448 File Offset: 0x00066648
+		public static float GetWeight<U>(this U output) where U : struct, IPlayableOutput
+		{
+			return output.GetHandle().GetWeight();
+		}
+
+		// Token: 0x06003B6B RID: 15211 RVA: 0x00068474 File Offset: 0x00066674
+		public static void SetWeight<U>(this U output, float value) where U : struct, IPlayableOutput
+		{
+			output.GetHandle().SetWeight(value);
+		}
+	}
+}
@@ -0,0 +1,266 @@
+using System;
+using System.Runtime.CompilerServices;
+using UnityEngine.Scripting;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020000E5 RID: 229
+	[UsedByNativeCode]
+	public struct PlayableOutputHandle
+	{
+		// Token: 0x06001105 RID: 4357 RVA: 0x00016CB4 File Offset: 0x00014EB4
+		internal bool IsValid()
+		{
+			return PlayableOutputHandle.IsValidInternal(ref this);
+		}
+
+		// Token: 0x06001106 RID: 4358 RVA: 0x00016CD0 File Offset: 0x00014ED0
+		internal static bool IsValidInternal(ref PlayableOutputHandle handle)
+		{
+			return PlayableOutputHandle.INTERNAL_CALL_IsValidInternal(ref handle);
+		}
+
+		// Token: 0x06001107 RID: 4359
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern bool INTERNAL_CALL_IsValidInternal(ref PlayableOutputHandle handle);
+
+		// Token: 0x1700036E RID: 878
+		// (get) Token: 0x06001108 RID: 4360 RVA: 0x00016CEC File Offset: 0x00014EEC
+		public static PlayableOutputHandle Null
+		{
+			get
+			{
+				return new PlayableOutputHandle
+				{
+					m_Version = int.MaxValue
+				};
+			}
+		}
+
+		// Token: 0x06001109 RID: 4361 RVA: 0x00016D18 File Offset: 0x00014F18
+		internal static Type GetPlayableOutputTypeOf(ref PlayableOutputHandle handle)
+		{
+			return PlayableOutputHandle.INTERNAL_CALL_GetPlayableOutputTypeOf(ref handle);
+		}
+
+		// Token: 0x0600110A RID: 4362
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern Type INTERNAL_CALL_GetPlayableOutputTypeOf(ref PlayableOutputHandle handle);
+
+		// Token: 0x0600110B RID: 4363 RVA: 0x00016D34 File Offset: 0x00014F34
+		internal bool IsPlayableOutputOfType<T>()
+		{
+			return PlayableOutputHandle.GetPlayableOutputTypeOf(ref this) == typeof(T);
+		}
+
+		// Token: 0x0600110C RID: 4364 RVA: 0x00016D5C File Offset: 0x00014F5C
+		internal Object GetReferenceObject()
+		{
+			return PlayableOutputHandle.GetInternalReferenceObject(ref this);
+		}
+
+		// Token: 0x0600110D RID: 4365 RVA: 0x00016D78 File Offset: 0x00014F78
+		internal void SetReferenceObject(Object value)
+		{
+			PlayableOutputHandle.SetInternalReferenceObject(ref this, value);
+		}
+
+		// Token: 0x0600110E RID: 4366 RVA: 0x00016D84 File Offset: 0x00014F84
+		internal static Object GetInternalReferenceObject(ref PlayableOutputHandle handle)
+		{
+			return PlayableOutputHandle.INTERNAL_CALL_GetInternalReferenceObject(ref handle);
+		}
+
+		// Token: 0x0600110F RID: 4367
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern Object INTERNAL_CALL_GetInternalReferenceObject(ref PlayableOutputHandle handle);
+
+		// Token: 0x06001110 RID: 4368 RVA: 0x00016DA0 File Offset: 0x00014FA0
+		internal static void SetInternalReferenceObject(ref PlayableOutputHandle handle, Object target)
+		{
+			PlayableOutputHandle.INTERNAL_CALL_SetInternalReferenceObject(ref handle, target);
+		}
+
+		// Token: 0x06001111 RID: 4369
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_SetInternalReferenceObject(ref PlayableOutputHandle handle, Object target);
+
+		// Token: 0x06001112 RID: 4370 RVA: 0x00016DAC File Offset: 0x00014FAC
+		internal Object GetUserData()
+		{
+			return PlayableOutputHandle.GetInternalUserData(ref this);
+		}
+
+		// Token: 0x06001113 RID: 4371 RVA: 0x00016DC8 File Offset: 0x00014FC8
+		internal void SetUserData(Object value)
+		{
+			PlayableOutputHandle.SetInternalUserData(ref this, value);
+		}
+
+		// Token: 0x06001114 RID: 4372 RVA: 0x00016DD4 File Offset: 0x00014FD4
+		internal static Object GetInternalUserData(ref PlayableOutputHandle handle)
+		{
+			return PlayableOutputHandle.INTERNAL_CALL_GetInternalUserData(ref handle);
+		}
+
+		// Token: 0x06001115 RID: 4373
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern Object INTERNAL_CALL_GetInternalUserData(ref PlayableOutputHandle handle);
+
+		// Token: 0x06001116 RID: 4374 RVA: 0x00016DF0 File Offset: 0x00014FF0
+		internal static void SetInternalUserData(ref PlayableOutputHandle handle, [Writable] Object target)
+		{
+			PlayableOutputHandle.INTERNAL_CALL_SetInternalUserData(ref handle, target);
+		}
+
+		// Token: 0x06001117 RID: 4375
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_SetInternalUserData(ref PlayableOutputHandle handle, [Writable] Object target);
+
+		// Token: 0x06001118 RID: 4376 RVA: 0x00016DFC File Offset: 0x00014FFC
+		internal PlayableHandle GetSourcePlayable()
+		{
+			return PlayableOutputHandle.GetSourcePlayableInternal(ref this);
+		}
+
+		// Token: 0x06001119 RID: 4377 RVA: 0x00016E18 File Offset: 0x00015018
+		internal void SetSourcePlayable(PlayableHandle value)
+		{
+			PlayableOutputHandle.SetSourcePlayableInternal(ref this, ref value);
+		}
+
+		// Token: 0x0600111A RID: 4378 RVA: 0x00016E24 File Offset: 0x00015024
+		internal static PlayableHandle GetSourcePlayableInternal(ref PlayableOutputHandle handle)
+		{
+			PlayableHandle playableHandle;
+			PlayableOutputHandle.INTERNAL_CALL_GetSourcePlayableInternal(ref handle, out playableHandle);
+			return playableHandle;
+		}
+
+		// Token: 0x0600111B RID: 4379
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_GetSourcePlayableInternal(ref PlayableOutputHandle handle, out PlayableHandle value);
+
+		// Token: 0x0600111C RID: 4380 RVA: 0x00016E44 File Offset: 0x00015044
+		internal static void SetSourcePlayableInternal(ref PlayableOutputHandle handle, ref PlayableHandle target)
+		{
+			PlayableOutputHandle.INTERNAL_CALL_SetSourcePlayableInternal(ref handle, ref target);
+		}
+
+		// Token: 0x0600111D RID: 4381
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_SetSourcePlayableInternal(ref PlayableOutputHandle handle, ref PlayableHandle target);
+
+		// Token: 0x0600111E RID: 4382 RVA: 0x00016E50 File Offset: 0x00015050
+		internal int GetSourceInputPort()
+		{
+			return PlayableOutputHandle.GetSourceInputPortInternal(ref this);
+		}
+
+		// Token: 0x0600111F RID: 4383 RVA: 0x00016E6C File Offset: 0x0001506C
+		internal void SetSourceInputPort(int value)
+		{
+			PlayableOutputHandle.SetSourceInputPortInternal(ref this, value);
+		}
+
+		// Token: 0x06001120 RID: 4384 RVA: 0x00016E78 File Offset: 0x00015078
+		internal static int GetSourceInputPortInternal(ref PlayableOutputHandle handle)
+		{
+			return PlayableOutputHandle.INTERNAL_CALL_GetSourceInputPortInternal(ref handle);
+		}
+
+		// Token: 0x06001121 RID: 4385
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern int INTERNAL_CALL_GetSourceInputPortInternal(ref PlayableOutputHandle handle);
+
+		// Token: 0x06001122 RID: 4386 RVA: 0x00016E94 File Offset: 0x00015094
+		internal static void SetSourceInputPortInternal(ref PlayableOutputHandle handle, int port)
+		{
+			PlayableOutputHandle.INTERNAL_CALL_SetSourceInputPortInternal(ref handle, port);
+		}
+
+		// Token: 0x06001123 RID: 4387
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_SetSourceInputPortInternal(ref PlayableOutputHandle handle, int port);
+
+		// Token: 0x06001124 RID: 4388 RVA: 0x00016EA0 File Offset: 0x000150A0
+		internal float GetWeight()
+		{
+			return PlayableOutputHandle.GetWeightInternal(ref this);
+		}
+
+		// Token: 0x06001125 RID: 4389 RVA: 0x00016EBC File Offset: 0x000150BC
+		internal void SetWeight(float value)
+		{
+			PlayableOutputHandle.SetWeightInternal(ref this, value);
+		}
+
+		// Token: 0x06001126 RID: 4390 RVA: 0x00016EC8 File Offset: 0x000150C8
+		internal static void SetWeightInternal(ref PlayableOutputHandle handle, float weight)
+		{
+			PlayableOutputHandle.INTERNAL_CALL_SetWeightInternal(ref handle, weight);
+		}
+
+		// Token: 0x06001127 RID: 4391
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void INTERNAL_CALL_SetWeightInternal(ref PlayableOutputHandle handle, float weight);
+
+		// Token: 0x06001128 RID: 4392 RVA: 0x00016ED4 File Offset: 0x000150D4
+		internal static float GetWeightInternal(ref PlayableOutputHandle handle)
+		{
+			return PlayableOutputHandle.INTERNAL_CALL_GetWeightInternal(ref handle);
+		}
+
+		// Token: 0x06001129 RID: 4393
+		[GeneratedByOldBindingsGenerator]
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern float INTERNAL_CALL_GetWeightInternal(ref PlayableOutputHandle handle);
+
+		// Token: 0x0600112A RID: 4394 RVA: 0x00016EF0 File Offset: 0x000150F0
+		public override int GetHashCode()
+		{
+			return this.m_Handle.GetHashCode() ^ this.m_Version.GetHashCode();
+		}
+
+		// Token: 0x0600112B RID: 4395 RVA: 0x00016F28 File Offset: 0x00015128
+		public static bool operator ==(PlayableOutputHandle lhs, PlayableOutputHandle rhs)
+		{
+			return PlayableOutputHandle.CompareVersion(lhs, rhs);
+		}
+
+		// Token: 0x0600112C RID: 4396 RVA: 0x00016F44 File Offset: 0x00015144
+		public static bool operator !=(PlayableOutputHandle lhs, PlayableOutputHandle rhs)
+		{
+			return !PlayableOutputHandle.CompareVersion(lhs, rhs);
+		}
+
+		// Token: 0x0600112D RID: 4397 RVA: 0x00016F64 File Offset: 0x00015164
+		public override bool Equals(object p)
+		{
+			return p is PlayableOutputHandle && PlayableOutputHandle.CompareVersion(this, (PlayableOutputHandle)p);
+		}
+
+		// Token: 0x0600112E RID: 4398 RVA: 0x00016F98 File Offset: 0x00015198
+		internal static bool CompareVersion(PlayableOutputHandle lhs, PlayableOutputHandle rhs)
+		{
+			return lhs.m_Handle == rhs.m_Handle && lhs.m_Version == rhs.m_Version;
+		}
+
+		// Token: 0x0400021A RID: 538
+		internal IntPtr m_Handle;
+
+		// Token: 0x0400021B RID: 539
+		internal int m_Version;
+	}
+}
@@ -0,0 +1,172 @@
+using System;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020004C0 RID: 1216
+	public struct ScriptPlayable<T> : IPlayable, IEquatable<ScriptPlayable<T>> where T : class, IPlayableBehaviour, new()
+	{
+		// Token: 0x06003B6C RID: 15212 RVA: 0x00068498 File Offset: 0x00066698
+		internal ScriptPlayable(PlayableHandle handle)
+		{
+			if (handle.IsValid())
+			{
+				if (!typeof(T).IsAssignableFrom(handle.GetPlayableType()))
+				{
+					throw new InvalidCastException(string.Format("Incompatible handle: Trying to assign a playable data of type `{0}` that is not compatible with the PlayableBehaviour of type `{1}`.", handle.GetPlayableType(), typeof(T)));
+				}
+			}
+			this.m_Handle = handle;
+		}
+
+		// Token: 0x17000D7C RID: 3452
+		// (get) Token: 0x06003B6D RID: 15213 RVA: 0x000684F8 File Offset: 0x000666F8
+		public static ScriptPlayable<T> Null
+		{
+			get
+			{
+				return ScriptPlayable<T>.m_NullPlayable;
+			}
+		}
+
+		// Token: 0x06003B6E RID: 15214 RVA: 0x00068514 File Offset: 0x00066714
+		public static ScriptPlayable<T> Create(PlayableGraph graph, int inputCount = 0)
+		{
+			PlayableHandle playableHandle = ScriptPlayable<T>.CreateHandle(graph, (T)((object)null), inputCount);
+			return new ScriptPlayable<T>(playableHandle);
+		}
+
+		// Token: 0x06003B6F RID: 15215 RVA: 0x00068540 File Offset: 0x00066740
+		public static ScriptPlayable<T> Create(PlayableGraph graph, T template, int inputCount = 0)
+		{
+			PlayableHandle playableHandle = ScriptPlayable<T>.CreateHandle(graph, template, inputCount);
+			return new ScriptPlayable<T>(playableHandle);
+		}
+
+		// Token: 0x06003B70 RID: 15216 RVA: 0x00068564 File Offset: 0x00066764
+		private static PlayableHandle CreateHandle(PlayableGraph graph, T template, int inputCount)
+		{
+			object obj;
+			if (template == null)
+			{
+				obj = ScriptPlayable<T>.CreateScriptInstance();
+			}
+			else
+			{
+				obj = ScriptPlayable<T>.CloneScriptInstance(template);
+			}
+			PlayableHandle playableHandle;
+			if (obj == null)
+			{
+				Debug.LogError("Could not create a ScriptPlayable of Type " + typeof(T).ToString());
+				playableHandle = PlayableHandle.Null;
+			}
+			else
+			{
+				PlayableHandle playableHandle2 = graph.CreatePlayableHandle();
+				if (!playableHandle2.IsValid())
+				{
+					playableHandle = PlayableHandle.Null;
+				}
+				else
+				{
+					playableHandle2.SetInputCount(inputCount);
+					playableHandle2.SetScriptInstance(obj);
+					playableHandle = playableHandle2;
+				}
+			}
+			return playableHandle;
+		}
+
+		// Token: 0x06003B71 RID: 15217 RVA: 0x00068604 File Offset: 0x00066804
+		private static object CreateScriptInstance()
+		{
+			IPlayableBehaviour playableBehaviour;
+			if (typeof(ScriptableObject).IsAssignableFrom(typeof(T)))
+			{
+				playableBehaviour = ScriptableObject.CreateInstance(typeof(T)) as T;
+			}
+			else
+			{
+				playableBehaviour = new T();
+			}
+			return playableBehaviour;
+		}
+
+		// Token: 0x06003B72 RID: 15218 RVA: 0x00068670 File Offset: 0x00066870
+		private static object CloneScriptInstance(IPlayableBehaviour source)
+		{
+			Object @object = source as Object;
+			object obj;
+			if (@object != null)
+			{
+				obj = ScriptPlayable<T>.CloneScriptInstanceFromEngineObject(@object);
+			}
+			else
+			{
+				ICloneable cloneable = source as ICloneable;
+				if (cloneable != null)
+				{
+					obj = ScriptPlayable<T>.CloneScriptInstanceFromIClonable(cloneable);
+				}
+				else
+				{
+					obj = null;
+				}
+			}
+			return obj;
+		}
+
+		// Token: 0x06003B73 RID: 15219 RVA: 0x000686C0 File Offset: 0x000668C0
+		private static object CloneScriptInstanceFromEngineObject(Object source)
+		{
+			Object @object = Object.Instantiate(source);
+			if (@object != null)
+			{
+				@object.hideFlags |= HideFlags.DontSave;
+			}
+			return @object;
+		}
+
+		// Token: 0x06003B74 RID: 15220 RVA: 0x000686FC File Offset: 0x000668FC
+		private static object CloneScriptInstanceFromIClonable(ICloneable source)
+		{
+			return source.Clone();
+		}
+
+		// Token: 0x06003B75 RID: 15221 RVA: 0x00068718 File Offset: 0x00066918
+		public PlayableHandle GetHandle()
+		{
+			return this.m_Handle;
+		}
+
+		// Token: 0x06003B76 RID: 15222 RVA: 0x00068734 File Offset: 0x00066934
+		public T GetBehaviour()
+		{
+			return this.m_Handle.GetObject<T>();
+		}
+
+		// Token: 0x06003B77 RID: 15223 RVA: 0x00068754 File Offset: 0x00066954
+		public static implicit operator Playable(ScriptPlayable<T> playable)
+		{
+			return new Playable(playable.GetHandle());
+		}
+
+		// Token: 0x06003B78 RID: 15224 RVA: 0x00068778 File Offset: 0x00066978
+		public static explicit operator ScriptPlayable<T>(Playable playable)
+		{
+			return new ScriptPlayable<T>(playable.GetHandle());
+		}
+
+		// Token: 0x06003B79 RID: 15225 RVA: 0x0006879C File Offset: 0x0006699C
+		public bool Equals(ScriptPlayable<T> other)
+		{
+			return this.GetHandle() == other.GetHandle();
+		}
+
+		// Token: 0x040011E6 RID: 4582
+		private PlayableHandle m_Handle;
+
+		// Token: 0x040011E7 RID: 4583
+		private static readonly ScriptPlayable<T> m_NullPlayable = new ScriptPlayable<T>(PlayableHandle.Null);
+	}
+}
@@ -0,0 +1,70 @@
+using System;
+using UnityEngine.Scripting;
+
+namespace UnityEngine.Playables
+{
+	// Token: 0x020004C1 RID: 1217
+	[RequiredByNativeCode]
+	public struct ScriptPlayableOutput : IPlayableOutput
+	{
+		// Token: 0x06003B7B RID: 15227 RVA: 0x000687D8 File Offset: 0x000669D8
+		internal ScriptPlayableOutput(PlayableOutputHandle handle)
+		{
+			if (handle.IsValid())
+			{
+				if (!handle.IsPlayableOutputOfType<ScriptPlayableOutput>())
+				{
+					throw new InvalidCastException("Can't set handle: the playable is not a ScriptPlayableOutput.");
+				}
+			}
+			this.m_Handle = handle;
+		}
+
+		// Token: 0x06003B7C RID: 15228 RVA: 0x00068808 File Offset: 0x00066A08
+		public static ScriptPlayableOutput Create(PlayableGraph graph, string name)
+		{
+			PlayableOutputHandle playableOutputHandle;
+			ScriptPlayableOutput scriptPlayableOutput;
+			if (!PlayableGraph.CreateScriptOutputInternal(ref graph, name, out playableOutputHandle))
+			{
+				scriptPlayableOutput = ScriptPlayableOutput.Null;
+			}
+			else
+			{
+				scriptPlayableOutput = new ScriptPlayableOutput(playableOutputHandle);
+			}
+			return scriptPlayableOutput;
+		}
+
+		// Token: 0x17000D7D RID: 3453
+		// (get) Token: 0x06003B7D RID: 15229 RVA: 0x00068840 File Offset: 0x00066A40
+		public static ScriptPlayableOutput Null
+		{
+			get
+			{
+				return new ScriptPlayableOutput(PlayableOutputHandle.Null);
+			}
+		}
+
+		// Token: 0x06003B7E RID: 15230 RVA: 0x00068860 File Offset: 0x00066A60
+		public PlayableOutputHandle GetHandle()
+		{
+			return this.m_Handle;
+		}
+
+		// Token: 0x06003B7F RID: 15231 RVA: 0x0006887C File Offset: 0x00066A7C
+		public static implicit operator PlayableOutput(ScriptPlayableOutput output)
+		{
+			return new PlayableOutput(output.GetHandle());
+		}
+
+		// Token: 0x06003B80 RID: 15232 RVA: 0x000688A0 File Offset: 0x00066AA0
+		public static explicit operator ScriptPlayableOutput(PlayableOutput output)
+		{
+			return new ScriptPlayableOutput(output.GetHandle());
+		}
+
+		// Token: 0x040011E8 RID: 4584
+		private PlayableOutputHandle m_Handle;
+	}
+}