Inheritance: UnityEngine.ScriptableObject
コード例 #1
0
 private bool DeleteEvents(ref AnimationEvent[] eventList, bool[] deleteIndices)
 {
     bool flag = false;
     for (int i = eventList.Length - 1; i >= 0; i--)
     {
         if (deleteIndices[i])
         {
             ArrayUtility.RemoveAt<AnimationEvent>(ref eventList, i);
             flag = true;
         }
     }
     if (flag)
     {
         this.m_EventsSelected = new bool[eventList.Length];
         this.m_Event = null;
     }
     return flag;
 }
コード例 #2
0
        private bool DeleteEvents(ref AnimationEvent[] eventList, bool[] deleteIndices)
        {
            bool flag = false;

            for (int i = eventList.Length - 1; i >= 0; i--)
            {
                if (deleteIndices[i])
                {
                    ArrayUtility.RemoveAt <AnimationEvent>(ref eventList, i);
                    flag = true;
                }
            }
            if (flag)
            {
                this.m_EventsSelected = new bool[eventList.Length];
                this.m_Event          = null;
            }
            return(flag);
        }
コード例 #3
0
        static void ResetValues(MenuCommand command)
        {
            AnimationWindowEvent awEvent = command.context as AnimationWindowEvent;
            AnimationWindowEvent[] awEvents = new AnimationWindowEvent[] {awEvent};

            AnimationWindowEventData data = GetData(awEvents);
            if (data.events == null || data.selectedEvents == null || data.selectedEvents.Length == 0)
                return;

            foreach (var evt in data.selectedEvents)
            {
                evt.functionName = "";
                evt.stringParameter = string.Empty;
                evt.floatParameter = 0f;
                evt.intParameter = 0;
                evt.objectReferenceParameter = null;
            }

            SetData(awEvents, data);
        }
コード例 #4
0
        public void EditEvents(GameObject gameObject, AnimationClip clip, bool[] selectedIndices)
        {
            List <AnimationWindowEvent> list = new List <AnimationWindowEvent>();

            for (int i = 0; i < selectedIndices.Length; i++)
            {
                if (selectedIndices[i])
                {
                    list.Add(AnimationWindowEvent.Edit(gameObject, clip, i));
                }
            }
            if (list.Count > 0)
            {
                Selection.objects = list.ToArray();
            }
            else
            {
                this.ClearSelection();
            }
        }
コード例 #5
0
        public void EditEvents(GameObject gameObject, AnimationClip clip, bool[] selectedIndices)
        {
            List <AnimationWindowEvent> awEvents = new List <AnimationWindowEvent>();

            for (int index = 0; index < selectedIndices.Length; ++index)
            {
                if (selectedIndices[index])
                {
                    awEvents.Add(AnimationWindowEvent.Edit(gameObject, clip, index));
                }
            }

            if (awEvents.Count > 0)
            {
                Selection.objects = awEvents.ToArray();
            }
            else
            {
                ClearSelection();
            }
        }
コード例 #6
0
        private static AnimationWindowEventData GetData(AnimationWindowEvent[] awEvents)
        {
            var data = new AnimationWindowEventData();

            if (awEvents.Length == 0)
            {
                return(data);
            }

            AnimationWindowEvent firstAwEvent = awEvents[0];

            data.root     = firstAwEvent.root;
            data.clip     = firstAwEvent.clip;
            data.clipInfo = firstAwEvent.clipInfo;

            if (data.clip != null)
            {
                data.events = AnimationUtility.GetAnimationEvents(data.clip);
            }
            else if (data.clipInfo != null)
            {
                data.events = data.clipInfo.GetEvents();
            }

            if (data.events != null)
            {
                List <AnimationEvent> selectedEvents = new List <AnimationEvent>();
                foreach (var awEvent in awEvents)
                {
                    if (awEvent.eventIndex >= 0 && awEvent.eventIndex < data.events.Length)
                    {
                        selectedEvents.Add(data.events[awEvent.eventIndex]);
                    }
                }

                data.selectedEvents = selectedEvents.ToArray();
            }

            return(data);
        }
コード例 #7
0
 private static AnimationWindowEventInspector.AnimationWindowEventData GetData(AnimationWindowEvent[] awEvents)
 {
     AnimationWindowEventInspector.AnimationWindowEventData animationWindowEventData = default(AnimationWindowEventInspector.AnimationWindowEventData);
     AnimationWindowEventInspector.AnimationWindowEventData result;
     if (awEvents.Length == 0)
     {
         result = animationWindowEventData;
     }
     else
     {
         AnimationWindowEvent animationWindowEvent = awEvents[0];
         animationWindowEventData.root     = animationWindowEvent.root;
         animationWindowEventData.clip     = animationWindowEvent.clip;
         animationWindowEventData.clipInfo = animationWindowEvent.clipInfo;
         if (animationWindowEventData.clip != null)
         {
             animationWindowEventData.events = AnimationUtility.GetAnimationEvents(animationWindowEventData.clip);
         }
         else if (animationWindowEventData.clipInfo != null)
         {
             animationWindowEventData.events = animationWindowEventData.clipInfo.GetEvents();
         }
         if (animationWindowEventData.events != null)
         {
             List <AnimationEvent> list = new List <AnimationEvent>();
             for (int i = 0; i < awEvents.Length; i++)
             {
                 AnimationWindowEvent animationWindowEvent2 = awEvents[i];
                 if (animationWindowEvent2.eventIndex >= 0 && animationWindowEvent2.eventIndex < animationWindowEventData.events.Length)
                 {
                     list.Add(animationWindowEventData.events[animationWindowEvent2.eventIndex]);
                 }
             }
             animationWindowEventData.selectedEvents = list.ToArray();
         }
         result = animationWindowEventData;
     }
     return(result);
 }
コード例 #8
0
        static public AnimationWindowEvent CreateAndEdit(GameObject root, AnimationClip clip, float time)
        {
            AnimationEvent animationEvent = new AnimationEvent();

            animationEvent.time = time;

            // Or add a new one
            AnimationEvent[] events = AnimationUtility.GetAnimationEvents(clip);
            int eventIndex          = InsertAnimationEvent(ref events, clip, animationEvent);

            AnimationWindowEvent animationWindowEvent = CreateInstance <AnimationWindowEvent>();

            animationWindowEvent.hideFlags = HideFlags.HideInHierarchy;
            animationWindowEvent.name      = "Animation Event";

            animationWindowEvent.root       = root;
            animationWindowEvent.clip       = clip;
            animationWindowEvent.clipInfo   = null;
            animationWindowEvent.eventIndex = eventIndex;

            return(animationWindowEvent);
        }
コード例 #9
0
 private static void SetData(AnimationWindowEvent[] awEvents, AnimationWindowEventInspector.AnimationWindowEventData data)
 {
     if (data.events != null)
     {
         if (data.clip != null)
         {
             Undo.RegisterCompleteObjectUndo(data.clip, "Animation Event Change");
             AnimationUtility.SetAnimationEvents(data.clip, data.events);
         }
         else if (data.clipInfo != null)
         {
             for (int i = 0; i < awEvents.Length; i++)
             {
                 AnimationWindowEvent animationWindowEvent = awEvents[i];
                 if (animationWindowEvent.eventIndex >= 0 && animationWindowEvent.eventIndex < data.events.Length)
                 {
                     data.clipInfo.SetEvent(animationWindowEvent.eventIndex, data.events[animationWindowEvent.eventIndex]);
                 }
             }
         }
     }
 }
コード例 #10
0
        private static void ResetValues(MenuCommand command)
        {
            AnimationWindowEvent animationWindowEvent = command.context as AnimationWindowEvent;

            AnimationWindowEvent[] awEvents = new AnimationWindowEvent[]
            {
                animationWindowEvent
            };
            AnimationWindowEventInspector.AnimationWindowEventData data = AnimationWindowEventInspector.GetData(awEvents);
            if (data.events != null && data.selectedEvents != null && data.selectedEvents.Length != 0)
            {
                AnimationEvent[] selectedEvents = data.selectedEvents;
                for (int i = 0; i < selectedEvents.Length; i++)
                {
                    AnimationEvent animationEvent = selectedEvents[i];
                    animationEvent.functionName             = "";
                    animationEvent.stringParameter          = string.Empty;
                    animationEvent.floatParameter           = 0f;
                    animationEvent.intParameter             = 0;
                    animationEvent.objectReferenceParameter = null;
                }
                AnimationWindowEventInspector.SetData(awEvents, data);
            }
        }
コード例 #11
0
 private void Select(AnimationWindowEvent evt)
 {
     this.m_EventsSelected = new bool[AnimationUtility.GetAnimationEvents(evt.clip).Length];
     this.m_EventsSelected[evt.eventIndex] = true;
     Selection.activeObject = evt;
 }
コード例 #12
0
 private void Select(AnimationWindowEvent evt)
 {
     this.m_EventsSelected = new bool[AnimationUtility.GetAnimationEvents(evt.clip).Length];
     this.m_EventsSelected[evt.eventIndex] = true;
     Selection.activeObject = evt;
 }
コード例 #13
0
        public void AddEvent(float time, GameObject gameObject, AnimationClip animationClip)
        {
            AnimationWindowEvent awEvent = AnimationWindowEvent.CreateAndEdit(gameObject, animationClip, time);

            Selection.activeObject = awEvent;
        }
コード例 #14
0
        public void EditEvent(GameObject gameObject, AnimationClip clip, int index)
        {
            AnimationWindowEvent awEvent = AnimationWindowEvent.Edit(gameObject, clip, index);

            Selection.activeObject = awEvent;
        }
コード例 #15
0
        public void EventLineGUI(Rect rect, AnimationWindowState state)
        {
            if (!(state.selectedItem == null))
            {
                AnimationClip animationClip  = state.selectedItem.animationClip;
                GameObject    rootGameObject = state.selectedItem.rootGameObject;
                GUI.BeginGroup(rect);
                Color color = GUI.color;
                Rect  rect2 = new Rect(0f, 0f, rect.width, rect.height);
                float time  = Mathf.Max((float)Mathf.RoundToInt(state.PixelToTime(Event.current.mousePosition.x, rect) * state.frameRate) / state.frameRate, 0f);
                if (animationClip != null)
                {
                    AnimationEvent[] animationEvents = AnimationUtility.GetAnimationEvents(animationClip);
                    Texture          image           = EditorGUIUtility.IconContent("Animation.EventMarker").image;
                    Rect[]           array           = new Rect[animationEvents.Length];
                    Rect[]           array2          = new Rect[animationEvents.Length];
                    int num  = 1;
                    int num2 = 0;
                    for (int i = 0; i < animationEvents.Length; i++)
                    {
                        AnimationEvent animationEvent = animationEvents[i];
                        if (num2 == 0)
                        {
                            num = 1;
                            while (i + num < animationEvents.Length && animationEvents[i + num].time == animationEvent.time)
                            {
                                num++;
                            }
                            num2 = num;
                        }
                        num2--;
                        float num3 = Mathf.Floor(state.FrameToPixel(animationEvent.time * animationClip.frameRate, rect));
                        int   num4 = 0;
                        if (num > 1)
                        {
                            float num5 = (float)Mathf.Min((num - 1) * (image.width - 1), (int)(state.FrameDeltaToPixel(rect) - (float)(image.width * 2)));
                            num4 = Mathf.FloorToInt(Mathf.Max(0f, num5 - (float)((image.width - 1) * num2)));
                        }
                        Rect rect3 = new Rect(num3 + (float)num4 - (float)(image.width / 2), (rect.height - 10f) * (float)(num2 - num + 1) / (float)Mathf.Max(1, num - 1), (float)image.width, (float)image.height);
                        array[i]  = rect3;
                        array2[i] = rect3;
                    }
                    if (this.m_DirtyTooltip)
                    {
                        if (this.m_HoverEvent >= 0 && this.m_HoverEvent < array.Length)
                        {
                            this.m_InstantTooltipText  = AnimationWindowEventInspector.FormatEvent(rootGameObject, animationEvents[this.m_HoverEvent]);
                            this.m_InstantTooltipPoint = new Vector2(array[this.m_HoverEvent].xMin + (float)((int)(array[this.m_HoverEvent].width / 2f)) + rect.x - 30f, rect.yMax);
                        }
                        this.m_DirtyTooltip = false;
                    }
                    bool[] array3 = new bool[animationEvents.Length];
                    UnityEngine.Object[] objects = Selection.objects;
                    UnityEngine.Object[] array4  = objects;
                    for (int j = 0; j < array4.Length; j++)
                    {
                        UnityEngine.Object   @object = array4[j];
                        AnimationWindowEvent animationWindowEvent = @object as AnimationWindowEvent;
                        if (animationWindowEvent != null)
                        {
                            if (animationWindowEvent.eventIndex >= 0 && animationWindowEvent.eventIndex < array3.Length)
                            {
                                array3[animationWindowEvent.eventIndex] = true;
                            }
                        }
                    }
                    Vector2        zero = Vector2.zero;
                    int            num6;
                    float          num7;
                    float          num8;
                    HighLevelEvent highLevelEvent = EditorGUIExt.MultiSelection(rect, array2, new GUIContent(image), array, ref array3, null, out num6, out zero, out num7, out num8, GUIStyle.none);
                    if (highLevelEvent != HighLevelEvent.None)
                    {
                        switch (highLevelEvent)
                        {
                        case HighLevelEvent.DoubleClick:
                            if (num6 != -1)
                            {
                                this.EditEvents(rootGameObject, animationClip, array3);
                            }
                            else
                            {
                                this.EventLineContextMenuAdd(new AnimationEventTimeLine.EventLineContextMenuObject(rootGameObject, animationClip, time, -1, array3));
                            }
                            break;

                        case HighLevelEvent.ContextClick:
                        {
                            GenericMenu genericMenu = new GenericMenu();
                            AnimationEventTimeLine.EventLineContextMenuObject userData = new AnimationEventTimeLine.EventLineContextMenuObject(rootGameObject, animationClip, animationEvents[num6].time, num6, array3);
                            int num9 = array3.Count((bool selected) => selected);
                            genericMenu.AddItem(new GUIContent("Add Animation Event"), false, new GenericMenu.MenuFunction2(this.EventLineContextMenuAdd), userData);
                            genericMenu.AddItem(new GUIContent((num9 <= 1) ? "Delete Animation Event" : "Delete Animation Events"), false, new GenericMenu.MenuFunction2(this.EventLineContextMenuDelete), userData);
                            genericMenu.ShowAsContext();
                            this.m_InstantTooltipText = null;
                            this.m_DirtyTooltip       = true;
                            state.Repaint();
                            break;
                        }

                        case HighLevelEvent.BeginDrag:
                            this.m_EventsAtMouseDown = animationEvents;
                            this.m_EventTimes        = new float[animationEvents.Length];
                            for (int k = 0; k < animationEvents.Length; k++)
                            {
                                this.m_EventTimes[k] = animationEvents[k].time;
                            }
                            break;

                        case HighLevelEvent.Drag:
                        {
                            for (int l = animationEvents.Length - 1; l >= 0; l--)
                            {
                                if (array3[l])
                                {
                                    AnimationEvent animationEvent2 = this.m_EventsAtMouseDown[l];
                                    animationEvent2.time = this.m_EventTimes[l] + zero.x * state.PixelDeltaToTime(rect);
                                    animationEvent2.time = Mathf.Max(0f, animationEvent2.time);
                                    animationEvent2.time = (float)Mathf.RoundToInt(animationEvent2.time * animationClip.frameRate) / animationClip.frameRate;
                                }
                            }
                            int[] array5 = new int[array3.Length];
                            for (int m = 0; m < array5.Length; m++)
                            {
                                array5[m] = m;
                            }
                            Array.Sort(this.m_EventsAtMouseDown, array5, new AnimationEventTimeLine.EventComparer());
                            bool[]  array6 = (bool[])array3.Clone();
                            float[] array7 = (float[])this.m_EventTimes.Clone();
                            for (int n = 0; n < array5.Length; n++)
                            {
                                array3[n]            = array6[array5[n]];
                                this.m_EventTimes[n] = array7[array5[n]];
                            }
                            this.EditEvents(rootGameObject, animationClip, array3);
                            Undo.RegisterCompleteObjectUndo(animationClip, "Move Event");
                            AnimationUtility.SetAnimationEvents(animationClip, this.m_EventsAtMouseDown);
                            this.m_DirtyTooltip = true;
                            break;
                        }

                        case HighLevelEvent.Delete:
                            this.DeleteEvents(animationClip, array3);
                            break;

                        case HighLevelEvent.SelectionChanged:
                            state.ClearKeySelections();
                            this.EditEvents(rootGameObject, animationClip, array3);
                            break;
                        }
                    }
                    this.CheckRectsOnMouseMove(rect, animationEvents, array);
                    if (Event.current.type == EventType.ContextClick && rect2.Contains(Event.current.mousePosition))
                    {
                        Event.current.Use();
                        GenericMenu genericMenu2 = new GenericMenu();
                        AnimationEventTimeLine.EventLineContextMenuObject userData2 = new AnimationEventTimeLine.EventLineContextMenuObject(rootGameObject, animationClip, time, -1, array3);
                        int num10 = array3.Count((bool selected) => selected);
                        genericMenu2.AddItem(new GUIContent("Add Animation Event"), false, new GenericMenu.MenuFunction2(this.EventLineContextMenuAdd), userData2);
                        if (num10 > 0)
                        {
                            genericMenu2.AddItem(new GUIContent((num10 <= 1) ? "Delete Animation Event" : "Delete Animation Events"), false, new GenericMenu.MenuFunction2(this.EventLineContextMenuDelete), userData2);
                        }
                        genericMenu2.ShowAsContext();
                    }
                }
                GUI.color = color;
                GUI.EndGroup();
            }
        }
コード例 #16
0
        public bool HandleEventManipulation(Rect rect, ref AnimationEvent[] events, AnimationClipInfoProperties clipInfo)
        {
            int     num8;
            float   num9;
            float   num10;
            Texture image = EditorGUIUtility.IconContent("Animation.EventMarker").image;
            bool    flag  = false;

            Rect[] hitPositions = new Rect[events.Length];
            Rect[] positions    = new Rect[events.Length];
            int    num          = 1;
            int    num2         = 0;

            for (int i = 0; i < events.Length; i++)
            {
                AnimationEvent event2 = events[i];
                if (num2 == 0)
                {
                    num = 1;
                    while (((i + num) < events.Length) && (events[i + num].time == event2.time))
                    {
                        num++;
                    }
                    num2 = num;
                }
                num2--;
                float num4 = Mathf.Floor(this.m_Timeline.TimeToPixel(event2.time, rect));
                int   num5 = 0;
                if (num > 1)
                {
                    float num6 = Mathf.Min((int)((num - 1) * (image.width - 1)), (int)(((int)(1f / this.m_Timeline.PixelDeltaToTime(rect))) - (image.width * 2)));
                    num5 = Mathf.FloorToInt(Mathf.Max((float)0f, (float)(num6 - ((image.width - 1) * num2))));
                }
                Rect rect2 = new Rect((num4 + num5) - (image.width / 2), ((rect.height - 10f) * ((num2 - num) + 1)) / ((float)Mathf.Max(1, num - 1)), (float)image.width, (float)image.height);
                hitPositions[i] = rect2;
                positions[i]    = rect2;
            }
            this.m_EventRects = new Rect[hitPositions.Length];
            for (int j = 0; j < hitPositions.Length; j++)
            {
                this.m_EventRects[j] = new Rect(hitPositions[j].x + rect.x, hitPositions[j].y + rect.y, hitPositions[j].width, hitPositions[j].height);
            }
            if (((this.m_EventsSelected == null) || (this.m_EventsSelected.Length != events.Length)) || (this.m_EventsSelected.Length == 0))
            {
                this.m_EventsSelected = new bool[events.Length];
                this.m_Event          = null;
            }
            Vector2 zero = Vector2.zero;

            switch (EditorGUIExt.MultiSelection(rect, positions, new GUIContent(image), hitPositions, ref this.m_EventsSelected, null, out num8, out zero, out num9, out num10, GUIStyle.none))
            {
            case HighLevelEvent.ContextClick:
            {
                GenericMenu menu = new GenericMenu();
                menu.AddItem(new GUIContent("Add Animation Event"), false, new GenericMenu.MenuFunction2(this.EventLineContextMenuAdd), new EventModificationContextMenuObjet(clipInfo, events[num8].time, num8));
                menu.AddItem(new GUIContent("Delete Animation Event"), false, new GenericMenu.MenuFunction2(this.EventLineContextMenuDelete), new EventModificationContextMenuObjet(clipInfo, events[num8].time, num8));
                menu.ShowAsContext();
                this.m_InstantTooltipText = null;
                break;
            }

            case HighLevelEvent.BeginDrag:
                m_EventsAtMouseDown = events;
                m_EventTimes        = new float[events.Length];
                for (int k = 0; k < events.Length; k++)
                {
                    m_EventTimes[k] = events[k].time;
                }
                break;

            case HighLevelEvent.Drag:
            {
                for (int m = events.Length - 1; m >= 0; m--)
                {
                    if (this.m_EventsSelected[m])
                    {
                        AnimationEvent event4 = m_EventsAtMouseDown[m];
                        event4.time = Mathf.Clamp01(m_EventTimes[m] + (zero.x / rect.width));
                    }
                }
                int[] items = new int[this.m_EventsSelected.Length];
                for (int n = 0; n < items.Length; n++)
                {
                    items[n] = n;
                }
                Array.Sort(m_EventsAtMouseDown, items, new AnimationEventTimeLine.EventComparer());
                bool[]  flagArray = (bool[])this.m_EventsSelected.Clone();
                float[] numArray2 = (float[])m_EventTimes.Clone();
                for (int num14 = 0; num14 < items.Length; num14++)
                {
                    this.m_EventsSelected[num14] = flagArray[items[num14]];
                    m_EventTimes[num14]          = numArray2[items[num14]];
                }
                events = m_EventsAtMouseDown;
                flag   = true;
                break;
            }

            case HighLevelEvent.Delete:
                flag = this.DeleteEvents(ref events, this.m_EventsSelected);
                break;

            case HighLevelEvent.SelectionChanged:
                this.m_Event = (num8 < 0) ? null : AnimationWindowEvent.Edit(clipInfo, num8);
                break;
            }
            this.CheckRectsOnMouseMove(rect, events, hitPositions);
            return(flag);
        }
コード例 #17
0
 public void SelectEvent(AnimationEvent[] events, int index, AnimationClipInfoProperties clipInfo)
 {
     this.m_EventsSelected = new bool[events.Length];
     this.m_EventsSelected[index] = true;
     this.m_Event = AnimationWindowEvent.Edit(clipInfo, index);
 }
コード例 #18
0
        public bool HandleEventManipulation(Rect rect, ref AnimationEvent[] events, AnimationClipInfoProperties clipInfo)
        {
            int num8;
            float num9;
            float num10;
            Texture image = EditorGUIUtility.IconContent("Animation.EventMarker").image;
            bool flag = false;
            Rect[] hitPositions = new Rect[events.Length];
            Rect[] positions = new Rect[events.Length];
            int num = 1;
            int num2 = 0;
            for (int i = 0; i < events.Length; i++)
            {
                AnimationEvent event2 = events[i];
                if (num2 == 0)
                {
                    num = 1;
                    while (((i + num) < events.Length) && (events[i + num].time == event2.time))
                    {
                        num++;
                    }
                    num2 = num;
                }
                num2--;
                float num4 = Mathf.Floor(this.m_Timeline.TimeToPixel(event2.time, rect));
                int num5 = 0;
                if (num > 1)
                {
                    float num6 = Mathf.Min((int) ((num - 1) * (image.width - 1)), (int) (((int) (1f / this.m_Timeline.PixelDeltaToTime(rect))) - (image.width * 2)));
                    num5 = Mathf.FloorToInt(Mathf.Max((float) 0f, (float) (num6 - ((image.width - 1) * num2))));
                }
                Rect rect2 = new Rect((num4 + num5) - (image.width / 2), ((rect.height - 10f) * ((num2 - num) + 1)) / ((float) Mathf.Max(1, num - 1)), (float) image.width, (float) image.height);
                hitPositions[i] = rect2;
                positions[i] = rect2;
            }
            this.m_EventRects = new Rect[hitPositions.Length];
            for (int j = 0; j < hitPositions.Length; j++)
            {
                this.m_EventRects[j] = new Rect(hitPositions[j].x + rect.x, hitPositions[j].y + rect.y, hitPositions[j].width, hitPositions[j].height);
            }
            if (((this.m_EventsSelected == null) || (this.m_EventsSelected.Length != events.Length)) || (this.m_EventsSelected.Length == 0))
            {
                this.m_EventsSelected = new bool[events.Length];
                this.m_Event = null;
            }
            Vector2 zero = Vector2.zero;
            switch (EditorGUIExt.MultiSelection(rect, positions, new GUIContent(image), hitPositions, ref this.m_EventsSelected, null, out num8, out zero, out num9, out num10, GUIStyle.none))
            {
                case HighLevelEvent.ContextClick:
                {
                    GenericMenu menu = new GenericMenu();
                    menu.AddItem(new GUIContent("Add Animation Event"), false, new GenericMenu.MenuFunction2(this.EventLineContextMenuAdd), new EventModificationContextMenuObjet(clipInfo, events[num8].time, num8));
                    menu.AddItem(new GUIContent("Delete Animation Event"), false, new GenericMenu.MenuFunction2(this.EventLineContextMenuDelete), new EventModificationContextMenuObjet(clipInfo, events[num8].time, num8));
                    menu.ShowAsContext();
                    this.m_InstantTooltipText = null;
                    break;
                }
                case HighLevelEvent.BeginDrag:
                    m_EventsAtMouseDown = events;
                    m_EventTimes = new float[events.Length];
                    for (int k = 0; k < events.Length; k++)
                    {
                        m_EventTimes[k] = events[k].time;
                    }
                    break;

                case HighLevelEvent.Drag:
                {
                    for (int m = events.Length - 1; m >= 0; m--)
                    {
                        if (this.m_EventsSelected[m])
                        {
                            AnimationEvent event4 = m_EventsAtMouseDown[m];
                            event4.time = Mathf.Clamp01(m_EventTimes[m] + (zero.x / rect.width));
                        }
                    }
                    int[] items = new int[this.m_EventsSelected.Length];
                    for (int n = 0; n < items.Length; n++)
                    {
                        items[n] = n;
                    }
                    Array.Sort(m_EventsAtMouseDown, items, new AnimationEventTimeLine.EventComparer());
                    bool[] flagArray = (bool[]) this.m_EventsSelected.Clone();
                    float[] numArray2 = (float[]) m_EventTimes.Clone();
                    for (int num14 = 0; num14 < items.Length; num14++)
                    {
                        this.m_EventsSelected[num14] = flagArray[items[num14]];
                        m_EventTimes[num14] = numArray2[items[num14]];
                    }
                    events = m_EventsAtMouseDown;
                    flag = true;
                    break;
                }
                case HighLevelEvent.Delete:
                    flag = this.DeleteEvents(ref events, this.m_EventsSelected);
                    break;

                case HighLevelEvent.SelectionChanged:
                    this.m_Event = (num8 < 0) ? null : AnimationWindowEvent.Edit(clipInfo, num8);
                    break;
            }
            this.CheckRectsOnMouseMove(rect, events, hitPositions);
            return flag;
        }
コード例 #19
0
        public bool HandleEventManipulation(Rect rect, ref AnimationEvent[] events, AnimationClipInfoProperties clipInfo)
        {
            Texture image  = EditorGUIUtility.IconContent("Animation.EventMarker").image;
            bool    result = false;

            Rect[] array  = new Rect[events.Length];
            Rect[] array2 = new Rect[events.Length];
            int    num    = 1;
            int    num2   = 0;

            for (int i = 0; i < events.Length; i++)
            {
                AnimationEvent animationEvent = events[i];
                if (num2 == 0)
                {
                    num = 1;
                    while (i + num < events.Length && events[i + num].time == animationEvent.time)
                    {
                        num++;
                    }
                    num2 = num;
                }
                num2--;
                float num3 = Mathf.Floor(this.m_Timeline.TimeToPixel(animationEvent.time, rect));
                int   num4 = 0;
                if (num > 1)
                {
                    float num5 = (float)Mathf.Min((num - 1) * (image.width - 1), (int)(1f / this.m_Timeline.PixelDeltaToTime(rect) - (float)(image.width * 2)));
                    num4 = Mathf.FloorToInt(Mathf.Max(0f, num5 - (float)((image.width - 1) * num2)));
                }
                Rect rect2 = new Rect(num3 + (float)num4 - (float)(image.width / 2), (rect.height - 10f) * (float)(num2 - num + 1) / (float)Mathf.Max(1, num - 1), (float)image.width, (float)image.height);
                array[i]  = rect2;
                array2[i] = rect2;
            }
            this.m_EventRects = new Rect[array.Length];
            for (int j = 0; j < array.Length; j++)
            {
                this.m_EventRects[j] = new Rect(array[j].x + rect.x, array[j].y + rect.y, array[j].width, array[j].height);
            }
            if (this.m_EventsSelected == null || this.m_EventsSelected.Length != events.Length || this.m_EventsSelected.Length == 0)
            {
                this.m_EventsSelected = new bool[events.Length];
                this.m_Event          = null;
            }
            Vector2        zero = Vector2.zero;
            int            num6;
            float          num7;
            float          num8;
            HighLevelEvent highLevelEvent = EditorGUIExt.MultiSelection(rect, array2, new GUIContent(image), array, ref this.m_EventsSelected, null, out num6, out zero, out num7, out num8, GUIStyle.none);

            if (highLevelEvent != HighLevelEvent.None)
            {
                switch (highLevelEvent)
                {
                case HighLevelEvent.ContextClick:
                {
                    GenericMenu genericMenu = new GenericMenu();
                    genericMenu.AddItem(new GUIContent("Add Animation Event"), false, new GenericMenu.MenuFunction2(this.EventLineContextMenuAdd), new EventManipulationHandler.EventModificationContextMenuObjet(clipInfo, events[num6].time, num6));
                    genericMenu.AddItem(new GUIContent("Delete Animation Event"), false, new GenericMenu.MenuFunction2(this.EventLineContextMenuDelete), new EventManipulationHandler.EventModificationContextMenuObjet(clipInfo, events[num6].time, num6));
                    genericMenu.ShowAsContext();
                    this.m_InstantTooltipText = null;
                    break;
                }

                case HighLevelEvent.BeginDrag:
                    EventManipulationHandler.m_EventsAtMouseDown = events;
                    EventManipulationHandler.m_EventTimes        = new float[events.Length];
                    for (int k = 0; k < events.Length; k++)
                    {
                        EventManipulationHandler.m_EventTimes[k] = events[k].time;
                    }
                    break;

                case HighLevelEvent.Drag:
                {
                    for (int l = events.Length - 1; l >= 0; l--)
                    {
                        if (this.m_EventsSelected[l])
                        {
                            AnimationEvent animationEvent2 = EventManipulationHandler.m_EventsAtMouseDown[l];
                            animationEvent2.time = Mathf.Clamp01(EventManipulationHandler.m_EventTimes[l] + zero.x / rect.width);
                        }
                    }
                    int[] array3 = new int[this.m_EventsSelected.Length];
                    for (int m = 0; m < array3.Length; m++)
                    {
                        array3[m] = m;
                    }
                    Array.Sort(EventManipulationHandler.m_EventsAtMouseDown, array3, new AnimationEventTimeLine.EventComparer());
                    bool[]  array4 = (bool[])this.m_EventsSelected.Clone();
                    float[] array5 = (float[])EventManipulationHandler.m_EventTimes.Clone();
                    for (int n = 0; n < array3.Length; n++)
                    {
                        this.m_EventsSelected[n] = array4[array3[n]];
                        EventManipulationHandler.m_EventTimes[n] = array5[array3[n]];
                    }
                    events = EventManipulationHandler.m_EventsAtMouseDown;
                    result = true;
                    break;
                }

                case HighLevelEvent.Delete:
                    result = this.DeleteEvents(ref events, this.m_EventsSelected);
                    break;

                case HighLevelEvent.SelectionChanged:
                    this.m_Event = ((num6 < 0) ? null : AnimationWindowEvent.Edit(clipInfo, num6));
                    break;
                }
            }
            this.CheckRectsOnMouseMove(rect, events, array);
            return(result);
        }
コード例 #20
0
 public void SelectEvent(AnimationEvent[] events, int index, AnimationClipInfoProperties clipInfo)
 {
     this.m_EventsSelected        = new bool[events.Length];
     this.m_EventsSelected[index] = true;
     this.m_Event = AnimationWindowEvent.Edit(clipInfo, index);
 }
コード例 #21
0
        public void EventLineGUI(Rect rect, AnimationWindowState state)
        {
            if (state.selectedItem != null)
            {
                AnimationClip animationClip  = state.selectedItem.animationClip;
                GameObject    rootGameObject = state.selectedItem.rootGameObject;
                GUI.BeginGroup(rect);
                Color color = GUI.color;
                Rect  rect2 = new Rect(0f, 0f, rect.width, rect.height);
                float time  = Mathf.Max((float)(((float)Mathf.RoundToInt(state.PixelToTime(Event.current.mousePosition.x, rect) * state.frameRate)) / state.frameRate), (float)0f);
                if (animationClip != null)
                {
                    int              num8;
                    float            num9;
                    float            num10;
                    AnimationEvent[] animationEvents = AnimationUtility.GetAnimationEvents(animationClip);
                    Texture          image           = EditorGUIUtility.IconContent("Animation.EventMarker").image;
                    Rect[]           hitPositions    = new Rect[animationEvents.Length];
                    Rect[]           positions       = new Rect[animationEvents.Length];
                    int              num2            = 1;
                    int              num3            = 0;
                    for (int i = 0; i < animationEvents.Length; i++)
                    {
                        AnimationEvent event2 = animationEvents[i];
                        if (num3 == 0)
                        {
                            num2 = 1;
                            while (((i + num2) < animationEvents.Length) && (animationEvents[i + num2].time == event2.time))
                            {
                                num2++;
                            }
                            num3 = num2;
                        }
                        num3--;
                        float num5 = Mathf.Floor(state.FrameToPixel(event2.time * animationClip.frameRate, rect));
                        int   num6 = 0;
                        if (num2 > 1)
                        {
                            float num7 = Mathf.Min((int)((num2 - 1) * (image.width - 1)), (int)(((int)state.FrameDeltaToPixel(rect)) - (image.width * 2)));
                            num6 = Mathf.FloorToInt(Mathf.Max((float)0f, (float)(num7 - ((image.width - 1) * num3))));
                        }
                        Rect rect3 = new Rect((num5 + num6) - (image.width / 2), ((rect.height - 10f) * ((num3 - num2) + 1)) / ((float)Mathf.Max(1, num2 - 1)), (float)image.width, (float)image.height);
                        hitPositions[i] = rect3;
                        positions[i]    = rect3;
                    }
                    if (this.m_DirtyTooltip)
                    {
                        if ((this.m_HoverEvent >= 0) && (this.m_HoverEvent < hitPositions.Length))
                        {
                            this.m_InstantTooltipText  = AnimationWindowEventInspector.FormatEvent(rootGameObject, animationEvents[this.m_HoverEvent]);
                            this.m_InstantTooltipPoint = new Vector2(((hitPositions[this.m_HoverEvent].xMin + ((int)(hitPositions[this.m_HoverEvent].width / 2f))) + rect.x) - 30f, rect.yMax);
                        }
                        this.m_DirtyTooltip = false;
                    }
                    if ((this.m_EventsSelected == null) || (this.m_EventsSelected.Length != animationEvents.Length))
                    {
                        this.m_EventsSelected = new bool[animationEvents.Length];
                    }
                    Vector2 zero = Vector2.zero;
                    switch (EditorGUIExt.MultiSelection(rect, positions, new GUIContent(image), hitPositions, ref this.m_EventsSelected, null, out num8, out zero, out num9, out num10, GUIStyle.none))
                    {
                    case HighLevelEvent.DoubleClick:
                        if (num8 == -1)
                        {
                            this.EventLineContextMenuAdd(new EventLineContextMenuObject(rootGameObject, animationClip, time, -1));
                            break;
                        }
                        Selection.activeObject = AnimationWindowEvent.Edit(rootGameObject, animationClip, num8);
                        break;

                    case HighLevelEvent.ContextClick:
                    {
                        GenericMenu menu = new GenericMenu();
                        EventLineContextMenuObject userData = new EventLineContextMenuObject(rootGameObject, animationClip, animationEvents[num8].time, num8);
                        menu.AddItem(new GUIContent("Edit Animation Event"), false, new GenericMenu.MenuFunction2(this.EventLineContextMenuEdit), userData);
                        menu.AddItem(new GUIContent("Add Animation Event"), false, new GenericMenu.MenuFunction2(this.EventLineContextMenuAdd), userData);
                        menu.AddItem(new GUIContent("Delete Animation Event"), false, new GenericMenu.MenuFunction2(this.EventLineContextMenuDelete), userData);
                        menu.ShowAsContext();
                        this.m_InstantTooltipText = null;
                        this.m_DirtyTooltip       = true;
                        state.Repaint();
                        break;
                    }

                    case HighLevelEvent.BeginDrag:
                        this.m_EventsAtMouseDown = animationEvents;
                        this.m_EventTimes        = new float[animationEvents.Length];
                        for (int j = 0; j < animationEvents.Length; j++)
                        {
                            this.m_EventTimes[j] = animationEvents[j].time;
                        }
                        break;

                    case HighLevelEvent.Drag:
                    {
                        for (int k = animationEvents.Length - 1; k >= 0; k--)
                        {
                            if (this.m_EventsSelected[k])
                            {
                                AnimationEvent event6 = this.m_EventsAtMouseDown[k];
                                event6.time = this.m_EventTimes[k] + (zero.x * state.PixelDeltaToTime(rect));
                                event6.time = Mathf.Max(0f, event6.time);
                                event6.time = ((float)Mathf.RoundToInt(event6.time * animationClip.frameRate)) / animationClip.frameRate;
                            }
                        }
                        int[] items = new int[this.m_EventsSelected.Length];
                        for (int m = 0; m < items.Length; m++)
                        {
                            items[m] = m;
                        }
                        Array.Sort(this.m_EventsAtMouseDown, items, new EventComparer());
                        bool[]  flagArray = (bool[])this.m_EventsSelected.Clone();
                        float[] numArray2 = (float[])this.m_EventTimes.Clone();
                        for (int n = 0; n < items.Length; n++)
                        {
                            this.m_EventsSelected[n] = flagArray[items[n]];
                            this.m_EventTimes[n]     = numArray2[items[n]];
                        }
                        Undo.RegisterCompleteObjectUndo(animationClip, "Move Event");
                        AnimationUtility.SetAnimationEvents(animationClip, this.m_EventsAtMouseDown);
                        this.m_DirtyTooltip = true;
                        break;
                    }

                    case HighLevelEvent.Delete:
                        this.DeleteEvents(animationClip, this.m_EventsSelected);
                        break;

                    case HighLevelEvent.SelectionChanged:
                        state.ClearKeySelections();
                        if (num8 != -1)
                        {
                            Selection.activeObject = AnimationWindowEvent.Edit(rootGameObject, animationClip, num8);
                        }
                        break;
                    }
                    this.CheckRectsOnMouseMove(rect, animationEvents, hitPositions);
                }
                if ((Event.current.type == EventType.ContextClick) && rect2.Contains(Event.current.mousePosition))
                {
                    Event.current.Use();
                    GenericMenu menu2 = new GenericMenu();
                    menu2.AddItem(new GUIContent("Add Animation Event"), false, new GenericMenu.MenuFunction2(this.EventLineContextMenuAdd), new EventLineContextMenuObject(rootGameObject, animationClip, time, -1));
                    menu2.ShowAsContext();
                }
                GUI.color = color;
                GUI.EndGroup();
            }
        }
コード例 #22
0
 public static void OnEditAnimationEvent(AnimationWindowEvent awevt)
 {
     AnimationEvent[] array = null;
     if (awevt.clip != null)
     {
         array = AnimationUtility.GetAnimationEvents(awevt.clip);
     }
     else if (awevt.clipInfo != null)
     {
         array = awevt.clipInfo.GetEvents();
     }
     if (array != null && awevt.eventIndex >= 0 && awevt.eventIndex < array.Length)
     {
         AnimationEvent evt = array[awevt.eventIndex];
         GUI.changed = false;
         if (awevt.root != null)
         {
             List <AnimationWindowEventMethod> list = AnimationWindowEventInspector.CollectSupportedMethods(awevt);
             List <string> list2 = new List <string>(list.Count);
             for (int i = 0; i < list.Count; i++)
             {
                 AnimationWindowEventMethod animationWindowEventMethod = list[i];
                 string str = " ( )";
                 if (animationWindowEventMethod.parameterType != null)
                 {
                     if (animationWindowEventMethod.parameterType == typeof(float))
                     {
                         str = " ( float )";
                     }
                     else if (animationWindowEventMethod.parameterType == typeof(int))
                     {
                         str = " ( int )";
                     }
                     else
                     {
                         str = string.Format(" ( {0} )", animationWindowEventMethod.parameterType.Name);
                     }
                 }
                 list2.Add(animationWindowEventMethod.name + str);
             }
             int count = list.Count;
             int num   = list.FindIndex((AnimationWindowEventMethod method) => method.name == evt.functionName);
             if (num == -1)
             {
                 num = list.Count;
                 list.Add(new AnimationWindowEventMethod
                 {
                     name          = evt.functionName,
                     parameterType = null
                 });
                 if (string.IsNullOrEmpty(evt.functionName))
                 {
                     list2.Add("(No Function Selected)");
                 }
                 else
                 {
                     list2.Add(evt.functionName + " (Function Not Supported)");
                 }
             }
             EditorGUIUtility.labelWidth = 130f;
             int num2 = num;
             num = EditorGUILayout.Popup("Function: ", num, list2.ToArray(), new GUILayoutOption[0]);
             if (num2 != num && num != -1 && num != count)
             {
                 evt.functionName    = list[num].name;
                 evt.stringParameter = string.Empty;
             }
             Type parameterType = list[num].parameterType;
             if (parameterType != null)
             {
                 EditorGUILayout.Space();
                 if (parameterType == typeof(AnimationEvent))
                 {
                     EditorGUILayout.PrefixLabel("Event Data");
                 }
                 else
                 {
                     EditorGUILayout.PrefixLabel("Parameters");
                 }
                 AnimationWindowEventInspector.DoEditRegularParameters(evt, parameterType);
             }
         }
         else
         {
             evt.functionName = EditorGUILayout.TextField(new GUIContent("Function"), evt.functionName, new GUILayoutOption[0]);
             AnimationWindowEventInspector.DoEditRegularParameters(evt, typeof(AnimationEvent));
         }
         if (GUI.changed)
         {
             if (awevt.clip != null)
             {
                 Undo.RegisterCompleteObjectUndo(awevt.clip, "Animation Event Change");
                 AnimationUtility.SetAnimationEvents(awevt.clip, array);
             }
             else if (awevt.clipInfo != null)
             {
                 awevt.clipInfo.SetEvent(awevt.eventIndex, evt);
             }
         }
     }
 }
コード例 #23
0
        public void EventLineGUI(Rect rect, AnimationWindowState state)
        {
            //  We only display and manipulate animation events from the main
            //  game object in selection.  If we ever want to update to handle
            //  a multiple selection, a single timeline might not be sufficient...
            AnimationClip clip     = state.activeAnimationClip;
            GameObject    animated = state.activeRootGameObject;

            GUI.BeginGroup(rect);
            Color backupCol = GUI.color;

            Rect eventLineRect = new Rect(0, 0, rect.width, rect.height);

            float mousePosTime = Mathf.Max(Mathf.RoundToInt(state.PixelToTime(Event.current.mousePosition.x, rect) * state.frameRate) / state.frameRate, 0.0f);

            // Draw events
            if (clip != null)
            {
                AnimationEvent[] events      = AnimationUtility.GetAnimationEvents(clip);
                Texture          eventMarker = EditorGUIUtility.IconContent("Animation.EventMarker").image;

                // Calculate rects
                Rect[] hitRects   = new Rect[events.Length];
                Rect[] drawRects  = new Rect[events.Length];
                int    shared     = 1;
                int    sharedLeft = 0;
                for (int i = 0; i < events.Length; i++)
                {
                    AnimationEvent evt = events[i];

                    if (sharedLeft == 0)
                    {
                        shared = 1;
                        while (i + shared < events.Length && events[i + shared].time == evt.time)
                        {
                            shared++;
                        }
                        sharedLeft = shared;
                    }
                    sharedLeft--;

                    // Important to take floor of positions of GUI stuff to get pixel correct alignment of
                    // stuff drawn with both GUI and Handles/GL. Otherwise things are off by one pixel half the time.
                    float keypos       = Mathf.Floor(state.FrameToPixel(evt.time * clip.frameRate, rect));
                    int   sharedOffset = 0;
                    if (shared > 1)
                    {
                        float spread = Mathf.Min((shared - 1) * (eventMarker.width - 1), (int)(state.FrameDeltaToPixel(rect) - eventMarker.width * 2));
                        sharedOffset = Mathf.FloorToInt(Mathf.Max(0, spread - (eventMarker.width - 1) * (sharedLeft)));
                    }

                    Rect r = new Rect(
                        keypos + sharedOffset - eventMarker.width / 2,
                        (rect.height - 10) * (float)(sharedLeft - shared + 1) / Mathf.Max(1, shared - 1),
                        eventMarker.width,
                        eventMarker.height);

                    hitRects[i]  = r;
                    drawRects[i] = r;
                }

                // Store tooptip info
                if (m_DirtyTooltip)
                {
                    if (m_HoverEvent >= 0 && m_HoverEvent < hitRects.Length)
                    {
                        m_InstantTooltipText  = AnimationWindowEventInspector.FormatEvent(animated, events[m_HoverEvent]);
                        m_InstantTooltipPoint = new Vector2(hitRects[m_HoverEvent].xMin + (int)(hitRects[m_HoverEvent].width / 2) + rect.x - 30, rect.yMax);
                    }
                    m_DirtyTooltip = false;
                }

                bool[] selectedEvents = new bool[events.Length];

                Object[] selectedObjects = Selection.objects;
                foreach (Object selectedObject in selectedObjects)
                {
                    AnimationWindowEvent awe = selectedObject as AnimationWindowEvent;
                    if (awe != null)
                    {
                        if (awe.eventIndex >= 0 && awe.eventIndex < selectedEvents.Length)
                        {
                            selectedEvents[awe.eventIndex] = true;
                        }
                    }
                }

                Vector2 offset = Vector2.zero;
                int     clickedIndex;
                float   startSelection, endSelection;

                // TODO: GUIStyle.none has hopping margins that need to be fixed
                HighLevelEvent hEvent = EditorGUIExt.MultiSelection(
                    rect,
                    drawRects,
                    new GUIContent(eventMarker),
                    hitRects,
                    ref selectedEvents,
                    null,
                    out clickedIndex,
                    out offset,
                    out startSelection,
                    out endSelection,
                    GUIStyle.none
                    );

                if (hEvent != HighLevelEvent.None)
                {
                    switch (hEvent)
                    {
                    case HighLevelEvent.BeginDrag:
                        m_EventsAtMouseDown = events;
                        m_EventTimes        = new float[events.Length];
                        for (int i = 0; i < events.Length; i++)
                        {
                            m_EventTimes[i] = events[i].time;
                        }
                        break;

                    case HighLevelEvent.SelectionChanged:
                        state.ClearKeySelections();
                        EditEvents(animated, clip, selectedEvents);
                        break;

                    case HighLevelEvent.Delete:
                        DeleteEvents(clip, selectedEvents);
                        break;

                    case HighLevelEvent.DoubleClick:

                        if (clickedIndex != -1)
                        {
                            EditEvents(animated, clip, selectedEvents);
                        }
                        else
                        {
                            EventLineContextMenuAdd(new EventLineContextMenuObject(animated, clip, mousePosTime, -1, selectedEvents));
                        }
                        break;

                    case HighLevelEvent.Drag:
                        for (int i = events.Length - 1; i >= 0; i--)
                        {
                            if (selectedEvents[i])
                            {
                                AnimationEvent evt = m_EventsAtMouseDown[i];
                                evt.time = m_EventTimes[i] + offset.x * state.PixelDeltaToTime(rect);
                                evt.time = Mathf.Max(0.0F, evt.time);
                                evt.time = Mathf.RoundToInt(evt.time * clip.frameRate) / clip.frameRate;
                            }
                        }
                        int[] order = new int[selectedEvents.Length];
                        for (int i = 0; i < order.Length; i++)
                        {
                            order[i] = i;
                        }
                        System.Array.Sort(m_EventsAtMouseDown, order, new EventComparer());
                        bool[]  selectedOld = (bool[])selectedEvents.Clone();
                        float[] timesOld    = (float[])m_EventTimes.Clone();
                        for (int i = 0; i < order.Length; i++)
                        {
                            selectedEvents[i] = selectedOld[order[i]];
                            m_EventTimes[i]   = timesOld[order[i]];
                        }

                        // Update selection to reflect new order.
                        EditEvents(animated, clip, selectedEvents);

                        Undo.RegisterCompleteObjectUndo(clip, "Move Event");
                        AnimationUtility.SetAnimationEvents(clip, m_EventsAtMouseDown);
                        m_DirtyTooltip = true;
                        break;

                    case HighLevelEvent.ContextClick:
                        GenericMenu menu                = new GenericMenu();
                        var         contextData         = new EventLineContextMenuObject(animated, clip, events[clickedIndex].time, clickedIndex, selectedEvents);
                        int         selectedEventsCount = selectedEvents.Count(selected => selected);

                        menu.AddItem(
                            EditorGUIUtility.TrTextContent("Add Animation Event"),
                            false,
                            EventLineContextMenuAdd,
                            contextData);
                        menu.AddItem(
                            new GUIContent(selectedEventsCount > 1 ? "Delete Animation Events" : "Delete Animation Event"),
                            false,
                            EventLineContextMenuDelete,
                            contextData);
                        menu.ShowAsContext();

                        // Mouse may move while context menu is open - make sure instant tooltip is handled
                        m_InstantTooltipText = null;
                        m_DirtyTooltip       = true;
                        state.Repaint();
                        break;
                    }
                }

                CheckRectsOnMouseMove(rect, events, hitRects);

                // Create context menu on context click
                if (Event.current.type == EventType.ContextClick && eventLineRect.Contains(Event.current.mousePosition))
                {
                    Event.current.Use();
                    // Create menu
                    GenericMenu menu                = new GenericMenu();
                    var         contextData         = new EventLineContextMenuObject(animated, clip, mousePosTime, -1, selectedEvents);
                    int         selectedEventsCount = selectedEvents.Count(selected => selected);

                    menu.AddItem(
                        EditorGUIUtility.TrTextContent("Add Animation Event"),
                        false,
                        EventLineContextMenuAdd,
                        contextData);

                    if (selectedEventsCount > 0)
                    {
                        menu.AddItem(
                            new GUIContent(selectedEventsCount > 1 ? "Delete Animation Events" : "Delete Animation Event"),
                            false,
                            EventLineContextMenuDelete,
                            contextData);
                    }

                    menu.ShowAsContext();
                }
            }

            GUI.color = backupCol;
            GUI.EndGroup();
        }
コード例 #24
0
 public static void OnEditAnimationEvent(AnimationWindowEvent awe)
 {
     OnEditAnimationEvents(new AnimationWindowEvent[] { awe });
 }
コード例 #25
0
        public static List <AnimationWindowEventMethod> CollectSupportedMethods(AnimationWindowEvent awevt)
        {
            List <AnimationWindowEventMethod> list = new List <AnimationWindowEventMethod>();
            List <AnimationWindowEventMethod> result;

            if (awevt.root == null)
            {
                result = list;
            }
            else
            {
                MonoBehaviour[]  components = awevt.root.GetComponents <MonoBehaviour>();
                HashSet <string> hashSet    = new HashSet <string>();
                MonoBehaviour[]  array      = components;
                for (int i = 0; i < array.Length; i++)
                {
                    MonoBehaviour monoBehaviour = array[i];
                    if (!(monoBehaviour == null))
                    {
                        Type type = monoBehaviour.GetType();
                        while (type != typeof(MonoBehaviour) && type != null)
                        {
                            MethodInfo[] methods = type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                            for (int j = 0; j < methods.Length; j++)
                            {
                                MethodInfo methodInfo = methods[j];
                                string     name       = methodInfo.Name;
                                if (AnimationWindowEventInspector.IsSupportedMethodName(name))
                                {
                                    ParameterInfo[] parameters = methodInfo.GetParameters();
                                    if (parameters.Length <= 1)
                                    {
                                        Type type2 = null;
                                        if (parameters.Length == 1)
                                        {
                                            type2 = parameters[0].ParameterType;
                                            if (type2 != typeof(string) && type2 != typeof(float) && type2 != typeof(int) && type2 != typeof(AnimationEvent) && type2 != typeof(UnityEngine.Object) && !type2.IsSubclassOf(typeof(UnityEngine.Object)) && !type2.IsEnum)
                                            {
                                                goto IL_1C7;
                                            }
                                        }
                                        AnimationWindowEventMethod item = default(AnimationWindowEventMethod);
                                        item.name          = methodInfo.Name;
                                        item.parameterType = type2;
                                        int num = list.FindIndex((AnimationWindowEventMethod m) => m.name == name);
                                        if (num != -1)
                                        {
                                            if (list[num].parameterType != type2)
                                            {
                                                hashSet.Add(name);
                                            }
                                        }
                                        list.Add(item);
                                    }
                                }
                                IL_1C7 :;
                            }
                            type = type.BaseType;
                        }
                    }
                }
                foreach (string current in hashSet)
                {
                    for (int k = list.Count - 1; k >= 0; k--)
                    {
                        if (list[k].name.Equals(current))
                        {
                            list.RemoveAt(k);
                        }
                    }
                }
                result = list;
            }
            return(result);
        }
コード例 #26
0
        public void AddEvent(float time, GameObject rootGameObject, AnimationClip animationClip)
        {
            AnimationWindowEvent evt = AnimationWindowEvent.CreateAndEdit(rootGameObject, animationClip, time);

            this.Select(evt);
        }