public static void DrawVolume(Object undoObj, ref float refMinVolume, ref float refMaxVolume, ref bool refRandomVolume)
{
float minVolume = refMinVolume;
float maxVolume = refMaxVolume;
bool randomVolume = refRandomVolume;
InUndoHelper.GUIUndo(undoObj, "Random Volume", ref randomVolume, () => EditorGUILayout.Toggle("Random Volume", randomVolume));
if (!randomVolume)
{
InUndoHelper.GUIUndo(undoObj, "Volume", () => EditorGUILayout.Slider("Volume", minVolume, 0, 1), v =>
{
minVolume = v;
if (minVolume > maxVolume)
{
maxVolume = Mathf.Clamp01(minVolume + 0.1f);
}
});
}
else
{
InUndoHelper.GUIUndo(undoObj, "Random Volume", ref minVolume, ref maxVolume, (out float newMinVolume, out float newMaxVolume) =>
{
EditorGUILayout.MinMaxSlider(new GUIContent("Volume"), ref minVolume, ref maxVolume, 0, 1);
newMinVolume = Mathf.Clamp(EditorGUILayout.FloatField("Min volume", minVolume), 0, maxVolume);
newMaxVolume = Mathf.Clamp(EditorGUILayout.FloatField("Max volume", maxVolume), minVolume, 1);
});
}
refMinVolume = minVolume;
refMaxVolume = maxVolume;
refRandomVolume = randomVolume;
}
private static void SetSpatialBlend(InAudioNodeData baseData)
{
float minBlend = 0;
float maxBlend = 1;
InUndoHelper.GUIUndo(baseData, "Random Spatial Blend", ref baseData.RandomBlend, () =>
EditorGUILayout.Toggle("Random Spatial Blend", baseData.RandomBlend));
if (!baseData.RandomBlend)
{
InUndoHelper.GUIUndo(baseData, "Blend", () =>
EditorGUILayout.Slider("Blend (2D <-> 3D)", baseData.MinBlend, minBlend, maxBlend),
v =>
{
baseData.MinBlend = v;
if (baseData.MinBlend > baseData.MaxBlend)
{
baseData.MaxBlend = baseData.MinBlend + 0.1f;
}
baseData.MaxBlend = Mathf.Clamp(baseData.MaxBlend, minBlend, 3.0f);
});
}
else
{
InUndoHelper.GUIUndo(baseData, "Random Pitch",
ref baseData.MinBlend, ref baseData.MaxBlend,
(out float v1, out float v2) =>
{
EditorGUILayout.MinMaxSlider(new GUIContent("Blend (2D <-> 3D)"), ref baseData.MinBlend, ref baseData.MaxBlend,
minBlend, maxBlend);
v1 = Mathf.Clamp(EditorGUILayout.FloatField("Min Blend", baseData.MinBlend), minBlend, baseData.MaxBlend);
v2 = Mathf.Clamp(EditorGUILayout.FloatField("Max Blend", baseData.MaxBlend), baseData.MinBlend, maxBlend);
});
}
}
public static void Draw(InAudioNode node)
{
var nodeData = node._nodeData;
EditorGUILayout.BeginVertical();
var data = node._nodeData as InFolderData;
#region Mixer
DataDrawerHelper.DrawMixer(node);
#endregion
EditorGUILayout.Separator();
#region Volume
if (Application.isPlaying)
{
InUndoHelper.GUIUndo(nodeData, "Folder volume", ref data.runtimeVolume, () => EditorGUILayout.Slider("Runtime Volume", data.runtimeVolume, 0, 1));
}
else
{
InUndoHelper.GUIUndo(nodeData, "Folder volume", ref data.VolumeMin, () => EditorGUILayout.Slider("Initial Volume", data.VolumeMin, 0, 1));
}
#endregion
EditorGUILayout.EndVertical();
}
private static void SetPitch(InAudioNodeData baseData)
{
float minPitch = 0.001f;
float maxPitch = 3;
InUndoHelper.GUIUndo(baseData, "Random Pitch", ref baseData.RandomPitch, () =>
EditorGUILayout.Toggle("Random Pitch", baseData.RandomPitch));
if (!baseData.RandomPitch)
{
InUndoHelper.GUIUndo(baseData, "Pitch", () =>
EditorGUILayout.Slider("Pitch", baseData.MinPitch, minPitch, maxPitch),
v =>
{
baseData.MinPitch = v;
if (baseData.MinPitch > baseData.MaxPitch)
{
baseData.MaxPitch = baseData.MinPitch + 0.1f;
}
baseData.MaxPitch = Mathf.Clamp(baseData.MaxPitch, minPitch, 3.0f);
});
}
else
{
InUndoHelper.GUIUndo(baseData, "Random Pitch",
ref baseData.MinPitch, ref baseData.MaxPitch,
(out float v1, out float v2) =>
{
EditorGUILayout.MinMaxSlider(new GUIContent("Pitch"), ref baseData.MinPitch, ref baseData.MaxPitch,
minPitch, maxPitch);
v1 = Mathf.Clamp(EditorGUILayout.FloatField("Min pitch", baseData.MinPitch), minPitch, baseData.MaxPitch);
v2 = Mathf.Clamp(EditorGUILayout.FloatField("Max pitch", baseData.MaxPitch), baseData.MinPitch, maxPitch);
});
}
}
public static void Draw(InAudioNode node)
{
node.ScrollPosition = GUILayout.BeginScrollView(node.ScrollPosition);
InUndoHelper.GUIUndo(node, "Name Change", ref node.Name, () =>
EditorGUILayout.TextField("Name", node.Name));
Rect area = GUILayoutUtility.GetLastRect();
EditorGUILayout.Separator();
EditorGUILayout.BeginHorizontal();
InAudioData audioData = node._nodeData as InAudioData;
EditorGUILayout.BeginVertical();
EditorGUILayout.BeginHorizontal();
var clip = (AudioClip)EditorGUILayout.ObjectField(audioData.AudioClip, typeof(AudioClip), false);
Rect buttonArea = area;
if (Application.isPlaying)
{
buttonArea.x += buttonArea.width - 100;
buttonArea.width = 70;
GUI.enabled = false;
EditorGUI.LabelField(buttonArea, "Is Loaded");
buttonArea.x += 70;
buttonArea.width = 10;
EditorGUI.Toggle(buttonArea, audioData.IsLoaded);
GUI.enabled = true;
}
AudioSource source = InAudioInstanceFinder.Instance.GetComponent <AudioSource>();
AudioPreview(node, source, audioData);
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
if (clip != audioData.AudioClip) //Assign new clip
{
InUndoHelper.RecordObjectFull(audioData, "Changed " + node.Name + " Clip");
audioData.AudioClip = clip;
EditorUtility.SetDirty(node._nodeData.gameObject);
}
EditorGUILayout.EndHorizontal();
if (clip != null)
{
DrawImportSettings(clip);
}
NodeTypeDataDrawer.Draw(node);
GUILayout.EndScrollView();
}
public static void Draw(InAudioNode node)
{
node.ScrollPosition = GUILayout.BeginScrollView(node.ScrollPosition);
InUndoHelper.GUIUndo(node, "Name Change", ref node.Name, () =>
EditorGUILayout.TextField("Name", node.Name));
NodeTypeDataDrawer.Draw(node);
GUILayout.EndScrollView();
}
private static float DrawItem(InAudioNode node, InLayerData item)
{
EditorGUILayout.BeginVertical(GUILayout.Height(220));
var trackData = node._nodeData as InTrackData;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.BeginVertical(GUILayout.Width(150));
GUILayout.Label("Left");
GUILayout.Label("Inside left");
InUndoHelper.GUIUndo(trackData, "Zoom", ref item.Zoom, () => Math.Max(0, EditorGUILayout.FloatField("Zoom", item.Zoom)));
GUILayout.FlexibleSpace();
if (GUILayout.Button("Delete Layer"))
{
InUndoHelper.RecordObjectFull(trackData, "Remove layer");
{
toRemove = item;
}
}
EditorGUILayout.Separator();
EditorGUILayout.EndVertical();
Rect dragArea = EditorGUILayout.BeginVertical();
//GUILayout.Label("Right");
item.ScrollPos = EditorGUILayout.BeginScrollView(item.ScrollPos, false, false);
GUILayout.Label("Hello");
Rect start = GUILayoutUtility.GetLastRect();
var t = new Texture2D(1, 1);
t.SetPixel(0, 0, Color.white);
GUI.DrawTexture(start, t, ScaleMode.StretchToFill);
//start.y += 20;
//GUI.Label(start, "Hello");
EditorGUILayout.EndScrollView();
EditorGUILayout.EndVertical();
EditorGUILayout.EndHorizontal();
//EditorGUILayout.EndScrollView();
EditorGUILayout.EndVertical();
DropAreaGUI <InAudioNode>(dragArea, item, otherNode => !TreeWalker.IsParentOf(node, otherNode) || node == otherNode, AfterDrag);
return(0);
}
public static void Draw(InAudioBankLink bankLink)
{
EditorGUILayout.BeginVertical();
InUndoHelper.GUIUndo(bankLink, "Name Change", ref bankLink._name, () =>
EditorGUILayout.TextField("Name", bankLink._name));
if (bankLink._type == AudioBankTypes.Bank)
{
EditorGUIHelper.DrawID(bankLink._guid);
//UndoHelper.GUIUndo(bankLink, "Load async", ref bankLink.LoadASync, () =>
// EditorGUILayout.Toggle("Load ASync", bankLink.LoadASync));
bool autoLoad = EditorGUILayout.Toggle("Auto load", bankLink._autoLoad);
if (autoLoad != bankLink._autoLoad) //Value has changed
{
InUndoHelper.RecordObjectFull(bankLink, "Bank Auto Load");
bankLink._autoLoad = autoLoad;
}
Rect lastArea = GUILayoutUtility.GetLastRect();
lastArea.y += 28;
lastArea.width = 200;
if (GUI.Button(lastArea, "Find Folders using this bank"))
{
EditorWindow.GetWindow <InAudioWindow>().Find(audioNode => audioNode.GetBank() != bankLink);
}
EditorGUILayout.Separator();
EditorGUILayout.Separator();
EditorGUILayout.Separator();
EditorGUILayout.Separator();
EditorGUILayout.Separator();
if (Application.isPlaying)
{
EditorGUILayout.Toggle("Is Loaded", bankLink.IsLoaded);
}
}
EditorGUILayout.EndVertical();
//UndoCheck.Instance.CheckDirty(node);
}
public static void Draw(InMusicFolder node)
{
node.ScrollPosition = EditorGUILayout.BeginScrollView(node.ScrollPosition);
var prop = new SerializedObject(node);
prop.Update();
EditorGUILayout.BeginVertical();
#region Mixer
DataDrawerHelper.DrawMixer(node, prop.FindProperty("_mixerGroup"));
#endregion
EditorGUILayout.Separator();
#region Volume & Pitch
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));
}
#endregion
EditorGUILayout.EndVertical();
prop.ApplyModifiedProperties();
EditorGUILayout.EndScrollView();
}
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 void DrawSelected(AudioEventAction eventAction)
{
if (eventAction != null)
{
Rect thisArea = EditorGUILayout.BeginVertical(GUILayout.Height(120));
EditorGUILayout.LabelField("");
var buttonArea = thisArea;
buttonArea.height = 16;
GUI.skin.label.alignment = TextAnchor.UpperLeft;
InUndoHelper.GUIUndo(eventAction, "Event Action Delay", ref eventAction.Delay, () =>
Mathf.Max(EditorGUI.FloatField(buttonArea, "Seconds Delay", eventAction.Delay), 0));
buttonArea.y += 33;
var bankLoadingAction = eventAction as InEventBankLoadingAction;
var audioAction = eventAction as InEventAudioAction;
var snapshotAction = eventAction as InEventSnapshotAction;
var mixerAction = eventAction as InEventMixerValueAction;
var musicControlAction = eventAction as InEventMusicControl;
var musicFadeAction = eventAction as InEventMusicFade;
var musicSoloMuteAction = eventAction as InEventSoloMuteMusic;
if (audioAction != null)
{
if (audioAction._eventActionType == EventActionTypes.Play || audioAction._eventActionType == EventActionTypes.Stop || audioAction._eventActionType == EventActionTypes.StopAll)
{
InUndoHelper.GUIUndo(audioAction, "Fade Time", ref audioAction.Fadetime,
() => Mathf.Max(0, EditorGUILayout.FloatField("Fade Time", audioAction.Fadetime)));
InUndoHelper.GUIUndo(audioAction, "Fade Type", ref audioAction.TweenType,
() => (LeanTweenType)EditorGUILayout.EnumPopup("Fade Type", audioAction.TweenType));
if (audioAction.TweenType == LeanTweenType.animationCurve)
{
EditorGUILayout.HelpBox("Animation curve type is not supported", MessageType.Warning);
}
}
}
else if (bankLoadingAction != null)
{
//todo
}
else if (snapshotAction != null)
{
InUndoHelper.GUIUndo(snapshotAction, "Snapshot Transition Action", ref snapshotAction.Snapshot, () =>
(AudioMixerSnapshot)EditorGUILayout.ObjectField("Transition Action", snapshotAction.Snapshot, typeof(AudioMixerSnapshot), false));
InUndoHelper.GUIUndo(snapshotAction, "Snapshot Transition Time", ref snapshotAction.TransitionTime, () =>
EditorGUILayout.FloatField("Transition Time", snapshotAction.TransitionTime));
}
else if (mixerAction != null)
{
InUndoHelper.GUIUndo(mixerAction, "Mixer Value", ref mixerAction.Mixer, () =>
(AudioMixer)EditorGUILayout.ObjectField("Audio Mixer", mixerAction.Mixer, typeof(AudioMixer), false));
InUndoHelper.GUIUndo(mixerAction, "Parameter", ref mixerAction.Parameter, () =>
EditorGUILayout.TextField("Parameter", mixerAction.Parameter));
InUndoHelper.GUIUndo(mixerAction, "Value", ref mixerAction.Value, () =>
EditorGUILayout.FloatField("Value", mixerAction.Value));
EditorGUILayout.Separator();
InUndoHelper.GUIUndo(mixerAction, "Transition Time", ref mixerAction.TransitionTime, () =>
Mathf.Max(0, EditorGUILayout.FloatField("Transition Time", mixerAction.TransitionTime)));
InUndoHelper.GUIUndo(mixerAction, "Transition Type", ref mixerAction.TransitionType, () =>
(LeanTweenType)EditorGUILayout.EnumPopup("Transition Type", mixerAction.TransitionType));
if (mixerAction.TransitionType == LeanTweenType.animationCurve)
{
EditorGUILayout.HelpBox("Animation curve type is not supported", MessageType.Warning);
}
}
else if (musicControlAction != null)
{
InUndoHelper.GUIUndo(musicControlAction, "Fade Action", ref musicControlAction.Fade, () =>
EditorGUILayout.Toggle("Fade Action", musicControlAction.Fade));
if (musicControlAction.Fade)
{
InUndoHelper.GUIUndo(musicControlAction, "Transition Time", ref musicControlAction.Duration, () =>
Mathf.Max(0, EditorGUILayout.FloatField("Transition Time", musicControlAction.Duration)));
InUndoHelper.GUIUndo(musicControlAction, "Transition Type", ref musicControlAction.TweenType, () =>
(LeanTweenType)EditorGUILayout.EnumPopup("Transition Type", musicControlAction.TweenType));
}
InUndoHelper.GUIUndo(musicControlAction, "Set Volume Target", ref musicControlAction.ChangeVolume,
() =>
EditorGUILayout.Toggle("Set Volume Target", musicControlAction.ChangeVolume));
if (musicControlAction.ChangeVolume)
{
InUndoHelper.GUIUndo(musicControlAction, "Volume Target", ref musicControlAction.Duration,
() => Mathf.Clamp01(EditorGUILayout.Slider("Volume Target", musicControlAction.Duration, 0, 1)));
}
}
else if (musicFadeAction != null)
{
if (musicFadeAction._eventActionType == EventActionTypes.CrossfadeMusic)
{
InUndoHelper.GUIUndo(musicFadeAction, "Fade Target", ref musicFadeAction.From, () => EditorGUILayout.ObjectField("From Target", musicFadeAction.To, typeof(InEventMusicFade), false) as InMusicGroup);
InUndoHelper.GUIUndo(musicFadeAction, "Fade Target", ref musicFadeAction.To, () => EditorGUILayout.ObjectField("To Target", musicFadeAction.To, typeof(InEventMusicFade), false) as InMusicGroup);
}
if (musicFadeAction._eventActionType == EventActionTypes.FadeMusic)
{
InUndoHelper.GUIUndo(musicFadeAction, "Volume Target", ref musicFadeAction.ToVolumeTarget, () =>
EditorGUILayout.Slider("Volume Target", musicFadeAction.ToVolumeTarget, 0f, 1f));
}
InUndoHelper.GUIUndo(musicFadeAction, "Transition Time", ref musicFadeAction.Duration, () =>
Mathf.Max(0, EditorGUILayout.FloatField("Transition Time", musicFadeAction.Duration)));
InUndoHelper.GUIUndo(musicFadeAction, "Transition Type", ref musicFadeAction.TweenType, () =>
(LeanTweenType)EditorGUILayout.EnumPopup("Transition Type", musicFadeAction.TweenType));
if (musicFadeAction.TweenType == LeanTweenType.animationCurve)
{
EditorGUILayout.HelpBox("Animation curve type is not supported", MessageType.Warning);
}
if (musicFadeAction._eventActionType == EventActionTypes.FadeMusic)
{
InUndoHelper.GUIUndo(musicFadeAction, "Do At End", ref musicFadeAction.DoAtEndTo, () =>
(MusicState)EditorGUILayout.EnumPopup("Do At End", musicFadeAction.DoAtEndTo));
if (musicFadeAction.DoAtEndTo == MusicState.Playing)
{
EditorGUILayout.HelpBox("\"Playing\" does the same as \"Nothing\", it does not start playing", MessageType.Info);
}
}
}
else if (musicSoloMuteAction != null)
{
InUndoHelper.GUIUndo(musicSoloMuteAction, "Set Solo", ref musicSoloMuteAction.SetSolo, () =>
EditorGUILayout.Toggle("Set Solo", musicSoloMuteAction.SetSolo));
if (musicSoloMuteAction.SetSolo)
{
InUndoHelper.GUIUndo(musicSoloMuteAction, "Solo Target", ref musicSoloMuteAction.SoloTarget, () =>
EditorGUILayout.Toggle("Solo Target", musicSoloMuteAction.SoloTarget));
}
EditorGUILayout.Separator();
InUndoHelper.GUIUndo(musicSoloMuteAction, "Set Mute", ref musicSoloMuteAction.SetMute, () =>
EditorGUILayout.Toggle("Set Mute", musicSoloMuteAction.SetMute));
if (musicSoloMuteAction.SetMute)
{
InUndoHelper.GUIUndo(musicSoloMuteAction, "Solo Mute", ref musicSoloMuteAction.MuteTarget, () =>
EditorGUILayout.Toggle("Solo Mute", musicSoloMuteAction.MuteTarget));
}
}
EditorGUILayout.EndVertical();
}
}
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);
}
public static void Draw(InAudioNode node)
{
node.ScrollPosition = GUILayout.BeginScrollView(node.ScrollPosition);
//UndoHandler.CheckUndo(new UnityEngine.Object[] { node, node.AudioData }, "Random Data Node Change");
InUndoHelper.GUIUndo(node, "Name Change", ref node.Name, () =>
EditorGUILayout.TextField("Name", node.Name));
NodeTypeDataDrawer.Draw(node);
EditorGUILayout.Separator();
InAudioNodeData baseData = (InAudioNodeData)node._nodeData;
if (baseData.SelectedArea == 0)
{
EditorGUILayout.BeginVertical();
var randomData = (node._nodeData as RandomData);
var weights = randomData.weights;
InUndoHelper.GUIUndo(node._nodeData, "Do Not Repeat Last #", ref randomData.doNotRepeat, () => Mathf.Max(0, EditorGUILayout.IntField("Do Not Repeat Last #", randomData.doNotRepeat)));
if (randomData.doNotRepeat >= weights.Count && weights.Count > 0)
{
EditorGUILayout.HelpBox("The number of random elements that should be repeated exceeds the number of nodes.\nThe number will be clambed to " + (randomData.weights.Count - 1) + ".", MessageType.Info);
}
EditorGUILayout.Separator();
EditorGUILayout.LabelField("Weights");
if (node._children.Count == weights.Count)
{
for (int i = 0; i < node._children.Count; ++i)
{
var child = node._children[i];
int index = i;
InUndoHelper.GUIUndo(node._nodeData, "Weights",
() => EditorGUILayout.IntSlider(child.Name, weights[index], 0, 100), i1 =>
weights[index] = i1);
}
if (node._children.Count == 0)
{
EditorGUILayout.HelpBox("Node has no children to weight.", MessageType.None);
}
}
else
{
EditorGUILayout.HelpBox("The number of weights does not match the children count.\n" + node._children.Count + " children was found and " + randomData.weights.Count + " weights.", MessageType.Error);
if (GUILayout.Button("Fix weights"))
{
weights.Clear();
for (int i = 0; i < node._children.Count; i++)
{
weights.Add(50);
}
}
}
EditorGUILayout.EndVertical();
}
//UndoHandler.CheckGUIChange();
EditorGUILayout.EndScrollView();
}
public static void DrawName(InAudioNode node)
{
InUndoHelper.GUIUndo(node, "Name Change", ref node.Name, () =>
EditorGUILayout.TextField("Name", node.Name));
}
public static void DrawSelectedArea(InAudioNode node, InAudioNodeData baseData)
{
InUndoHelper.GUIUndo(node, "Name Change", ref baseData.SelectedArea, () =>
GUILayout.Toolbar(baseData.SelectedArea, new[] { "Audio", "Attenuation" }));
}
public static void Draw(InAudioNode node)
{
var nodeData = node._nodeData;
EditorGUILayout.BeginVertical();
var data = node._nodeData as InFolderData;
#region Bank
InUndoHelper.GUIUndo(node, "Name Change", ref node.Name, () =>
EditorGUILayout.TextField("Name", node.Name));
if (node._type == AudioNodeType.Folder)
{
bool overrideparent = EditorGUILayout.Toggle("Override Parent Bank", data.OverrideParentBank);
if (overrideparent != data.OverrideParentBank)
{
AudioBankWorker.ChangeBankOverride(node);
}
}
else
{
EditorGUILayout.LabelField(""); //To fill out the area from the toggle
}
if (data.OverrideParentBank == false && node._type != AudioNodeType.Root)
{
GUI.enabled = false;
}
EditorGUILayout.BeginHorizontal();
var parentLink = FindParentBank(node);
if (data.OverrideParentBank)
{
if (data.BankLink != null)
{
EditorGUILayout.LabelField("Bank", data.BankLink.GetName);
}
else
{
if (parentLink != null)
{
EditorGUILayout.LabelField("Bank", "Missing Bank, using parent bank" + parentLink.GetName);
}
else
{
EditorGUILayout.LabelField("Bank", "Missing Banks, no bank found");
}
}
}
else
{
if (parentLink != null)
{
EditorGUILayout.LabelField("Using Bank", parentLink.GetName);
}
else
{
EditorGUILayout.LabelField("Using Bank", "Missing");
}
}
bool wasEnabled = GUI.enabled;
GUI.enabled = true;
if (GUILayout.Button("Find", GUILayout.Width(50)))
{
EditorWindow.GetWindow <AuxWindow>().FindBank(parentLink);
}
Rect findArea = GUILayoutUtility.GetLastRect();
findArea.y += 20;
if (GUI.Button(findArea, "Find"))
{
EditorWindow.GetWindow <AuxWindow>().FindBank(data.BankLink);
}
GUI.enabled = wasEnabled;
GUILayout.Button("Drag new bank here", GUILayout.Width(140));
var newBank = OnDragging.BusDragging(GUILayoutUtility.GetLastRect());
if (newBank != null)
{
AudioBankWorker.ChangeAudioNodeBank(node, newBank);
}
GUI.enabled = true;
EditorGUILayout.EndHorizontal();
GUI.enabled = false;
if (data.BankLink != null)
{
EditorGUILayout.LabelField("Node Bank", data.BankLink.GetName);
}
else
{
EditorGUILayout.LabelField("Node Bank", "Missing Bank");
}
GUI.enabled = true;
if (Application.isPlaying)
{
EditorGUILayout.Toggle("Is Loaded", BankLoader.IsLoaded(parentLink));
}
#endregion
if (data.ExternalPlacement)
{
EditorGUILayout.Separator();
GUI.enabled = false;
EditorGUILayout.ObjectField("Placed on", node.gameObject, typeof(GameObject), false);
GUI.enabled = true;
EditorGUILayout.Separator();
}
#region Mixer
DataDrawerHelper.DrawMixer(node);
#endregion
EditorGUILayout.Separator();
#region Volume
if (Application.isPlaying)
{
InUndoHelper.GUIUndo(nodeData, "Folder volume", ref data.runtimeVolume, () => EditorGUILayout.Slider("Runtime Volume", data.runtimeVolume, 0, 1));
}
else
{
InUndoHelper.GUIUndo(nodeData, "Folder volume", ref data.VolumeMin, () => EditorGUILayout.Slider("Initial Volume", data.VolumeMin, 0, 1));
}
#endregion
EditorGUILayout.EndVertical();
}
public static void Draw(InMusicFolder node)
{
node.ScrollPosition = EditorGUILayout.BeginScrollView(node.ScrollPosition);
var prop = new SerializedObject(node);
prop.Update();
EditorGUILayout.BeginVertical();
#region Bank
InUndoHelper.GUIUndo(node, "Name Change", ref node._name, () =>
EditorGUILayout.TextField("Name", node._name));
if (!node.IsRoot)
{
bool overrideparent = EditorGUILayout.Toggle("Override Parent Bank", node._overrideParentBank);
if (overrideparent != node._overrideParentBank)
{
AudioBankWorker.ChangeBankOverride(node);
}
}
else
{
EditorGUILayout.Separator();
}
if (node._overrideParentBank == false && !node.IsRoot)
{
GUI.enabled = false;
}
EditorGUILayout.BeginHorizontal();
var parentLink = node.GetBank();
if (node._overrideParentBank)
{
if (node._bankLink != null)
{
EditorGUILayout.LabelField("Bank", node._bankLink.GetName);
}
else
{
if (parentLink != null)
{
EditorGUILayout.LabelField("Bank", "Missing Bank, using parent bank" + parentLink.GetName);
}
else
{
EditorGUILayout.LabelField("Bank", "Missing Banks, no bank found");
}
}
}
else
{
if (parentLink != null)
{
EditorGUILayout.LabelField("Using Bank", parentLink.GetName);
}
else
{
EditorGUILayout.LabelField("Using Bank", "Missing");
}
}
bool wasEnabled = GUI.enabled;
GUI.enabled = true;
if (GUILayout.Button("Find", GUILayout.Width(50)))
{
EditorWindow.GetWindow <AuxWindow>().FindBank(parentLink);
}
Rect findArea = GUILayoutUtility.GetLastRect();
findArea.y += 20;
if (GUI.Button(findArea, "Find"))
{
EditorWindow.GetWindow <AuxWindow>().FindBank(node._bankLink);
}
GUI.enabled = wasEnabled;
GUILayout.Button("Drag new bank here", GUILayout.Width(140));
var newBank = OnDragging.BusDragging(GUILayoutUtility.GetLastRect());
if (newBank != null)
{
AudioBankWorker.ChangeMusicNodeBank(node, newBank);
}
GUI.enabled = true;
EditorGUILayout.EndHorizontal();
GUI.enabled = false;
if (node._bankLink != null)
{
EditorGUILayout.LabelField("Node Bank", node._bankLink.GetName);
}
else
{
EditorGUILayout.LabelField("Node Bank", "Missing Bank");
}
GUI.enabled = true;
if (Application.isPlaying)
{
EditorGUILayout.Toggle("Is Loaded", BankLoader.IsLoaded(parentLink));
}
#endregion
EditorGUILayout.Separator();
EditorGUILayout.Separator();
#region Mixer
DataDrawerHelper.DrawMixer(node, prop.FindProperty("_mixerGroup"));
#endregion
EditorGUILayout.Separator();
#region Volume & Pitch
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));
}
#endregion
EditorGUILayout.EndVertical();
prop.ApplyModifiedProperties();
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;
}
}
