private void End()
{
if (this.PlaybackFinished != null)
{
this.PlaybackFinished(this);
}
if (this.isLoopingSequence || this.isPingPongingSequence)
{
return;
}
USTimelineContainer[] array = this.TimelineContainers;
for (int i = 0; i < array.Length; i++)
{
USTimelineContainer uSTimelineContainer = array[i];
USTimelineBase[] timelines = uSTimelineContainer.Timelines;
for (int j = 0; j < timelines.Length; j++)
{
USTimelineBase uSTimelineBase = timelines[j];
if (uSTimelineBase.AffectedObject != null)
{
uSTimelineBase.EndTimeline();
}
}
}
}
public USTimelineContainer CreateNewTimelineContainer(Transform affectedObject)
{
USTimelineContainer uSTimelineContainer = new GameObject("Timelines for " + affectedObject.name)
{
transform =
{
parent = base.transform
}
}.AddComponent <USTimelineContainer>();
uSTimelineContainer.AffectedObject = affectedObject;
int num = 0;
USTimelineContainer[] array = this.TimelineContainers;
for (int i = 0; i < array.Length; i++)
{
USTimelineContainer uSTimelineContainer2 = array[i];
if (uSTimelineContainer2.Index > num)
{
num = uSTimelineContainer2.Index;
}
}
uSTimelineContainer.Index = num + 1;
return(uSTimelineContainer);
}
public void Stop()
{
if (this.PlaybackStopped != null)
{
this.PlaybackStopped(this);
}
base.StopCoroutine("UpdateSequencerCoroutine");
USTimelineContainer[] array = this.TimelineContainers;
for (int i = 0; i < array.Length; i++)
{
USTimelineContainer uSTimelineContainer = array[i];
USTimelineBase[] timelines = uSTimelineContainer.Timelines;
for (int j = 0; j < timelines.Length; j++)
{
USTimelineBase uSTimelineBase = timelines[j];
if (uSTimelineBase.GetType() == typeof(USTimelineObserver) || uSTimelineBase.AffectedObject != null)
{
uSTimelineBase.StopTimeline();
}
}
}
this.isFreshPlayback = true;
this.playing = false;
this.runningTime = 0f;
}
public static float FindPrevKeyframeTime(USSequencer sequence)
{
float num = 0f;
USTimelineContainer[] timelineContainers = sequence.TimelineContainers;
for (int i = 0; i < timelineContainers.Length; i++)
{
USTimelineContainer uSTimelineContainer = timelineContainers[i];
USTimelineBase[] timelines = uSTimelineContainer.Timelines;
for (int j = 0; j < timelines.Length; j++)
{
USTimelineBase uSTimelineBase = timelines[j];
USTimelineProperty uSTimelineProperty = uSTimelineBase as USTimelineProperty;
if (uSTimelineProperty)
{
foreach (USPropertyInfo current in uSTimelineProperty.Properties)
{
foreach (USInternalCurve current2 in current.curves)
{
float num2 = current2.FindPrevKeyframeTime(sequence.RunningTime);
if (num2 > num)
{
num = num2;
}
}
}
}
}
}
return(num);
}
public static void ProcessTimelineContainer(USTimelineContainer timelineContainer)
{
foreach (var baseTimeline in timelineContainer.Timelines)
{
ProcessTimeline(baseTimeline);
}
}
public static USTimelineBase DuplicateTimeline(USTimelineBase timeline, USTimelineContainer newTimelineContainer)
{
var duplicateTimelineGameObject = Object.Instantiate(timeline.gameObject) as GameObject;
var duplicateTimeline = duplicateTimelineGameObject.GetComponent <USTimelineBase>();
duplicateTimeline.transform.parent = newTimelineContainer.transform;
duplicateTimeline.transform.name = timeline.name;
USDetachScriptableObjects.ProcessTimeline(duplicateTimeline);
return(duplicateTimeline);
}
public static USTimelineContainer DuplicateTimelineContainer(USTimelineContainer timelineContainer, USSequencer newSequence)
{
var duplicateTimelineGameObject = Object.Instantiate(timelineContainer.gameObject) as GameObject;
var duplicateTimelineContainer = duplicateTimelineGameObject.GetComponent <USTimelineContainer>();
duplicateTimelineContainer.transform.parent = newSequence.transform;
duplicateTimelineContainer.transform.name = timelineContainer.name;
USDetachScriptableObjects.ProcessTimelineContainer(duplicateTimelineContainer);
return(duplicateTimelineContainer);
}
public void AddNewTimelineContainer(USTimelineContainer timelineContainer)
{
var newHierarchyItem = CreateInstance(typeof(USTimelineContainerHierarchyItem)) as USTimelineContainerHierarchyItem;
USUndoManager.RegisterCreatedObjectUndo(newHierarchyItem, "Add New Timeline Container");
USUndoManager.RegisterCompleteObjectUndo(newHierarchyItem, "Add New Timeline Container");
newHierarchyItem.SetupWithTimelineContainer(timelineContainer);
USUndoManager.RegisterCompleteObjectUndo(USHierarchy, "Add New Timeline Container");
USHierarchy.AddHierarchyItemToRoot(newHierarchyItem as IUSHierarchyItem);
}
public static bool HasTimelineContainerWithAffectedObject(USSequencer sequence, Transform affectedObject)
{
USTimelineContainer[] timelineContainers = sequence.TimelineContainers;
for (int i = 0; i < timelineContainers.Length; i++)
{
USTimelineContainer uSTimelineContainer = timelineContainers[i];
if (uSTimelineContainer.AffectedObject == affectedObject)
{
return(true);
}
}
return(false);
}
static public string GetReadableTimelineContainerName(USTimelineContainer timelineContainer)
{
timelineContainer.RenameTimelineContainer();
var name = "";
name = timelineContainer.name.Replace("_Timelines for ", "");
if (name.Contains("Timelines for "))
{
name = timelineContainer.name.Replace("Timelines for ", "");
}
return(name);
}
public USTimelineContainer GetTimelineContainerFor(Transform affectedObject)
{
USTimelineContainer[] array = this.TimelineContainers;
for (int i = 0; i < array.Length; i++)
{
USTimelineContainer uSTimelineContainer = array[i];
if (uSTimelineContainer.AffectedObject == affectedObject)
{
return(uSTimelineContainer);
}
}
return(null);
}
public bool HasTimelineContainerFor(Transform affectedObject)
{
USTimelineContainer[] array = this.TimelineContainers;
for (int i = 0; i < array.Length; i++)
{
USTimelineContainer uSTimelineContainer = array[i];
if (uSTimelineContainer.AffectedObject == affectedObject)
{
return(true);
}
}
return(false);
}
private void Start()
{
USTimelineContainer[] array = this.TimelineContainers;
for (int i = 0; i < array.Length; i++)
{
USTimelineContainer uSTimelineContainer = array[i];
if (uSTimelineContainer)
{
USTimelineBase[] timelines = uSTimelineContainer.Timelines;
for (int j = 0; j < timelines.Length; j++)
{
USTimelineBase uSTimelineBase = timelines[j];
USTimelineEvent uSTimelineEvent = uSTimelineBase as USTimelineEvent;
if (uSTimelineEvent)
{
USEventBase[] events = uSTimelineEvent.Events;
for (int k = 0; k < events.Length; k++)
{
USEventBase uSEventBase = events[k];
uSEventBase.FixupAdditionalObjects();
}
}
USTimelineObserver uSTimelineObserver = uSTimelineBase as USTimelineObserver;
if (uSTimelineObserver)
{
foreach (USObserverKeyframe current in uSTimelineObserver.observerKeyframes)
{
if (!(current.cameraPath == string.Empty))
{
GameObject gameObject = GameObject.Find(current.cameraPath);
if (gameObject)
{
Camera component = gameObject.GetComponent <Camera>();
if (component)
{
current.KeyframeCamera = component;
}
}
}
}
}
USTimelineObjectPath uSTimelineObjectPath = uSTimelineBase as USTimelineObjectPath;
if (uSTimelineObjectPath)
{
uSTimelineObjectPath.FixupAdditionalObjects();
}
}
}
}
}
public static void CreateAndAttachObserver(USSequencer sequence)
{
USTimelineContainer[] timelineContainers = sequence.TimelineContainers;
for (int i = 0; i < timelineContainers.Length; i++)
{
USTimelineContainer uSTimelineContainer = timelineContainers[i];
USTimelineBase[] timelines = uSTimelineContainer.Timelines;
for (int j = 0; j < timelines.Length; j++)
{
USTimelineBase uSTimelineBase = timelines[j];
if (uSTimelineBase is USTimelineObserver)
{
return;
}
}
}
Camera x = null;
Camera[] array = UnityEngine.Object.FindObjectsOfType(typeof(Camera)) as Camera[];
Camera[] array2 = array;
for (int k = 0; k < array2.Length; k++)
{
Camera camera = array2[k];
if (camera.tag == "MainCamera")
{
x = camera;
}
}
if (x == null)
{
Debug.LogWarning("There is no main camera in the scene, we need one for our observer track.");
}
GameObject gameObject = new GameObject("_Timelines for Observer");
gameObject.transform.parent = sequence.transform;
USTimelineContainer uSTimelineContainer2 = gameObject.AddComponent(typeof(USTimelineContainer)) as USTimelineContainer;
uSTimelineContainer2.Index = -1;
new GameObject("Observer")
{
transform =
{
parent = gameObject.transform
}
}.AddComponent(typeof(USTimelineObserver));
}
public static bool IsObserverContainer(Transform transform)
{
USTimelineContainer component = transform.GetComponent <USTimelineContainer>();
if (component == null)
{
return(false);
}
USTimelineBase[] timelines = component.Timelines;
for (int i = 0; i < timelines.Length; i++)
{
USTimelineBase uSTimelineBase = timelines[i];
if (USRuntimeUtility.IsObserverTimeline(uSTimelineBase.transform))
{
return(true);
}
}
return(false);
}
public void Pause()
{
if (this.PlaybackPaused != null)
{
this.PlaybackPaused(this);
}
this.playing = false;
USTimelineContainer[] array = this.TimelineContainers;
for (int i = 0; i < array.Length; i++)
{
USTimelineContainer uSTimelineContainer = array[i];
USTimelineBase[] timelines = uSTimelineContainer.Timelines;
for (int j = 0; j < timelines.Length; j++)
{
USTimelineBase uSTimelineBase = timelines[j];
uSTimelineBase.PauseTimeline();
}
}
}
static public void CreateAndAttachObserver(USSequencer sequence)
{
foreach (USTimelineContainer timelineContainer in sequence.TimelineContainers)
{
foreach (USTimelineBase timelineBase in timelineContainer.Timelines)
{
if (timelineBase is USTimelineObserver)
{
return;
}
}
}
Camera mainCamera = null;
Camera[] cameras = GameObject.FindObjectsOfType(typeof(Camera)) as Camera[];
foreach (Camera camera in cameras)
{
if (camera.tag == "MainCamera")
{
mainCamera = camera;
}
}
if (mainCamera == null)
{
Debug.LogWarning("There is no main camera in the scene, we need one for our observer track.");
}
GameObject spawnedContainer = new GameObject("_Timelines for Observer");
spawnedContainer.transform.parent = sequence.transform;
USTimelineContainer ourTimelineContainer = spawnedContainer.AddComponent(typeof(USTimelineContainer)) as USTimelineContainer;
ourTimelineContainer.Index = -1;
GameObject spawnedObserver = new GameObject("Observer");
spawnedObserver.transform.parent = spawnedContainer.transform;
spawnedObserver.AddComponent(typeof(USTimelineObserver));
}
public void Play()
{
if (this.PlaybackStarted != null)
{
this.PlaybackStarted(this);
}
base.StartCoroutine("UpdateSequencerCoroutine");
if (this.isFreshPlayback)
{
USTimelineContainer[] array = this.TimelineContainers;
for (int i = 0; i < array.Length; i++)
{
USTimelineContainer uSTimelineContainer = array[i];
USTimelineBase[] timelines = uSTimelineContainer.Timelines;
for (int j = 0; j < timelines.Length; j++)
{
USTimelineBase uSTimelineBase = timelines[j];
uSTimelineBase.StartTimeline();
}
}
this.isFreshPlayback = false;
}
else
{
USTimelineContainer[] array2 = this.TimelineContainers;
for (int k = 0; k < array2.Length; k++)
{
USTimelineContainer uSTimelineContainer2 = array2[k];
USTimelineBase[] timelines2 = uSTimelineContainer2.Timelines;
for (int l = 0; l < timelines2.Length; l++)
{
USTimelineBase uSTimelineBase2 = timelines2[l];
uSTimelineBase2.ResumeTimeline();
}
}
}
this.playing = true;
this.previousTime = Time.time;
}
public void SetupWithTimelineContainer(USTimelineContainer timelineContainer)
{
TimelineContainer = timelineContainer;
var timelines = TimelineContainer.Timelines;
if (TimelineContainer.Timelines.Count() > Children.Count)
{
var notInBoth = timelines.Where(
(timeline) => !Children.Any(
(item) =>
((item is IUSTimelineHierarchyItem) && (item as IUSTimelineHierarchyItem).IsForThisTimeline(timeline))
)
);
foreach (var extraTimeline in notInBoth)
{
IUSHierarchyItem hierarchyItem = null;
var customKeyValuePairs = USEditorUtility.CustomTimelineAttributes;
foreach (var customKeyValuePair in customKeyValuePairs)
{
if (extraTimeline.GetType() == customKeyValuePair.Key.InspectedType)
{
hierarchyItem = CreateInstance(customKeyValuePair.Value) as IUSHierarchyItem;
// This is here to capture the change in USTimelineBase BaseTimeline on the IUSTimelineHierarchyItem that occurse during initialize
USUndoManager.RegisterCompleteObjectUndo(hierarchyItem, "Add New Timeline");
hierarchyItem.Initialize(extraTimeline);
}
}
AddChild(hierarchyItem);
}
}
}
public static bool CanContextClickTimelineContainer(USTimelineContainer timelineContainer)
{
return(!USRuntimeUtility.HasObserverTimeline(timelineContainer.transform));
}
IEnumerator EventUpdate(CutSceneEventData __CutSceneEventData)
{
List <CutSceneEventDataList> EventList = new List <CutSceneEventDataList>();
for (int i = 0; i < __CutSceneEventData.EventList.Length; i++)
{
EventList.Add(__CutSceneEventData.EventList[i]);
}
int DefaultIdx = -1;
for (int i = 0; i < EventList.Count; i++)
{
if (EventList[i].ActionType == eCutSceneEvent.SetRaidStartDefault)
{
DefaultIdx = i;
break;
}
}
if (DefaultIdx != -1)
{
EventList.Insert(DefaultIdx + 1, CreateCutSceneEventDataList(eCutSceneEvent.StartUpdate, Vector3.zero));
EventList.Insert(DefaultIdx + 1, CreateCutSceneEventDataList(eCutSceneEvent.SetRaidDefaultPos, Vector3.zero));
EventList.Insert(DefaultIdx + 1, CreateCutSceneEventDataList(eCutSceneEvent.SetFadeOut, Vector3.zero));
EventList.Insert(DefaultIdx + 1, CreateCutSceneEventDataList(eCutSceneEvent.StopUpdate, Vector3.zero));
}
Unit unit = null;
for (int i = 0; i < EventList.Count; i++)
{
//Debug.Log("EventList ActionType " + EventList[i].ActionType);
switch (EventList[i].ActionType)
{
#region 이전데이터
//< 카메라 포커싱처리
case eCutSceneEvent.Focusing:
if (EventList[i].ActionBool)
{
if (G_GameInfo.GameInfo.FocusingCam != null)
{
G_GameInfo.GameInfo.FocusingCam.StartEffect(0, true);
}
}
else
{
if (G_GameInfo.GameInfo.FocusingCam != null && G_GameInfo.GameInfo.FocusingCam.gameObject.activeSelf)
{
G_GameInfo.GameInfo.FocusingCam.EndEffect(true);
}
}
break;
//< 사운드 실행
case eCutSceneEvent.PlayBgmSound:
//SoundHelper.PlayBgmSound((uint)EventList[i].ActionValue);
break;
//< 보스 UI 출력
case eCutSceneEvent.ShowBossUI:
if (null == UIMgr.GetUI("InGame/BossCutscenePanel"))
{
UIMgr.Open("InGame/BossCutscenePanel", EventList[i].ActionValue);
}
break;
//< 기본 셋트 한번에 다해줌
case eCutSceneEvent.SetDefaultBoss:
//< 포커싱처리
G_GameInfo.GameInfo.FocusingCam.StartEffect(0, true);
//< 사운드실행
//SoundHelper.PlayBgmSound(9008);
unit = CutSceneMgr.CutSceneEventDic[0].GetComponent <Unit>();
G_GameInfo.GameInfo.FocusingCam.AddObject(unit.gameObject);
//< 보스 유아이 실행
//if (null == UIMgr.GetUI("InGame/BossCutscenePanel"))
// UIMgr.Open("InGame/BossCutscenePanel", (float)3);
//< 해당 애니메이션 플레이 시간을 얻는다.
eAnimName aniName2 = GetAniName("Anim_intro");
if (aniName2 != eAnimName.Anim_idle)
{
EventList[i].ActionDelay = unit.Animator.GetAnimLength(aniName2) + 1;
}
//EventList[i].ActionDelay += unit.Animator.GetAnimLength(eAnimName.Anim_special);
Sequence.Duration = EventList[i].ActionDelay + 0.5f;
USTimelineProperty Infolist = Sequence.GetComponentInChildren <USTimelineProperty>();
//CutSceneMgr.seq.Duration=EventList[i].ActionDelay+0.5f;
//UI 라이트를 컨트롤 한다. 다시 켜주는 건 CutSceneMgr 에 있음. EndScene 마지막
Transform Shadow;
Shadow = GameObject.Find("UI_ShadowLight").GetComponent <Transform> ();
USTimelineContainer Container = Sequence.CreateNewTimelineContainer(Shadow);
GameObject test = new GameObject("Evnet Timeline");
test.transform.parent = Container.transform;
Component Evnt = test.AddComponent("USTimelineEvent");
GameObject First = new GameObject("USEnableComponentEvent");
GameObject Second = new GameObject("USEnableComponentEvent");
First.transform.parent = Evnt.transform;
Second.transform.parent = Evnt.transform;
First.AddComponent("USEnableComponentEvent");
Second.AddComponent("USEnableComponentEvent");
First.GetComponent <USEnableComponentEvent> ().ComponentName = "Light";
//Second.GetComponent<USEnableComponentEvent> ().ComponentName = "Light";
//Second.GetComponent<USEnableComponentEvent> ().enableComponent=true;
First.GetComponent <USEnableComponentEvent> ().FireTime = 0.0f;
//Second.GetComponent<USEnableComponentEvent> ().FireTime = Sequence.Duration;
//
Infolist.Properties [0].curves [0].Keys[1].Time = 0.7f;
Infolist.Properties [0].curves [1].Keys [1].Time = 0.7f;
Infolist.Properties [0].curves [2].Keys [1].Time = 0.7f;
Infolist.Properties [1].curves [0].Keys[1].Time = 0.7f;
Infolist.Properties [1].curves [1].Keys [1].Time = 0.7f;
Infolist.Properties [1].curves [2].Keys [1].Time = 0.7f;
Infolist.Properties [1].curves [3].Keys [1].Time = 0.7f;
Infolist.Properties [0].curves [0].Keys[3].Time = Sequence.Duration + 10;
Infolist.Properties [0].curves [1].Keys [3].Time = Sequence.Duration + 10;
Infolist.Properties [0].curves [2].Keys [3].Time = Sequence.Duration + 10;
Infolist.Properties [1].curves [0].Keys[3].Time = Sequence.Duration + 10;
Infolist.Properties [1].curves [1].Keys [3].Time = Sequence.Duration + 10;
Infolist.Properties [1].curves [2].Keys [3].Time = Sequence.Duration + 10;
Infolist.Properties [1].curves [3].Keys [3].Time = Sequence.Duration + 10;
Infolist.Properties [0].curves[0].Keys[2].Time = Sequence.Duration;
Infolist.Properties [0].curves [1].Keys [2].Time = Sequence.Duration;
Infolist.Properties [0].curves [2].Keys [2].Time = Sequence.Duration;
Infolist.Properties [1].curves [0].Keys[2].Time = Sequence.Duration;
Infolist.Properties [1].curves [1].Keys [2].Time = Sequence.Duration;
Infolist.Properties [1].curves [2].Keys [2].Time = Sequence.Duration;
Infolist.Properties [1].curves [3].Keys [2].Time = Sequence.Duration;
break;
#endregion 이전데이터
//< 해당 위치로 강제이동
case eCutSceneEvent.ImmediatelyMove:
CutSceneMgr.CutSceneEventDic[0].transform.position = EventList[i].ActionPos;
break;
//< 이펙트 실행
case eCutSceneEvent.SpawnEffect:
SpawnEffect(EventList[i]);
break;
//< 카메라 쉐이킹
case eCutSceneEvent.CameraShake:
CutSceneMgr.Shake((byte)EventList[i].ActionValue);
break;
//< 보스 UI 출력
case eCutSceneEvent.ShowRaidBossUI:
if (null == UIMgr.GetUI("InGame/BossCutscenePanel"))
{
UIMgr.Open("InGame/BossCutscenePanel", EventList[i].ActionValue);
}
break;
//< 보스 대화 출력
case eCutSceneEvent.RaidBossTalk:
unit = CutSceneMgr.CutSceneEventDic[0].GetComponent <Unit>();
G_GameInfo.GameInfo.StartCoroutine(RaidBossTalkUpdate(unit, EventList[i].ActionString));
break;
//< 애니메이션 실행
case eCutSceneEvent.AnimaionPlay:
unit = CutSceneMgr.CutSceneEventDic[(int)EventList[i].ActionValue].GetComponent <Unit>();
if (unit != null)
{
eAnimName aniName = GetAniName(EventList[i].ActionString);
unit.PlayAnim(aniName, false, 0.2f, true);
//< 해당 애니메이션 플레이 시간을 얻는다.
if (aniName != eAnimName.Anim_idle)
{
EventList[i].ActionDelay = unit.Animator.GetAnimLength(aniName) - 0.2f;
}
}
else
{
//< 유닛이 없다면 그냥 바로 실행시켜준다.
CutSceneMgr.CutSceneEventDic[(int)EventList[i].ActionValue].animation.CrossFade(EventList[i].ActionString, 0.5f);
}
break;
//< 플레이 자체는 멈춰둔다.
case eCutSceneEvent.StopUpdate:
CutSceneMgr.seq.Pause();
break;
case eCutSceneEvent.StartUpdate:
CutSceneMgr.seq.Play();
break;
//< 페이드 인(밝아지는처리)
case eCutSceneEvent.SetFadeIn:
CutSceneMgr.seq.Pause();
yield return(G_GameInfo._GameInfo.StartCoroutine(_CameraFadeEventObj.FadeInUpdate()));
CutSceneMgr.seq.Play();
//< 스킵버튼 체크한다.
SetSkipPanel();
break;
//< 페이드 아웃(어두워지는 처리)
case eCutSceneEvent.SetFadeOut:
if (_CameraFadeEventObj == null)
{
_CameraFadeEventObj = (Instantiate(Resources.Load("Camera/CameraFadeEvent")) as GameObject).GetComponent <CameraFadeEvent>();
_CameraFadeEventObj.transform.parent = CutSceneMgr.startCamObj.transform;
_CameraFadeEventObj.transform.localPosition = new Vector3(0, 0, 1);
_CameraFadeEventObj.transform.localRotation = Quaternion.identity;
}
GameObject panel = UIMgr.GetUI("CutSceneSkipPanel");
if (panel != null)
{
panel.GetComponent <UIBasePanel>().Close();
}
yield return(G_GameInfo._GameInfo.StartCoroutine(_CameraFadeEventObj.FadeOutUpdate()));
break;
//< 레이드를 위한 기본 카메라 위치 셋팅
case eCutSceneEvent.SetRaidDefaultPos:
CutSceneMgr.startRootObj.transform.position = Vector3.zero;
CutSceneMgr.startRootObj.transform.rotation = Quaternion.identity;
CutSceneMgr.startCamObj.transform.parent = CutSceneMgr.startRootObj.transform;
CutSceneMgr.startCamObj.transform.localPosition = Vector3.zero;
CutSceneMgr.startCamObj.transform.localRotation = Quaternion.identity;
break;
case eCutSceneEvent.SetActive:
CutSceneMgr.CutSceneEventDic[(int)EventList[i].ActionValue].SetActive(EventList[i].ActionBool);
break;
case eCutSceneEvent.SetTimeScale:
SetTimeScale(EventList[i]);
break;
}
//< 딜레이동안 대기
yield return(new WaitForSeconds(EventList[i].ActionDelay));
}
yield return(null);
}
public void DeleteTimelineContainer(USTimelineContainer timelineContainer)
{
UnityEngine.Object.DestroyImmediate(timelineContainer.gameObject);
}
public static int GetNumberOfTimelinesOfType(Type type, USTimelineContainer timelineContainer)
{
return(timelineContainer.transform.GetComponentsInChildren(type).Length);
}
public void UpdateSequencer(float deltaTime)
{
deltaTime *= this.playbackRate;
if (this.playing)
{
this.runningTime += deltaTime;
float num = this.runningTime;
if (num <= 0f)
{
num = 0f;
}
if (num > this.Duration)
{
num = this.Duration;
}
this.BeforeUpdate(this, this.runningTime);
USTimelineContainer[] array = this.TimelineContainers;
for (int i = 0; i < array.Length; i++)
{
USTimelineContainer uSTimelineContainer = array[i];
uSTimelineContainer.ProcessTimelines(num, this.PlaybackRate);
}
this.AfterUpdate(this, this.runningTime);
bool flag = false;
if (this.playbackRate > 0f && this.RunningTime >= this.duration)
{
flag = true;
}
if (this.playbackRate < 0f && this.RunningTime <= 0f)
{
flag = true;
}
if (flag)
{
if (this.isLoopingSequence)
{
float num2 = 0f;
if (this.playbackRate > 0f && this.RunningTime >= this.Duration)
{
num2 = this.RunningTime - this.Duration;
}
if (this.playbackRate < 0f && this.RunningTime <= 0f)
{
num2 = this.Duration + this.RunningTime;
}
this.Stop();
this.runningTime = num2;
this.previousTime = -1f;
this.Play();
this.UpdateSequencer(0f);
return;
}
if (this.isPingPongingSequence)
{
if (this.playbackRate > 0f && this.RunningTime >= this.Duration)
{
this.runningTime = this.Duration + (this.Duration - this.RunningTime);
}
if (this.playbackRate < 0f && this.RunningTime <= 0f)
{
this.runningTime = -1f * this.RunningTime;
}
this.playbackRate *= -1f;
return;
}
this.playing = false;
base.StopCoroutine("UpdateSequencerCoroutine");
this.End();
}
}
if (this.setSkipTime > 0f)
{
USTimelineContainer[] array2 = this.TimelineContainers;
for (int j = 0; j < array2.Length; j++)
{
USTimelineContainer uSTimelineContainer2 = array2[j];
uSTimelineContainer2.SkipTimelineTo(this.setSkipTime);
}
this.runningTime = this.setSkipTime;
this.previousTime = Time.time;
this.setSkipTime = -1f;
}
}
public static int Comparer(USTimelineContainer a, USTimelineContainer b)
{
return(a.Index.CompareTo(b.Index));
}
public void DeleteTimelineContainer(USTimelineContainer timelineContainer)
{
DestroyImmediate(timelineContainer.gameObject);
}
public virtual void ResetCachedData()
{
timelineContainer = null;
}
