public MecanimEvent(MecanimEvent other) {
normalizedTime = other.normalizedTime;
functionName = other.functionName;
paramType = other.paramType;
switch(paramType) {
case MecanimEventParamTypes.Int32:
intParam = other.intParam;
break;
case MecanimEventParamTypes.Float:
floatParam = other.floatParam;
break;
case MecanimEventParamTypes.String:
stringParam = other.stringParam;
break;
case MecanimEventParamTypes.Boolean:
boolParam = other.boolParam;
break;
}
condition = new EventCondition();
condition.conditions = new List<EventConditionEntry>(other.condition.conditions);
critical = other.critical;
isEnable = other.isEnable;
}
public static MecanimEventEditorPopup Show(MecanimEventEditor editor, MecanimEvent e, KeyValuePair<string, EventConditionParamTypes>[] availableParameters) {
actived = EditorWindow.GetWindow<MecanimEventEditorPopup>(false, "Edit Event");
actived.eventEditing = e;
actived.eventTemp = new MecanimEvent(e);
actived.editor = editor;
actived.availableParameters = availableParameters;
actived.conditionList = new UnityEditorInternal.ReorderableList(actived.eventTemp.condition.conditions, typeof(EventConditionEntry));
actived.conditionList.drawElementCallback = new UnityEditorInternal.ReorderableList.ElementCallbackDelegate(actived.DrawConditionsElement);
actived.conditionList.drawHeaderCallback = new UnityEditorInternal.ReorderableList.HeaderCallbackDelegate(actived.DrawConditionsHeader);
return actived;
}
void Reset() {
displayEvents = null;
targetController = null;
targetStateMachine = null;
targetState = null;
targetEvent = null;
selectedLayer = 0;
selectedState = 0;
selectedEvent = 0;
MecanimEventEditorPopup.Destroy();
}
public void SetEvents(AnimatorController controller, int layer, int stateNameHash, MecanimEvent[] events) {
if (!data.ContainsKey(controller)) {
data[controller] = new Dictionary<int, Dictionary<int, List<MecanimEvent>>>();
}
if (!data[controller].ContainsKey(layer)) {
data[controller][layer] = new Dictionary<int, List<MecanimEvent>>();
}
if (!data[controller][layer].ContainsKey(stateNameHash)) {
data[controller][layer][stateNameHash] = new List<MecanimEvent>();
}
data[controller][layer][stateNameHash] = new List<MecanimEvent>(events);
}
private void Update()
{
var events =
MecanimEventManager.GetEvents(loadedData, lastStates, animatorController.GetInstanceID(), animator);
foreach (var e in events)
{
MecanimEvent.SetCurrentContext(e);
switch (emitType)
{
case MecanimEventEmitTypes.Upwards:
if (e.paramType != MecanimEventParamTypes.None)
{
SendMessageUpwards(e.functionName, e.parameter, SendMessageOptions.DontRequireReceiver);
}
else
{
SendMessageUpwards(e.functionName, SendMessageOptions.DontRequireReceiver);
}
break;
case MecanimEventEmitTypes.Broadcast:
if (e.paramType != MecanimEventParamTypes.None)
{
BroadcastMessage(e.functionName, e.parameter, SendMessageOptions.DontRequireReceiver);
}
else
{
BroadcastMessage(e.functionName, SendMessageOptions.DontRequireReceiver);
}
break;
default:
if (e.paramType != MecanimEventParamTypes.None)
{
SendMessage(e.functionName, e.parameter, SendMessageOptions.DontRequireReceiver);
}
else
{
SendMessage(e.functionName, SendMessageOptions.DontRequireReceiver);
}
break;
}
}
}
private MecanimEvent[] CollectEvents(Animator animator, int animatorControllerId, int layer, int nameHash, int tagHash,
float normalizedTimeStart, float normalizedTimeEnd, bool onlyCritical = false)
{
List <MecanimEvent> events;
if (loadedData.ContainsKey(animatorControllerId) &&
loadedData[animatorControllerId].ContainsKey(layer) &&
loadedData[animatorControllerId][layer].ContainsKey(nameHash))
{
events = loadedData[animatorControllerId][layer][nameHash];
}
else
{
return(new MecanimEvent[0]);
}
List <MecanimEvent> ret = new List <MecanimEvent>();
foreach (MecanimEvent e in events)
{
if (e.normalizedTime >= normalizedTimeStart && e.normalizedTime < normalizedTimeEnd)
{
if (e.condition.Test(animator))
{
if (onlyCritical && !e.critical)
{
continue;
}
MecanimEvent finalEvent = new MecanimEvent(e);
EventContext context = new EventContext();
context.controllerId = animatorControllerId;
context.layer = layer;
context.stateHash = nameHash;
context.tagHash = tagHash;
finalEvent.SetContext(context);
ret.Add(finalEvent);
}
}
}
return(ret.ToArray());
}
private void DrawEventPanel()
{
GUILayout.BeginVertical();
if (targetState != null)
{
displayEvents =
new List <MecanimEvent>(eventInspector.GetEvents(targetController, selectedLayer,
targetState.GetFullPathHash(targetStateMachine)));
SortEvents();
GUILayout.Label(displayEvents.Count + " event(s) in this state.");
var eventNames = new List <string>();
foreach (var e in displayEvents)
{
eventNames.Add(string.Format("{3}{0}({1})@{2}", e.functionName, e.parameter,
e.normalizedTime.ToString("0.0000"), e.isEnable ? "" : "[DISABLED]"));
}
GUILayout.BeginVertical("Box");
eventPanelScrollPos = GUILayout.BeginScrollView(eventPanelScrollPos);
selectedEvent = GUILayout.SelectionGrid(selectedEvent, eventNames.ToArray(), 1);
if (selectedEvent >= 0 && selectedEvent < displayEvents.Count)
{
targetEvent = displayEvents[selectedEvent];
}
else
{
targetEvent = null;
}
GUILayout.EndScrollView();
GUILayout.EndVertical();
}
else
{
GUILayout.Label("No event.");
}
GUILayout.EndVertical();
}
private void Update()
{
List <MecanimEvent> events = MecanimEventManager.GetEvents(this.animatorController.GetInstanceID(), this.animator);
for (int i = 0; i < events.Count; i++)
{
MecanimEvent mecanimEvent = events[i];
MecanimEvent.SetCurrentContext(mecanimEvent);
MecanimEventEmitTypes mecanimEventEmitTypes = this.emitType;
if (mecanimEventEmitTypes != MecanimEventEmitTypes.Upwards)
{
if (mecanimEventEmitTypes != MecanimEventEmitTypes.Broadcast)
{
if (mecanimEvent.paramType != MecanimEventParamTypes.None)
{
base.SendMessage(mecanimEvent.functionName, mecanimEvent.parameter, SendMessageOptions.DontRequireReceiver);
}
else
{
base.SendMessage(mecanimEvent.functionName, SendMessageOptions.DontRequireReceiver);
}
}
else if (mecanimEvent.paramType != MecanimEventParamTypes.None)
{
base.BroadcastMessage(mecanimEvent.functionName, mecanimEvent.parameter, SendMessageOptions.DontRequireReceiver);
}
else
{
base.BroadcastMessage(mecanimEvent.functionName, SendMessageOptions.DontRequireReceiver);
}
}
else if (mecanimEvent.paramType != MecanimEventParamTypes.None)
{
base.SendMessageUpwards(mecanimEvent.functionName, mecanimEvent.parameter, SendMessageOptions.DontRequireReceiver);
}
else
{
base.SendMessageUpwards(mecanimEvent.functionName, SendMessageOptions.DontRequireReceiver);
}
MecanimEventManager.PoolEvent(mecanimEvent);
}
events.Clear();
}
/// <summary>
/// 结束当前的状态
/// </summary>
/// <param name="nStateHash">如果当前处于 ifStateHash时</param>
/// <param name="layer"></param>
public void FinishCurrentState(int ifStateHash, Statelayer layer = Statelayer.Normal)
{
if (!mHasSetup)
{
return;
}
if (layer >= Statelayer.Count || ifStateHash == 0)
{
return;
}
EventContext content = new EventContext();
content.curstate = ifStateHash;
MecanimEvent even = new MecanimEvent(MecanimEvent.MEC_ANIM_END, content);
mAnimStates[(uint)layer].CurrentAnimState.HandlemAnimatorEvent(even);
}
public MecanimEventDataEntry(MecanimEventDataEntry other)
{
animatorController = other.animatorController;
layer = other.layer;
stateNameHash = other.stateNameHash;
if (other.events == null)
{
events = new MecanimEvent[0];
}
else
{
events = new MecanimEvent[other.events.Length];
for (var i = 0; i < events.Length; i++)
{
events[i] = new MecanimEvent(other.events[i]);
}
}
}
void DrawStatePanel()
{
GUILayout.BeginVertical(GUILayout.Width(200));
if (targetStateMachine != null)
{
List <AnimatorState> availableStates = GetStatesRecursive(targetStateMachine);
List <string> stateNames = new List <string>();
foreach (AnimatorState s in availableStates)
{
stateNames.Add(s.name);
}
GUILayout.Label(availableStates.Count + " state(s) in selected layer.");
GUILayout.BeginVertical("Box");
statePanelScrollPos = GUILayout.BeginScrollView(statePanelScrollPos);
selectedState = GUILayout.SelectionGrid(selectedState, stateNames.ToArray(), 1);
if (selectedState >= 0 && selectedState < availableStates.Count)
{
targetState = availableStates[selectedState];
}
else
{
targetState = null;
targetEvent = null;
}
GUILayout.EndScrollView();
GUILayout.EndVertical();
}
else
{
GUILayout.Label("No state machine available.");
}
GUILayout.EndVertical();
}
// Token: 0x06001598 RID: 5528 RVA: 0x00078D84 File Offset: 0x00076F84
private void Update()
{
ICollection <MecanimEvent> events = MecanimEventManager.GetEvents(this.animatorController.GetInstanceID(), this.animator);
foreach (MecanimEvent mecanimEvent in events)
{
MecanimEvent.SetCurrentContext(mecanimEvent);
MecanimEventEmitTypes mecanimEventEmitTypes = this.emitType;
if (mecanimEventEmitTypes != MecanimEventEmitTypes.Upwards)
{
if (mecanimEventEmitTypes != MecanimEventEmitTypes.Broadcast)
{
if (mecanimEvent.paramType != MecanimEventParamTypes.None)
{
base.SendMessage(mecanimEvent.functionName, mecanimEvent.parameter, SendMessageOptions.DontRequireReceiver);
}
else
{
base.SendMessage(mecanimEvent.functionName, SendMessageOptions.DontRequireReceiver);
}
}
else if (mecanimEvent.paramType != MecanimEventParamTypes.None)
{
base.BroadcastMessage(mecanimEvent.functionName, mecanimEvent.parameter, SendMessageOptions.DontRequireReceiver);
}
else
{
base.BroadcastMessage(mecanimEvent.functionName, SendMessageOptions.DontRequireReceiver);
}
}
else if (mecanimEvent.paramType != MecanimEventParamTypes.None)
{
base.SendMessageUpwards(mecanimEvent.functionName, mecanimEvent.parameter, SendMessageOptions.DontRequireReceiver);
}
else
{
base.SendMessageUpwards(mecanimEvent.functionName, SendMessageOptions.DontRequireReceiver);
}
}
}
void Update()
{
if (mecanimEventHandler == null || animatorController == null)
{
return;
}
MecanimEvent[] events = MecanimEventManager.GetEvents(loadedData, lastStates, animatorController.GetInstanceID(), animator);
foreach (MecanimEvent e in events)
{
MecanimEvent.SetCurrentContext(e);
var m = ReflectionHelper.GetMethodRecursive(mecanimEventHandler, e.functionName);
if (e.paramType == MecanimEventParamTypes.None)
{
m.FastInvoke(mecanimEventHandler);
}
else
{
m.FastInvoke(mecanimEventHandler, e.parameter);
}
}
}
private void DrawEventKey(Rect rect, MecanimEvent key)
{
float keyTime = key.normalizedTime;
Rect keyRect = new Rect(rect.x + rect.width * keyTime - 3, rect.y + 25, 6, 18);
int eventKeyCtrl = key.GetHashCode();
Event e = Event.current;
switch (e.type)
{
case EventType.Repaint:
Color savedColor = GUI.color;
if (targetEvent == key)
{
GUI.color = Color.red;
}
else
{
GUI.color = Color.green;
}
GUI.skin.button.Draw(keyRect, new GUIContent(), eventKeyCtrl);
GUI.color = savedColor;
if (hotEventKey == eventKeyCtrl || (hotEventKey == 0 && keyRect.Contains(e.mousePosition)))
{
string labelString = string.Format("{0}({1})@{2}", key.functionName, key.parameter, key.normalizedTime.ToString("0.0000"));
Vector2 size = EditorStyles.largeLabel.CalcSize(new GUIContent(labelString));
Rect infoRect = new Rect(rect.x + rect.width * keyTime - size.x / 2, rect.y + 50, size.x, size.y);
EditorStyles.largeLabel.Draw(infoRect, new GUIContent(labelString), eventKeyCtrl);
}
break;
case EventType.MouseDown:
if (keyRect.Contains(e.mousePosition))
{
hotEventKey = eventKeyCtrl;
enableTempPreview = true;
tempPreviewPlaybackTime = key.normalizedTime;
SetActiveEvent(key);
if (e.clickCount > 1)
{
MecanimEventEditorPopup.Show(this, key, GetConditionParameters());
}
e.Use();
}
break;
case EventType.MouseDrag:
if (hotEventKey == eventKeyCtrl)
{
if (e.button == 0)
{
Vector2 guiPos = e.mousePosition;
float clampedX = Mathf.Clamp(guiPos.x, rect.x, rect.x + rect.width);
key.normalizedTime = (clampedX - rect.x) / rect.width;
tempPreviewPlaybackTime = key.normalizedTime;
SetActiveEvent(key);
}
e.Use();
}
break;
case EventType.MouseUp:
if (hotEventKey == eventKeyCtrl)
{
hotEventKey = 0;
enableTempPreview = false;
eventInspector.SetPlaybackTime(playbackTime); // reset to original time
if (e.button == 1)
{
MecanimEventEditorPopup.Show(this, key, GetConditionParameters());
}
e.Use();
}
break;
}
}
void DrawTimelinePanel()
{
if (!enableTempPreview)
{
playbackTime = eventInspector.GetPlaybackTime();
}
GUILayout.BeginVertical(); {
GUILayout.Space(10);
GUILayout.BeginHorizontal(); {
GUILayout.Space(20);
playbackTime = Timeline(playbackTime);
GUILayout.Space(10);
}
GUILayout.EndHorizontal();
GUILayout.FlexibleSpace();
GUILayout.BeginHorizontal(); {
if (GUILayout.Button("Tools"))
{
GenericMenu menu = new GenericMenu();
GenericMenu.MenuFunction2 callback = delegate(object obj) {
int id = (int)obj;
switch (id)
{
case 1:
{
//stateClipboard = eventInspector.GetEvents(targetController, selectedLayer, targetState.uniqueNameHash);
break;
}
case 2:
{
//eventInspector.InsertEventsCopy(targetController, selectedLayer, targetState.uniqueNameHash, stateClipboard);
break;
}
case 3:
{
controllerClipboard = eventInspector.GetEvents(targetController);
break;
}
case 4:
{
eventInspector.InsertControllerEventsCopy(targetController, controllerClipboard);
break;
}
}
};
if (targetState == null)
{
menu.AddDisabledItem(new GUIContent("Copy All Events From Selected State"));
}
else
{
menu.AddItem(new GUIContent("Copy All Events From Selected State"), false, callback, 1);
}
if (targetState == null || stateClipboard == null || stateClipboard.Length == 0)
{
menu.AddDisabledItem(new GUIContent("Paste All Events To Selected State"));
}
else
{
menu.AddItem(new GUIContent("Paste All Events To Selected State"), false, callback, 2);
}
if (targetController == null)
{
menu.AddDisabledItem(new GUIContent("Copy All Events From Selected Controller"));
}
else
{
menu.AddItem(new GUIContent("Copy All Events From Selected Controller"), false, callback, 3);
}
if (targetController == null || controllerClipboard == null || controllerClipboard.Count == 0)
{
menu.AddDisabledItem(new GUIContent("Paste All Events To Selected Controller"));
}
else
{
menu.AddItem(new GUIContent("Paste All Events To Selected Controller"), false, callback, 4);
}
menu.ShowAsContext();
}
GUILayout.FlexibleSpace();
if (GUILayout.Button("Add", GUILayout.Width(80)))
{
MecanimEvent newEvent = new MecanimEvent();
newEvent.normalizedTime = playbackTime;
newEvent.functionName = "MessageName";
newEvent.paramType = MecanimEventParamTypes.None;
displayEvents.Add(newEvent);
SortEvents();
SetActiveEvent(newEvent);
MecanimEventEditorPopup.Show(this, newEvent, GetConditionParameters());
}
if (GUILayout.Button("Del", GUILayout.Width(80)))
{
DelEvent(targetEvent);
}
EditorGUI.BeginDisabledGroup(targetEvent == null);
if (GUILayout.Button("Copy", GUILayout.Width(80)))
{
clipboard = new MecanimEvent(targetEvent);
}
EditorGUI.EndDisabledGroup();
EditorGUI.BeginDisabledGroup(clipboard == null);
if (GUILayout.Button("Paste", GUILayout.Width(80)))
{
MecanimEvent newEvent = new MecanimEvent(clipboard);
displayEvents.Add(newEvent);
SortEvents();
SetActiveEvent(newEvent);
}
EditorGUI.EndDisabledGroup();
EditorGUI.BeginDisabledGroup(targetEvent == null);
if (GUILayout.Button("Edit", GUILayout.Width(80)))
{
MecanimEventEditorPopup.Show(this, targetEvent, GetConditionParameters());
}
EditorGUI.EndDisabledGroup();
if (GUILayout.Button("Save", GUILayout.Width(80)))
{
eventInspector.SaveData();
}
if (GUILayout.Button("Close", GUILayout.Width(80)))
{
Close();
}
}
GUILayout.EndHorizontal();
}
GUILayout.EndVertical();
if (enableTempPreview)
{
eventInspector.SetPlaybackTime(tempPreviewPlaybackTime);
eventInspector.StopPlaying();
}
else
{
eventInspector.SetPlaybackTime(playbackTime);
}
SaveState();
}
private static MecanimEvent[] CollectEvents(Dictionary<int, Dictionary<int, Dictionary<int, List<MecanimEvent>>>> contextLoadedData,
Animator animator,
int animatorControllerId,
int layer, int nameHash,
int tagHash,
float normalizedTimeStart,
float normalizedTimeEnd,
bool onlyCritical = false) {
List<MecanimEvent> events;
if (contextLoadedData.ContainsKey(animatorControllerId) &&
contextLoadedData[animatorControllerId].ContainsKey(layer) &&
contextLoadedData[animatorControllerId][layer].ContainsKey(nameHash)) {
events = contextLoadedData[animatorControllerId][layer][nameHash];
}
else {
return new MecanimEvent[0];
}
List<MecanimEvent> ret = new List<MecanimEvent>();
foreach (MecanimEvent e in events) {
if (!e.isEnable)
continue;
if (e.normalizedTime >= normalizedTimeStart && e.normalizedTime < normalizedTimeEnd) {
if (e.condition.Test(animator)) {
if (onlyCritical && !e.critical)
continue;
MecanimEvent finalEvent = new MecanimEvent(e);
EventContext context = new EventContext();
context.controllerId = animatorControllerId;
context.layer = layer;
context.stateHash = nameHash;
context.tagHash = tagHash;
finalEvent.SetContext(context);
ret.Add(finalEvent);
}
}
}
return ret.ToArray();
}
void DrawEventPanel() {
GUILayout.BeginVertical();
if (targetState != null) {
displayEvents = new List<MecanimEvent>(eventInspector.GetEvents(targetController, selectedLayer, targetState.GetFullPathHash(targetStateMachine)));
SortEvents();
GUILayout.Label(displayEvents.Count + " event(s) in this state.");
List<string> eventNames = new List<string>();
foreach (MecanimEvent e in displayEvents) {
eventNames.Add(string.Format("{3}{0}({1})@{2}", e.functionName, e.parameter, e.normalizedTime.ToString("0.0000"), e.isEnable?"":"[DISABLED]"));
}
GUILayout.BeginVertical("Box");
eventPanelScrollPos = GUILayout.BeginScrollView(eventPanelScrollPos);
selectedEvent = GUILayout.SelectionGrid(selectedEvent, eventNames.ToArray(), 1);
if (selectedEvent >= 0 && selectedEvent < displayEvents.Count) {
targetEvent = displayEvents[selectedEvent];
}
else {
targetEvent = null;
}
GUILayout.EndScrollView();
GUILayout.EndVertical();
}
else {
GUILayout.Label("No event.");
}
GUILayout.EndVertical();
}
public virtual void RecieveMecAnimEvent(MecanimEvent eve)
{
}
public void InsertEventsCopy(AnimatorController controller, int layer, int stateNameHash, MecanimEvent[] events) {
List<MecanimEvent> allEvents = new List<MecanimEvent>(GetEvents(controller, layer, stateNameHash));
foreach (MecanimEvent e in events) {
allEvents.Add(new MecanimEvent(e));
}
SetEvents(controller, layer, stateNameHash, allEvents.ToArray());
}
public virtual void HandlemAnimatorEvent(MecanimEvent animEvent)
{
}
public static void SetCurrentContext(MecanimEvent e)
{
MecanimEvent.Context = e.context;
}
void DrawControllerPanel()
{
GUILayout.BeginVertical(GUILayout.Width(200));
// controller to add field.
GUILayout.BeginHorizontal();
{
controllerToAdd = EditorGUILayout.ObjectField(controllerToAdd, typeof(RuntimeAnimatorController), false) as RuntimeAnimatorController;
EditorGUI.BeginDisabledGroup(controllerToAdd == null);
if (GUILayout.Button("Add", GUILayout.ExpandWidth(true), GUILayout.Height(16)))
{
eventInspector.AddController(controllerToAdd);
}
EditorGUI.EndDisabledGroup();
//GUILayout.Button("Del", EditorStyles.toolbarButton, GUILayout.Width(38), GUILayout.Height(16));
GUILayout.Space(4);
}
GUILayout.EndHorizontal();
// controller list
GUILayout.BeginVertical("Box");
controllerPanelScrollPos = GUILayout.BeginScrollView(controllerPanelScrollPos);
RuntimeAnimatorController[] controllers = eventInspector.GetControllers();
string[] controllerNames = new string[controllers.Length];
for (int i = 0; i < controllers.Length; i++)
{
controllerNames [i] = controllers [i].name;
}
selectedController = GUILayout.SelectionGrid(selectedController, controllerNames, 1);
if (selectedController >= 0 && selectedController < controllers.Length)
{
targetController = controllers [selectedController];
if (targetController is AnimatorOverrideController)
{
overrides = new List <KeyValuePair <AnimationClip, AnimationClip> > (((AnimatorOverrideController)targetController).overridesCount);
((AnimatorOverrideController)targetController).GetOverrides(overrides);
}
else
{
overrides = null;
}
// eventInspectorSaveLastEditController (targetController);
}
else
{
targetController = null;
targetStateMachine = null;
targetState = null;
targetEvent = null;
}
GUILayout.EndScrollView();
GUILayout.EndVertical();
GUILayout.EndVertical();
}
public static void SetCurrentContext(MecanimEvent e)
{
MecanimEvent.Context = e.context;
}
private void DrawEventKey(Rect rect, MecanimEvent key) {
float keyTime = key.normalizedTime;
Rect keyRect = new Rect(rect.x + rect.width * keyTime - 3, rect.y+25, 6, 18);
int eventKeyCtrl = key.GetHashCode();
Event e = Event.current;
switch(e.type) {
case EventType.Repaint:
Color savedColor = GUI.color;
if (targetEvent == key)
GUI.color = Color.red;
else
GUI.color = Color.green;
GUI.skin.button.Draw(keyRect, new GUIContent(), eventKeyCtrl);
GUI.color = savedColor;
if (hotEventKey == eventKeyCtrl || (hotEventKey == 0 && keyRect.Contains(e.mousePosition))) {
string labelString = string.Format("{0}({1})@{2}", key.functionName, key.parameter, key.normalizedTime.ToString("0.0000"));
Vector2 size = EditorStyles.largeLabel.CalcSize(new GUIContent(labelString));
Rect infoRect= new Rect(rect.x + rect.width * keyTime - size.x/2, rect.y + 50, size.x, size.y);
EditorStyles.largeLabel.Draw(infoRect, new GUIContent(labelString), eventKeyCtrl);
}
break;
case EventType.MouseDown:
if (keyRect.Contains(e.mousePosition)) {
hotEventKey = eventKeyCtrl;
enableTempPreview =true;
tempPreviewPlaybackTime = key.normalizedTime;
SetActiveEvent(key);
if (e.clickCount > 1)
MecanimEventEditorPopup.Show(this, key, GetConditionParameters());
e.Use();
}
break;
case EventType.MouseDrag:
if (hotEventKey == eventKeyCtrl) {
if (e.button == 0) {
Vector2 guiPos = e.mousePosition;
float clampedX = Mathf.Clamp(guiPos.x, rect.x, rect.x + rect.width);
key.normalizedTime = (clampedX - rect.x) / rect.width;
tempPreviewPlaybackTime = key.normalizedTime;
SetActiveEvent(key);
}
e.Use();
}
break;
case EventType.MouseUp:
if (hotEventKey == eventKeyCtrl) {
hotEventKey = 0;
enableTempPreview = false;
eventInspector.SetPlaybackTime(playbackTime); // reset to original time
if (e.button == 1)
MecanimEventEditorPopup.Show(this, key, GetConditionParameters());
e.Use();
}
break;
}
}
private void SetActiveEvent(MecanimEvent key) {
int i = displayEvents.IndexOf(key);
if (i >= 0) {
selectedEvent = i;
targetEvent = key;
}
}
public void DelEvent(MecanimEvent e) {
if (displayEvents != null) {
displayEvents.Remove(e);
SaveState();
}
}
void DrawTimelinePanel() {
if (!enableTempPreview)
playbackTime = eventInspector.GetPlaybackTime();
GUILayout.BeginVertical(); {
GUILayout.Space(10);
GUILayout.BeginHorizontal(); {
GUILayout.Space(20);
playbackTime = Timeline(playbackTime);
GUILayout.Space(10);
}
GUILayout.EndHorizontal();
GUILayout.FlexibleSpace();
GUILayout.BeginHorizontal(); {
if (GUILayout.Button("Tools")) {
GenericMenu menu = new GenericMenu();
GenericMenu.MenuFunction2 callback = delegate(object obj) {
int id = (int)obj;
switch(id)
{
case 1:
{
stateClipboard = eventInspector.GetEvents(targetController, selectedLayer, targetState.GetFullPathHash(targetStateMachine));
break;
}
case 2:
{
eventInspector.InsertEventsCopy(targetController, selectedLayer, targetState.GetFullPathHash(targetStateMachine), stateClipboard);
break;
}
case 3:
{
controllerClipboard = eventInspector.GetEvents(targetController);
break;
}
case 4:
{
eventInspector.InsertControllerEventsCopy(targetController, controllerClipboard);
break;
}
}
};
if (targetState == null)
menu.AddDisabledItem(new GUIContent("Copy All Events From Selected State"));
else
menu.AddItem(new GUIContent("Copy All Events From Selected State"), false, callback, 1);
if (targetState == null || stateClipboard == null || stateClipboard.Length == 0)
menu.AddDisabledItem(new GUIContent("Paste All Events To Selected State"));
else
menu.AddItem(new GUIContent("Paste All Events To Selected State"), false, callback, 2);
if (targetController == null)
menu.AddDisabledItem(new GUIContent("Copy All Events From Selected Controller"));
else
menu.AddItem(new GUIContent("Copy All Events From Selected Controller"), false, callback, 3);
if (targetController == null || controllerClipboard == null || controllerClipboard.Count == 0)
menu.AddDisabledItem(new GUIContent("Paste All Events To Selected Controller"));
else
menu.AddItem(new GUIContent("Paste All Events To Selected Controller"), false, callback, 4);
menu.ShowAsContext();
}
GUILayout.FlexibleSpace();
if (GUILayout.Button("Add", GUILayout.Width(80))) {
MecanimEvent newEvent = new MecanimEvent();
newEvent.normalizedTime = playbackTime;
newEvent.functionName = "MessageName";
newEvent.paramType = MecanimEventParamTypes.None;
displayEvents.Add(newEvent);
SortEvents();
SetActiveEvent(newEvent);
MecanimEventEditorPopup.Show(this, newEvent, GetConditionParameters());
}
if (GUILayout.Button("Del", GUILayout.Width(80))) {
DelEvent(targetEvent);
}
EditorGUI.BeginDisabledGroup(targetEvent == null);
if (GUILayout.Button("Copy", GUILayout.Width(80))) {
clipboard = new MecanimEvent(targetEvent);
}
EditorGUI.EndDisabledGroup();
EditorGUI.BeginDisabledGroup(clipboard == null);
if (GUILayout.Button("Paste", GUILayout.Width(80))) {
MecanimEvent newEvent = new MecanimEvent(clipboard);
displayEvents.Add(newEvent);
SortEvents();
SetActiveEvent(newEvent);
}
EditorGUI.EndDisabledGroup();
EditorGUI.BeginDisabledGroup(targetEvent == null);
if (GUILayout.Button("Edit", GUILayout.Width(80))) {
MecanimEventEditorPopup.Show(this, targetEvent, GetConditionParameters());
}
EditorGUI.EndDisabledGroup();
if (GUILayout.Button("Save", GUILayout.Width(80))) {
eventInspector.SaveData();
}
if (GUILayout.Button("Close", GUILayout.Width(80))) {
Close();
}
}
GUILayout.EndHorizontal();
}
GUILayout.EndVertical();
if (enableTempPreview) {
eventInspector.SetPlaybackTime(tempPreviewPlaybackTime);
eventInspector.StopPlaying();
}
else {
eventInspector.SetPlaybackTime(playbackTime);
}
SaveState();
}
void DrawControllerPanel() {
GUILayout.BeginVertical(GUILayout.Width(200));
// controller to add field.
GUILayout.BeginHorizontal(); {
controllerToAdd = EditorGUILayout.ObjectField(controllerToAdd, typeof(AnimatorController), false) as AnimatorController;
EditorGUI.BeginDisabledGroup(controllerToAdd == null);
if (GUILayout.Button("Add", GUILayout.ExpandWidth(true), GUILayout.Height(16))) {
eventInspector.AddController(controllerToAdd);
}
EditorGUI.EndDisabledGroup();
//GUILayout.Button("Del", EditorStyles.toolbarButton, GUILayout.Width(38), GUILayout.Height(16));
GUILayout.Space(4);
}
GUILayout.EndHorizontal();
// controller list
GUILayout.BeginVertical("Box");
controllerPanelScrollPos = GUILayout.BeginScrollView(controllerPanelScrollPos);
AnimatorController[] controllers = eventInspector.GetControllers();
string [] controllerNames = new string[controllers.Length];
for (int i = 0; i < controllers.Length; i++) {
controllerNames[i] = controllers[i].name;
}
selectedController = GUILayout.SelectionGrid(selectedController, controllerNames, 1);
if (selectedController >= 0 && selectedController < controllers.Length) {
targetController = controllers[selectedController];
eventInspector.SaveLastEditController(targetController);
}
else {
targetController = null;
targetStateMachine = null;
targetState = null;
targetEvent = null;
}
GUILayout.EndScrollView();
GUILayout.EndVertical();
GUILayout.EndVertical();
}
void OnGUI() {
EditorGUI.BeginDisabledGroup(!eventTemp.isEnable); {
EditorGUILayout.BeginHorizontal();
eventTemp.normalizedTime = Mathf.Clamp(EditorGUILayout.FloatField("Normalized Time", eventTemp.normalizedTime), 0.0f, 1.0f);
if (GUILayout.Button("Current", GUILayout.MaxWidth(60))) {
eventTemp.normalizedTime = editor.PlaybackTime;
}
EditorGUILayout.EndHorizontal();
eventTemp.functionName = EditorGUILayout.TextField("Message", eventTemp.functionName);
eventTemp.paramType = (MecanimEventParamTypes)EditorGUILayout.EnumPopup("Parameter Type", eventTemp.paramType);
switch(eventTemp.paramType) {
case MecanimEventParamTypes.Int32:
eventTemp.intParam = EditorGUILayout.IntField("Parameter", eventTemp.intParam);
break;
case MecanimEventParamTypes.Float:
eventTemp.floatParam = EditorGUILayout.FloatField("Parameter", eventTemp.floatParam);
break;
case MecanimEventParamTypes.String:
eventTemp.stringParam = EditorGUILayout.TextField("Parameter", eventTemp.stringParam);
break;
case MecanimEventParamTypes.Boolean:
eventTemp.boolParam = EditorGUILayout.Popup(new GUIContent("Parameter"), eventTemp.boolParam == true ? 1 : 0, booleanPopup) == 1 ? true : false;
break;
}
GUIContent toggleLabel = new GUIContent("Critical", "A critical event won't be missed even state was interrupted.");
eventTemp.critical = EditorGUILayout.Toggle(toggleLabel, eventTemp.critical);
if (availableParameters.Length > 0)
conditionList.DoLayoutList();
else
eventTemp.condition.conditions.Clear();
GUILayout.Space(10);
GUILayout.FlexibleSpace();
}
EditorGUI.EndDisabledGroup();
GUILayout.BeginHorizontal();
if (GUILayout.Button("Copy", GUILayout.MinWidth(60))) {
MecanimEventEditor.clipboard = new MecanimEvent(eventTemp);
}
EditorGUI.BeginDisabledGroup(MecanimEventEditor.clipboard == null);
if (GUILayout.Button("Paste", GUILayout.MinWidth(60))) {
eventTemp = new MecanimEvent(MecanimEventEditor.clipboard);
}
EditorGUI.EndDisabledGroup();
if (GUILayout.Button(eventTemp.isEnable?"Disable":"Enable")) {
eventTemp.isEnable = !eventTemp.isEnable;
}
GUILayout.FlexibleSpace();
GUILayout.Space(20);
if (GUILayout.Button("Save", GUILayout.MinWidth(80))) {
eventEditing.normalizedTime = eventTemp.normalizedTime;
eventEditing.functionName = eventTemp.functionName;
eventEditing.paramType = eventTemp.paramType;
eventEditing.intParam = eventTemp.intParam;
eventEditing.floatParam = eventTemp.floatParam;
eventEditing.stringParam = eventTemp.stringParam;
eventEditing.boolParam = eventTemp.boolParam;
eventEditing.condition = eventTemp.condition;
eventEditing.critical = eventTemp.critical;
eventEditing.isEnable = eventTemp.isEnable;
Close();
}
// GUILayout.Space(20);
//
// if (GUILayout.Button("Delete", GUILayout.MinWidth(80))) {
// editor.DelEvent(eventEditing);
// Close();
// }
GUILayout.Space(20);
if (GUILayout.Button("Cancel", GUILayout.MinWidth(80))) {
Close();
}
GUILayout.Space(20);
GUILayout.EndHorizontal();
GUILayout.Space(10);
}
private void OnGUI()
{
EditorGUI.BeginDisabledGroup(!eventTemp.isEnable);
{
EditorGUILayout.BeginHorizontal();
eventTemp.normalizedTime =
Mathf.Clamp(EditorGUILayout.FloatField("Normalized Time", eventTemp.normalizedTime), 0.0f, 1.0f);
if (GUILayout.Button("Current", GUILayout.MaxWidth(60)))
{
eventTemp.normalizedTime = editor.PlaybackTime;
}
EditorGUILayout.EndHorizontal();
eventTemp.functionName = EditorGUILayout.TextField("Message", eventTemp.functionName);
eventTemp.paramType =
(MecanimEventParamTypes)EditorGUILayout.EnumPopup("Parameter Type", eventTemp.paramType);
switch (eventTemp.paramType)
{
case MecanimEventParamTypes.Int32:
eventTemp.intParam = EditorGUILayout.IntField("Parameter", eventTemp.intParam);
break;
case MecanimEventParamTypes.Float:
eventTemp.floatParam = EditorGUILayout.FloatField("Parameter", eventTemp.floatParam);
break;
case MecanimEventParamTypes.String:
eventTemp.stringParam = EditorGUILayout.TextField("Parameter", eventTemp.stringParam);
break;
case MecanimEventParamTypes.Boolean:
eventTemp.boolParam =
EditorGUILayout.Popup(new GUIContent("Parameter"), eventTemp.boolParam ? 1 : 0, booleanPopup) ==
1
? true
: false;
break;
}
var toggleLabel =
new GUIContent("Critical", "A critical event won't be missed even state was interrupted.");
eventTemp.critical = EditorGUILayout.Toggle(toggleLabel, eventTemp.critical);
if (availableParameters.Length > 0)
{
conditionList.DoLayoutList();
}
else
{
eventTemp.condition.conditions.Clear();
}
GUILayout.Space(10);
GUILayout.FlexibleSpace();
}
EditorGUI.EndDisabledGroup();
GUILayout.BeginHorizontal();
if (GUILayout.Button("Copy", GUILayout.MinWidth(60)))
{
MecanimEventEditor.clipboard = new MecanimEvent(eventTemp);
}
EditorGUI.BeginDisabledGroup(MecanimEventEditor.clipboard == null);
if (GUILayout.Button("Paste", GUILayout.MinWidth(60)))
{
eventTemp = new MecanimEvent(MecanimEventEditor.clipboard);
}
EditorGUI.EndDisabledGroup();
if (GUILayout.Button(eventTemp.isEnable ? "Disable" : "Enable"))
{
eventTemp.isEnable = !eventTemp.isEnable;
}
GUILayout.FlexibleSpace();
GUILayout.Space(20);
if (GUILayout.Button("Save", GUILayout.MinWidth(80)))
{
eventEditing.normalizedTime = eventTemp.normalizedTime;
eventEditing.functionName = eventTemp.functionName;
eventEditing.paramType = eventTemp.paramType;
eventEditing.intParam = eventTemp.intParam;
eventEditing.floatParam = eventTemp.floatParam;
eventEditing.stringParam = eventTemp.stringParam;
eventEditing.boolParam = eventTemp.boolParam;
eventEditing.condition = eventTemp.condition;
eventEditing.critical = eventTemp.critical;
eventEditing.isEnable = eventTemp.isEnable;
Close();
}
// GUILayout.Space(20);
//
// if (GUILayout.Button("Delete", GUILayout.MinWidth(80))) {
// editor.DelEvent(eventEditing);
// Close();
// }
GUILayout.Space(20);
if (GUILayout.Button("Cancel", GUILayout.MinWidth(80)))
{
Close();
}
GUILayout.Space(20);
GUILayout.EndHorizontal();
GUILayout.Space(10);
}
public static void PoolEvent(MecanimEvent me)
{
me.Reset();
me.GetContext().Reset();
MecanimEventManager.pooledEvents.Push(me);
}
public MecanimEvent(MecanimEvent other)
{
this.Copy(other);
}
void DrawLayerPanel() {
GUILayout.BeginVertical(GUILayout.Width(200));
if (targetController != null) {
int layerCount = targetController.layers.Length;
GUILayout.Label(layerCount + " layer(s) in selected controller");
if (Event.current.type == EventType.Layout || layers == null) {
layers = targetController.layers;
}
GUILayout.BeginVertical("Box");
layerPanelScrollPos = GUILayout.BeginScrollView(layerPanelScrollPos);
string[] layerNames = new string[layerCount];
for (int layer = 0; layer < layerCount; layer++) {
layerNames[layer] = "[" + layer.ToString() + "]" + layers[layer].name;
}
selectedLayer = GUILayout.SelectionGrid(selectedLayer, layerNames, 1);
if (selectedLayer >= 0 && selectedLayer < layerCount) {
if (layers[selectedLayer].syncedLayerIndex != -1)
{
targetStateMachine = layers[layers[selectedLayer].syncedLayerIndex].stateMachine;
}
else
{
targetStateMachine = layers[selectedLayer].stateMachine;
}
}
else {
targetStateMachine = null;
targetState = null;
targetEvent = null;
}
GUILayout.EndScrollView();
GUILayout.EndVertical();
}
else {
GUILayout.Label("No layer available.");
}
GUILayout.EndVertical();
}
public void HandleMecAnimEvent(MecanimEvent animEvent)
{
CurrentAnimState.HandlemAnimatorEvent(animEvent);
}
void DrawStatePanel() {
GUILayout.BeginVertical(GUILayout.Width(200));
if (targetStateMachine != null) {
List<AnimatorState> availableStates = GetStatesRecursive(targetStateMachine);
List<string> stateNames = new List<string>();
foreach (AnimatorState s in availableStates) {
stateNames.Add(s.name);
}
GUILayout.Label(availableStates.Count + " state(s) in selected layer.");
GUILayout.BeginVertical("Box");
statePanelScrollPos = GUILayout.BeginScrollView(statePanelScrollPos);
selectedState = GUILayout.SelectionGrid(selectedState, stateNames.ToArray(), 1);
if (selectedState >= 0 && selectedState < availableStates.Count) {
targetState = availableStates[selectedState];
}
else {
targetState = null;
targetEvent = null;
}
GUILayout.EndScrollView();
GUILayout.EndVertical();
}
else {
GUILayout.Label("No state machine available.");
}
GUILayout.EndVertical();
}
