public static void MoveNodeOneUp <T>(T node) where T : Object, InITreeNode <T>
{
if (node is InAudioNode)//As parent could be a random one, it needs to record this first
{
InUndoHelper.RecordObject(new Object[] { node._getParent, (node._getParent as InAudioNode)._nodeData },
"Undo Reorder Of " + node.GetName);
}
else
{
InUndoHelper.RecordObject(new Object[] { node._getParent }, "Undo Reorder Of " + node.GetName);
}
var children = node._getParent._getChildren;
var index = children.IndexOf(node);
if (index != 0 && children.Count > 0)
{
//TODO Remove hack
if (node.GetType() == typeof(InAudioNode))
{
var audioNode = node as InAudioNode;
if (audioNode._parent._type == AudioNodeType.Random)
{
(audioNode._parent._nodeData as RandomData).weights.SwapAtIndexes(index, index - 1);
}
}
children.SwapAtIndexes(index, index - 1);
}
}
public static void ChangeBankOverride(InMusicFolder node)
{
var all = GetAllBanks();
InUndoHelper.RecordObject(all.ToArray().AddObj(node), "Changed Bank");
node._overrideParentBank = !node._overrideParentBank;
RebuildBanks();
}
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);
});
}
public static void ChangeAudioNodeBank(InAudioNode node, InAudioBankLink newBank)
{
var all = GetAllBanks();
InUndoHelper.RecordObject(all.ToArray().AddObj(node._nodeData), "Changed Bank");
InFolderData data = (node._nodeData as InFolderData);
data.BankLink = newBank;
RebuildBanks();
}
public static AudioEventAction AddEventAction(InAudioEventNode audioevent, Type eventActionType, EventActionTypes enumType)
{
InUndoHelper.RecordObject(audioevent, "Event Action Creation");
var eventAction = audioevent.gameObject.AddComponentUndo(eventActionType) as AudioEventAction;
audioevent._actionList.Add(eventAction);
eventAction._eventActionType = enumType;
return(eventAction);
}
public static void ChangeBankOverride(InAudioNode node)
{
var all = GetAllBanks();
InUndoHelper.RecordObject(all.ToArray().AddObj(node._nodeData), "Changed Bank");
InFolderData data = (node._nodeData as InFolderData);
data.OverrideParentBank = !data.OverrideParentBank;
RebuildBanks();
}
public static InAudioEventNode DeleteActionAtIndex(InAudioEventNode audioevent, int index)
{
InUndoHelper.RecordObject(audioevent, "Event Action Creation");
InUndoHelper.Destroy(audioevent._actionList[index]);
audioevent._actionList.RemoveAt(index);
return(audioevent);
}
private static void MoveNode(InAudioNode node, InAudioNode nodeToMove)
{
InUndoHelper.RecordObject(
new UnityEngine.Object[]
{ node, node._nodeData, node._parent, node._parent != null ? node._parent._nodeData : null, nodeToMove._parent._nodeData, nodeToMove, nodeToMove._parent, nodeToMove._parent._nodeData }.AddObj(),
"Audio Node Move");
NodeWorker.ReasignNodeParent(nodeToMove, node);
Event.current.UseEvent();
}
public static void ChangeMusicNodeBank(InMusicNode node, InAudioBankLink newBank)
{
var all = GetAllBanks();
InUndoHelper.RecordObject(all.ToArray().AddObj(node), "Changed Bank");
InMusicFolder data = (node as InMusicFolder);
data._bankLink = newBank;
RebuildBanks();
}
private void AssignNewParent(InAudioNode newParent, InAudioNode node, int index)
{
if (newParent._type == AudioNodeType.Random)
{
var randomData = newParent._nodeData as RandomData;
InUndoHelper.RecordObject(randomData, "Random weights");
randomData.weights.Insert(index, 50);
}
newParent._children.Insert(index, node);
node._parent = newParent;
}
private static InAudioEventNode CreateEvent(GameObject go, InAudioEventNode parent, int guid, EventNodeType type)
{
var node = go.AddComponentUndo <InAudioEventNode>();
node._type = type;
node._guid = guid;
node.Name = parent.Name + " Child";
InUndoHelper.RecordObject(parent, "Parrent asign");
node.AssignParent(parent);
return(node);
}
public static InAudioNode CreateChild(GameObject go, InAudioNode parent, AudioNodeType newNodeType)
{
InUndoHelper.RecordObject(InUndoHelper.Array(parent).Concat(parent.GetAuxData()).ToArray(), "Undo Node Creation");
OnRandomNode(parent);
var child = CreateNode(go, parent, GUIDCreator.Create(), newNodeType);
parent.EditorSettings.IsFoldedOut = true;
child.Name = parent.Name + " Child";
AddDataClass(child);
return(child);
}
private static void HandleDragging(AudioEventAction currentAction, Rect dragArea)
{
if (currentAction != null)
{
if (currentAction is InEventAudioAction)
{
InAudioNode dragged = OnDragging.DraggingObject <InAudioNode>(dragArea, node => node.IsPlayable);
if (dragged != null)
{
InUndoHelper.RecordObject(currentAction, "Change Action Type");
currentAction.Target = dragged;
}
}
else if (currentAction is InEventBankLoadingAction)
{
InAudioBankLink dragged = OnDragging.DraggingObject <InAudioBankLink>(dragArea,
bank => bank._type == AudioBankTypes.Bank);
if (dragged != null)
{
InUndoHelper.RecordObject(currentAction, "Change Action Type");
currentAction.Target = dragged;
}
}
else if (currentAction is InEventMixerValueAction)
{
AudioMixer dragged = OnDragging.DraggingObject <AudioMixer>(dragArea);
if (dragged != null)
{
InUndoHelper.RecordObject(currentAction, "Change Action Type");
currentAction.Target = dragged;
}
}
else if (currentAction is InEventMusicControl || currentAction is InEventMusicFade || currentAction is InEventSoloMuteMusic)
{
InMusicGroup dragged = OnDragging.DraggingObject <InMusicGroup>(dragArea);
if (dragged != null)
{
InUndoHelper.RecordObject(currentAction, "Change Action Type");
currentAction.Target = dragged;
}
}
}
}
public static InAudioNode CreateChild(GameObject go, InAudioNode parent, AudioNodeType newNodeType)
{
var bank = parent.GetBank();
InUndoHelper.RecordObject(InUndoHelper.Array(parent, bank).Concat(parent.GetAuxData()).ToArray(), "Undo Node Creation");
OnRandomNode(parent);
var child = CreateNode(go, parent, GUIDCreator.Create(), newNodeType);
parent.FoldedOut = true;
child.Name = parent.Name + " Child";
var data = AddDataClass(child);
if (newNodeType == AudioNodeType.Folder)
{
(data as InFolderData).BankLink = parent.GetBank();
}
return(child);
}
public static void AddNewParent(InAudioNode node, AudioNodeType parentType)
{
InUndoHelper.RecordObject(new Object[] { node, node._parent }, "Undo Add New Parent for " + node.Name);
var newParent = CreateNode(node.gameObject, node._parent, parentType);
var oldParent = node._parent;
newParent.MixerGroup = node.MixerGroup;
newParent.EditorSettings.IsFoldedOut = true;
int index = oldParent._children.FindIndex(node);
NodeWorker.RemoveFromParent(node);
node.AssignParent(newParent);
OnRandomNode(newParent);
NodeWorker.RemoveFromParent(newParent);
oldParent._children.Insert(index, newParent);
}
public static void AddNewParent(InAudioNode node, AudioNodeType parentType)
{
InUndoHelper.RecordObject(new Object[] { node, node._parent, node.GetBank() }, "Undo Add New Parent for " + node.Name);
var newParent = CreateNode(node.gameObject, node._parent, parentType);
var oldParent = node._parent;
newParent.MixerGroup = node.MixerGroup;
newParent.FoldedOut = true;
if (node._type == AudioNodeType.Folder)
{
InFolderData data = (InFolderData)newParent._nodeData;
data.BankLink = oldParent.GetBank();
}
int index = oldParent._children.FindIndex(node);
NodeWorker.RemoveFromParent(node);
node.AssignParent(newParent);
OnRandomNode(newParent);
NodeWorker.RemoveFromParent(newParent);
oldParent._children.Insert(index, newParent);
}
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;
}
});
}
}
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);
}
});
}
}
}
public static void Draw(InMusicGroup node)
{
node.ScrollPosition = EditorGUILayout.BeginScrollView(node.ScrollPosition);
var prop = new SerializedObject(node);
prop.Update();
EditorGUILayout.PropertyField(prop.FindProperty("_name"));
if (!Application.isPlaying)
{
InUndoHelper.GUIUndo(node, "Volume", ref node._minVolume, () => EditorGUILayout.Slider("Initial Volume", node._minVolume, 0f, 1f));
}
else
{
InUndoHelper.GUIUndo(node, "Volume", ref node.runtimeVolume, () => EditorGUILayout.Slider("Current Volume", node.runtimeVolume, 0f, 1f));
}
if (!Application.isPlaying)
{
InUndoHelper.GUIUndo(node, "Pitch", ref node._minPitch, () => EditorGUILayout.Slider("Initial Pitch", node._minPitch, 0f, 3f));
}
else
{
InUndoHelper.GUIUndo(node, "Pitch", ref node.runtimePitch, () => EditorGUILayout.Slider("Current Pitch", node.runtimePitch, 0f, 3f));
}
EditorGUILayout.BeginHorizontal();
if (Application.isPlaying)
{
GUILayout.FlexibleSpace();
if (GUILayout.Button("Save volume & pitch"))
{
InUndoHelper.RecordObject(node, "Volume & Pitch for Music");
node._minVolume = node.runtimeVolume;
node._minPitch = node.runtimePitch;
Debug.Log("InAudio: Saved volume: " + node._minVolume + ", pitch: " + node._minPitch);
}
}
EditorGUILayout.EndHorizontal();
var playingInfo = node.PlayingInfo;
if (playingInfo.Fading && Application.isPlaying)
{
EditorGUILayout.Slider("Volume target", playingInfo.TargetVolume, 0f, 1f);
GUI.enabled = false;
var duration = playingInfo.EndTime - playingInfo.StartTime;
var left = playingInfo.EndTime - Time.time;
EditorGUILayout.Slider("Time elapsed", duration - left, 0, duration);
GUI.enabled = true;
}
EditorGUILayout.PropertyField(prop.FindProperty("_loop"));
EditorGUILayout.Separator();
DataDrawerHelper.DrawMixer(node, prop.FindProperty("_mixerGroup"));
EditorGUILayout.Separator();
prop.ApplyModifiedProperties();
if (!Application.isPlaying)
{
InUndoHelper.GUIUndo(node, "Mute", ref node._mute, () => EditorGUILayout.Toggle("Initial Mute", node._mute));
}
else
{
InUndoHelper.GUIUndo(node, "Mute", ref node.runtimeMute, () => EditorGUILayout.Toggle("Currently Mute", node.runtimeMute));
}
if (!Application.isPlaying)
{
InUndoHelper.GUIUndo(node, "Solo", ref node._solo, () => EditorGUILayout.Toggle("Initial Solo", node._solo));
}
else
{
InUndoHelper.GUIUndo(node, "Solo", ref node.runtimeSolo, () => EditorGUILayout.Toggle("Currently Solo", node.runtimeSolo));
}
EditorGUILayout.Separator();
prop.Update();
EditorGUILayout.LabelField("Clips in node");
if (Application.isPlaying)
{
ReorderableListGUI.ListField(prop.FindProperty("_clips"), ReorderableListFlags.DisableDuplicateCommand | ReorderableListFlags.DisableContextMenu | ReorderableListFlags.DisableReordering | ReorderableListFlags.HideRemoveButtons);
var rect = GUILayoutUtility.GetLastRect();
for (int i = 0; i < node._clips.Count; i++)
{
var progress = rect;
progress.height = 3;
progress.x += 5;
progress.width -= 30;
progress.y += i * 20 + 20;
//GUI.DrawTexture(progress, EditorResources.Background);
var item = node._clips[i];
var player = node.PlayingInfo.Players.Find(s => s.clip == item);
if (player != null)
{
EditorGUI.DrawRect(progress, Color.white);
float pos = (float)player.ExactPosition();
if (node.PlayingInfo.State == MusicState.Playing || node.PlayingInfo.State == MusicState.Paused)
{
progress.width = progress.width * Mathf.Clamp01(pos / item.length);
EditorGUI.DrawRect(progress, Color.green);
}
}
}
}
else
{
ReorderableListGUI.ListField(prop.FindProperty("_clips"), ReorderableListFlags.DisableDuplicateCommand);
}
prop.ApplyModifiedProperties();
EditorGUILayout.Separator();
if (node._children.Count > 0)
{
EditorGUILayout.LabelField("Child nodes");
ReorderableListGUI.ListField(node._children, (position, item) =>
{
EditorGUI.LabelField(position, item._name);
return(item);
},
ReorderableListFlags.DisableContextMenu | ReorderableListFlags.DisableReordering |
ReorderableListFlags.HideAddButton | ReorderableListFlags.HideRemoveButtons);
}
EditorGUILayout.EndScrollView();
}
//private static GameObject go;
public static void Draw(InAudioNode node)
{
if (Application.isPlaying)
{
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("Play Node"))
{
if (preview != null)
{
preview.Stop();
}
preview = InAudio.Play(InAudioInstanceFinder.Instance.gameObject, node);
preview.SpatialBlend = 0.0f;
preview.OnCompleted = (go, audioNode) => preview = null;
}
if (GUILayout.Button("Stop Playing Node") && preview != null)
{
InAudio.StopAll(InAudioInstanceFinder.Instance.gameObject);
}
if (GUILayout.Button("Stop All Instances"))
{
InAudio.StopAllOfNode(node);
}
EditorGUILayout.EndHorizontal();
}
InAudioNodeData baseData = (InAudioNodeData)node._nodeData;
EditorGUILayout.Separator();
DrawSelectedArea(node, baseData);
Seperators(2);
if (baseData.SelectedArea == 0)
{
EditorGUIHelper.DrawID(node._guid);
#region Volume
DataDrawerHelper.DrawVolume(baseData, ref baseData.MinVolume, ref baseData.MaxVolume, ref baseData.RandomVolume);
#endregion
Seperators(2);
#region Parent pitch
SetPitch(baseData);
#endregion
Seperators(2);
#region Spatial blend
SetSpatialBlend(baseData);
#endregion
Seperators(2);
#region Delay
GUILayout.BeginHorizontal();
GUILayout.BeginVertical();
InUndoHelper.GUIUndo(baseData, "Randomize Delay", ref baseData.RandomizeDelay, () =>
EditorGUILayout.Toggle("Randomize Delay", baseData.RandomizeDelay));
if (baseData.RandomizeDelay)
{
InUndoHelper.GUIUndo(baseData, "Delay Change", ref baseData.InitialDelayMin, ref baseData.InitialDelayMax,
(out float v1, out float v2) =>
{
v1 = Mathf.Clamp(EditorGUILayout.FloatField("Min delay", baseData.InitialDelayMin), 0, baseData.InitialDelayMax);
v2 = Mathf.Clamp(EditorGUILayout.FloatField("Max delay", baseData.InitialDelayMax), baseData.InitialDelayMin, float.MaxValue);
});
}
else
{
InUndoHelper.GUIUndo(baseData, "Delay", ref baseData.InitialDelayMin, () =>
{
float delay = Mathf.Max(EditorGUILayout.FloatField("Initial delay", baseData.InitialDelayMin), 0);
if (delay > baseData.InitialDelayMax)
{
baseData.InitialDelayMax = baseData.InitialDelayMin + 0.001f;
}
return(delay);
});
}
GUILayout.EndVertical();
GUILayout.BeginVertical();
GUILayout.EndVertical();
GUILayout.EndHorizontal();
#endregion
Seperators(2);
#region Audio bus
DataDrawerHelper.DrawMixer(node);
#endregion
Seperators(2);
#region Loops
GUI.enabled = true;
GUILayout.BeginVertical();
InUndoHelper.GUIUndo(baseData, "Use looping", ref baseData.Loop, () => EditorGUILayout.Toggle("Loop", baseData.Loop));
if (baseData.Loop)
{
GUI.enabled = baseData.Loop;
InUndoHelper.GUIUndo(baseData, "Loop Infinite", ref baseData.LoopInfinite,
() => EditorGUILayout.Toggle("Loop Infinite", baseData.LoopInfinite));
if (baseData.Loop)
{
GUI.enabled = !baseData.LoopInfinite;
}
InUndoHelper.GUIUndo(baseData, "Loop Randomize", ref baseData.RandomizeLoops,
() => EditorGUILayout.Toggle("Randomize Loop Count", baseData.RandomizeLoops));
if (!baseData.RandomizeLoops)
{
InUndoHelper.GUIUndo(baseData, "Loop Count",
ref baseData.MinIterations, () => (byte)Mathf.Clamp(EditorGUILayout.IntField("Loop Count", baseData.MinIterations), 0, 255));
}
else
{
GUILayout.BeginHorizontal();
InUndoHelper.GUIUndo(baseData, "Loop Count", ref baseData.MinIterations, ref baseData.MaxIterations,
(out byte v1, out byte v2) =>
{
v1 = (byte)Mathf.Clamp(EditorGUILayout.IntField("Min Loop Count", baseData.MinIterations), 0, 255);
v2 = (byte)Mathf.Clamp(EditorGUILayout.IntField("Max Loop Count", baseData.MaxIterations), 0, 255);
//Clamp to 0-255 and so that min/max doesn't overlap
v2 = (byte)Mathf.Clamp(v2, v1, 255);
v1 = (byte)Mathf.Clamp(v1, 0, v2);
});
GUILayout.EndHorizontal();
}
}
GUI.enabled = true;
GUILayout.EndVertical();
#endregion
Seperators(2);
#region Instance limiting
InUndoHelper.GUIUndo(baseData, "Limit Instances (Global)", ref baseData.LimitInstances, () => EditorGUILayout.Toggle("Limit Instances", baseData.LimitInstances));
GUI.enabled = baseData.LimitInstances;
if (baseData.LimitInstances)
{
InUndoHelper.GUIUndo(baseData, "Max Instance Cont", ref baseData.MaxInstances, () => Math.Max(EditorGUILayout.IntField("Max Instance Count", baseData.MaxInstances), 0));
InUndoHelper.GUIUndo(baseData, "Stealing Type", ref baseData.InstanceStealingTypes, () => (InstanceStealingTypes)EditorGUILayout.EnumPopup("Stealing Type", baseData.InstanceStealingTypes));
}
GUI.enabled = true;
#endregion
Seperators(2);
#region Priority
InUndoHelper.GUIUndo(baseData, "Priority", ref baseData.Priority, () => EditorGUILayout.IntSlider("Priority", baseData.Priority, 0, 255));
#endregion
Seperators(2);
#region Sample offset
InUndoHelper.GUIUndo(baseData, "Random Second Offset", ref baseData.RandomSecondsOffset, () =>
EditorGUILayout.Toggle("Random Second Offset", baseData.RandomSecondsOffset));
if (baseData.RandomSecondsOffset)
{
InUndoHelper.GUIUndo(baseData, "First item offset", ref baseData.MinSecondsOffset, ref baseData.MaxSecondsOffset,
(out float v1, out float v2) =>
{
v1 = Mathf.Clamp(EditorGUILayout.FloatField("Min offset", baseData.MinSecondsOffset), 0, baseData.MaxSecondsOffset);
v2 = Mathf.Clamp(EditorGUILayout.FloatField("Max offset", baseData.MaxSecondsOffset), baseData.MinSecondsOffset, float.MaxValue);
});
}
else
{
InUndoHelper.GUIUndo(baseData, "Delay", ref baseData.MinSecondsOffset, () =>
{
var delay = Mathf.Max(EditorGUILayout.FloatField("First clip offset", baseData.MinSecondsOffset), 0);
if (delay > baseData.MaxSecondsOffset)
{
baseData.MaxSecondsOffset = baseData.MinSecondsOffset + 1;
}
return(delay);
});
}
if (node._type == AudioNodeType.Audio)
{
var nodeData = node._nodeData as InAudioData;
if (nodeData.AudioClip != null)
{
float length = nodeData.AudioClip.ExactLength();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("Clip length");
EditorGUILayout.SelectableLabel(length.ToString(), GUILayout.Height(EditorGUIUtility.singleLineHeight));
EditorGUILayout.EndHorizontal();
if (baseData.RandomSecondsOffset && (baseData.MinSecondsOffset > length || baseData.MaxSecondsOffset > length))
{
EditorGUILayout.HelpBox("Offset exceeds sound clip length", MessageType.Warning);
}
else if (baseData.MinSecondsOffset > length)
{
EditorGUILayout.HelpBox("Offset exceeds sound clip length", MessageType.Warning);
}
}
}
#endregion
}
else
{
#region Attenuation
if (!node._parent.IsRootOrFolder)
{
InUndoHelper.GUIUndo(baseData, "Override Parent", ref baseData.OverrideAttenuation, () => GUILayout.Toggle(baseData.OverrideAttenuation, "Override Parent"));
}
GUI.enabled = baseData.OverrideAttenuation;
if (node._parent.IsRootOrFolder)
{
GUI.enabled = true;
}
InUndoHelper.GUIUndo(node, "Rolloff Mode", ref baseData.RolloffMode, () => (AudioRolloffMode)EditorGUILayout.EnumPopup("Volume Rolloff", baseData.RolloffMode));
InUndoHelper.GUIUndo(baseData, "Set Rolloff Distance", ref baseData.MinDistance, ref baseData.MaxDistance,
(out float v1, out float v2) =>
{
if (baseData.RolloffMode != AudioRolloffMode.Custom)
{
v1 = EditorGUILayout.FloatField("Min Distance", baseData.MinDistance);
}
else
{
v1 = baseData.MinDistance;
}
v2 = EditorGUILayout.FloatField("Max Distance", baseData.MaxDistance);
v1 = Mathf.Max(v1, 0.00001f);
v2 = Mathf.Max(v2, v1 + 0.01f);
});
if (baseData.RolloffMode == AudioRolloffMode.Custom)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("Rolloff");
InUndoHelper.GUIUndo(baseData, "Set Rolloff Curve", ref baseData.FalloffCurve, () => EditorGUILayout.CurveField(baseData.FalloffCurve, GUILayout.Height(200), GUILayout.Width(200)));
//baseData.FalloffCurve = EditorGUILayout.CurveField(baseData.FalloffCurve, GUILayout.Height(200), GUILayout.Width(200));
EditorGUILayout.EndHorizontal();
var keys = baseData.FalloffCurve.keys;
int keyCount = keys.Length;
for (int i = 0; i < keyCount; i++)
{
Keyframe key = keys[i];
key.time = Mathf.Clamp01(key.time);
key.value = Mathf.Clamp01(key.value);
try
{
baseData.FalloffCurve.MoveKey(i, key);
}
catch (Exception)
{
}
}
if (GUILayout.Button("Reset curve", GUILayout.Width(150)))
{
InUndoHelper.RecordObject(baseData, "Reset Curve");
baseData.FalloffCurve = new AnimationCurve(new Keyframe(0, 1), new Keyframe(0.1f, 1), new Keyframe(1, 0));
}
if (Selection.activeObject == null)
{
EditorGUILayout.HelpBox("Please select any game object in the scene.\nIt fixes a bug in Unity Editor API",
MessageType.Info, true);
}
EditorGUILayout.HelpBox("Unity does not support setting custom rolloff via scripts. This will perform slower than a log/linear rolloff curve", MessageType.Warning, true);
GUI.enabled = false;
}
#endregion
GUI.enabled = true;
}
}
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();
}
}
private void UndoAll(string message)
{
InUndoHelper.RecordObject(
SplineController.Nodes.Cast <Object>().ToArray().Add(SplineController), message);
}
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();
}
}
