private static bool AllowedStealing(InAudioNode audioNode, List <InstanceInfo> currentInstances)
{
var data = (InAudioNodeData)audioNode.NodeData;
if (data.LimitInstances && currentInstances.Count >= data.MaxInstances)
{
InPlayer player = null;
var stealType = data.InstanceStealingTypes;
if (stealType == InstanceStealingTypes.NoStealing)
{
return(false);
}
int index = 0;
InstanceInfo foundInfo;
if (stealType == InstanceStealingTypes.Newest)
{
double newestTime = 0;
for (int i = 0; i < currentInstances.Count; i++)
{
InstanceInfo instanceInfo = currentInstances[i];
if (instanceInfo.Timestamp > newestTime)
{
newestTime = instanceInfo.Timestamp;
index = i;
}
}
}
else if (stealType == InstanceStealingTypes.Oldest)
{
double oldestTime = Double.MaxValue;
for (int i = 0; i < currentInstances.Count; i++)
{
InstanceInfo instanceInfo = currentInstances[i];
if (instanceInfo.Timestamp < oldestTime)
{
oldestTime = instanceInfo.Timestamp;
index = i;
}
}
}
foundInfo = currentInstances[index];
player = foundInfo.Player;
currentInstances.SwapRemoveAt(ref index);
if (player != null)
{
player.Stop();
}
}
return(true);
}
private void Play(GameObject controllingObject, InAudioNode audioNode, InPlayer player, float fade, LeanTweenType fadeType)
{
ObjectAudioList tupleList = GetValue(GOAudioNodes, controllingObject);
RuntimeInfo runtimeInfo = runtimeInfoPool.GetObject();
tupleList.InfoList.Add(runtimeInfo);
runtimeInfo.Node = audioNode;
runtimeInfo.Player = player;
runtimeInfo.ListIndex = tupleList.InfoList.Count - 1;
runtimeInfo.PlacedIn = tupleList;
player._internalPlay(audioNode, controllingObject, runtimeInfo, fade, fadeType);
}
/// <summary>
/// Play an audio node directly with fade in time
/// </summary>
/// <param name="gameObject">The game object to attach to and be controlled by</param>
/// <param name="audioNode">The node to play</param>
/// <param name="fadeTime">How long it should take to fade in from 0 to 1 in volume</param>
/// <param name="tweeenType">The curve of fading</param>
/// <returns>A controller for the playing node</returns>
public static InPlayer Play(GameObject gameObject, InAudioNode audioNode, float fadeTime, LeanTweenType tweeenType)
{
if (instance == null || audioNode == null || audioNode.IsRootOrFolder)
{
return(null);
}
InPlayer player = instance._inAudioEventWorker.PlayAttachedTo(gameObject, audioNode, gameObject);
player.Volume = 0.0f;
LTDescr tweever = LeanTween.value(gameObject, (f, o) => { (o as InPlayer).Volume = f; }, 0, 1.0f, fadeTime);
tweever.onUpdateParam = player;
tweever.tweenType = tweeenType;
return(player);
}
/// <summary>
/// Play an audio node in world space with a custom fade, attached to another game object
/// </summary>
/// <param name="gameObject">The game object to attach to and be controlled by</param>
/// <param name="audioNode">The node to play</param>
/// <param name="position">The world position to play at</param>
/// <param name="fadeTime">How long it should take to fade in from 0 to 1 in volume</param>
/// <param name="tweeenType">The curve of fading</param>
/// <param name="startVolume">The starting volume</param>
/// <param name="endVolume">The end volume</param>
/// <returns>A controller for the playing node</returns>
public static InPlayer PlayAtPosition(GameObject gameObject, InAudioNode audioNode, Vector3 position, float fadeTime, LeanTweenType tweeenType, float startVolume, float endVolume)
{
if (instance == null || audioNode == null || audioNode.IsRootOrFolder)
{
return(null);
}
InPlayer player = instance._inAudioEventWorker.PlayAtPosition(gameObject, audioNode, position);
player.Volume = startVolume;
LTDescr tweever = LeanTween.value(gameObject, (f, o) => { (o as InPlayer).Volume = f; }, startVolume, endVolume, fadeTime);
tweever.onUpdateParam = player;
tweever.tweenType = tweeenType;
return(player);
}
public InPlayer[] GetPlayers(GameObject go)
{
ObjectAudioList infoList;
GOAudioNodes.TryGetValue(go.GetInstanceID(), out infoList);
if (infoList != null)
{
InPlayer[] players = new InPlayer[infoList.InfoList.Count];
var list = infoList.InfoList;
for (int i = 0; i < list.Count; i++)
{
players[i] = infoList.InfoList[i].Player;
}
return(players);
}
return(null);
}
private void PlayFollowing(GameObject controllingObject,InAudioNode audioNode, InPlayer player, float fade, LeanTweenType fadeType, AudioParameters parameters)
{
var runtimeInfo = PreparePlay(controllingObject, audioNode, player);
player._internalPlayFollowing(audioNode, controllingObject, runtimeInfo, fade, fadeType, parameters);
}
public InPlayer[] GetPlayers(GameObject go)
{
ObjectAudioList infoList;
GOAudioNodes.TryGetValue(go.GetInstanceID(), out infoList);
if (infoList != null)
{
InPlayer[] players = new InPlayer[infoList.InfoList.Count];
var list = infoList.InfoList;
for (int i = 0; i < list.Count; i++)
{
players[i] = infoList.InfoList[i].Player;
}
return players;
}
return null;
}
public InstanceInfo(double timestamp, InPlayer player)
{
Timestamp = timestamp;
Player = player;
}
//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;
}
}
private RuntimeInfo PreparePlay(GameObject controllingObject, InAudioNode audioNode, InPlayer player)
{
ObjectAudioList tupleList = GetValue(GOAudioNodes, controllingObject);
RuntimeInfo runtimeInfo = new RuntimeInfo();
tupleList.InfoList.Add(runtimeInfo);
runtimeInfo.Node = audioNode;
runtimeInfo.Player = player;
runtimeInfo.PlacedIn = tupleList;
return(runtimeInfo);
}
private void InitializeController(InPlayer controller)
{
controller.internalInitialize(FreeController);
}
//private static GameObject go;
public static void Draw(InAudioNode node)
{
if (Application.isPlaying)
{
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("Play Node"))
{
var link = node.GetBank();
if (link != null && link.IsLoaded)
{
if (preview != null)
{
preview.Stop();
}
preview = InAudio.Play(InAudioInstanceFinder.Instance.gameObject, node);
preview.SpatialBlend = 0.0f;
preview.OnCompleted = (go, audioNode) => preview = null;
}
else
{
Debug.Log("InAudio: Cannot preview node as its beloning bank is not loaded");
}
}
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._clip != null)
{
float length = nodeData._clip.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;
}
}
public void Set(InAudioNode node, InPlayer player)
{
Node = node;
Player = player;
}
private RuntimeInfo PreparePlay(GameObject controllingObject, InAudioNode audioNode, InPlayer player)
{
ObjectAudioList tupleList = GetValue(GOAudioNodes, controllingObject);
RuntimeInfo runtimeInfo = new RuntimeInfo();
tupleList.InfoList.Add(runtimeInfo);
runtimeInfo.Node = audioNode;
runtimeInfo.Player = player;
runtimeInfo.PlacedIn = tupleList;
return runtimeInfo;
}
public void Set(InAudioNode node, InPlayer player)
{
Node = node;
Player = player;
}
private void InitializeController(InPlayer controller)
{
controller.internalInitialize(FreeController);
}
private void PlayFollowing(GameObject controllingObject, InAudioNode audioNode, InPlayer player, float fade, LeanTweenType fadeType, AudioParameters parameters)
{
var runtimeInfo = PreparePlay(controllingObject, audioNode, player);
player._internalPlayFollowing(audioNode, controllingObject, runtimeInfo, fade, fadeType, parameters);
}
