コード例 #1
0
        /// <summary>
        /// If the `property` is a "Start Time" field, this method draws it as well as the "End Time" below it and
        /// returns true.
        /// </summary>
        public static bool TryDoStartTimeField(ref Rect area, SerializedProperty rootProperty,
                                               SerializedProperty property, GUIContent label)
        {
            if (!property.propertyPath.EndsWith("." + NormalizedStartTimeFieldName))
            {
                return(false);
            }

            // Start Time.
            label.text = AnimancerGUI.GetNarrowText("Start Time");
            AnimationTimeAttribute.nextDefaultValue = AnimancerEvent.Sequence.GetDefaultNormalizedStartTime(Context.Transition.Speed);
            EditorGUI.PropertyField(area, property, label, false);

            AnimancerGUI.NextVerticalArea(ref area);

            // End Time.
            var events = rootProperty.FindPropertyRelative("_Events");

            using (var context = SerializableEventSequenceDrawer.Context.Get(events))
            {
                var areaCopy = area;
                var index    = Mathf.Max(0, context.Times.Count - 1);
                SerializableEventSequenceDrawer.DoTimeGUI(ref areaCopy, context, index, true);
            }

            return(true);
        }
コード例 #2
0
        /************************************************************************************************************************/

        private static void RoundEventTime(SerializableEventSequenceDrawer.Context context)
        {
            var index = context.SelectedEvent;
            var time  = context.Times.GetElement(index);
            var value = time.floatValue;

            if (TryRoundValue(ref value))
            {
                time.floatValue = value;
                SerializableEventSequenceDrawer.SyncEventTimeChange(context, index, value);
            }
        }
コード例 #3
0
        /************************************************************************************************************************/

        private void NudgeEventTime(SerializableEventSequenceDrawer.Context context, float offsetPixels)
        {
            var index = context.SelectedEvent;
            var time  = context.Times.GetElement(index);

            var value = time.floatValue;

            value = NormalizedToSeconds(value);
            value = SecondsToPixels(value);

            value += offsetPixels;

            value           = PixelsToSeconds(value);
            value           = SecondsToNormalized(value);
            time.floatValue = value;

            SerializableEventSequenceDrawer.SyncEventTimeChange(context, index, value);
        }
コード例 #4
0
        /************************************************************************************************************************/

        private void ShowContextMenu(Event currentEvent, SerializableEventSequenceDrawer.Context context)
        {
            context = context.Copy();
            var time             = SecondsToNormalized(PixelsToSeconds(currentEvent.mousePosition.x));
            var hasSelectedEvent = context.SelectedEvent >= 0;

            var menu = new GenericMenu();

            AddContextFunction(menu, context, "Add Event (Double Click)", true,
                               () => SerializableEventSequenceDrawer.AddEvent(context, time));

            AddContextFunction(menu, context, "Remove Event (Delete)", hasSelectedEvent,
                               () => SerializableEventSequenceDrawer.RemoveEvent(context, context.SelectedEvent));

            const string NudgePrefix = "Nudge Event Time/";

            AddContextFunction(menu, context, NudgePrefix + "Left 1 Pixel (Left Arrow)", hasSelectedEvent,
                               () => NudgeEventTime(context, -1));
            AddContextFunction(menu, context, NudgePrefix + "Left 10 Pixels (Shift + Left Arrow)", hasSelectedEvent,
                               () => NudgeEventTime(context, -10));
            AddContextFunction(menu, context, NudgePrefix + "Right 1 Pixel (Right Arrow)", hasSelectedEvent,
                               () => NudgeEventTime(context, 1));
            AddContextFunction(menu, context, NudgePrefix + "Right 10 Pixels (Shift + Right Arrow)", hasSelectedEvent,
                               () => NudgeEventTime(context, 10));

            var canRoundTime = hasSelectedEvent;

            if (canRoundTime)
            {
                time         = context.Times.GetElement(context.SelectedEvent).floatValue;
                canRoundTime = TryRoundValue(ref time);
            }

            AddContextFunction(menu, context, $"Round Event Time to {time}x (Space)", canRoundTime,
                               () => RoundEventTime(context));

            menu.ShowAsContext();
        }
コード例 #5
0
        /// <summary>Draws the details of the <see cref="SerializableEventSequenceDrawer.Context.Callbacks"/>.</summary>
        private void DoEventsGUI(SerializableEventSequenceDrawer.Context context, out float addEventNormalizedTime)
        {
            addEventNormalizedTime = float.NaN;
            var currentEvent = Event.current;

            EventControlIDs.Clear();
            var selectedEventControlID = -1;

            var baseControlID = GUIUtility.GetControlID(EventHash - 1, FocusType.Passive);

            for (int i = 0; i < EventTimes.Count; i++)
            {
                var controlID = GUIUtility.GetControlID(EventHash + i, FocusType.Keyboard);
                EventControlIDs.Add(controlID);
                if (context.SelectedEvent == i)
                {
                    selectedEventControlID = controlID;
                }
            }

            EventControlIDs.Add(baseControlID);

            switch (currentEvent.type)
            {
            case EventType.Repaint:
                RepaintEventsGUI(context);
                break;

            case EventType.MouseDown:
                OnMouseDown(currentEvent, context, ref addEventNormalizedTime);
                break;

            case EventType.MouseUp:
                OnMouseUp(currentEvent, context);
                break;

            case EventType.MouseDrag:
                if (_Duration <= 0)
                {
                    break;
                }

                var hotControl = GUIUtility.hotControl;
                if (hotControl == baseControlID)
                {
                    SetPreviewTime(context, currentEvent);
                    GUIUtility.ExitGUI();
                }
                else
                {
                    for (int i = 0; i < EventTimes.Count; i++)
                    {
                        if (hotControl == EventControlIDs[i])
                        {
                            if (context.Times.Count < 1)
                            {
                                context.Times.Count = 1;
                            }

                            var seconds = PixelsToSeconds(currentEvent.mousePosition.x);

                            if (currentEvent.control)
                            {
                                SnapToFrameRate(context, ref seconds);
                            }

                            var timeProperty   = context.Times.GetElement(i);
                            var normalizedTime = seconds / _Duration;
                            timeProperty.floatValue = normalizedTime;
                            SerializableEventSequenceDrawer.SyncEventTimeChange(context, i, normalizedTime);
                            timeProperty.serializedObject.ApplyModifiedProperties();
                            timeProperty.serializedObject.Update();

                            GUIUtility.hotControl = EventControlIDs[context.SelectedEvent];
                            GUI.changed           = true;

                            SetPreviewTime(context, currentEvent);
                            GUIUtility.ExitGUI();
                        }
                    }
                }
                break;

            case EventType.KeyUp:
                if (GUIUtility.keyboardControl != selectedEventControlID)
                {
                    break;
                }

                var exitGUI = false;

                switch (currentEvent.keyCode)
                {
                case KeyCode.Delete:
                case KeyCode.Backspace:
                    SerializableEventSequenceDrawer.RemoveEvent(context, context.SelectedEvent);
                    exitGUI = true;
                    break;

                case KeyCode.LeftArrow: NudgeEventTime(context, Event.current.shift ? -10 : -1); break;

                case KeyCode.RightArrow: NudgeEventTime(context, Event.current.shift ? 10 : 1); break;

                case KeyCode.Space: RoundEventTime(context); break;

                default: return;        // Don't call Use.
                }

                currentEvent.Use();
                GUI.changed = true;

                if (exitGUI)
                {
                    GUIUtility.ExitGUI();
                }
                break;
            }
        }