using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine.Animations;
using UnityEngine.Playables;
using UnityEngine.Serialization;

namespace UnityEngine.Timeline
{
	// Token: 0x0200001F RID: 31
	[Serializable]
	public abstract class TrackAsset : PlayableAsset, IInterval, ISerializationCallbackReceiver, IPropertyPreview
	{
		// Token: 0x060000F7 RID: 247 RVA: 0x00002713 File Offset: 0x00000913
		protected TrackAsset()
		{
			this.m_MediaType = TrackAsset.GetMediaType(base.GetType());
		}

		// Token: 0x1700004E RID: 78
		// (get) Token: 0x060000F8 RID: 248 RVA: 0x00002744 File Offset: 0x00000944
		// (set) Token: 0x060000F9 RID: 249 RVA: 0x0000275E File Offset: 0x0000095E
		public int intervalBit { get; set; }

		// Token: 0x1700004F RID: 79
		// (get) Token: 0x060000FA RID: 250 RVA: 0x00002768 File Offset: 0x00000968
		public double start
		{
			get
			{
				this.UpdateDuration();
				return (double)this.m_Start;
			}
		}

		// Token: 0x17000050 RID: 80
		// (get) Token: 0x060000FB RID: 251 RVA: 0x00002790 File Offset: 0x00000990
		public double end
		{
			get
			{
				this.UpdateDuration();
				return (double)this.m_End;
			}
		}

		// Token: 0x17000051 RID: 81
		// (get) Token: 0x060000FC RID: 252 RVA: 0x000027B8 File Offset: 0x000009B8
		public long intervalStart
		{
			get
			{
				return this.m_Start.GetTick();
			}
		}

		// Token: 0x17000052 RID: 82
		// (get) Token: 0x060000FD RID: 253 RVA: 0x000027D8 File Offset: 0x000009D8
		public long intervalEnd
		{
			get
			{
				return this.m_End.GetTick();
			}
		}

		// Token: 0x17000053 RID: 83
		// (get) Token: 0x060000FE RID: 254 RVA: 0x000027F8 File Offset: 0x000009F8
		public sealed override double duration
		{
			get
			{
				this.UpdateDuration();
				return (double)(this.m_End - this.m_Start);
			}
		}

		// Token: 0x17000054 RID: 84
		// (get) Token: 0x060000FF RID: 255 RVA: 0x0000282C File Offset: 0x00000A2C
		// (set) Token: 0x06000100 RID: 256 RVA: 0x00002847 File Offset: 0x00000A47
		public bool muted
		{
			get
			{
				return this.m_Muted;
			}
			set
			{
				this.m_Muted = value;
			}
		}

		// Token: 0x17000055 RID: 85
		// (get) Token: 0x06000101 RID: 257 RVA: 0x00002854 File Offset: 0x00000A54
		public TimelineAsset timelineAsset
		{
			get
			{
				TrackAsset trackAsset = this;
				while (trackAsset != null)
				{
					TimelineAsset timelineAsset;
					if (trackAsset.parent == null)
					{
						timelineAsset = null;
					}
					else
					{
						TimelineAsset timelineAsset2 = trackAsset.parent as TimelineAsset;
						if (!(timelineAsset2 != null))
						{
							trackAsset = trackAsset.parent as TrackAsset;
							continue;
						}
						timelineAsset = timelineAsset2;
					}
					return timelineAsset;
				}
				return null;
			}
		}

		// Token: 0x17000056 RID: 86
		// (get) Token: 0x06000102 RID: 258 RVA: 0x000028C4 File Offset: 0x00000AC4
		// (set) Token: 0x06000103 RID: 259 RVA: 0x000028DF File Offset: 0x00000ADF
		public PlayableAsset parent
		{
			get
			{
				return this.m_Parent;
			}
			internal set
			{
				this.m_Parent = value;
			}
		}

		// Token: 0x06000104 RID: 260 RVA: 0x000028EC File Offset: 0x00000AEC
		public IEnumerable<TimelineClip> GetClips()
		{
			return this.clips;
		}

		// Token: 0x17000057 RID: 87
		// (get) Token: 0x06000105 RID: 261 RVA: 0x00002908 File Offset: 0x00000B08
		internal TimelineClip[] clips
		{
			get
			{
				if (this.m_Clips == null)
				{
					this.m_Clips = new List<TimelineClip>();
				}
				if (this.m_ClipsCache == null)
				{
					this.m_ClipsCache = this.m_Clips.ToArray();
				}
				return this.m_ClipsCache;
			}
		}

		// Token: 0x17000058 RID: 88
		// (get) Token: 0x06000106 RID: 262 RVA: 0x00002958 File Offset: 0x00000B58
		public bool isEmpty
		{
			get
			{
				return this.m_Clips == null || this.m_Clips.Count == 0;
			}
		}

		// Token: 0x17000059 RID: 89
		// (get) Token: 0x06000107 RID: 263 RVA: 0x0000298C File Offset: 0x00000B8C
		public bool isSubTrack
		{
			get
			{
				TrackAsset trackAsset = this.parent as TrackAsset;
				return trackAsset != null && trackAsset.GetType() == base.GetType();
			}
		}

		// Token: 0x1700005A RID: 90
		// (get) Token: 0x06000108 RID: 264 RVA: 0x000029CC File Offset: 0x00000BCC
		public override IEnumerable<PlayableBinding> outputs
		{
			get
			{
				TrackBindingTypeAttribute attribute = Attribute.GetCustomAttribute(base.GetType(), typeof(TrackBindingTypeAttribute)) as TrackBindingTypeAttribute;
				Type trackBindingType = ((attribute == null) ? null : attribute.type);
				yield return new PlayableBinding
				{
					sourceObject = this,
					streamName = base.name,
					streamType = DataStreamType.None,
					sourceBindingType = trackBindingType
				};
				yield break;
			}
		}

		// Token: 0x06000109 RID: 265 RVA: 0x000029F8 File Offset: 0x00000BF8
		public IEnumerable<TrackAsset> GetChildTracks()
		{
			return this.m_Children.ToArray();
		}

		// Token: 0x1700005B RID: 91
		// (get) Token: 0x0600010A RID: 266 RVA: 0x00002A18 File Offset: 0x00000C18
		// (set) Token: 0x0600010B RID: 267 RVA: 0x00002A33 File Offset: 0x00000C33
		internal string customPlayableTypename
		{
			get
			{
				return this.m_CustomPlayableFullTypename;
			}
			set
			{
				this.m_CustomPlayableFullTypename = value;
			}
		}

		// Token: 0x1700005C RID: 92
		// (get) Token: 0x0600010C RID: 268 RVA: 0x00002A40 File Offset: 0x00000C40
		// (set) Token: 0x0600010D RID: 269 RVA: 0x00002A5B File Offset: 0x00000C5B
		internal AnimationClip animClip
		{
			get
			{
				return this.m_AnimClip;
			}
			set
			{
				this.m_AnimClip = value;
			}
		}

		// Token: 0x1700005D RID: 93
		// (get) Token: 0x0600010E RID: 270 RVA: 0x00002A68 File Offset: 0x00000C68
		// (set) Token: 0x0600010F RID: 271 RVA: 0x00002A82 File Offset: 0x00000C82
		internal bool displayCascadeClips { get; set; }

		// Token: 0x1700005E RID: 94
		// (get) Token: 0x06000110 RID: 272 RVA: 0x00002A8C File Offset: 0x00000C8C
		// (set) Token: 0x06000111 RID: 273 RVA: 0x00002AA7 File Offset: 0x00000CA7
		internal bool soloed
		{
			get
			{
				return this.m_Soloed;
			}
			set
			{
				this.m_Soloed = value;
			}
		}

		// Token: 0x1700005F RID: 95
		// (get) Token: 0x06000112 RID: 274 RVA: 0x00002AB4 File Offset: 0x00000CB4
		// (set) Token: 0x06000113 RID: 275 RVA: 0x00002ACF File Offset: 0x00000CCF
		internal float height
		{
			get
			{
				return this.m_Height;
			}
			set
			{
				this.m_Height = value;
			}
		}

		// Token: 0x17000060 RID: 96
		// (get) Token: 0x06000114 RID: 276 RVA: 0x00002ADC File Offset: 0x00000CDC
		// (set) Token: 0x06000115 RID: 277 RVA: 0x00002AF7 File Offset: 0x00000CF7
		internal List<TrackAsset> subTracks
		{
			get
			{
				return this.m_Children;
			}
			set
			{
				this.m_Children = value;
			}
		}

		// Token: 0x17000061 RID: 97
		// (get) Token: 0x06000116 RID: 278 RVA: 0x00002B04 File Offset: 0x00000D04
		// (set) Token: 0x06000117 RID: 279 RVA: 0x00002B1F File Offset: 0x00000D1F
		internal bool locked
		{
			get
			{
				return this.m_Locked;
			}
			set
			{
				this.m_Locked = value;
			}
		}

		// Token: 0x17000062 RID: 98
		// (get) Token: 0x06000118 RID: 280 RVA: 0x00002B2C File Offset: 0x00000D2C
		internal TimelineAsset.MediaType mediaType
		{
			get
			{
				return this.m_MediaType;
			}
		}

		// Token: 0x17000063 RID: 99
		// (get) Token: 0x06000119 RID: 281 RVA: 0x00002B48 File Offset: 0x00000D48
		internal virtual bool compilable
		{
			get
			{
				return !this.muted && !this.isEmpty;
			}
		}

		// Token: 0x0600011A RID: 282 RVA: 0x00002B74 File Offset: 0x00000D74
		public void OnBeforeSerialize()
		{
		}

		// Token: 0x0600011B RID: 283 RVA: 0x00002B77 File Offset: 0x00000D77
		public void OnAfterDeserialize()
		{
			this.m_ClipsCache = null;
			this.InvalidateTimelineCaches();
		}

		// Token: 0x0600011C RID: 284 RVA: 0x00002B88 File Offset: 0x00000D88
		public virtual void OnEnable()
		{
			if (this.m_Children == null)
			{
				this.m_Children = new List<TrackAsset>();
			}
			if (this.m_Clips == null)
			{
				this.m_Clips = new List<TimelineClip>();
			}
			if (this.m_Children.Count > 0)
			{
				List<TrackAsset> list = this.m_Children.Where((TrackAsset t) => t != null).ToList<TrackAsset>();
				this.m_Children = list;
			}
			this.displayCascadeClips = false;
		}

		// Token: 0x0600011D RID: 285 RVA: 0x00002C14 File Offset: 0x00000E14
		public virtual Playable CreateTrackMixer(PlayableGraph graph, GameObject go, int inputCount)
		{
			return Playable.Create(graph, inputCount);
		}

		// Token: 0x0600011E RID: 286 RVA: 0x00002C30 File Offset: 0x00000E30
		public sealed override Playable CreatePlayable(PlayableGraph graph, GameObject go)
		{
			return Playable.Null;
		}

		// Token: 0x0600011F RID: 287 RVA: 0x00002C4C File Offset: 0x00000E4C
		public TimelineClip CreateDefaultClip()
		{
			TrackClipTypeAttribute trackClipTypeAttribute = base.GetType().GetCustomAttributes(typeof(TrackClipTypeAttribute), true).OfType<TrackClipTypeAttribute>()
				.FirstOrDefault((TrackClipTypeAttribute t) => typeof(IPlayableAsset).IsAssignableFrom(t.inspectedType) && typeof(ScriptableObject).IsAssignableFrom(t.inspectedType));
			TimelineClip timelineClip;
			if (trackClipTypeAttribute == null)
			{
				Debug.LogWarning("Cannot create a default clip for type " + base.GetType());
				timelineClip = null;
			}
			else
			{
				timelineClip = this.CreateClipOfType(trackClipTypeAttribute.inspectedType);
			}
			return timelineClip;
		}

		// Token: 0x06000120 RID: 288 RVA: 0x00002CD0 File Offset: 0x00000ED0
		internal TimelineClip CreateClipOfType(Type type)
		{
			if (type == null || !typeof(IPlayableAsset).IsAssignableFrom(type) || !typeof(ScriptableObject).IsAssignableFrom(type))
			{
				throw new InvalidOperationException("Cannot create an clip for type " + type.Name);
			}
			ScriptableObject scriptableObject = ScriptableObject.CreateInstance(type);
			if (scriptableObject == null)
			{
				throw new InvalidOperationException("Could not create an instance of the ScriptableObject type " + type.Name);
			}
			scriptableObject.name = type.Name;
			TimelineCreateUtilities.SaveAssetIntoObject(scriptableObject, this);
			TimelineClip timelineClip = this.CreateNewClipContainerInternal();
			timelineClip.displayName = scriptableObject.name;
			timelineClip.asset = scriptableObject;
			try
			{
				this.OnCreateClipFromAsset(scriptableObject, timelineClip);
			}
			catch (Exception ex)
			{
				Debug.LogError(ex.Message, scriptableObject);
				return null;
			}
			this.AddClip(timelineClip);
			return timelineClip;
		}

		// Token: 0x06000121 RID: 289 RVA: 0x00002DC0 File Offset: 0x00000FC0
		internal void AddClip(TimelineClip newClip)
		{
			if (!this.m_Clips.Contains(newClip))
			{
				this.m_Clips.Add(newClip);
				this.m_ClipsCache = null;
			}
		}

		// Token: 0x06000122 RID: 290 RVA: 0x00002DEC File Offset: 0x00000FEC
		internal Playable CreatePlayableGraph(PlayableGraph graph, GameObject go, IntervalTree tree)
		{
			this.UpdateDuration();
			return this.OnCreatePlayableGraph(graph, go, tree);
		}

		// Token: 0x06000123 RID: 291 RVA: 0x00002E10 File Offset: 0x00001010
		internal virtual Playable OnCreatePlayableGraph(PlayableGraph graph, GameObject go, IntervalTree tree)
		{
			if (tree == null)
			{
				throw new ArgumentException("IntervalTree argument cannot be null", "tree");
			}
			if (go == null)
			{
				throw new ArgumentException("GameObject argument cannot be null", "go");
			}
			Playable playable = this.CreateTrackMixer(graph, go, this.clips.Length);
			for (int i = 0; i < this.clips.Length; i++)
			{
				Playable playable2 = this.CreatePlayable(graph, go, this.clips[i]);
				if (playable2.IsValid<Playable>())
				{
					playable2.SetDuration(this.clips[i].duration);
					RuntimeClip runtimeClip = new RuntimeClip(this.clips[i], playable2, playable);
					tree.Add(runtimeClip);
					graph.Connect<Playable, Playable>(playable2, 0, playable, i);
					playable.SetInputWeight(i, 0f);
				}
			}
			return playable;
		}

		// Token: 0x06000124 RID: 292 RVA: 0x00002EE8 File Offset: 0x000010E8
		internal bool IsCompatibleWithClip(TimelineClip clip)
		{
			return this.ValidateClipType(clip.underlyingAsset.GetType());
		}

		// Token: 0x06000125 RID: 293 RVA: 0x00002F0E File Offset: 0x0000110E
		internal void SortClips()
		{
			this.m_Clips.Sort((TimelineClip clip1, TimelineClip clip2) => clip1.start.CompareTo(clip2.start));
			this.m_ClipsCache = null;
		}

		// Token: 0x06000126 RID: 294 RVA: 0x00002F40 File Offset: 0x00001140
		internal void SetClips(List<TimelineClip> clips)
		{
			this.m_Clips = clips;
			this.m_ClipsCache = clips.ToArray();
		}

		// Token: 0x06000127 RID: 295 RVA: 0x00002F58 File Offset: 0x00001158
		internal TimelineClip CreateClipFromAsset(Object asset)
		{
			TimelineClip timelineClip;
			if (asset == null)
			{
				timelineClip = null;
			}
			else
			{
				TimelineAsset timelineAsset = asset as TimelineAsset;
				if (timelineAsset == null && !this.ValidateClipType(asset.GetType()))
				{
					throw new InvalidOperationException(string.Format("Cannot create a clip for track {0} with clip type: {1}. Did you forget a ClipClass attribute?", base.GetType(), asset.GetType()));
				}
				TimelineClip timelineClip2 = this.CreateNewClipContainerInternal();
				timelineClip2.underlyingAsset = asset;
				timelineClip2.displayName = asset.name;
				timelineClip2.asset = asset;
				try
				{
					this.OnCreateClipFromAsset(asset, timelineClip2);
				}
				catch (Exception ex)
				{
					Debug.LogError(ex.Message, asset);
					this.RemoveClip(timelineClip2);
					return null;
				}
				timelineClip = timelineClip2;
			}
			return timelineClip;
		}

		// Token: 0x06000128 RID: 296 RVA: 0x00003020 File Offset: 0x00001220
		internal virtual void OnCreateClipFromAsset(Object asset, TimelineClip clip)
		{
			clip.asset = asset;
			clip.underlyingAsset = asset;
			clip.displayName = asset.name;
			IPlayableAsset playableAsset = asset as IPlayableAsset;
			if (playableAsset != null)
			{
				double duration = playableAsset.duration;
				if (duration > 0.0 && !double.IsInfinity(duration))
				{
					clip.duration = duration;
				}
			}
		}

		// Token: 0x06000129 RID: 297 RVA: 0x00003080 File Offset: 0x00001280
		internal TimelineClip CreateNewClipContainerInternal()
		{
			TimelineClip timelineClip = new TimelineClip(this);
			timelineClip.asset = null;
			double num = 0.0;
			for (int i = 0; i < this.m_Clips.Count - 1; i++)
			{
				double num2 = this.m_Clips[i].duration;
				if (double.IsInfinity(num2))
				{
					num2 = (double)TimelineClip.kDefaultClipDurationInSeconds;
				}
				num = Math.Max(num, this.m_Clips[i].start + num2);
			}
			timelineClip.mixInCurve = AnimationCurve.EaseInOut(0f, 0f, 1f, 1f);
			timelineClip.mixOutCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f);
			timelineClip.start = num;
			timelineClip.duration = (double)TimelineClip.kDefaultClipDurationInSeconds;
			timelineClip.displayName = "untitled";
			return timelineClip;
		}

		// Token: 0x0600012A RID: 298 RVA: 0x0000316A File Offset: 0x0000136A
		internal void AddChild(TrackAsset child)
		{
			if (!(child == null))
			{
				this.m_Children.Add(child);
				child.parent = this;
				this.InvalidateTimelineCaches();
			}
		}

		// Token: 0x0600012B RID: 299 RVA: 0x00003198 File Offset: 0x00001398
		internal bool AddChildAfter(TrackAsset child, TrackAsset other)
		{
			bool flag;
			if (child == null)
			{
				flag = false;
			}
			else
			{
				int num = this.m_Children.IndexOf(other);
				if (num >= 0 && num != this.m_Children.Count - 1)
				{
					this.m_Children.Insert(num + 1, child);
				}
				else
				{
					this.m_Children.Add(child);
				}
				this.InvalidateTimelineCaches();
				child.parent = this;
				flag = true;
			}
			return flag;
		}

		// Token: 0x0600012C RID: 300 RVA: 0x00003218 File Offset: 0x00001418
		internal bool RemoveSubTrack(TrackAsset child)
		{
			bool flag;
			if (this.m_Children.Remove(child))
			{
				this.InvalidateTimelineCaches();
				child.parent = null;
				flag = true;
			}
			else
			{
				flag = false;
			}
			return flag;
		}

		// Token: 0x0600012D RID: 301 RVA: 0x00003254 File Offset: 0x00001454
		internal void RemoveClip(TimelineClip clip)
		{
			this.m_Clips.Remove(clip);
			this.m_ClipsCache = null;
		}

		// Token: 0x0600012E RID: 302 RVA: 0x0000326C File Offset: 0x0000146C
		internal virtual void GetEvaluationTime(out double outStart, out double outDuration)
		{
			if (this.clips.Length == 0)
			{
				outStart = 0.0;
				outDuration = 0.0;
			}
			else
			{
				outStart = double.MaxValue;
				double num = 0.0;
				for (int i = 0; i < this.clips.Length; i++)
				{
					outStart = Math.Min(this.clips[i].start, outStart);
					num = Math.Max(this.clips[i].start + this.clips[i].duration, num);
				}
				outStart = Math.Max(outStart, 0.0);
				outDuration = num - outStart;
			}
		}

		// Token: 0x0600012F RID: 303 RVA: 0x00003323 File Offset: 0x00001523
		internal virtual void GetSequenceTime(out double outStart, out double outDuration)
		{
			this.GetEvaluationTime(out outStart, out outDuration);
		}

		// Token: 0x06000130 RID: 304 RVA: 0x00003330 File Offset: 0x00001530
		public virtual void GatherProperties(PlayableDirector director, IPropertyCollector driver)
		{
			GameObject gameObjectBinding = this.GetGameObjectBinding(director);
			if (gameObjectBinding != null)
			{
				driver.PushActiveGameObject(gameObjectBinding);
			}
			if (this.animClip != null)
			{
				driver.AddFromClip(this.animClip);
			}
			foreach (TimelineClip timelineClip in this.clips)
			{
				if (timelineClip.curves != null && timelineClip.asset != null)
				{
					driver.AddObjectProperties(timelineClip.asset, timelineClip.curves);
				}
				IPropertyPreview propertyPreview = timelineClip.asset as IPropertyPreview;
				if (propertyPreview != null)
				{
					propertyPreview.GatherProperties(director, driver);
				}
			}
			foreach (TrackAsset trackAsset in this.subTracks)
			{
				if (trackAsset != null)
				{
					trackAsset.GatherProperties(director, driver);
				}
			}
			if (gameObjectBinding != null)
			{
				driver.PopActiveGameObject();
			}
		}

		// Token: 0x06000131 RID: 305 RVA: 0x00003460 File Offset: 0x00001660
		internal GameObject GetGameObjectBinding(PlayableDirector director)
		{
			GameObject gameObject;
			if (director == null)
			{
				gameObject = null;
			}
			else
			{
				GameObject gameObject2 = director.GetGenericBinding(this) as GameObject;
				if (gameObject2 != null)
				{
					gameObject = gameObject2;
				}
				else
				{
					Component component = director.GetGenericBinding(this) as Component;
					if (component != null)
					{
						gameObject = component.gameObject;
					}
					else
					{
						gameObject = null;
					}
				}
			}
			return gameObject;
		}

		// Token: 0x06000132 RID: 306 RVA: 0x000034D0 File Offset: 0x000016D0
		private bool ValidateClipType(Type clipType)
		{
			foreach (object obj in base.GetType().GetCustomAttributes(typeof(TrackClipTypeAttribute), true))
			{
				TrackClipTypeAttribute trackClipTypeAttribute = obj as TrackClipTypeAttribute;
				if (trackClipTypeAttribute.inspectedType.IsAssignableFrom(clipType))
				{
					return true;
				}
			}
			return false;
		}

		// Token: 0x06000133 RID: 307 RVA: 0x0000353C File Offset: 0x0000173C
		private TimelineClip NestPlayableAsset(PlayableAsset asset)
		{
			DataStreamType dataStreamType = DataStreamType.None;
			switch (this.mediaType)
			{
			case TimelineAsset.MediaType.Animation:
				dataStreamType = DataStreamType.Animation;
				break;
			case TimelineAsset.MediaType.Audio:
				dataStreamType = DataStreamType.Audio;
				break;
			case TimelineAsset.MediaType.Video:
				dataStreamType = DataStreamType.Video;
				break;
			case TimelineAsset.MediaType.Script:
				dataStreamType = DataStreamType.None;
				break;
			}
			int num = -1;
			int num2 = 0;
			foreach (PlayableBinding playableBinding in asset.outputs)
			{
				if (playableBinding.streamType == dataStreamType)
				{
					num = num2;
					break;
				}
				num2++;
			}
			if (num < 0)
			{
				throw new InvalidOperationException("Cannot nest asset because it does not contain any compatible tracks");
			}
			TimelineClip timelineClip = this.CreateNewClipContainerInternal();
			timelineClip.asset = asset;
			timelineClip.displayName = asset.name;
			timelineClip.duration = asset.duration;
			return timelineClip;
		}

		// Token: 0x06000134 RID: 308 RVA: 0x0000363C File Offset: 0x0000183C
		private void UpdateDuration()
		{
			if (this.clips.Length == 0)
			{
				this.m_ClipsHash = 0;
				this.m_Start = 0;
				this.m_End = (DiscreteTime)((!(this.m_AnimClip != null)) ? 0f : this.m_AnimClip.length);
			}
			else
			{
				int num = HashUtility.CombineHash(this.clips.Select((TimelineClip c) => c.Hash()).ToArray<int>());
				if (num != this.m_ClipsHash)
				{
					this.m_ClipsHash = num;
					double num2;
					double num3;
					this.GetSequenceTime(out num2, out num3);
					this.m_Start = (DiscreteTime)num2;
					this.m_End = (DiscreteTime)(num2 + num3);
					this.CalculateExtrapolationTimes();
				}
			}
		}

		// Token: 0x06000135 RID: 309 RVA: 0x00003718 File Offset: 0x00001918
		protected internal virtual Playable CreatePlayable(PlayableGraph graph, GameObject go, TimelineClip clip)
		{
			IPlayableAsset playableAsset = clip.asset as IPlayableAsset;
			Playable playable2;
			if (playableAsset != null)
			{
				Playable playable = playableAsset.CreatePlayable(graph, go);
				if (playable.IsValid<Playable>())
				{
					playable.SetAnimatedProperties(clip.curves);
					playable.SetSpeed(clip.timeScale);
				}
				playable2 = playable;
			}
			else
			{
				playable2 = Playable.Null;
			}
			return playable2;
		}

		// Token: 0x06000136 RID: 310 RVA: 0x0000377C File Offset: 0x0000197C
		private void InvalidateTimelineCaches()
		{
			TimelineAsset timelineAsset = this.timelineAsset;
			if (timelineAsset != null)
			{
				timelineAsset.Invalidate();
			}
		}

		// Token: 0x06000137 RID: 311 RVA: 0x000037A8 File Offset: 0x000019A8
		private static TimelineAsset.MediaType GetMediaType(Type t)
		{
			object[] customAttributes = t.GetCustomAttributes(typeof(TrackMediaType), true);
			TimelineAsset.MediaType mediaType;
			if (customAttributes.Length > 0 && customAttributes[0] is TrackMediaType)
			{
				mediaType = ((TrackMediaType)customAttributes[0]).m_MediaType;
			}
			else
			{
				mediaType = TimelineAsset.MediaType.Script;
			}
			return mediaType;
		}

		// Token: 0x04000078 RID: 120
		[SerializeField]
		private bool m_Locked;

		// Token: 0x04000079 RID: 121
		[SerializeField]
		private bool m_Muted;

		// Token: 0x0400007A RID: 122
		[SerializeField]
		private bool m_Soloed;

		// Token: 0x0400007B RID: 123
		[SerializeField]
		private float m_Height;

		// Token: 0x0400007C RID: 124
		[SerializeField]
		private string m_CustomPlayableFullTypename = string.Empty;

		// Token: 0x0400007D RID: 125
		[NonSerialized]
		private DiscreteTime m_Start;

		// Token: 0x0400007E RID: 126
		[NonSerialized]
		private DiscreteTime m_End;

		// Token: 0x0400007F RID: 127
		[SerializeField]
		[FormerlySerializedAs("m_animClip")]
		private AnimationClip m_AnimClip;

		// Token: 0x04000080 RID: 128
		[NonSerialized]
		private TimelineClip[] m_ClipsCache;

		// Token: 0x04000081 RID: 129
		[NonSerialized]
		private int m_ClipsHash;

		// Token: 0x04000082 RID: 130
		[SerializeField]
		private PlayableAsset m_Parent;

		// Token: 0x04000083 RID: 131
		[SerializeField]
		private List<TrackAsset> m_Children;

		// Token: 0x04000084 RID: 132
		private TimelineAsset.MediaType m_MediaType;

		// Token: 0x04000085 RID: 133
		[SerializeField]
		protected internal List<TimelineClip> m_Clips = new List<TimelineClip>();
	}
}