private void SetCamera(USObserverKeyframe keyframe, float time, Shared.TypeOfTransition transitionType, float transitionDuration, Camera camera)
{
if (AnimationHelper.IsInAnimationMode)
{
ObserverTimeline.StopTimeline();
ObserverTimeline.StartTimeline();
}
if (keyframe != null)
{
USUndoManager.PropertyChange(keyframe, "Set Camera");
keyframe.KeyframeCamera = camera;
}
else
{
USUndoManager.RegisterCompleteObjectUndo(this, "Set Camera");
var newKeyframe = CreateInstance <USObserverKeyframe>();
newKeyframe.FireTime = time;
newKeyframe.KeyframeCamera = camera;
newKeyframe.TransitionType = transitionType;
newKeyframe.TransitionDuration = transitionDuration;
USUndoManager.RegisterCreatedObjectUndo(newKeyframe, "Set Camera");
USUndoManager.RegisterCompleteObjectUndo(ObserverTimeline, "Set Camera");
ObserverTimeline.AddKeyframe(newKeyframe);
var cachedData = CreateInstance <ObserverRenderData>();
cachedData.Keyframe = newKeyframe;
cachedObserverRenderData.Add(cachedData);
}
ObserverTimeline.Process(ObserverTimeline.Sequence.RunningTime, ObserverTimeline.Sequence.PlaybackRate);
}
public USObserverKeyframe AddKeyframe(USObserverKeyframe keyframe)
{
keyframe.observer = this;
this.observerKeyframes.Add(keyframe);
this.SortKeyframes();
if (this.observerKeyframes.Count == 1 && base.Sequence.HasSequenceBeenStarted)
{
this.DisableAllCameras();
}
return(keyframe);
}
public void RemoveKeyframe(USObserverKeyframe keyframe)
{
if (keyframe == null)
{
return;
}
if (!this.observerKeyframes.Contains(keyframe))
{
return;
}
this.observerKeyframes.Remove(keyframe);
}
private void RemoveKeyframe(USObserverKeyframe keyframe)
{
USUndoManager.RegisterCompleteObjectUndo(this, "Remove Keyframe");
var data = cachedObserverRenderData.Where(element => element.Keyframe == keyframe).First();
cachedObserverRenderData.Remove(data);
USUndoManager.PropertyChange(ObserverTimeline, "Remove Keyframe");
ObserverTimeline.RemoveKeyframe(keyframe);
ObserverTimeline.Process(ObserverTimeline.Sequence.RunningTime, ObserverTimeline.Sequence.PlaybackRate);
USUndoManager.DestroyImmediate(data);
USUndoManager.DestroyImmediate(keyframe);
}
private int KeyframeComparer(USObserverKeyframe a, USObserverKeyframe b)
{
if (a == null && b == null)
{
return(0);
}
if (a == null)
{
return(-1);
}
if (b == null)
{
return(1);
}
return(a.FireTime.CompareTo(b.FireTime));
}
private USObserverKeyframe KeyframeBefore(USObserverKeyframe currentlyActiveKeyframe)
{
if (currentlyActiveKeyframe == null)
{
return(null);
}
USObserverKeyframe uSObserverKeyframe = null;
foreach (USObserverKeyframe current in this.observerKeyframes)
{
if (current.FireTime < currentlyActiveKeyframe.FireTime && (uSObserverKeyframe == null || uSObserverKeyframe.FireTime < current.FireTime))
{
uSObserverKeyframe = current;
}
}
return(uSObserverKeyframe);
}
List <USObserverKeyframe> CollectAllKeyframesBetween(USObserverKeyframe prevKeyframe, USObserverKeyframe currentKeyframe)
{
var earliestKeyframe = default(USObserverKeyframe);
var latestKeyframe = default(USObserverKeyframe);
if (prevKeyframe == null)
{
earliestKeyframe = observerKeyframes[0];
}
else if (currentKeyframe == null)
{
earliestKeyframe = observerKeyframes[0];
}
else
{
earliestKeyframe = prevKeyframe.FireTime < currentKeyframe.FireTime ? prevKeyframe : currentKeyframe;
}
if (prevKeyframe == null)
{
latestKeyframe = currentKeyframe;
}
else if (currentKeyframe == null)
{
latestKeyframe = prevKeyframe;
}
else
{
latestKeyframe = earliestKeyframe == prevKeyframe ? currentKeyframe : prevKeyframe;
}
var keyframes = new List <USObserverKeyframe>();
foreach (var keyframe in observerKeyframes)
{
if (keyframe.FireTime >= earliestKeyframe.FireTime && keyframe.FireTime <= latestKeyframe.FireTime)
{
keyframes.Add(keyframe);
}
}
return(keyframes);
}
private void RevertToSnapshot()
{
foreach (USTimelineObserver.SnapShotEntry current in this.currentSnapshots)
{
if (current.camera != null)
{
current.camera.enabled = current.state;
}
if (current.listener != null)
{
current.listener.enabled = current.state;
}
if (current.camera != null)
{
current.camera.targetTexture = current.target;
}
}
this.CurrentlyActiveKeyframe = null;
}
private List <USObserverKeyframe> CollectAllKeyframesBetween(USObserverKeyframe prevKeyframe, USObserverKeyframe currentKeyframe)
{
USObserverKeyframe uSObserverKeyframe;
if (prevKeyframe == null)
{
uSObserverKeyframe = this.observerKeyframes[0];
}
else if (currentKeyframe == null)
{
uSObserverKeyframe = this.observerKeyframes[0];
}
else
{
uSObserverKeyframe = ((prevKeyframe.FireTime >= currentKeyframe.FireTime) ? currentKeyframe : prevKeyframe);
}
USObserverKeyframe uSObserverKeyframe2;
if (prevKeyframe == null)
{
uSObserverKeyframe2 = currentKeyframe;
}
else if (currentKeyframe == null)
{
uSObserverKeyframe2 = prevKeyframe;
}
else
{
uSObserverKeyframe2 = ((!(uSObserverKeyframe == prevKeyframe)) ? prevKeyframe : currentKeyframe);
}
List <USObserverKeyframe> list = new List <USObserverKeyframe>();
foreach (USObserverKeyframe current in this.observerKeyframes)
{
if (current.FireTime >= uSObserverKeyframe.FireTime && current.FireTime <= uSObserverKeyframe2.FireTime)
{
list.Add(current);
}
}
return(list);
}
USObserverKeyframe KeyframeBefore(USObserverKeyframe currentlyActiveKeyframe)
{
if (currentlyActiveKeyframe == default(USObserverKeyframe))
{
return(default(USObserverKeyframe));
}
var keyframeBefore = default(USObserverKeyframe);
foreach (var keyframe in observerKeyframes)
{
if (keyframe.FireTime < currentlyActiveKeyframe.FireTime)
{
if (keyframeBefore == default(USObserverKeyframe) || keyframeBefore.FireTime < keyframe.FireTime)
{
keyframeBefore = keyframe;
}
}
}
return(keyframeBefore);
}
private void RevertToSnapshot()
{
#if DEBUG_OBSERVER
Debug.LogWarning("Reverting to snapshot");
#endif
foreach (var currentSnapshot in currentSnapshots)
{
if (currentSnapshot.camera != null)
{
currentSnapshot.camera.enabled = currentSnapshot.state;
}
if (currentSnapshot.listener != null)
{
currentSnapshot.listener.enabled = currentSnapshot.state;
}
if (currentSnapshot.camera)
{
currentSnapshot.camera.targetTexture = currentSnapshot.target;
}
}
CurrentlyActiveKeyframe = null;
}
private void HandleEvent()
{
var isContext = Event.current.type == EventType.MouseDown && Event.current.button == 1;
if (!isContext)
{
return;
}
var contextMenu = new GenericMenu();
var newTime = (((Event.current.mousePosition.x + XScroll - DisplayArea.x) / DisplayArea.width) * Duration) / XScale;
USObserverKeyframe overKeyframe = null;
foreach (var data in cachedObserverRenderData)
{
if (data.RenderRect.Contains(Event.current.mousePosition))
{
contextMenu.AddItem(new GUIContent("Remove Observer Keyframe"), false, () => { RemoveKeyframe(data.Keyframe); });
contextMenu.AddSeparator("");
overKeyframe = data.Keyframe;
break;
}
}
var cameras = Resources.FindObjectsOfTypeAll(typeof(Camera)) as Camera[];
cameras = cameras.OrderBy(camera => camera.name).ToArray();
foreach (var camera in cameras)
{
if (!ObserverTimeline.IsValidCamera(camera))
{
continue;
}
var assetPath = AssetDatabase.GetAssetPath(camera.gameObject.transform.root.gameObject);
if (!string.IsNullOrEmpty(assetPath))
{
continue;
}
var cutTransition = Shared.TypeOfTransition.Cut;
var cutDuration = Shared.TransitionHelper.DefaultTransitionTimeFor(cutTransition);
contextMenu.AddItem(new GUIContent(String.Format("Set Camera/Cut/{0}", camera.name)), false, (settingCamera) => SetCamera(overKeyframe, newTime, cutTransition, cutDuration, (Camera)settingCamera), camera);
var transitions = Enum.GetValues(typeof(Shared.TypeOfTransition)).Cast <Shared.TypeOfTransition>();
foreach (var transition in transitions)
{
if (transition == Shared.TypeOfTransition.Cut)
{
continue;
}
var transitionType = transition; // Keep a local copy of this, so it's safed for our delegate.
var transitionDuration = Shared.TransitionHelper.DefaultTransitionTimeFor(transitionType);
contextMenu.AddItem(new GUIContent(String.Format("Set Camera/Transition/{0}/{1}", camera.name, transitionType)), false, (settingCamera) => SetCamera(overKeyframe, newTime, transitionType, transitionDuration, (Camera)settingCamera), camera);
}
}
if (DisplayArea.Contains(Event.current.mousePosition))
{
Event.current.Use();
contextMenu.ShowAsContext();
}
}
public override void Process(float sequencerTime, float playbackRate)
{
var currentKeyframe = default(USObserverKeyframe);
for (var index = 0; index < observerKeyframes.Count; index++)
{
var keyframe = observerKeyframes[index];
if (keyframe.FireTime > sequencerTime)
{
continue;
}
if (currentKeyframe == null)
{
currentKeyframe = keyframe;
}
if (keyframe.FireTime > currentKeyframe.FireTime)
{
currentKeyframe = keyframe;
}
}
if (CurrentlyActiveKeyframe != null)
{
if (sequencerTime >= (CurrentlyActiveKeyframe.FireTime + CurrentlyActiveKeyframe.TransitionDuration) && CurrentlyActiveKeyframe.Fired)
{
CurrentlyActiveKeyframe.Process(sequencerTime - CurrentlyActiveKeyframe.FireTime);
CurrentlyActiveKeyframe.End();
var prevKeyframe = KeyframeBefore(CurrentlyActiveKeyframe);
if (prevKeyframe && prevKeyframe.AudioListener)
{
prevKeyframe.AudioListener.enabled = false;
}
}
}
if (currentKeyframe != CurrentlyActiveKeyframe)
{
var prevKeyframe = CurrentlyActiveKeyframe;
CurrentlyActiveKeyframe = currentKeyframe;
var allKeyframesBetween = CollectAllKeyframesBetween(prevKeyframe, CurrentlyActiveKeyframe);
var forwards = (prevKeyframe == null && CurrentlyActiveKeyframe != null) || (CurrentlyActiveKeyframe != null && prevKeyframe.FireTime < CurrentlyActiveKeyframe.FireTime);
if (forwards)
{
for (var index = 0; index < allKeyframesBetween.Count(); index++)
{
if (prevKeyframe != null && index == 0)
{
continue;
}
if (index - 1 >= 0)
{
allKeyframesBetween[index - 1].UnFire();
}
allKeyframesBetween[index].Fire((index > 0 ? allKeyframesBetween[index - 1].KeyframeCamera : default(Camera)));
if (index != allKeyframesBetween.Count() - 1)
{
allKeyframesBetween[index].Process(sequencerTime - CurrentlyActiveKeyframe.FireTime);
allKeyframesBetween[index].End();
}
}
}
else
{
for (var index = allKeyframesBetween.Count() - 1; index >= 0; index--)
{
if (CurrentlyActiveKeyframe != null && index == 0)
{
var keyframeBefore = KeyframeBefore(CurrentlyActiveKeyframe);
allKeyframesBetween[index].Fire(keyframeBefore ? keyframeBefore.KeyframeCamera : default(Camera));
continue;
}
var shouldRevert = true;
// Simple Hack so the when playing a ping pong'd sequence there isn't a frame of no cameras
if (Sequence.IsPingPonging && allKeyframesBetween[index].FireTime <= 0.0f)
{
shouldRevert = false;
}
if (shouldRevert)
{
allKeyframesBetween[index].Revert();
}
}
}
}
if (CurrentlyActiveKeyframe)
{
CurrentlyActiveKeyframe.Process(sequencerTime - CurrentlyActiveKeyframe.FireTime);
}
}
public override void Process(float sequencerTime, float playbackRate)
{
USObserverKeyframe uSObserverKeyframe = null;
for (int i = 0; i < this.observerKeyframes.Count; i++)
{
USObserverKeyframe uSObserverKeyframe2 = this.observerKeyframes[i];
if (uSObserverKeyframe2.FireTime <= sequencerTime)
{
if (uSObserverKeyframe == null)
{
uSObserverKeyframe = uSObserverKeyframe2;
}
if (uSObserverKeyframe2.FireTime > uSObserverKeyframe.FireTime)
{
uSObserverKeyframe = uSObserverKeyframe2;
}
}
}
if (this.CurrentlyActiveKeyframe != null && sequencerTime >= this.CurrentlyActiveKeyframe.FireTime + this.CurrentlyActiveKeyframe.TransitionDuration && this.CurrentlyActiveKeyframe.Fired)
{
this.CurrentlyActiveKeyframe.Process(sequencerTime - this.CurrentlyActiveKeyframe.FireTime);
this.CurrentlyActiveKeyframe.End();
USObserverKeyframe uSObserverKeyframe3 = this.KeyframeBefore(this.CurrentlyActiveKeyframe);
if (uSObserverKeyframe3 && uSObserverKeyframe3.AudioListener)
{
uSObserverKeyframe3.AudioListener.enabled = false;
}
}
if (uSObserverKeyframe != this.CurrentlyActiveKeyframe)
{
USObserverKeyframe currentlyActiveKeyframe = this.CurrentlyActiveKeyframe;
this.CurrentlyActiveKeyframe = uSObserverKeyframe;
List <USObserverKeyframe> list = this.CollectAllKeyframesBetween(currentlyActiveKeyframe, this.CurrentlyActiveKeyframe);
bool flag = (currentlyActiveKeyframe == null && this.CurrentlyActiveKeyframe != null) || (this.CurrentlyActiveKeyframe != null && currentlyActiveKeyframe.FireTime < this.CurrentlyActiveKeyframe.FireTime);
if (flag)
{
for (int j = 0; j < list.Count <USObserverKeyframe>(); j++)
{
if (!(currentlyActiveKeyframe != null) || j != 0)
{
if (j - 1 >= 0)
{
list[j - 1].UnFire();
}
list[j].Fire((j <= 0) ? null : list[j - 1].KeyframeCamera);
if (j != list.Count <USObserverKeyframe>() - 1)
{
list[j].Process(sequencerTime - this.CurrentlyActiveKeyframe.FireTime);
list[j].End();
}
}
}
}
else
{
for (int k = list.Count <USObserverKeyframe>() - 1; k >= 0; k--)
{
if (this.CurrentlyActiveKeyframe != null && k == 0)
{
USObserverKeyframe uSObserverKeyframe4 = this.KeyframeBefore(this.CurrentlyActiveKeyframe);
list[k].Fire((!uSObserverKeyframe4) ? null : uSObserverKeyframe4.KeyframeCamera);
}
else
{
bool flag2 = true;
if (base.Sequence.IsPingPonging && list[k].FireTime <= 0f)
{
flag2 = false;
}
if (flag2)
{
list[k].Revert();
}
}
}
}
}
if (this.CurrentlyActiveKeyframe)
{
this.CurrentlyActiveKeyframe.Process(sequencerTime - this.CurrentlyActiveKeyframe.FireTime);
}
}
