Example #1
0
        public void ResizeEventsLeft(int delta)
        {
            int howMuchCanResize = int.MaxValue;

            // making them bigger?
            if (delta < 0)
            {
                for (int i = 0; i != _selectedEvents.Count; ++i)
                {
                    int evtId = _selectedEvents[i].GetRuntimeObject().GetId();
                    int howMuchCanEvtResize = _selectedEvents[i]._evt.Start;
                    if (evtId > 0)
                    {
                        howMuchCanEvtResize -= _selectedEvents[i]._evt.GetTrack().GetEvent(evtId - 1).End;
                    }

                    if (howMuchCanResize > howMuchCanEvtResize)
                    {
                        howMuchCanResize = howMuchCanEvtResize;
                    }
                }

                delta = Mathf.Clamp(delta, -howMuchCanResize, 0);
            }
            else             // making them smaller
            {
                for (int i = 0; i != _selectedEvents.Count; ++i)
                {
                    int howMuchCanEvtResize = _selectedEvents[i]._evt.Length - _selectedEvents[i]._evt.GetMinLength();
                    if (howMuchCanResize > howMuchCanEvtResize)
                    {
                        howMuchCanResize = howMuchCanEvtResize;
                    }
                }

                delta = Mathf.Clamp(delta, 0, howMuchCanResize);
            }

            for (int i = 0; i != _selectedEvents.Count; ++i)
            {
                FrameRange evtRange = _selectedEvents[i]._evt.FrameRange;
                evtRange.Start += delta;
                FUtility.Resize(_selectedEvents[i]._evt, evtRange);
            }
        }
Example #2
0
        public override void OnInspectorGUI()
        {
            //		EditorGUILayout.PropertyField( _script );

            if (_allEventsSameType)
            {
                serializedObject.Update();
                EditorGUILayout.PropertyField(_triggerOnSkip);
            }
            else
            {
                bool triggerOnSkipMatch = true;

                for (int i = 0; i != targets.Length; ++i)
                {
                    if (((FEvent)targets[i]).TriggerOnSkip != _evt.TriggerOnSkip)
                    {
                        triggerOnSkipMatch = false;
                        break;
                    }
                }

                EditorGUI.BeginChangeCheck();
                bool triggerOnSkip = EditorGUILayout.Toggle("Trigger On Skip", _evt.TriggerOnSkip, triggerOnSkipMatch ? EditorStyles.toggle : "ToggleMixed");
                if (EditorGUI.EndChangeCheck())
                {
                    Undo.RecordObjects(targets, " Inspector");
                    for (int i = 0; i != targets.Length; ++i)
                    {
                        FEvent evt = (FEvent)targets[i];
                        evt.TriggerOnSkip = triggerOnSkip;
                    }
                }
            }

            //        EditorGUILayout.IntField( "Instance ID", _evt.GetInstanceID() );

            float startFrame = _evt.Start;
            float endFrame   = _evt.End;

            FrameRange validRange = _evt.GetTrack().GetValidRange(_evt);

            EditorGUI.BeginChangeCheck();

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel("Range");
            GUILayout.Label("S:", EditorStyles.label);
            GUI.SetNextControlName(FRAMERANGE_START_FIELD_ID);
            startFrame = EditorGUILayout.IntField(_evt.Start);
            GUILayout.Label("E:", EditorStyles.label);
            endFrame = EditorGUILayout.IntField(_evt.End);
            EditorGUILayout.EndHorizontal();

            if (EditorGUI.EndChangeCheck())
            {
                bool changedStart = GUI.GetNameOfFocusedControl() == FRAMERANGE_START_FIELD_ID;

                for (int i = 0; i != targets.Length; ++i)
                {
                    FEvent evt = (FEvent)targets[i];

                    FrameRange newFrameRange = evt.FrameRange;
                    if (changedStart)
                    {
                        if (startFrame <= newFrameRange.End)
                        {
                            newFrameRange.Start = (int)startFrame;
                        }
                    }
                    else if (endFrame >= newFrameRange.Start)
                    {
                        newFrameRange.End = (int)endFrame;
                    }

                    if (newFrameRange.Length >= evt.GetMinLength() && newFrameRange.Length <= evt.GetMaxLength())
                    {
                        FUtility.Resize(evt, newFrameRange);
                    }
                }
            }

            if (targets.Length == 1)
            {
                EditorGUI.BeginChangeCheck();
                EditorGUILayout.BeginHorizontal();
                GUILayout.Space(EditorGUIUtility.labelWidth);
                float sliderStartFrame = startFrame;
                float sliderEndFrame   = endFrame;
                EditorGUILayout.MinMaxSlider(ref sliderStartFrame, ref sliderEndFrame, validRange.Start, validRange.End);
                EditorGUILayout.EndHorizontal();
                if (EditorGUI.EndChangeCheck())
                {
                    FrameRange newFrameRange = new FrameRange((int)sliderStartFrame, (int)sliderEndFrame);
                    if (newFrameRange.Length < _evt.GetMinLength())
                    {
                        if (sliderStartFrame != startFrame)                          // changed start
                        {
                            newFrameRange.Start = newFrameRange.End - _evt.GetMinLength();
                        }
                        else
                        {
                            newFrameRange.Length = _evt.GetMinLength();
                        }
                    }

                    FUtility.Resize(_evt, newFrameRange);
                }
            }


            if (_allEventsSameType)
            {
                serializedObject.ApplyModifiedProperties();
                base.OnInspectorGUI();
            }
        }
        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 = _animEvt.IsAnimationEditable();

            if (isBlending)
            {
                transitionOffsetRect.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;

                        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.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) - _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) - _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)
                    {
//						animTrackEditor.ClearPreview();

                        int animFrameLength = Mathf.RoundToInt(animationClipDragged.length * animationClipDragged.frameRate);

                        FAnimationEventInspector.SetAnimationClip(_animEvt, animationClipDragged);
                        FUtility.Resize(_animEvt, new FrameRange(_animEvt.Start, _animEvt.Start + animFrameLength));

                        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);

                    GUI.color = new Color(1f, 1f, 1f, 0.3f);

                    GUI.DrawTexture(r, t);

                    if (Event.current.alt)
                    {
                        GUI.color = Color.white;
                    }

                    transitionOffsetStyle.Draw(transitionOffsetRect, false, false, false, false);
                }

//				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);
                }
            }
        }