static void Init()
{
// Get existing open window or if none, make a new one:
SequenceEditor window = (SequenceEditor)GetWindow(typeof(SequenceEditor));
window.Show();
}
protected virtual void OnBodyContextClick()
{
int t = SequenceEditor.GetFrameForX(Event.current.mousePosition.x - _headerWidth);
GUIContent selectAllEvents = new GUIContent("Select All Events");
GUIContent addEventAtFrame = new GUIContent("Add Event At Frame");
GUIContent addEventFillGap = new GUIContent("Add Event Fill Gap");
GenericMenu menu = new GenericMenu();
menu.AddItem(selectAllEvents, false, SelectAllEvents);
if (Track.CanAddAt(t))
{
menu.AddItem(addEventAtFrame, false, AddEventAtPoint, t);
menu.AddItem(addEventFillGap, false, AddEventFillGap, t);
}
else
{
menu.AddDisabledItem(addEventAtFrame);
menu.AddDisabledItem(addEventFillGap);
}
menu.ShowAsContext();
Event.current.Use();
}
private void Delete()
{
List <FEventEditor> eventEditors = new List <FEventEditor>();
eventEditors.Add(this);
SequenceEditor.DestroyEvents(eventEditors);
}
public static void ShowWindow()
{
SequenceEditor window = EditorWindow.GetWindow <SequenceEditor>(false, "Tweener");
window.wantsMouseMove = true;
UnityEngine.Object.DontDestroyOnLoad(window);
}
public void Init(SequenceHolder _sequenceHolder)
{
if (_sequenceHolder == null || editorWindow != null)
{
Destroy(gameObject);
}
else
{
editorWindow = this;
}
sequenceHolder = _sequenceHolder;
sequence = sequenceHolder.GetSequence();
sequenceVisualization = new List <Image>();
foreach (bool slot in sequence)
{
GameObject t = new GameObject("slot", typeof(RectTransform));
Image i = t.AddComponent <Image>();
i.sprite = slot ? on : off;
t.transform.SetParent(sequenceParent);
if (i != null)
{
sequenceVisualization.Add(i);
}
}
highlightTargetPos = sequenceParent.position;
Time.timeScale = 0;
}
void AddTrackMenu(object param)
{
KeyValuePair <Type, FEventAttribute> kvp = (KeyValuePair <Type, FEventAttribute>)param;
Undo.RecordObjects(new UnityEngine.Object[] { Container, this }, "add Track");
FTrack track = (FTrack)typeof(FContainer).GetMethod("Add", new Type[] { typeof(FrameRange) }).MakeGenericMethod(kvp.Key).Invoke(Container, new object[] { SequenceEditor.ViewRange });
string evtName = track.gameObject.name;
int nameStart = 0;
int nameEnd = evtName.Length;
if (nameEnd > 2 && evtName[0] == 'F' && char.IsUpper(evtName[1]))
{
nameStart = 1;
}
if (evtName.EndsWith("Event"))
{
nameEnd = evtName.Length - "Event".Length;
}
evtName = evtName.Substring(nameStart, nameEnd - nameStart);
track.gameObject.name = ObjectNames.NicifyVariableName(evtName);
SequenceEditor.Refresh();
Undo.RegisterCreatedObjectUndo(track.gameObject, string.Empty);
SequenceEditor.SelectExclusive(SequenceEditor.GetEditor <FEventEditor>(track.GetEvent(0)));
}
protected virtual void OnHeaderInput(Rect labelRect, Rect iconRect)
{
if (Event.current.type == EventType.MouseDown && Event.current.clickCount > 1 && labelRect.Contains(Event.current.mousePosition))
{
Selection.activeTransform = this.Obj.transform;
Event.current.Use();
}
else if (Event.current.type == EventType.MouseDown && labelRect.Contains(Event.current.mousePosition))
{
if (Event.current.button == 0)
{
if (Event.current.shift)
{
SequenceEditor.Select(this);
}
else
{
SequenceEditor.SelectExclusive(this);
}
}
else if (Event.current.button == 1)
{
ShowHeaderContextMenu();
}
Event.current.Use();
}
}
public virtual void OnToggle(bool on)
{
Undo.RecordObject(Track, on ? "enable" : "disable");
Track.enabled = on;
EditorUtility.SetDirty(Track);
if (Track.RequiresEditorCache)
{
if (on)
{
Track.CreateCache();
}
else
{
Track.ClearCache();
}
}
if (!SequenceEditor.Sequence.IsStopped)
{
int currentFrame = SequenceEditor.Sequence.CurrentFrame;
SequenceEditor.Stop();
SequenceEditor.SetCurrentFrame(currentFrame);
}
SequenceEditor.SetDirty(this);
SequenceEditor.NotifyDirtyTracks();
}
public virtual void DrawCurves()
{
foreach (EventNode previousNode in previousNodes)
{
SequenceEditor.DrawNodeCurve(previousNode.windowRect, windowRect);
}
}
// public override void OnTogglePreview ()
// {
//// int currentFrame = Track.Sequence.GetCurrentFrame();
//
// base.OnTogglePreview();
//
//// if( currentFrame >= 0 )
//// SequenceEditor.SetCurrentFrame( currentFrame );
// }
public override void Render(Rect rect, float headerWidth)
{
// bool isPreviewing = _track.IsPreviewing;
base.Render(rect, headerWidth);
// if( isPreviewing != _track.IsPreviewing )
// {
// if( Event.current.alt )
// SyncWithAnimationWindow = true;
// }
switch (Event.current.type)
{
case EventType.DragUpdated:
if (rect.Contains(Event.current.mousePosition))
{
int numAnimationsDragged = FAnimationEventInspector.NumAnimationsDragAndDrop(Track.Sequence.FrameRate);
int frame = SequenceEditor.GetFrameForX(Event.current.mousePosition.x);
DragAndDrop.visualMode = numAnimationsDragged > 0 && Track.CanAddAt(frame) ? DragAndDropVisualMode.Copy : DragAndDropVisualMode.Rejected;
Event.current.Use();
}
break;
case EventType.DragPerform:
if (rect.Contains(Event.current.mousePosition))
{
AnimationClip animClip = FAnimationEventInspector.GetAnimationClipDragAndDrop(Track.Sequence.FrameRate);
if (animClip && Mathf.Approximately(animClip.frameRate, Track.Sequence.FrameRate))
{
int frame = SequenceEditor.GetFrameForX(Event.current.mousePosition.x);
int maxLength;
if (Track.CanAddAt(frame, out maxLength))
{
FPlayAnimationEvent animEvt = FEvent.Create <FPlayAnimationEvent>(new FrameRange(frame, frame + Mathf.Min(maxLength, Mathf.RoundToInt(animClip.length * animClip.frameRate))));
Track.Add(animEvt);
FAnimationEventInspector.SetAnimationClip(animEvt, animClip);
DragAndDrop.AcceptDrag();
}
}
Event.current.Use();
}
break;
}
// if( _wasPreviewing != _track.IsPreviewing )
// {
// if( _wasPreviewing )
// SequenceEditor.OnUpdateEvent.RemoveListener( OnUpdate );
// else
// SequenceEditor.OnUpdateEvent.AddListener( OnUpdate );
//
// _wasPreviewing = _track.IsPreviewing;
// }
}
public virtual void OnToggle(bool on)
{
Undo.RecordObject(Track, on ? "enable" : "disable");
Track.enabled = on;
EditorUtility.SetDirty(Track);
SequenceEditor.SetDirty(this);
}
void DeleteTimeline()
{
UnityEngine.Object[] objsToSave = new UnityEngine.Object[] { SequenceEditor.GetSequence(), _timeline };
Undo.RegisterCompleteObjectUndo(objsToSave, string.Empty);
Undo.SetTransformParent(_timeline.transform, null, string.Empty);
SequenceEditor.GetSequence().Remove(_timeline);
Undo.DestroyObjectImmediate(_timeline.gameObject);
}
private void Duplicate()
{
GameObject go = GameObject.Instantiate(Obj.gameObject);
go.transform.parent = Obj.transform.parent;
go.name = SequenceEditor.GetUniqueContainerName(Obj.gameObject.name);
Undo.RegisterCreatedObjectUndo(go, "duplicate " + Obj.gameObject.name);
}
private void StopDragSelecting(Vector2 mousePos)
{
if (!_isDragSelecting)
{
return;
}
_isDragSelecting = false;
FrameRange selectedRange = new FrameRange();
bool isSelectingTimelines;
Rect selectionRect = GetDragSelectionRect(_dragSelectingStartPos, mousePos, out selectedRange, out isSelectingTimelines);
if (!Event.current.shift && !Event.current.control)
{
SequenceEditor.DeselectAll();
}
for (int i = 0; i != Editors.Count; ++i)
{
Rect timelineRect = Editors[i].Rect;
if (timelineRect.yMin >= selectionRect.yMax)
{
break;
}
if (timelineRect.yMax <= selectionRect.yMin)
{
continue;
}
for (int j = 0; j != Editors[i].Editors.Count; ++j)
{
Rect trackRect = Editors[i].Editors[j].Rect;
if (trackRect.yMin >= selectionRect.yMax)
{
break;
}
if (trackRect.yMax <= selectionRect.yMin)
{
continue;
}
if (Event.current.control)
{
Editors[i].Editors[j].DeselectEvents(selectedRange);
}
else
{
Editors[i].Editors[j].SelectEvents(selectedRange);
}
}
}
}
protected virtual void OnBodyContextClick()
{
int t = SequenceEditor.GetFrameForX(Event.current.mousePosition.x - HeaderWidth);
GUIContent selectAllEvents = new GUIContent("选择所有事件");
GUIContent addEventAtFrame = new GUIContent("在当前帧添加事件");
GUIContent addEventFillGap = new GUIContent("添加事件填充剩余空隙");
GUIContent pasteEvent = new GUIContent("粘贴事件");
GenericMenu menu = new GenericMenu();
menu.AddItem(selectAllEvents, false, SelectAllEvents);
if (Track.CanAddAt(t))
{
menu.AddItem(addEventAtFrame, false, AddEventAtPoint, t);
menu.AddItem(addEventFillGap, false, AddEventFillGap, t);
}
else
{
menu.AddDisabledItem(addEventAtFrame);
menu.AddDisabledItem(addEventFillGap);
}
if (FSequenceEditor.CopyObject != null)
{
FEvent copyEvt = FSequenceEditor.CopyObject as FEvent;
if (copyEvt != null)
{
if (FSequenceEditor.CopyObject.GetType() != Track.GetEventType())
{
menu.AddDisabledItem(pasteEvent);
}
else
{
FEvent eventBefore = Track.GetEventBefore(t);
FEvent eventAfter = Track.GetEventAfter(t);
FrameRange validRange = new FrameRange(eventBefore == null ? 0 : eventBefore.End, eventAfter == null ? SequenceEditor.Sequence.Length : eventAfter.Start);
if (validRange.Length >= copyEvt.Length)
{
menu.AddItem(pasteEvent, false, PasteEvent, t);
}
else
{
menu.AddDisabledItem(pasteEvent);
}
}
}
}
menu.ShowAsContext();
Event.current.Use();
}
public static void ShowEditor(int sequenceIndex)
{
seqIndex = sequenceIndex;
Load();
SequenceEditor editor = EditorWindow.GetWindow <SequenceEditor>(false, sequence.id);
editor.Init();
}
void ChangeOwner()
{
Undo.RecordObject(_timeline, "Change Timeline Owner");
_timeline.SetOwner(Selection.activeTransform);
_timeline.name = Selection.activeTransform.name;
if (!SequenceEditor.GetSequence().IsStopped)
{
_timeline.Init();
}
}
public override void Render(Rect rect, float headerWidth)
{
Rect = rect;
Rect headerRect = rect;
headerRect.height = HeaderHeight;
RenderHeader(headerRect, headerWidth);
Rect headerTimelineRect = rect;
headerTimelineRect.xMin += headerWidth;
if (headerTimelineRect.Contains(Event.current.mousePosition))
{
SequenceEditor.SetMouseHover(Event.current.mousePosition.x - headerWidth, this);
}
headerRect.width = headerWidth;
HeaderRect = headerRect;
Rect listRect = rect;
listRect.yMin += HeaderHeight;
_contentOffset.y = listRect.y;
if (_showPercentage.value > 0)
{
listRect.height *= _showPercentage.value;
RenderList(listRect, headerWidth);
}
if (IsSelected && Event.current.type == EventType.Repaint)
{
float lineWidth = 3;
float halfLineWidth = lineWidth * 0.33f;
Color c = Handles.selectedColor; //FGUI.GetTextColor();//Color.white;//new Color(0.5f, 0.7f, 0.1f, 1f);//FGUI.GetSelectionColor();
c.a = 1f;
Handles.color = c;
Vector3 pt0 = new Vector3(rect.xMin + halfLineWidth, rect.yMin + halfLineWidth);
Vector3 pt1 = new Vector3(rect.xMin + halfLineWidth, rect.yMax - halfLineWidth);
Vector3 pt2 = new Vector3(rect.xMax - halfLineWidth, rect.yMax - halfLineWidth);
Vector3 pt3 = new Vector3(rect.xMax - halfLineWidth, rect.yMin + halfLineWidth);
// Handles.DrawAAPolyLine( lineWidth, pt0, pt1, pt2, pt3, pt0 );
Handles.DrawSolidRectangleWithOutline(new Vector3[] { pt0, pt1, pt2, pt3 }, new Color(0, 0, 0, 0), c);
// Handles.DrawPolyLine( pt0, pt1, pt2, pt3, pt0 );
}
Handles.color = FGUI.GetLineColor();
Handles.DrawLine(Rect.min, Rect.min + new Vector2(Rect.width, 0));
Handles.DrawLine(Rect.max - new Vector2(Rect.width, 0), Rect.max);
}
public void DeselectEvents(FrameRange range)
{
for (int i = 0; i != _eventEditors.Count; ++i)
{
if (range.Overlaps(_eventEditors[i]._evt.FrameRange))
{
SequenceEditor.Deselect(_eventEditors[i]);
}
else if (_eventEditors[i]._evt.Start > range.End)
{
break;
}
}
}
void DuplicateTrack()
{
Undo.RecordObjects(new UnityEngine.Object[] { _timelineEditor, _track.GetTimeline() }, string.Empty);
GameObject duplicateTrack = (GameObject)Instantiate(_track.gameObject);
duplicateTrack.name = _track.gameObject.name;
Undo.SetTransformParent(duplicateTrack.transform, _track.GetTimeline().transform, string.Empty);
Undo.RegisterCreatedObjectUndo(duplicateTrack, "duplicate Track");
if (!SequenceEditor.GetSequence().IsStopped)
{
duplicateTrack.GetComponent <FTrack>().Init();
}
}
void DuplicateTimeline()
{
UnityEngine.Object[] objsToSave = new UnityEngine.Object[] { SequenceEditor, SequenceEditor.GetSequence() };
Undo.RecordObjects(objsToSave, string.Empty);
GameObject duplicateTimeline = (GameObject)Instantiate(_timeline.gameObject);
duplicateTimeline.name = _timeline.gameObject.name;
Undo.SetTransformParent(duplicateTimeline.transform, _timeline.Sequence.TimelineContainer, string.Empty);
Undo.RegisterCreatedObjectUndo(duplicateTimeline, "duplicate Timeline");
if (!SequenceEditor.GetSequence().IsStopped)
{
duplicateTimeline.GetComponent <FTimeline>().Init();
}
}
private void OnUpdate()
{
if (!_syncWithAnimationWindow)
{
return;
}
if (Selection.activeTransform != Track.Owner)
{
Selection.activeTransform = Track.Owner;
}
if (!AnimationMode.InAnimationMode())
{
// AnimationMode.StartAnimationMode();
AnimationWindowProxy.StartAnimationMode();
}
// if( _track.IsPreviewing )
{
int animWindowFrame = AnimationWindowProxy.GetCurrentFrame();
FEvent[] evts = new FEvent[2];
int numEvts = Track.GetEventsAt(SequenceEditor.Sequence.CurrentFrame, ref evts);
if (numEvts > 0)
{
FPlayAnimationEvent animEvt = (FPlayAnimationEvent)evts[numEvts - 1];
if (animEvt.ControlsAnimation)
{
int normCurrentFrame = SequenceEditor.Sequence.CurrentFrame - animEvt.Start;
if (animWindowFrame > animEvt.Length)
{
animWindowFrame = animEvt.Length;
AnimationWindowProxy.SetCurrentFrame(animWindowFrame, animEvt.LengthTime);
}
if (animWindowFrame >= 0 && animWindowFrame != normCurrentFrame)
{
SequenceEditor.SetCurrentFrame(animEvt.Start + animWindowFrame);
SequenceEditor.Repaint();
// Debug.Log( "AnimWindow->Flux: " + (animEvt.Start + animWindowFrame) );
}
}
}
}
}
protected override void Init(FObject obj)
{
_track = (FTrack)obj;
_eventEditors.Clear();
List <FEvent> events = _track.GetEvents();
for (int i = 0; i < events.Count; ++i)
{
FEvent evt = events[i];
FEventEditor evtEditor = SequenceEditor.GetEditor <FEventEditor>(evt);
evtEditor.Init(evt, this);
_eventEditors.Add(evtEditor);
}
}
void AddTimeline()
{
Undo.IncrementCurrentGroup();
UnityEngine.Object[] objsToSave = new UnityEngine.Object[] { SequenceEditor, SequenceEditor.GetSequence() };
Undo.RecordObjects(objsToSave, string.Empty);
GameObject timelineGO = new GameObject("TimeLine");
FTimeline timeline = timelineGO.AddComponent <Flux.FTimeline>();
//timeline.SetOwner(((GameObject)obj).transform);
SequenceEditor.GetSequence().Add(timeline);
Undo.RegisterCompleteObjectUndo(objsToSave, string.Empty);
Undo.RegisterCreatedObjectUndo(timeline.gameObject, "create Timeline");
Undo.CollapseUndoOperations(Undo.GetCurrentGroup());
}
public override void Init(FObject obj, FEditor owner)
{
base.Init(obj, owner);
_eventEditors.Clear();
List <FEvent> events = Track.Events;
for (int i = 0; i < events.Count; ++i)
{
FEvent evt = events[i];
FEventEditor evtEditor = SequenceEditor.GetEditor <FEventEditor>(evt);
evtEditor.Init(evt, this);
_eventEditors.Add(evtEditor);
}
}
public override void Init(FObject obj, FEditor owner)
{
base.Init(obj, owner);
Editors.Clear();
List <FTrack> tracks = Container.Tracks;
for (int i = 0; i < tracks.Count; ++i)
{
FTrack track = tracks[i];
FTrackEditor trackEditor = SequenceEditor.GetEditor <FTrackEditor>(track);
trackEditor.Init(track, this);
Editors.Add(trackEditor);
}
_icon = new GUIContent(FUtility.GetFluxTexture("Plus.png"));
}
// pixelsPerFrame can be calculated from rect and viewRange, but being cached on a higher level
public void Render(Rect rect, FrameRange viewRange, float pixelsPerFrame, FrameRange validKeyframeRange)
{
Rect = rect;
_eventRect = rect;
int eventStartFrame = Mathf.Max(Evt.Start, viewRange.Start);
int eventEndFrame = Mathf.Min(Evt.End, viewRange.End);
_eventRect.xMin += (eventStartFrame - viewRange.Start) * pixelsPerFrame; // first set the start
_eventRect.xMax = _eventRect.xMin + Mathf.Max(4, (eventEndFrame - eventStartFrame) * pixelsPerFrame); // then width
if (_eventRect.Contains(Event.current.mousePosition))
{
SequenceEditor.SetMouseHover(Event.current.mousePosition.x - rect.x, this);
}
RenderEvent(viewRange, validKeyframeRange);
}
public override void Init(FObject obj, FEditor owner)
{
base.Init(obj, owner);
Editors.Clear();
List <FTimeline> timelines = Container.Timelines;
for (int i = 0; i < timelines.Count; ++i)
{
FTimeline timeline = timelines[i];
FTimelineEditor timelineEditor = SequenceEditor.GetEditor <FTimelineEditor>(timeline);
timelineEditor.Init(timeline, this);
Editors.Add(timelineEditor);
}
_icon = new GUIContent(FUtility.GetFluxTexture("Folder.png"));
// _contentOffset = new Vector2(8, HeaderHeight);
}
// pixelsPerFrame can be calculated from rect and viewRange, but being cached on a higher level
public void Render(Rect rect, FrameRange viewRange, float pixelsPerFrame, FrameRange validKeyframeRange)
{
Rect = rect;
_eventRect = rect;
int eventStartFrame = Mathf.Max(Evt.Start, viewRange.Start);
int eventEndFrame = Mathf.Min(Evt.End, viewRange.End);
_eventRect.xMin = SequenceEditor.GetXForFrame(eventStartFrame);
_eventRect.xMax = SequenceEditor.GetXForFrame(eventEndFrame);
if (_eventRect.Contains(Event.current.mousePosition))
{
SequenceEditor.SetMouseHover(Event.current.mousePosition.x, this);
}
RenderEvent(viewRange, validKeyframeRange);
}
public override void Render(Rect rect, float headerWidth)
{
base.Render(rect, headerWidth);
switch (Event.current.type)
{
case EventType.DragUpdated:
if (rect.Contains(Event.current.mousePosition))
{
int numAnimationsDragged = FAnimationEventInspector.NumAnimationsDragAndDrop(Track.Sequence.FrameRate);
int frame = SequenceEditor.GetFrameForX(Event.current.mousePosition.x);
DragAndDrop.visualMode = numAnimationsDragged > 0 && Track.CanAddAt(frame) ? DragAndDropVisualMode.Copy : DragAndDropVisualMode.Rejected;
Event.current.Use();
}
break;
case EventType.DragPerform:
if (rect.Contains(Event.current.mousePosition))
{
AnimationClip animClip = FAnimationEventInspector.GetAnimationClipDragAndDrop(Track.Sequence.FrameRate);
if (animClip && Mathf.Approximately(animClip.frameRate, Track.Sequence.FrameRate))
{
int frame = SequenceEditor.GetFrameForX(Event.current.mousePosition.x);
int maxLength;
if (Track.CanAddAt(frame, out maxLength))
{
FPlayAnimationEvent animEvt = FEvent.Create <FPlayAnimationEvent>(new FrameRange(frame, frame + Mathf.Min(maxLength, Mathf.RoundToInt(animClip.length * animClip.frameRate))));
Track.Add(animEvt);
FAnimationEventInspector.SetAnimationClip(animEvt, animClip);
DragAndDrop.AcceptDrag();
}
}
Event.current.Use();
}
break;
}
}
