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;
}
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);
}
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);
}
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();
}
}
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();
}
}
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);
}
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);
}
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);
}
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]);
}
}
}
}
}
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);
}
}
private void Select(AnimationWindowEvent evt)
{
this.m_EventsSelected = new bool[AnimationUtility.GetAnimationEvents(evt.clip).Length];
this.m_EventsSelected[evt.eventIndex] = true;
Selection.activeObject = evt;
}
private void Select(AnimationWindowEvent evt)
{
this.m_EventsSelected = new bool[AnimationUtility.GetAnimationEvents(evt.clip).Length];
this.m_EventsSelected[evt.eventIndex] = true;
Selection.activeObject = evt;
}
public void AddEvent(float time, GameObject gameObject, AnimationClip animationClip)
{
AnimationWindowEvent awEvent = AnimationWindowEvent.CreateAndEdit(gameObject, animationClip, time);
Selection.activeObject = awEvent;
}
public void EditEvent(GameObject gameObject, AnimationClip clip, int index)
{
AnimationWindowEvent awEvent = AnimationWindowEvent.Edit(gameObject, clip, index);
Selection.activeObject = awEvent;
}
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();
}
}
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);
}
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);
}
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;
}
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);
}
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);
}
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();
}
}
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);
}
}
}
}
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();
}
public static void OnEditAnimationEvent(AnimationWindowEvent awe)
{
OnEditAnimationEvents(new AnimationWindowEvent[] { awe });
}
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);
}
public void AddEvent(float time, GameObject rootGameObject, AnimationClip animationClip)
{
AnimationWindowEvent evt = AnimationWindowEvent.CreateAndEdit(rootGameObject, animationClip, time);
this.Select(evt);
}
