public static void Duplicate(InAudioNode audioNode)
{
InUndoHelper.DoInGroup(() =>
{
List <Object> toUndo = new List <Object>();
toUndo.Add(audioNode._parent);
toUndo.AddRange(audioNode._parent.GetAuxData());
InUndoHelper.RecordObjectFull(toUndo.ToArray(), "Undo Duplication Of " + audioNode.Name);
if (audioNode._parent._type == AudioNodeType.Random)
{
(audioNode._parent._nodeData as RandomData).weights.Add(50);
}
NodeWorker.DuplicateHierarchy(audioNode, (@oldNode, newNode) =>
{
var gameObject = audioNode.gameObject;
if (oldNode._nodeData != null)
{
NodeDuplicate(oldNode, newNode, gameObject);
}
});
});
}
private void genericPlaceHere(T p, T n)
{
InUndoHelper.DoInGroup(() =>
{
InUndoHelper.RecordObjects("Location", p, p._getParent, n, n._getParent);
DeattachFromParent(n);
if (p._getChildren.Any() && p.IsFoldedOut)
{
AssignNewParent(p, n, 0);
}
else if (n._getParent == p._getParent)
{
var index = p._getParent._getChildren.IndexOf(p);
AssignNewParent(p._getParent, n, index + 1);
}
else
{
if (!p.IsRoot)
{
int newIndex = p._getParent._getChildren.IndexOf(p) + 1;
AssignNewParent(p._getParent, n, newIndex);
}
else
{
int newIndex = p._getChildren.IndexOf(p) + 1;
AssignNewParent(p, n, newIndex);
}
}
});
}
public static bool OnDrop(InAudioEventNode audioevent, Object[] objects)
{
InUndoHelper.DoInGroup(() =>
{
//if (audioevent.Type == EventNodeType.Folder)
//{
// UndoHelper.RecordObjectInOld(audioevent, "Created event");
// audioevent = CreateNode(audioevent, EventNodeType.Event);
//}
if (objects[0] as InAudioEventNode)
{
var movingEvent = objects[0] as InAudioEventNode;
if (movingEvent.gameObject != audioevent.gameObject)
{
if (EditorUtility.DisplayDialog("Move?",
"Warning, this will break all external references to this and all child nodes!\n" +
"Move node from\"" + movingEvent.gameObject.name +
"\" to \"" + audioevent.gameObject.name + "\"?", "Ok", "Cancel"))
{
InUndoHelper.DoInGroup(() =>
{
CopyTo(movingEvent, audioevent);
DeleteNodeNoGroup(movingEvent);
});
}
}
else
{
InUndoHelper.RecordObjectFull(new Object[] { audioevent, movingEvent, movingEvent._parent }, "Event Move");
NodeWorker.ReasignNodeParent(movingEvent, audioevent);
audioevent.EditorSettings.IsFoldedOut = true;
}
}
var audioNode = objects[0] as InAudioNode;
if (audioNode != null && audioNode.IsPlayable)
{
InUndoHelper.RecordObjectFull(audioevent, "Adding of Audio Action");
var action = AddEventAction <InEventAudioAction>(audioevent,
EventActionTypes.Play);
action.Node = audioNode;
}
var musicGroup = objects[0] as InMusicGroup;
if (musicGroup != null)
{
InUndoHelper.RecordObjectFull(audioevent, "Adding of Music Action");
var action = AddEventAction <InEventMusicControl>(audioevent,
EventActionTypes.PlayMusic);
action.MusicGroup = musicGroup;
}
Event.current.UseEvent();
});
return(true);
}
public static void DeleteFolder(InAudioBankLink toDelete)
{
InUndoHelper.DoInGroup(() =>
{
InUndoHelper.RecordObjectFull(toDelete._parent, "Delete Bank Folder");
toDelete._parent._getChildren.Remove(toDelete);
InUndoHelper.Destroy(toDelete);
});
}
public static void DeleteNode(InAudioEventNode node)
{
InUndoHelper.DoInGroup(() =>
{
InUndoHelper.RegisterUndo(node._parent, "Event Deletion");
node._parent._children.Remove(node);
DeleteNodeRec(node);
});
}
public static void DeleteBank(InAudioBankLink toDelete)
{
InUndoHelper.DoInGroup(() =>
{
InUndoHelper.RecordObject(InAudioInstanceFinder.DataManager.AudioTree.gameObject.GetComponents <MonoBehaviour>().Add(toDelete).Add(InAudioInstanceFinder.DataManager.MusicTree.gameObject.GetComponents <MonoBehaviour>()), "Bank detele");
toDelete._parent._getChildren.Remove(toDelete);
InUndoHelper.Destroy(toDelete);
});
}
private void CreateFolder(InMusicNode parent)
{
InUndoHelper.DoInGroup(() =>
{
InUndoHelper.RecordObjectFull(parent, "Create Music Folder");
parent.EditorSettings.IsFoldedOut = true;
MusicWorker.CreateFolder(parent.gameObject, parent);
});
}
private void CreateMusicGroup(InMusicNode parent)
{
InUndoHelper.DoInGroup(() =>
{
InUndoHelper.RecordObjectFull(parent, "Create Music Folder");
parent.FoldedOut = true;
MusicWorker.CreateMusicGroup(parent);
});
}
private void CreateChild(InAudioEventNode node, EventNodeType type)
{
InUndoHelper.DoInGroup(() =>
{
InUndoHelper.RegisterUndo(node, "Event Creation");
AudioEventWorker.CreateNode(node, type);
});
node.EditorSettings.IsFoldedOut = true;
}
private void CreateFolderInNewPrefab(InAudioEventNode parent)
{
InAudioWindowOpener.ShowNewDataWindow((gameObject =>
{
InUndoHelper.DoInGroup(() =>
{
var node = AudioEventWorker.CreateNode(parent, gameObject, EventNodeType.Folder);
node.Name += " (External)";
node.PlacedExternaly = true;
});
}));
isDirty = true;
}
public static void ConvertNodeType(InAudioNode node, AudioNodeType newType)
{
if (newType == node._type)
{
return;
}
InUndoHelper.DoInGroup(() =>
{
InUndoHelper.RecordObjectFull(new Object[] { node, node._nodeData }, "Change Node Type");
node._type = newType;
InUndoHelper.Destroy(node._nodeData);
AddDataClass(node);
});
}
private void CombineNodes(InSplineNode splineNode, InSplineNode[] conditioned)
{
InUndoHelper.DoInGroup(() => {
#if UNITY_4_1 || UNITY_4_2
Undo.RegisterSceneUndo("Combine nodes");
#else
UndoAll("Combine nodes");
#endif
HashSet <InSplineNode> periphery = new HashSet <InSplineNode>();
foreach (var node in conditioned)
{
var connected = node.SplineController.FindConnectedNodes(node);
for (int i = 0; i < connected.Length; i++)
{
var connectedTo = connected[i];
periphery.Add(connectedTo);
}
node.UnconnectAll();
}
foreach (var node in conditioned)
{
if (node != null)
{
InUndoHelper.Destroy(node.gameObject);
}
}
foreach (var node in periphery)
{
splineNode.ConnectTo(node);
}
var connections = splineNode.SplineController.Connections;
for (int i = 0; i < connections.Count; i++)
{
if (!connections[i].IsValid())
{
connections.SafeRemoveAt(ref i);
}
}
});
//Selection.activeGameObject = null;
Repaint();
}
public static void DeleteNode(InAudioNode node)
{
InUndoHelper.DoInGroup(() =>
{
InUndoHelper.RecordObjects("Undo Deletion of " + node.Name, node, node._nodeData, node._parent, node._parent._nodeData);
if (node._parent._type == AudioNodeType.Random) //We also need to remove the child from the weight list
{
var data = node._parent._nodeData as RandomData;
if (data != null)
{
data.weights.RemoveAt(node._parent._children.FindIndex(node)); //Find in parent, and then remove the weight in the random node
}
node._parent._children.Remove(node);
}
DeleteNodeRec(node);
});
}
private void DrawList(SerializedProperty arrayProp, SerializedProperty arrayPropSize,
Action <int> deleteAction = null)
{
if (arrayProp.isExpanded)
{
if (!arrayPropSize.hasMultipleDifferentValues)
{
for (int i = 0; i < arrayProp.arraySize; i++)
{
EditorGUILayout.BeginHorizontal();
GUI.enabled = false;
EditorGUILayout.PropertyField(arrayProp.GetArrayElementAtIndex(i));
GUI.enabled = true;
if (deleteAction != null)
{
if (GUILayout.Button("X", GUILayout.Width(20)))
{
int index = i;
InUndoHelper.DoInGroup(() =>
{
#if UNITY_4_1 || UNITY_4_2
Undo.RegisterSceneUndo("Delete element in spline");
#else
UndoAll("Delete element in spline");
#endif
deleteAction(index);
});
}
}
EditorGUILayout.EndHorizontal();
}
}
else
{
EditorGUILayout.HelpBox("Cannot show lists of different lengths.", MessageType.None);
}
}
}
public void ReceiveNode(InMusicGroup group)
{
if (SelectedNode != null)
{
InUndoHelper.DoInGroup(() =>
{
TreeWalker.ForEachParent(SelectedNode, n => n.EditorSettings.IsFoldedOut = true);
InUndoHelper.RecordObject(SelectedNode, "Send to Event");
if (SelectedNode.IsRootOrFolder)
{
var myEvent = AudioEventWorker.CreateNode(SelectedNode, EventNodeType.Event);
var myAction = AudioEventWorker.AddEventAction <InEventMusicControl>(myEvent, EventActionTypes.PlayMusic);
myAction.Target = group;
SelectedNode = myEvent;
treeDrawer.SelectedNode = myEvent;
}
else
{
var myAction = AudioEventWorker.AddEventAction <InEventMusicControl>(SelectedNode, EventActionTypes.PlayMusic);
myAction.Target = group;
}
});
}
}
private static void ChangeAction(InAudioEventNode audioEvent, AudioEventAction action, EventActionTypes newEnumType)
{
for (int i = 0; i < audioEvent._actionList.Count; ++i)
{
if (audioEvent._actionList[i] == action)
{
Type oldType = AudioEventAction.ActionEnumToType(action._eventActionType);
Type newType = AudioEventAction.ActionEnumToType(newEnumType);
if (oldType != newType)
{
InUndoHelper.DoInGroup(() => AudioEventWorker.ReplaceActionDestructiveAt(audioEvent, newEnumType, i));
}
else
{
InUndoHelper.RecordObject(action, "Change Event Action Type");
action._eventActionType = newEnumType;
}
break;
}
}
}
public void ReceiveNode(InAudioNode node)
{
if (SelectedNode != null)
{
InUndoHelper.DoInGroup(() =>
{
TreeWalker.ForEachParent(SelectedNode, n => n.FoldedOut = true);
InUndoHelper.RecordObject(SelectedNode, "Send to Event");
if (SelectedNode.IsRootOrFolder)
{
var myEvent = AudioEventWorker.CreateNode(SelectedNode, EventNodeType.Event);
var myAction = AudioEventWorker.AddEventAction <InEventAudioAction>(myEvent, EventActionTypes.Play);
myAction.Target = node;
SelectedNode = myEvent;
treeDrawer.SelectedNode = myEvent;
}
else
{
var myAction = AudioEventWorker.AddEventAction <InEventAudioAction>(SelectedNode, EventActionTypes.Play);
myAction.Target = node;
}
});
}
}
public override void OnInspectorGUI()
{
if (!InAudioInstanceFinder.IsValid)
{
EditorGUILayout.HelpBox("Please add the InAudio Manager to the scene", MessageType.Info);
if (GUILayout.Button("Add manager to scene"))
{
ErrorDrawer.AddManagerToScene();
}
}
serializedObject.Update();
EditorGUI.BeginChangeCheck();
if (serializedObject.FindProperty("SplineController").hasMultipleDifferentValues)
{
EditorGUILayout.HelpBox("Different spline controllers", MessageType.Warning);
return;
}
if (SplineNode.SplineController == null)
{
EditorGUILayout.HelpBox("Missing spline controller, please assign one", MessageType.Warning);
}
if (InAudioInstanceFinder.IsValid)
{
InAudioInstanceFinder.InAudioGuiUserPrefs.SelectedSplineController = SplineNode.SplineController;
}
bool add = GUILayout.Button("Add Node");
bool selectNew = false;
if (GUILayout.Button("Add and Select"))
{
add = true;
selectNew = true;
}
EditorGUILayout.Separator();
var objectField = EditorGUILayout.ObjectField("Controlling Spline", serializedObject.FindProperty("SplineController").objectReferenceValue, typeof(InSpline), true);
if (serializedObject.FindProperty("SplineController").objectReferenceValue == null)
{
serializedObject.FindProperty("SplineController").objectReferenceValue = objectField;
}
if (Selection.objects.Length == 1)
{
GUILayout.Button("Drag node here to connect");
OnDragging.DraggingObject <Object>(GUILayoutUtility.GetLastRect(), o =>
{
GameObject go = o as GameObject;
if (go != null)
{
var node = go.GetComponent <InSplineNode>();
if (node != SplineNode && !SplineNode.SplineController.ContainsConnection(SplineNode, node))
{
return(true);
}
}
return(false);
}, o =>
{
InUndoHelper.RecordObject(SplineNode.SplineController, "Connect nodes");
(o as GameObject).GetComponent <InSplineNode>().ConnectTo(SplineNode);
});
//var a = new SerializedObject(SplineNode.SplineController)
if (SplineNode.SplineController != null)
{
expandedConnections = EditorGUILayout.Foldout(expandedConnections, "Connected to");
for (int i = 0; i < SplineNode.SplineController.Connections.Count; i++)
{
EditorGUILayout.BeginHorizontal();
GUI.enabled = false;
var conc = SplineNode.SplineController.Connections[i];
if (conc.NodeA == SplineNode)
{
EditorGUILayout.ObjectField(conc.NodeB, typeof(InSplineNode), true);
GUI.enabled = true;
if (GUILayout.Button("X", GUILayout.Width(20)))
{
InUndoHelper.RecordObject(SplineNode.SplineController, "Remove spline connection");
SplineNode.SplineController.RemoveConnections(conc);
}
EditorUtility.SetDirty(SplineNode.SplineController);
}
else if (conc.NodeB == SplineNode)
{
EditorGUILayout.ObjectField(conc.NodeA, typeof(InSplineNode), true);
GUI.enabled = true;
if (GUILayout.Button("X", GUILayout.Width(20)))
{
InUndoHelper.RecordObject(SplineNode.SplineController, "Remove spline connection");
SplineNode.SplineController.RemoveConnections(conc);
}
EditorUtility.SetDirty(SplineNode.SplineController);
}
EditorGUILayout.EndHorizontal();
}
}
}
EditorGUILayout.Separator();
bool delete = true;
if (GUILayout.Button("Delete"))
{
InUndoHelper.DoInGroup(() =>
{
#if UNITY_4_1 || UNITY_4_2
Undo.RegisterSceneUndo("Combine nodes");
#else
UndoAll("Delete node");
#endif
foreach (var gameObject in Selection.gameObjects)
{
InUndoHelper.Destroy(gameObject);
}
delete = true;
});
}
if (add)
{
InUndoHelper.DoInGroup(() =>
{
#if UNITY_4_1 || UNITY_4_2
Undo.RegisterSceneUndo("Delete element in spline");
#else
UndoAll("Add new spline node");
#endif
GameObject go = InUndoHelper.CreateGO(SplineNode.SplineController.gameObject.name + " Node");
go.transform.parent = SplineNode.SplineController.transform;
go.transform.position = SplineNode.transform.position + SplineNode.transform.forward;
go.transform.position = SplineNode.transform.position;
var newNode = go.AddComponent <InSplineNode>();
newNode.SplineController = SplineNode.SplineController;
newNode.ConnectTo(SplineNode);
SplineNode.SplineController.Nodes.Add(newNode);
if (selectNew)
{
Selection.activeGameObject = go;
}
});
}
if (EditorGUI.EndChangeCheck() && delete == false)
{
serializedObject.ApplyModifiedProperties();
}
}
protected override void OnDrop(InMusicNode newParent, UnityEngine.Object[] objects)
{
if (newParent == null || objects == null)
{
return;
}
var dragged = objects[0] as InMusicNode;
if (dragged != null)
{
if (dragged.IsRoot || dragged == newParent)
{
return;
}
InUndoHelper.DoInGroup(() =>
{
if (dragged.gameObject != newParent.gameObject)
{
if (EditorUtility.DisplayDialog("Move?",
"Warning, this will break all external references to this and all child nodes!\n" +
"Move node from\"" + dragged.gameObject.name +
"\" to \"" + newParent.gameObject.name + "\"?", "Ok", "Cancel"))
{
treeDrawer.SelectedNode = TreeWalker.GetPreviousVisibleNode(treeDrawer.SelectedNode);
MusicWorker.Duplicate(newParent.gameObject, dragged, newParent);
DeleteNodeRec(dragged);
AudioBankWorker.RebuildBanks();
}
}
else
{
var oldParent = dragged._parent;
InUndoHelper.RecordObjects("Music drag-n-drop", dragged, oldParent, newParent);
dragged.MoveToNewParent(newParent);
newParent.IsFoldedOut = true;
}
Event.current.UseEvent();
});
}
else if (newParent._type == MusicNodeType.Music)
{
var clips = objects.Convert(o => o as AudioClip).TakeNonNulls();
var musicGroup = newParent as InMusicGroup;
if (musicGroup != null)
{
InUndoHelper.DoInGroup(() =>
{
InUndoHelper.RecordObject(newParent, "Music Clip Add");
foreach (var audioClip in clips)
{
musicGroup._clips.Add(audioClip);
}
});
}
}
}
private void DeleteNode(InMusicNode toDelete)
{
InUndoHelper.DoInGroup(() => DeleteNodeRec(toDelete));
}
protected override void OnDrop(InAudioNode node, UnityEngine.Object[] objects)
{
if (objects[0] as InAudioNode != null) //Drag N Drop internally in the tree, change the parent
{
InUndoHelper.DoInGroup(() =>
{
node.IsFoldedOut = true;
var nodeToMove = objects[0] as InAudioNode;
if (node.gameObject != nodeToMove.gameObject)
{
if (EditorUtility.DisplayDialog("Move?",
"Warning, this will break all external references to this and all child nodes!\n" +
"Move node from\"" + nodeToMove.gameObject.name +
"\" to \"" + node.gameObject.name + "\"?", "Ok", "Cancel"))
{
treeDrawer.SelectedNode = treeDrawer.SelectedNode._getParent;
isDirty = false;
AudioNodeWorker.CopyTo(nodeToMove, node);
AudioNodeWorker.DeleteNodeNoGroup(nodeToMove);
}
}
else
{
MoveNode(node, nodeToMove);
}
});
}
else if (node._type != AudioNodeType.Audio) //Create new audio nodes when we drop clips
{
InUndoHelper.DoInGroup(() =>
{
InUndoHelper.RecordObject(InUndoHelper.NodeUndo(node), "Adding Nodes to " + node.Name);
AudioClip[] clips = objects.Convert(o => o as AudioClip);
Array.Sort(clips, (clip, audioClip) => StringLogicalComparer.Compare(clip.name, audioClip.name));
for (int i = 0; i < clips.Length; ++i)
{
var clip = clips[i];
var child = AudioNodeWorker.CreateChild(node, AudioNodeType.Audio);
var path = AssetDatabase.GetAssetPath(clip);
try
{
//Try and get the name of the clip. Gets the name and removes the end. Assets/IntroSound.mp3 -> IntroSound
int lastIndex = path.LastIndexOf('/') + 1;
child.Name = path.Substring(lastIndex, path.LastIndexOf('.') - lastIndex);
}
catch (Exception)
//If it happens to be a mutant path. Not even sure if this is possible, but better safe than sorry
{
child.Name = node.Name + " Child";
}
var audioData = (child._nodeData as InAudioData);
audioData._clip = clip;
AudioBankWorker.AddNodeToBank(child);
Event.current.UseEvent();
}
});
}
else //Then it must be an audio clip dropped on an audio node, so assign the clip to that node
{
InUndoHelper.DoInGroup(() =>
{
var nodeData = (node._nodeData as InAudioData);
if (nodeData != null)
{
InUndoHelper.RecordObject(InUndoHelper.NodeUndo(node), "Change Audio Clip In " + node.Name);
nodeData._clip = objects[0] as AudioClip;
}
});
Event.current.UseEvent();
}
}
public override void OnInspectorGUI()
{
if (!InAudioInstanceFinder.IsValid)
{
EditorGUILayout.HelpBox("Please add the InAudio Manager to the scene", MessageType.Info);
if (GUILayout.Button("Add manager to scene"))
{
ErrorDrawer.AddManagerToScene();
}
}
serializedObject.Update();
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(serializedObject.FindProperty("SplineAudioEvent"));
EditorGUILayout.Separator();
bool add = GUILayout.Button("Add Node");
bool selectNew = false;
if (GUILayout.Button("Add and Select"))
{
add = true;
selectNew = true;
}
var nodeArray = serializedObject.FindProperty("Nodes");
var nodeArraySize = nodeArray.FindPropertyRelative("Array.size");
var connectionArray = serializedObject.FindProperty("Connections");
var connectionArraySize = connectionArray.FindPropertyRelative("Array.size");
nodeArray.isExpanded = EditorGUILayout.Foldout(nodeArray.isExpanded, "Nodes");
DrawList(nodeArray, nodeArraySize, i =>
{
var node = nodeArray.GetArrayElementAtIndex(i).objectReferenceValue as InSplineNode;
nodeArray.DeleteArrayElementAtIndex(i);
nodeArray.DeleteArrayElementAtIndex(i);
for (int j = 0; j < connectionArray.arraySize; j++)
{
var prop = connectionArray.GetArrayElementAtIndex(j);
if (prop.FindPropertyRelative("NodeA").objectReferenceValue == node ||
prop.FindPropertyRelative("NodeB").objectReferenceValue == node)
{
connectionArray.DeleteArrayElementAtIndex(j);
--j;
}
}
if (node != null)
{
InUndoHelper.Destroy(node.gameObject);
}
});
connectionArray.isExpanded = EditorGUILayout.Foldout(connectionArray.isExpanded, "Connections");
DrawList(connectionArray, connectionArraySize, connectionArray.DeleteArrayElementAtIndex);
if (add)
{
InUndoHelper.DoInGroup(() =>
{
UndoAll("Add new spline node");
GameObject newNodeGO = InUndoHelper.CreateGO(SplineController.gameObject.name + " Node");
var newNode = newNodeGO.AddComponent <InSplineNode>();
newNodeGO.transform.position = SplineController.transform.position;
newNode.SplineController = SplineController;
newNodeGO.transform.parent = SplineController.transform;
newNodeGO.transform.position = SplineController.transform.position +
SplineController.transform.forward;
int count = SplineController.Nodes.Count;
if (count > 0)
{
SplineController.Nodes[0].ConnectTo(newNode);
}
SplineController.Nodes.Add(newNode);
if (selectNew)
{
Selection.activeGameObject = newNodeGO;
}
});
}
if (EditorGUI.EndChangeCheck())
{
serializedObject.ApplyModifiedProperties();
}
}
public static bool Draw(InAudioEventNode audioevent)
{
if (ListAdapter == null)
{
ListAdapter = new EventActionListAdapter();
ListAdapter.DrawEvent = DrawItem;
ListAdapter.ClickedInArea = ClickedInArea;
}
if (lastEvent != audioevent)
{
ListAdapter.Event = audioevent;
audioEventAction = null;
if (audioevent._actionList.Count > 0)
{
audioEventAction = audioevent._actionList[0];
}
}
EditorGUILayout.BeginVertical();
lastEvent = audioevent;
InUndoHelper.GUIUndo(audioevent, "Name Change", ref audioevent.Name, () =>
EditorGUILayout.TextField("Name", audioevent.Name));
bool repaint = false;
if (audioevent._type == EventNodeType.Event)
{
EditorGUIHelper.DrawID(audioevent._guid);
if (Application.isPlaying)
{
eventObjectTarget = EditorGUILayout.ObjectField("Event preview target", eventObjectTarget, typeof(GameObject), true) as GameObject;
if (eventObjectTarget != null)
{
bool prefab = PrefabUtility.GetPrefabParent(eventObjectTarget) == null && PrefabUtility.GetPrefabObject(eventObjectTarget) != null;
if (!prefab)
{
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("Post event"))
{
InAudio.PostEvent(eventObjectTarget, audioevent);
}
if (GUILayout.Button("Stop All Sounds/Music in Event"))
{
InAudio.StopAll(eventObjectTarget);
foreach (var eventAction in audioevent._actionList)
{
var music = eventAction.Target as InMusicGroup;
if (music != null)
{
InAudio.Music.Stop(music);
}
}
}
EditorGUILayout.EndHorizontal();
}
else
{
EditorGUILayout.HelpBox("Cannot post events on Prefab", MessageType.Error);
}
}
EditorGUILayout.Separator();
}
InUndoHelper.GUIUndo(audioevent, "Delay", ref audioevent.Delay, () =>
Mathf.Max(EditorGUILayout.FloatField("Delay", audioevent.Delay), 0));
NewEventArea(audioevent);
EditorGUILayout.Separator();
EditorGUILayout.Separator();
scrollPos = EditorGUILayout.BeginScrollView(scrollPos);
repaint = DrawContent();
EditorGUILayout.EndScrollView();
DrawSelected(audioEventAction);
}
else if (audioevent._type == EventNodeType.Folder)
{
if (audioevent.PlacedExternaly)
{
EditorGUILayout.Separator();
GUI.enabled = false;
EditorGUILayout.ObjectField("Placed on", audioevent.gameObject, typeof(GameObject), false);
GUI.enabled = true;
EditorGUILayout.Separator();
}
}
EditorGUILayout.EndVertical();
if (toRemove != null)
{
InUndoHelper.DoInGroup(() =>
{
//Remove the required piece
int index = audioevent._actionList.FindIndex(toRemove);
AudioEventWorker.DeleteActionAtIndex(audioevent, index);
});
toRemove = null;
}
else //Remove all actions that does not excist.
{
audioevent._actionList.RemoveAll(p => p == null);
}
return(repaint);
}
