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

namespace UnityEngine.Timeline
{
	// Token: 0x02000018 RID: 24
	[Serializable]
	public class TimelineClip
	{
		// Token: 0x06000092 RID: 146 RVA: 0x0000537C File Offset: 0x0000357C
		internal TimelineClip(TrackAsset parent)
		{
			this.parentTrack = parent;
		}

		// Token: 0x17000020 RID: 32
		// (get) Token: 0x06000093 RID: 147 RVA: 0x0000540C File Offset: 0x0000360C
		// (set) Token: 0x06000094 RID: 148 RVA: 0x00005426 File Offset: 0x00003626
		internal int dirtyHash { get; set; }

		// Token: 0x17000021 RID: 33
		// (get) Token: 0x06000095 RID: 149 RVA: 0x00005430 File Offset: 0x00003630
		public bool hasPreExtrapolation
		{
			get
			{
				return this.m_PreExtrapolationMode != TimelineClip.ClipExtrapolation.None && this.m_PreExtrapolationTime > 0.0;
			}
		}

		// Token: 0x17000022 RID: 34
		// (get) Token: 0x06000096 RID: 150 RVA: 0x00005464 File Offset: 0x00003664
		public bool hasPostExtrapolation
		{
			get
			{
				return this.m_PostExtrapolationMode != TimelineClip.ClipExtrapolation.None && this.m_PostExtrapolationTime > 0.0;
			}
		}

		// Token: 0x17000023 RID: 35
		// (get) Token: 0x06000097 RID: 151 RVA: 0x00005498 File Offset: 0x00003698
		// (set) Token: 0x06000098 RID: 152 RVA: 0x000054E6 File Offset: 0x000036E6
		public double timeScale
		{
			get
			{
				return (!this.clipCaps.HasAny(ClipCaps.SpeedMultiplier)) ? 1.0 : Math.Max(TimelineClip.kTimeScaleMin, Math.Min(this.m_TimeScale, TimelineClip.kTimeScaleMax));
			}
			set
			{
				this.m_TimeScale = ((!this.clipCaps.HasAny(ClipCaps.SpeedMultiplier)) ? 1.0 : Math.Max(TimelineClip.kTimeScaleMin, Math.Min(value, TimelineClip.kTimeScaleMax)));
			}
		}

		// Token: 0x17000024 RID: 36
		// (get) Token: 0x06000099 RID: 153 RVA: 0x00005524 File Offset: 0x00003724
		// (set) Token: 0x0600009A RID: 154 RVA: 0x0000553F File Offset: 0x0000373F
		public double start
		{
			get
			{
				return this.m_Start;
			}
			set
			{
				this.m_Start = Math.Max(TimelineClip.SanitizeTimeValue(value, this.m_Start), 0.0);
			}
		}

		// Token: 0x17000025 RID: 37
		// (get) Token: 0x0600009B RID: 155 RVA: 0x00005564 File Offset: 0x00003764
		// (set) Token: 0x0600009C RID: 156 RVA: 0x0000557F File Offset: 0x0000377F
		public double duration
		{
			get
			{
				return this.m_Duration;
			}
			set
			{
				this.m_Duration = Math.Max(TimelineClip.SanitizeTimeValue(value, this.m_Duration), double.Epsilon);
			}
		}

		// Token: 0x17000026 RID: 38
		// (get) Token: 0x0600009D RID: 157 RVA: 0x000055A4 File Offset: 0x000037A4
		public double end
		{
			get
			{
				return this.m_Start + this.m_Duration;
			}
		}

		// Token: 0x17000027 RID: 39
		// (get) Token: 0x0600009E RID: 158 RVA: 0x000055C8 File Offset: 0x000037C8
		// (set) Token: 0x0600009F RID: 159 RVA: 0x00005604 File Offset: 0x00003804
		public double clipIn
		{
			get
			{
				return (!this.clipCaps.HasAny(ClipCaps.ClipIn)) ? 0.0 : this.m_ClipIn;
			}
			set
			{
				this.m_ClipIn = ((!this.clipCaps.HasAny(ClipCaps.ClipIn)) ? 0.0 : Math.Max(Math.Min(TimelineClip.SanitizeTimeValue(value, this.m_ClipIn), this.clipAssetDuration), 0.0));
			}
		}

		// Token: 0x17000028 RID: 40
		// (get) Token: 0x060000A0 RID: 160 RVA: 0x0000565C File Offset: 0x0000385C
		// (set) Token: 0x060000A1 RID: 161 RVA: 0x00005677 File Offset: 0x00003877
		public string displayName
		{
			get
			{
				return this.m_DisplayName;
			}
			set
			{
				this.m_DisplayName = value;
			}
		}

		// Token: 0x17000029 RID: 41
		// (get) Token: 0x060000A2 RID: 162 RVA: 0x00005684 File Offset: 0x00003884
		public double clipAssetDuration
		{
			get
			{
				IPlayableAsset playableAsset = this.m_Asset as IPlayableAsset;
				return (playableAsset == null) ? double.MaxValue : playableAsset.duration;
			}
		}

		// Token: 0x1700002A RID: 42
		// (get) Token: 0x060000A3 RID: 163 RVA: 0x000056C0 File Offset: 0x000038C0
		public AnimationClip curves
		{
			get
			{
				return this.m_AnimationCurves;
			}
		}

		// Token: 0x1700002B RID: 43
		// (get) Token: 0x060000A4 RID: 164 RVA: 0x000056DC File Offset: 0x000038DC
		// (set) Token: 0x060000A5 RID: 165 RVA: 0x000056F7 File Offset: 0x000038F7
		public Object asset
		{
			get
			{
				return this.m_Asset;
			}
			set
			{
				this.m_Asset = value;
			}
		}

		// Token: 0x1700002C RID: 44
		// (get) Token: 0x060000A6 RID: 166 RVA: 0x00005704 File Offset: 0x00003904
		// (set) Token: 0x060000A7 RID: 167 RVA: 0x0000573B File Offset: 0x0000393B
		public Object underlyingAsset
		{
			get
			{
				return (!(this.m_UnderlyingAsset != null)) ? this.m_Asset : this.m_UnderlyingAsset;
			}
			set
			{
				this.m_UnderlyingAsset = value;
			}
		}

		// Token: 0x1700002D RID: 45
		// (get) Token: 0x060000A8 RID: 168 RVA: 0x00005748 File Offset: 0x00003948
		// (set) Token: 0x060000A9 RID: 169 RVA: 0x00005764 File Offset: 0x00003964
		internal TrackAsset parentTrack
		{
			get
			{
				return this.m_ParentTrack;
			}
			set
			{
				if (!(value == null))
				{
					if (!(this.m_ParentTrack == value))
					{
						if (this.m_ParentTrack != null)
						{
							this.m_ParentTrack.RemoveClip(this);
						}
						this.m_ParentTrack = value;
						this.m_ParentTrack.AddClip(this);
					}
				}
			}
		}

		// Token: 0x1700002E RID: 46
		// (get) Token: 0x060000AA RID: 170 RVA: 0x000057CC File Offset: 0x000039CC
		// (set) Token: 0x060000AB RID: 171 RVA: 0x0000582A File Offset: 0x00003A2A
		public double easeInDuration
		{
			get
			{
				return (!this.clipCaps.HasAny(ClipCaps.Blending)) ? 0.0 : Math.Min(Math.Max(this.m_EaseInDuration, 0.0), this.duration * 0.49);
			}
			set
			{
				this.m_EaseInDuration = ((!this.clipCaps.HasAny(ClipCaps.Blending)) ? 0.0 : TimelineClip.SanitizeTimeValue(value, this.m_EaseInDuration));
			}
		}

		// Token: 0x1700002F RID: 47
		// (get) Token: 0x060000AC RID: 172 RVA: 0x00005860 File Offset: 0x00003A60
		// (set) Token: 0x060000AD RID: 173 RVA: 0x000058BE File Offset: 0x00003ABE
		public double easeOutDuration
		{
			get
			{
				return (!this.clipCaps.HasAny(ClipCaps.Blending)) ? 0.0 : Math.Min(Math.Max(this.m_EaseOutDuration, 0.0), this.duration * 0.49);
			}
			set
			{
				this.m_EaseOutDuration = ((!this.clipCaps.HasAny(ClipCaps.Blending)) ? 0.0 : TimelineClip.SanitizeTimeValue(value, this.m_EaseOutDuration));
			}
		}

		// Token: 0x17000030 RID: 48
		// (get) Token: 0x060000AE RID: 174 RVA: 0x000058F4 File Offset: 0x00003AF4
		public double eastOutTime
		{
			get
			{
				return this.duration - this.easeOutDuration + this.m_Start;
			}
		}

		// Token: 0x17000031 RID: 49
		// (get) Token: 0x060000AF RID: 175 RVA: 0x00005920 File Offset: 0x00003B20
		// (set) Token: 0x060000B0 RID: 176 RVA: 0x0000595B File Offset: 0x00003B5B
		public double blendInDuration
		{
			get
			{
				return (!this.clipCaps.HasAny(ClipCaps.Blending)) ? 0.0 : this.m_BlendInDuration;
			}
			set
			{
				this.m_BlendInDuration = ((!this.clipCaps.HasAny(ClipCaps.Blending)) ? 0.0 : TimelineClip.SanitizeTimeValue(value, this.m_BlendInDuration));
			}
		}

		// Token: 0x17000032 RID: 50
		// (get) Token: 0x060000B1 RID: 177 RVA: 0x00005990 File Offset: 0x00003B90
		// (set) Token: 0x060000B2 RID: 178 RVA: 0x000059CB File Offset: 0x00003BCB
		public double blendOutDuration
		{
			get
			{
				return (!this.clipCaps.HasAny(ClipCaps.Blending)) ? 0.0 : this.m_BlendOutDuration;
			}
			set
			{
				this.m_BlendOutDuration = ((!this.clipCaps.HasAny(ClipCaps.Blending)) ? 0.0 : TimelineClip.SanitizeTimeValue(value, this.m_BlendOutDuration));
			}
		}

		// Token: 0x17000033 RID: 51
		// (get) Token: 0x060000B3 RID: 179 RVA: 0x00005A00 File Offset: 0x00003C00
		// (set) Token: 0x060000B4 RID: 180 RVA: 0x00005A1B File Offset: 0x00003C1B
		public TimelineClip.BlendCurveMode blendInCurveMode
		{
			get
			{
				return this.m_BlendInCurveMode;
			}
			set
			{
				this.m_BlendInCurveMode = value;
			}
		}

		// Token: 0x17000034 RID: 52
		// (get) Token: 0x060000B5 RID: 181 RVA: 0x00005A28 File Offset: 0x00003C28
		// (set) Token: 0x060000B6 RID: 182 RVA: 0x00005A43 File Offset: 0x00003C43
		public TimelineClip.BlendCurveMode blendOutCurveMode
		{
			get
			{
				return this.m_BlendOutCurveMode;
			}
			set
			{
				this.m_BlendOutCurveMode = value;
			}
		}

		// Token: 0x17000035 RID: 53
		// (get) Token: 0x060000B7 RID: 183 RVA: 0x00005A50 File Offset: 0x00003C50
		public bool hasBlendIn
		{
			get
			{
				return this.clipCaps.HasAny(ClipCaps.Blending) && this.m_BlendInDuration > 0.0;
			}
		}

		// Token: 0x17000036 RID: 54
		// (get) Token: 0x060000B8 RID: 184 RVA: 0x00005A8C File Offset: 0x00003C8C
		public bool hasBlendOut
		{
			get
			{
				return this.clipCaps.HasAny(ClipCaps.Blending) && this.m_BlendOutDuration > 0.0;
			}
		}

		// Token: 0x17000037 RID: 55
		// (get) Token: 0x060000B9 RID: 185 RVA: 0x00005AC8 File Offset: 0x00003CC8
		// (set) Token: 0x060000BA RID: 186 RVA: 0x00005B0B File Offset: 0x00003D0B
		public AnimationCurve mixInCurve
		{
			get
			{
				if (this.m_MixInCurve == null || this.m_MixInCurve.length < 2)
				{
					this.m_MixInCurve = this.GetDefaultMixInCurve();
				}
				return this.m_MixInCurve;
			}
			set
			{
				this.m_MixInCurve = value;
			}
		}

		// Token: 0x17000038 RID: 56
		// (get) Token: 0x060000BB RID: 187 RVA: 0x00005B18 File Offset: 0x00003D18
		public float mixInPercentage
		{
			get
			{
				return (float)(this.mixInDuration / this.duration);
			}
		}

		// Token: 0x17000039 RID: 57
		// (get) Token: 0x060000BC RID: 188 RVA: 0x00005B3C File Offset: 0x00003D3C
		public double mixInDuration
		{
			get
			{
				return (!this.hasBlendIn) ? this.easeInDuration : this.blendInDuration;
			}
		}

		// Token: 0x1700003A RID: 58
		// (get) Token: 0x060000BD RID: 189 RVA: 0x00005B70 File Offset: 0x00003D70
		// (set) Token: 0x060000BE RID: 190 RVA: 0x00005BB3 File Offset: 0x00003DB3
		public AnimationCurve mixOutCurve
		{
			get
			{
				if (this.m_MixOutCurve == null || this.m_MixOutCurve.length < 2)
				{
					this.m_MixOutCurve = this.GetDefaultMixOutCurve();
				}
				return this.m_MixOutCurve;
			}
			set
			{
				this.m_MixOutCurve = value;
			}
		}

		// Token: 0x1700003B RID: 59
		// (get) Token: 0x060000BF RID: 191 RVA: 0x00005BC0 File Offset: 0x00003DC0
		public double mixOutTime
		{
			get
			{
				return this.duration - this.mixOutDuration + this.m_Start;
			}
		}

		// Token: 0x1700003C RID: 60
		// (get) Token: 0x060000C0 RID: 192 RVA: 0x00005BEC File Offset: 0x00003DEC
		public double mixOutDuration
		{
			get
			{
				return (!this.hasBlendOut) ? this.easeOutDuration : this.blendOutDuration;
			}
		}

		// Token: 0x1700003D RID: 61
		// (get) Token: 0x060000C1 RID: 193 RVA: 0x00005C20 File Offset: 0x00003E20
		public float mixOutPercentage
		{
			get
			{
				return (float)(this.mixOutDuration / this.duration);
			}
		}

		// Token: 0x1700003E RID: 62
		// (get) Token: 0x060000C2 RID: 194 RVA: 0x00005C44 File Offset: 0x00003E44
		// (set) Token: 0x060000C3 RID: 195 RVA: 0x00005C5F File Offset: 0x00003E5F
		public bool recordable
		{
			get
			{
				return this.m_Recordable;
			}
			internal set
			{
				this.m_Recordable = value;
			}
		}

		// Token: 0x1700003F RID: 63
		// (get) Token: 0x060000C4 RID: 196 RVA: 0x00005C6C File Offset: 0x00003E6C
		public bool locked
		{
			get
			{
				return this.parentTrack != null && this.parentTrack.locked;
			}
		}

		// Token: 0x17000040 RID: 64
		// (get) Token: 0x060000C5 RID: 197 RVA: 0x00005CA0 File Offset: 0x00003EA0
		// (set) Token: 0x060000C6 RID: 198 RVA: 0x00005CBA File Offset: 0x00003EBA
		public bool recordingSelected { get; set; }

		// Token: 0x17000041 RID: 65
		// (get) Token: 0x060000C7 RID: 199 RVA: 0x00005CC4 File Offset: 0x00003EC4
		public List<string> exposedParameters
		{
			get
			{
				List<string> list;
				if ((list = this.m_ExposedParameterNames) == null)
				{
					list = (this.m_ExposedParameterNames = new List<string>());
				}
				return list;
			}
		}

		// Token: 0x17000042 RID: 66
		// (get) Token: 0x060000C8 RID: 200 RVA: 0x00005CF4 File Offset: 0x00003EF4
		public ClipCaps clipCaps
		{
			get
			{
				ITimelineClipAsset timelineClipAsset = this.asset as ITimelineClipAsset;
				return (timelineClipAsset == null) ? TimelineClip.kDefaultClipCaps : timelineClipAsset.clipCaps;
			}
		}

		// Token: 0x060000C9 RID: 201 RVA: 0x00005D2C File Offset: 0x00003F2C
		internal int Hash()
		{
			return HashUtility.CombineHash(this.m_ID.GetHashCode(), this.m_Start.GetHashCode(), this.m_Duration.GetHashCode(), this.m_TimeScale.GetHashCode(), this.m_ClipIn.GetHashCode(), this.m_PreExtrapolationMode.GetHashCode(), this.m_PostExtrapolationMode.GetHashCode());
		}

		// Token: 0x060000CA RID: 202 RVA: 0x00005DC0 File Offset: 0x00003FC0
		public float EvaluateMixOut(double localTime)
		{
			float num;
			if (!this.clipCaps.HasAny(ClipCaps.Blending))
			{
				num = 1f;
			}
			else if (this.mixOutDuration > (double)Mathf.Epsilon)
			{
				float num2 = (float)(localTime - this.mixOutTime) / (float)this.mixOutDuration;
				num2 = Mathf.Clamp01(this.mixOutCurve.Evaluate(num2));
				num = num2;
			}
			else
			{
				num = 1f;
			}
			return num;
		}

		// Token: 0x060000CB RID: 203 RVA: 0x00005E34 File Offset: 0x00004034
		public float EvaluateMixIn(double localTime)
		{
			float num;
			if (!this.clipCaps.HasAny(ClipCaps.Blending))
			{
				num = 1f;
			}
			else if (this.mixInDuration > (double)Mathf.Epsilon)
			{
				float num2 = (float)(localTime - this.m_Start) / (float)this.mixInDuration;
				num2 = Mathf.Clamp01(this.mixInCurve.Evaluate(num2));
				num = num2;
			}
			else
			{
				num = 1f;
			}
			return num;
		}

		// Token: 0x060000CC RID: 204 RVA: 0x00005EA8 File Offset: 0x000040A8
		private AnimationCurve GetDefaultMixInCurve()
		{
			return AnimationCurve.EaseInOut(0f, 0f, 1f, 1f);
		}

		// Token: 0x060000CD RID: 205 RVA: 0x00005ED8 File Offset: 0x000040D8
		private AnimationCurve GetDefaultMixOutCurve()
		{
			return AnimationCurve.EaseInOut(0f, 1f, 1f, 0f);
		}

		// Token: 0x060000CE RID: 206 RVA: 0x00005F08 File Offset: 0x00004108
		public double ToLocalTime(double time)
		{
			double num;
			if (time < 0.0)
			{
				num = time;
			}
			else
			{
				if (this.IsPreExtrapolatedTime(time))
				{
					time = TimelineClip.GetExtrapolatedTime(time - this.m_Start, this.m_PreExtrapolationMode, this.m_Duration);
				}
				else if (this.IsPostExtrapolatedTime(time))
				{
					time = TimelineClip.GetExtrapolatedTime(time - this.m_Start, this.m_PostExtrapolationMode, this.m_Duration);
				}
				else
				{
					time -= this.m_Start;
				}
				time += this.clipIn;
				time *= this.timeScale;
				num = time;
			}
			return num;
		}

		// Token: 0x060000CF RID: 207 RVA: 0x00005FAC File Offset: 0x000041AC
		public double ToLocalTimeUnbound(double time)
		{
			return (time - this.m_Start + this.clipIn) * this.timeScale;
		}

		// Token: 0x060000D0 RID: 208 RVA: 0x00005FD8 File Offset: 0x000041D8
		internal double FromLocalTimeUnbound(double time)
		{
			return time / this.timeScale + this.m_Start - this.clipIn;
		}

		// Token: 0x17000043 RID: 67
		// (get) Token: 0x060000D1 RID: 209 RVA: 0x00006004 File Offset: 0x00004204
		public AnimationClip animationClip
		{
			get
			{
				AnimationClip animationClip;
				if (this.m_Asset == null)
				{
					animationClip = null;
				}
				else
				{
					AnimationPlayableAsset animationPlayableAsset = this.m_Asset as AnimationPlayableAsset;
					animationClip = ((!(animationPlayableAsset != null)) ? null : animationPlayableAsset.clip);
				}
				return animationClip;
			}
		}

		// Token: 0x060000D2 RID: 210 RVA: 0x00006058 File Offset: 0x00004258
		private static double SanitizeTimeValue(double value, double defaultValue)
		{
			double num;
			if (double.IsInfinity(value) || double.IsNaN(value))
			{
				Debug.LogError("Invalid time value assigned");
				num = defaultValue;
			}
			else
			{
				num = Math.Max(-TimelineClip.kMaxTimeValue, Math.Min(TimelineClip.kMaxTimeValue, value));
			}
			return num;
		}

		// Token: 0x17000044 RID: 68
		// (get) Token: 0x060000D3 RID: 211 RVA: 0x000060AC File Offset: 0x000042AC
		// (set) Token: 0x060000D4 RID: 212 RVA: 0x000060DE File Offset: 0x000042DE
		public TimelineClip.ClipExtrapolation postExtrapolationMode
		{
			get
			{
				return (!this.clipCaps.HasAny(ClipCaps.Extrapolation)) ? TimelineClip.ClipExtrapolation.None : this.m_PostExtrapolationMode;
			}
			internal set
			{
				this.m_PostExtrapolationMode = ((!this.clipCaps.HasAny(ClipCaps.Extrapolation)) ? TimelineClip.ClipExtrapolation.None : value);
			}
		}

		// Token: 0x17000045 RID: 69
		// (get) Token: 0x060000D5 RID: 213 RVA: 0x00006100 File Offset: 0x00004300
		// (set) Token: 0x060000D6 RID: 214 RVA: 0x00006132 File Offset: 0x00004332
		public TimelineClip.ClipExtrapolation preExtrapolationMode
		{
			get
			{
				return (!this.clipCaps.HasAny(ClipCaps.Extrapolation)) ? TimelineClip.ClipExtrapolation.None : this.m_PreExtrapolationMode;
			}
			internal set
			{
				this.m_PreExtrapolationMode = ((!this.clipCaps.HasAny(ClipCaps.Extrapolation)) ? TimelineClip.ClipExtrapolation.None : value);
			}
		}

		// Token: 0x060000D7 RID: 215 RVA: 0x00006153 File Offset: 0x00004353
		internal void SetPostExtrapolationTime(double time)
		{
			this.m_PostExtrapolationTime = time;
		}

		// Token: 0x060000D8 RID: 216 RVA: 0x0000615D File Offset: 0x0000435D
		internal void SetPreExtrapolationTime(double time)
		{
			this.m_PreExtrapolationTime = time;
		}

		// Token: 0x060000D9 RID: 217 RVA: 0x00006168 File Offset: 0x00004368
		public bool IsExtrapolatedTime(double sequenceTime)
		{
			return this.IsPreExtrapolatedTime(sequenceTime) || this.IsPostExtrapolatedTime(sequenceTime);
		}

		// Token: 0x060000DA RID: 218 RVA: 0x00006194 File Offset: 0x00004394
		public bool IsPreExtrapolatedTime(double sequenceTime)
		{
			return this.preExtrapolationMode != TimelineClip.ClipExtrapolation.None && sequenceTime < this.m_Start && sequenceTime >= this.m_Start - this.m_PreExtrapolationTime;
		}

		// Token: 0x060000DB RID: 219 RVA: 0x000061DC File Offset: 0x000043DC
		public bool IsPostExtrapolatedTime(double sequenceTime)
		{
			return this.postExtrapolationMode != TimelineClip.ClipExtrapolation.None && sequenceTime > this.end && sequenceTime - this.end < this.m_PostExtrapolationTime;
		}

		// Token: 0x17000046 RID: 70
		// (get) Token: 0x060000DC RID: 220 RVA: 0x0000621C File Offset: 0x0000441C
		public double extrapolatedStart
		{
			get
			{
				double num;
				if (this.m_PreExtrapolationMode != TimelineClip.ClipExtrapolation.None)
				{
					num = this.m_Start - this.m_PreExtrapolationTime;
				}
				else
				{
					num = this.m_Start;
				}
				return num;
			}
		}

		// Token: 0x17000047 RID: 71
		// (get) Token: 0x060000DD RID: 221 RVA: 0x00006258 File Offset: 0x00004458
		public double extrapolatedDuration
		{
			get
			{
				double num = this.m_Duration;
				if (this.m_PostExtrapolationMode != TimelineClip.ClipExtrapolation.None)
				{
					num += Math.Min(this.m_PostExtrapolationTime, TimelineClip.kMaxTimeValue);
				}
				if (this.m_PreExtrapolationMode != TimelineClip.ClipExtrapolation.None)
				{
					num += this.m_PreExtrapolationTime;
				}
				return num;
			}
		}

		// Token: 0x060000DE RID: 222 RVA: 0x000062A8 File Offset: 0x000044A8
		private static double GetExtrapolatedTime(double time, TimelineClip.ClipExtrapolation mode, double duration)
		{
			double num;
			if (duration == 0.0)
			{
				num = 0.0;
			}
			else
			{
				switch (mode)
				{
				case TimelineClip.ClipExtrapolation.Hold:
					if (time < 0.0)
					{
						return 0.0;
					}
					if (time > duration)
					{
						return duration;
					}
					break;
				case TimelineClip.ClipExtrapolation.Loop:
					if (time < 0.0)
					{
						time = duration - -time % duration;
					}
					else if (time > duration)
					{
						time %= duration;
					}
					break;
				case TimelineClip.ClipExtrapolation.PingPong:
					if (time < 0.0)
					{
						time = duration * 2.0 - -time % (duration * 2.0);
						time = duration - Math.Abs(time - duration);
					}
					else
					{
						time %= duration * 2.0;
						time = duration - Math.Abs(time - duration);
					}
					break;
				}
				num = time;
			}
			return num;
		}

		// Token: 0x060000DF RID: 223 RVA: 0x000063C3 File Offset: 0x000045C3
		internal void AllocateAnimatedParameterCurves()
		{
			if (this.m_AnimationCurves == null)
			{
				this.m_AnimationCurves = new AnimationClip();
				this.m_AnimationCurves.legacy = true;
			}
		}

		// Token: 0x060000E0 RID: 224 RVA: 0x000063F0 File Offset: 0x000045F0
		internal void ClearAnimatedParameterCurves()
		{
			this.m_AnimationCurves = null;
		}

		// Token: 0x04000041 RID: 65
		public static readonly ClipCaps kDefaultClipCaps = ClipCaps.Blending;

		// Token: 0x04000042 RID: 66
		public static readonly float kDefaultClipDurationInSeconds = 5f;

		// Token: 0x04000043 RID: 67
		public static readonly double kTimeScaleMin = 0.001;

		// Token: 0x04000044 RID: 68
		public static readonly double kTimeScaleMax = 1000.0;

		// Token: 0x04000045 RID: 69
		internal static readonly double kMinDuration = 0.016666666666666666;

		// Token: 0x04000046 RID: 70
		internal static readonly double kMaxTimeValue = 1000000.0;

		// Token: 0x04000047 RID: 71
		[SerializeField]
		private double m_Start;

		// Token: 0x04000048 RID: 72
		[SerializeField]
		private double m_ClipIn;

		// Token: 0x04000049 RID: 73
		[SerializeField]
		private Object m_Asset;

		// Token: 0x0400004A RID: 74
		[SerializeField]
		private Object m_UnderlyingAsset;

		// Token: 0x0400004B RID: 75
		[SerializeField]
		[FormerlySerializedAs("m_HackDuration")]
		private double m_Duration;

		// Token: 0x0400004C RID: 76
		[SerializeField]
		private int m_ParentID;

		// Token: 0x0400004D RID: 77
		[SerializeField]
		private double m_TimeScale = 1.0;

		// Token: 0x0400004E RID: 78
		[SerializeField]
		private AnimationCurve m_BlendCurve;

		// Token: 0x0400004F RID: 79
		[SerializeField]
		private TrackAsset m_ParentTrack;

		// Token: 0x04000050 RID: 80
		[SerializeField]
		private double m_EaseInDuration = 0.0;

		// Token: 0x04000051 RID: 81
		[SerializeField]
		private double m_EaseOutDuration = 0.0;

		// Token: 0x04000052 RID: 82
		[SerializeField]
		private double m_BlendInDuration = -1.0;

		// Token: 0x04000053 RID: 83
		[SerializeField]
		private double m_BlendOutDuration = -1.0;

		// Token: 0x04000054 RID: 84
		[SerializeField]
		private AnimationCurve m_MixInCurve = null;

		// Token: 0x04000055 RID: 85
		[SerializeField]
		private AnimationCurve m_MixOutCurve = null;

		// Token: 0x04000056 RID: 86
		[SerializeField]
		private TimelineClip.BlendCurveMode m_BlendInCurveMode = TimelineClip.BlendCurveMode.Auto;

		// Token: 0x04000057 RID: 87
		[SerializeField]
		private TimelineClip.BlendCurveMode m_BlendOutCurveMode = TimelineClip.BlendCurveMode.Auto;

		// Token: 0x04000058 RID: 88
		[SerializeField]
		private List<string> m_ExposedParameterNames;

		// Token: 0x04000059 RID: 89
		[SerializeField]
		private AnimationClip m_AnimationCurves;

		// Token: 0x0400005A RID: 90
		[SerializeField]
		public int m_ID = -1;

		// Token: 0x0400005B RID: 91
		[SerializeField]
		private bool m_Recordable = false;

		// Token: 0x0400005C RID: 92
		[SerializeField]
		private TimelineClip.ClipExtrapolation m_PostExtrapolationMode;

		// Token: 0x0400005D RID: 93
		[SerializeField]
		private TimelineClip.ClipExtrapolation m_PreExtrapolationMode;

		// Token: 0x0400005E RID: 94
		[SerializeField]
		private double m_PostExtrapolationTime;

		// Token: 0x0400005F RID: 95
		[SerializeField]
		private double m_PreExtrapolationTime;

		// Token: 0x04000060 RID: 96
		[SerializeField]
		private string m_DisplayName;

		// Token: 0x02000019 RID: 25
		public enum ClipExtrapolation
		{
			// Token: 0x04000064 RID: 100
			None,
			// Token: 0x04000065 RID: 101
			Hold,
			// Token: 0x04000066 RID: 102
			Loop,
			// Token: 0x04000067 RID: 103
			PingPong,
			// Token: 0x04000068 RID: 104
			Continue
		}

		// Token: 0x0200001A RID: 26
		public enum BlendCurveMode
		{
			// Token: 0x0400006A RID: 106
			Auto,
			// Token: 0x0400006B RID: 107
			Manual
		}
	}
}