public override void Init(FObject obj, FEditor owner)
{
base.Init(obj, owner);
Type evtType = obj.GetType();
object[] customAttributes = evtType.GetCustomAttributes(typeof(FEventAttribute), false);
if (customAttributes.Length > 0)
{
_isSingleFrame = ((FEventAttribute)customAttributes[0]).isSingleFrame;
}
if (_isSingleFrame && Evt.FrameRange.Length != 1)
{
FrameRange range = Evt.FrameRange;
range.Length = 1;
Evt.FrameRange = range;
}
if (_singleFrameStyle == null)
{
_singleFrameStyle = FUtility.GetFluxSkin().GetStyle("SingleFrame");
}
GUIContent singleWidth = new GUIContent(FUtility.GetFluxTexture("SingleFrame_Active.png"));
_singleSize = _singleFrameStyle.CalcSize(singleWidth);
}
public void OnGUI()
{
if (_timelineEditors == null)
{
return;
}
if (_timelineEditors.Count == 0)
{
if (_renderingOnEditorWindow)
{
_renderingOnEditorWindow.ShowNotification(new GUIContent("Drag GameObjects Here"));
}
}
_pixelsPerFrame = (_sequenceRect.width - _timelineHeaderWidth) / _viewRange.Length;
if (_timelineEditorIds.Length != _timelineEditors.Count)
{
_timelineEditorIds = new int[_timelineEditors.Count];
_timelineEditorHeights = new float[_timelineEditors.Count];
}
int timelineHeaderResizerId = EditorGUIUtility.GetControlID(FocusType.Passive);
float sequenceViewHeight = 0;
for (int i = 0; i != _timelineEditors.Count; ++i)
{
_timelineEditorIds[i] = EditorGUIUtility.GetControlID(FocusType.Passive);
_timelineEditorHeights[i] = _timelineEditors[i].GetHeight();
sequenceViewHeight += _timelineEditorHeights[i];
_timelineEditors[i].ReserveTrackGuiIds();
}
_scrollPos.y = GUI.VerticalScrollbar(_verticalScrollerRect, _scrollPos.y, Mathf.Min(_sequenceRect.height, sequenceViewHeight), 0, sequenceViewHeight);
Rect scrolledViewRect = _viewRect;
// scrolledViewRect.yMin -= _scrollPos.y;
GUI.BeginGroup(scrolledViewRect);
Rect timelineRect = _sequenceRect;
timelineRect.y = -_scrollPos.y;
timelineRect.height = 0;
Rect timelineDraggedRect = new Rect();
// Debug.Log( "sequence: " + _sequenceRect + " scrubber: " + _timeScrubberRect + " width: " + _timelineHeaderWidth );
Handles.color = FGUI.GetLineColor();
for (int i = 0; i != _timelineEditors.Count; ++i)
{
timelineRect.yMin = timelineRect.yMax;
timelineRect.height = _timelineEditors[i].GetHeight();
if (_timelineDragged != null)
{
if (_timelineDragged == _timelineEditors[i])
{
timelineDraggedRect = timelineRect;
continue;
}
else if (EditorGUIUtility.hotControl == _timelineEditorIds[_timelineDragged.GetRuntimeObject().GetId()])
{
if (i < _timelineDragged.GetRuntimeObject().GetId() && Event.current.mousePosition.y < timelineRect.yMax)
{
_timelineEditors[i].SetOffset(new Vector2(0, _timelineDragged.GetHeight()));
}
else if (i > _timelineDragged.GetRuntimeObject().GetId() && Event.current.mousePosition.y > timelineRect.yMin)
{
_timelineEditors[i].SetOffset(new Vector2(0, -_timelineDragged.GetHeight()));
}
else
{
_timelineEditors[i].SetOffset(Vector2.zero);
}
}
}
_timelineEditors[i].Render(_timelineEditorIds[i], timelineRect, _timelineHeaderWidth, _viewRange, _pixelsPerFrame);
}
if (_timelineDragged != null)
{
if (EditorGUIUtility.hotControl == _timelineEditorIds[_timelineDragged.GetRuntimeObject().GetId()])
{
timelineDraggedRect.y = Event.current.mousePosition.y;
}
// timelineRect.yMin = Event.current.mousePosition.y;
// timelineRect.height = _timelineDragged.GetHeight();
_timelineDragged.Render(_timelineEditorIds[_timelineDragged.GetRuntimeObject().GetId()], timelineDraggedRect, _timelineHeaderWidth, _viewRange, _pixelsPerFrame);
}
switch (Event.current.type)
{
case EventType.MouseDown:
// bool middleClick = Event.current.button == 2 || (Event.current.button == 0 && Event.current.alt);
//
// if( middleClick ) // middle button
if (Event.current.button == 0)
{
StartDragSelecting(Event.current.mousePosition);
Event.current.Use();
}
break;
case EventType.MouseUp:
if (_isDragSelecting)
{
StopDragSelecting(Event.current.mousePosition);
Event.current.Use();
}
break;
case EventType.Ignore:
if (_isDragSelecting)
{
StopDragSelecting(Event.current.mousePosition);
}
break;
case EventType.Repaint:
if (_isDragSelecting)
{
OnDragSelecting(Event.current.mousePosition);
}
break;
}
GUI.EndGroup();
if (_viewRange.End > _sequence.Length)
{
_viewRange.Start = 0;
_viewRange.End = _sequence.Length;
}
int newT = FGUI.TimeScrubber(_timeScrubberRect, _sequence.GetCurrentFrame(), _sequence.FrameRate, _viewRange);
if (newT != _sequence.GetCurrentFrame())
{
// _sequence.SetCurrentFrameEditor( newT );
SetCurrentFrame(newT);
if (Application.isPlaying)
{
Play(false);
Pause();
}
// Repaint();
// SceneView.RepaintAll();
// UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
// FUtility.RepaintGameView();
}
_viewRange = FGUI.ViewRangeBar(_viewRangeRect, _viewRange, _sequence.Length);
if (_timelineHeaderResizerRect.Contains(Event.current.mousePosition))
{
EditorGUIUtility.AddCursorRect(_timelineHeaderResizerRect, MouseCursor.ResizeHorizontal);
}
switch (Event.current.type)
{
case EventType.MouseDown:
bool leftClick = Event.current.button == 0 && !Event.current.alt;
// bool middleClick = Event.current.button == 2 || (Event.current.button == 0 && Event.current.alt);
if (leftClick) // left button
{
if (EditorGUIUtility.hotControl == 0 && _timelineHeaderResizerRect.Contains(Event.current.mousePosition))
{
EditorGUIUtility.hotControl = timelineHeaderResizerId;
Event.current.Use();
}
else if (_rect.Contains(Event.current.mousePosition))
{
DeselectAll();
Event.current.Use();
}
}
// else if( middleClick ) // middle button
// {
// StartDragSelecting( Event.current.mousePosition );
// Event.current.Use();
// }
break;
case EventType.MouseDrag:
if (EditorGUIUtility.hotControl == timelineHeaderResizerId)
{
_timelineHeaderWidth = (int)Mathf.Max(MINIMUM_HEADER_WIDTH, _timelineHeaderWidth + Event.current.delta.x);
RebuildLayout(_rect);
EditorWindow.GetWindow <FSequenceEditorWindow>().Repaint();
Event.current.Use();
}
if (_isDragSelecting)
{
Repaint();
}
break;
case EventType.MouseUp:
if (EditorGUIUtility.hotControl == timelineHeaderResizerId)
{
EditorGUIUtility.hotControl = 0;
Event.current.Use();
}
// if( _isDragSelecting )
// {
// StopDragSelecting( Event.current.mousePosition );
// Event.current.Use();
// }
break;
case EventType.Repaint:
Rect dragArea = _timelineHeaderResizerRect;
dragArea.xMax -= 10;
dragArea.xMin = dragArea.xMax - 16;
GUIStyle dragStyle = FUtility.GetFluxSkin().GetStyle("HorizontalPanelSeparatorHandle");
dragStyle.Draw(dragArea, GUIContent.none, 0);
// GUI.DrawTexture( dragArea, EditorGUIUtility.whiteTexture );
Handles.color = FGUI.GetLineColor(); // new Color(0.8f, 0.8f, 0.8f, 0.2f);
Handles.DrawLine(new Vector3(_viewRect.xMin - 16, _sequenceRect.yMax, 0), new Vector3(_viewRect.xMax - RIGHT_BORDER, _sequenceRect.yMax, 0));
// Handles.color = Color.black;
break;
case EventType.ScrollWheel:
if (_viewRect.Contains(Event.current.mousePosition))
{
_scrollPos.y += Event.current.delta.y * SCROLL_WHEEL_SPEED;
Event.current.Use();
}
break;
}
#if FLUX_TRIAL
GUIStyle watermarkLabel = new GUIStyle(GUI.skin.label);
watermarkLabel.fontSize = 24;
GUIContent watermark = new GUIContent("..::FLUX TRIAL::..");
Vector2 watermarkSize = watermarkLabel.CalcSize(watermark);
Rect watermarkRect = new Rect(_rect.width * 0.5f - watermarkSize.x * 0.5f, _rect.height * 0.5f - watermarkSize.y * 0.5f, watermarkSize.x, watermarkSize.y);
GUI.color = new Color(1f, 1f, 1f, 0.4f);
GUI.Label(watermarkRect, watermark, watermarkLabel);
#endif
}
protected override void RenderEvent(FrameRange viewRange, FrameRange validKeyframeRange)
{
if (_animEvtSO == null)
{
_animEvtSO = new SerializedObject(AnimEvt);
_blendLength = _animEvtSO.FindProperty("_blendLength");
_startOffset = _animEvtSO.FindProperty("_startOffset");
}
UpdateEventFromController();
_animEvtSO.Update();
FAnimationTrackEditor animTrackEditor = (FAnimationTrackEditor)TrackEditor;
Rect transitionOffsetRect = _eventRect;
int startOffsetHandleId = EditorGUIUtility.GetControlID(FocusType.Passive);
int transitionHandleId = EditorGUIUtility.GetControlID(FocusType.Passive);
bool isBlending = AnimEvt.IsBlending();
bool isAnimEditable = Flux.FUtility.IsAnimationEditable(AnimEvt._animationClip);
if (isBlending)
{
transitionOffsetRect.xMin = Rect.xMin + SequenceEditor.GetXForFrame(AnimEvt.Start + AnimEvt._blendLength) - 3;
transitionOffsetRect.width = 6;
transitionOffsetRect.yMin = transitionOffsetRect.yMax - 8;
}
switch (Event.current.type)
{
case EventType.MouseDown:
if (EditorGUIUtility.hotControl == 0 && Event.current.alt && !isAnimEditable)
{
if (isBlending && transitionOffsetRect.Contains(Event.current.mousePosition))
{
EditorGUIUtility.hotControl = transitionHandleId;
AnimatorWindowProxy.OpenAnimatorWindowWithAnimatorController((AnimatorController)AnimTrack.AnimatorController);
if (Selection.activeObject != _transitionToState)
{
Selection.activeObject = _transitionToState;
}
Event.current.Use();
}
else if (_eventRect.Contains(Event.current.mousePosition))
{
_mouseDown = SequenceEditor.GetFrameForX(Event.current.mousePosition.x) - AnimEvt.Start;
EditorGUIUtility.hotControl = startOffsetHandleId;
Event.current.Use();
}
}
break;
case EventType.Ignore:
case EventType.MouseUp:
if (EditorGUIUtility.hotControl == transitionHandleId ||
EditorGUIUtility.hotControl == startOffsetHandleId)
{
EditorGUIUtility.hotControl = 0;
Event.current.Use();
}
break;
case EventType.MouseDrag:
if (EditorGUIUtility.hotControl == transitionHandleId)
{
int mouseDragPos = Mathf.Clamp(SequenceEditor.GetFrameForX(Event.current.mousePosition.x - Rect.x) - AnimEvt.Start, 0, AnimEvt.Length);
if (_blendLength.intValue != mouseDragPos)
{
_blendLength.intValue = mouseDragPos;
FPlayAnimationEvent prevAnimEvt = (FPlayAnimationEvent)animTrackEditor.Track.GetEvent(AnimEvt.GetId() - 1);
if (_transitionDuration != null)
{
_transitionDuration.floatValue = (_blendLength.intValue / prevAnimEvt._animationClip.frameRate) / prevAnimEvt._animationClip.length;
}
Undo.RecordObject(this, "Animation Blending");
}
Event.current.Use();
}
else if (EditorGUIUtility.hotControl == startOffsetHandleId)
{
int mouseDragPos = Mathf.Clamp(SequenceEditor.GetFrameForX(Event.current.mousePosition.x - Rect.x) - AnimEvt.Start, 0, AnimEvt.Length);
int delta = _mouseDown - mouseDragPos;
_mouseDown = mouseDragPos;
_startOffset.intValue = Mathf.Clamp(_startOffset.intValue + delta, 0, AnimEvt._animationClip.isLooping ? AnimEvt.Length : Mathf.RoundToInt(AnimEvt._animationClip.length * AnimEvt._animationClip.frameRate) - AnimEvt.Length);
if (_transitionOffset != null)
{
_transitionOffset.floatValue = (_startOffset.intValue / AnimEvt._animationClip.frameRate) / AnimEvt._animationClip.length;
}
Undo.RecordObject(this, "Animation Offset");
Event.current.Use();
}
break;
}
_animEvtSO.ApplyModifiedProperties();
if (_transitionSO != null)
{
_transitionSO.ApplyModifiedProperties();
}
switch (Event.current.type)
{
case EventType.DragUpdated:
if (_eventRect.Contains(Event.current.mousePosition))
{
int numAnimationsDragged = FAnimationEventInspector.NumAnimationsDragAndDrop(Evt.Sequence.FrameRate);
DragAndDrop.visualMode = numAnimationsDragged > 0 ? DragAndDropVisualMode.Link : DragAndDropVisualMode.Rejected;
Event.current.Use();
}
break;
case EventType.DragPerform:
if (_eventRect.Contains(Event.current.mousePosition))
{
AnimationClip animationClipDragged = FAnimationEventInspector.GetAnimationClipDragAndDrop(Evt.Sequence.FrameRate);
if (animationClipDragged)
{
int animFrameLength = Mathf.RoundToInt(animationClipDragged.length * animationClipDragged.frameRate);
FAnimationEventInspector.SetAnimationClip(AnimEvt, animationClipDragged);
FrameRange maxRange = AnimEvt.GetMaxFrameRange();
SequenceEditor.MoveEvent(AnimEvt, new FrameRange(AnimEvt.Start, Mathf.Min(AnimEvt.Start + animFrameLength, maxRange.End)));
DragAndDrop.AcceptDrag();
Event.current.Use();
}
else
{
Event.current.Use();
}
}
break;
}
// FrameRange currentRange = Evt.FrameRange;
base.RenderEvent(viewRange, validKeyframeRange);
// if( isAnimEditable && currentRange.Length != Evt.FrameRange.Length )
// {
// FAnimationEventInspector.ScaleAnimationClip( AnimEvt._animationClip, Evt.FrameRange );
// }
if (Event.current.type == EventType.Repaint)
{
if (isBlending && !isAnimEditable && viewRange.Contains(AnimEvt.Start + AnimEvt._blendLength))
{
GUISkin skin = FUtility.GetFluxSkin();
GUIStyle transitionOffsetStyle = skin.GetStyle("BlendOffset");
Texture2D t = FUtility.GetFluxTexture("EventBlend.png");
Rect r = new Rect(_eventRect.xMin, _eventRect.yMin + 1, transitionOffsetRect.center.x - _eventRect.xMin, _eventRect.height - 2);
Color guiColor = GUI.color;
Color c = new Color(1f, 1f, 1f, 0.3f);
c.a *= guiColor.a;
GUI.color = c;
GUI.DrawTexture(r, t);
if (Event.current.alt)
{
GUI.color = Color.white;
}
transitionOffsetStyle.Draw(transitionOffsetRect, false, false, false, false);
GUI.color = guiColor;
// Debug.Log ( transitionOffsetRect );
}
// GUI.color = Color.red;
if (EditorGUIUtility.hotControl == transitionHandleId)
{
Rect transitionOffsetTextRect = transitionOffsetRect;
transitionOffsetTextRect.y -= 16;
transitionOffsetTextRect.height = 20;
transitionOffsetTextRect.width += 50;
GUI.Label(transitionOffsetTextRect, AnimEvt._blendLength.ToString(), EditorStyles.label);
}
if (EditorGUIUtility.hotControl == startOffsetHandleId)
{
Rect startOffsetTextRect = _eventRect;
GUI.Label(startOffsetTextRect, AnimEvt._startOffset.ToString(), EditorStyles.label);
}
}
}
protected virtual void RenderEvent(FrameRange viewRange, FrameRange validKeyframeRange)
{
int leftHandleId = EditorGUIUtility.GetControlID(FocusType.Passive);
int evtHandleId = EditorGUIUtility.GetControlID(FocusType.Passive);
int rightHandleId = EditorGUIUtility.GetControlID(FocusType.Passive);
bool leftHandleVisible = viewRange.Contains(_evt.Start);
bool rightHandleVisible = viewRange.Contains(_evt.End);
Rect leftHandleRect = _eventRect; leftHandleRect.width = 4;
Rect rightHandleRect = _eventRect; rightHandleRect.xMin = rightHandleRect.xMax - 4;
if (leftHandleVisible && IsSelected())
{
EditorGUIUtility.AddCursorRect(leftHandleRect, MouseCursor.ResizeHorizontal, leftHandleId);
}
if (rightHandleVisible && IsSelected())
{
EditorGUIUtility.AddCursorRect(rightHandleRect, MouseCursor.ResizeHorizontal, rightHandleId);
}
switch (Event.current.type)
{
case EventType.Repaint:
if (!viewRange.Overlaps(_evt.FrameRange))
{
break;
}
GUISkin skin = FUtility.GetFluxSkin();
GUIStyle eventStyle = skin.GetStyle("Event");
GUI.color = GetColor();
eventStyle.Draw(_eventRect, _isSelected, _isSelected, false, false);
GUI.color = Color.white;
break;
case EventType.MouseDown:
if (EditorGUIUtility.hotControl == 0 && IsSelected() && !Event.current.control && !Event.current.shift)
{
Vector2 mousePos = Event.current.mousePosition;
if (rightHandleVisible && rightHandleRect.Contains(mousePos))
{
EditorGUIUtility.hotControl = rightHandleId;
// keyframeOnSelect = evt.Start;
Event.current.Use();
}
else if (leftHandleVisible && leftHandleRect.Contains(mousePos))
{
EditorGUIUtility.hotControl = leftHandleId;
// keyframeOnSelect = evt.End;
Event.current.Use();
}
else if (_eventRect.Contains(mousePos))
{
EditorGUIUtility.hotControl = evtHandleId;
_mouseOffsetFrames = SequenceEditor.GetFrameForX(mousePos.x) - _evt.Start;
if (IsSelected())
{
if (Event.current.control)
{
SequenceEditor.Deselect(this);
}
}
else
{
if (Event.current.shift)
{
SequenceEditor.Select(this);
}
else if (!Event.current.control)
{
SequenceEditor.SelectExclusive(this);
}
}
Event.current.Use();
}
}
break;
case EventType.MouseUp:
if (EditorGUIUtility.hotControl != 0)
{
if (EditorGUIUtility.hotControl == evtHandleId ||
EditorGUIUtility.hotControl == leftHandleId ||
EditorGUIUtility.hotControl == rightHandleId)
{
EditorGUIUtility.hotControl = 0;
Event.current.Use();
SequenceEditor.Repaint();
}
}
break;
case EventType.MouseDrag:
if (EditorGUIUtility.hotControl != 0)
{
if (EditorGUIUtility.hotControl == evtHandleId)
{
int t = SequenceEditor.GetFrameForX(Event.current.mousePosition.x) - _mouseOffsetFrames;
int delta = t - _evt.Start;
SequenceEditor.MoveEvents(delta);
Event.current.Use();
}
else if (EditorGUIUtility.hotControl == leftHandleId || EditorGUIUtility.hotControl == rightHandleId)
{
int leftLimit = 0;
int rightLimit = 0;
bool draggingStart = EditorGUIUtility.hotControl == leftHandleId;
if (draggingStart)
{
leftLimit = validKeyframeRange.Start;
rightLimit = _evt.End - 1;
}
else
{
leftLimit = _evt.Start + 1;
rightLimit = validKeyframeRange.End;
}
int t = SequenceEditor.GetFrameForX(Event.current.mousePosition.x);
t = Mathf.Clamp(t, leftLimit, rightLimit);
int delta = t - (draggingStart ? _evt.Start : _evt.End);
if (draggingStart)
{
int newLength = _evt.Length - delta;
if (newLength < _evt.GetMinLength())
{
delta += newLength - _evt.GetMinLength();
}
if (newLength > _evt.GetMaxLength())
{
delta += newLength - _evt.GetMaxLength();
}
}
else
{
int newLength = _evt.Length + delta;
if (newLength < _evt.GetMinLength())
{
delta -= newLength - _evt.GetMinLength();
}
if (newLength > _evt.GetMaxLength())
{
delta -= newLength - _evt.GetMaxLength();
}
}
if (delta != 0)
{
if (draggingStart)
{
SequenceEditor.ResizeEventsLeft(delta);
}
else
{
SequenceEditor.ResizeEventsRight(delta);
}
}
Event.current.Use();
}
}
break;
}
}
