public void DumpHierarchy(string title, int level) { if (title != "") { Console.WriteLine(title); } string str = ""; int num = level; while (num-- > 0) { str += " "; } Console.WriteLine(str + "name=" + base.name); str += " "; AudioMixerEffectController[] effects = this.effects; for (int i = 0; i < effects.Length; i++) { AudioMixerEffectController audioMixerEffectController = effects[i]; Console.WriteLine(str + "effect=" + audioMixerEffectController.ToString()); } AudioMixerGroupController[] children = this.children; for (int j = 0; j < children.Length; j++) { AudioMixerGroupController audioMixerGroupController = children[j]; audioMixerGroupController.DumpHierarchy("", level + 1); } }
public AudioMixerEffectController CopyEffect(AudioMixerEffectController sourceEffect) { var copiedEffect = new AudioMixerEffectController(sourceEffect.effectName); copiedEffect.name = sourceEffect.name; copiedEffect.PreallocateGUIDs(); MixerParameterDefinition[] paramDefs = MixerEffectDefinitions.GetEffectParameters(sourceEffect.effectName); float value; foreach (var s in snapshots) { if (s.GetValue(sourceEffect.GetGUIDForMixLevel(), out value)) { s.SetValue(copiedEffect.GetGUIDForMixLevel(), value); } foreach (var p in paramDefs) { if (s.GetValue(sourceEffect.GetGUIDForParameter(p.name), out value)) { s.SetValue(copiedEffect.GetGUIDForParameter(p.name), value); } } } AssetDatabase.AddObjectToAsset(copiedEffect, this); return(copiedEffect); }
void RemoveExposedParametersContainedInEffect(AudioMixerEffectController effect) { // Cleanup exposed parameters that were in the effect var exposedParams = exposedParameters; if (exposedParams.Length == 0) { return; } var undoString = "Remove Exposed Effect Parameter"; if (exposedParams.Length > 1) { undoString = $"{undoString}s"; } Undo.RecordObject(this, undoString); foreach (var param in exposedParams) { if (effect.ContainsParameterGUID(param.guid)) { RemoveExposedParameter(param.guid); } } }
public static bool MoveEffect(ref List <AudioMixerEffectController> sourceEffects, int sourceIndex, ref List <AudioMixerEffectController> targetEffects, int targetIndex) { if (sourceEffects == targetEffects) { if (targetIndex > sourceIndex) { targetIndex--; } if (sourceIndex == targetIndex) { return(false); } } if (sourceIndex < 0 || sourceIndex >= sourceEffects.Count) { return(false); } if (targetIndex < 0 || targetIndex > targetEffects.Count) { return(false); } AudioMixerEffectController effect = sourceEffects[sourceIndex]; sourceEffects.RemoveAt(sourceIndex); targetEffects.Insert(targetIndex, effect); return(true); }
void ClearSendConnectionsTo(AudioMixerEffectController sendTarget) { var allGroups = GetAllAudioGroupsSlow(); foreach (var g in allGroups) { foreach (var e in g.effects) { if (e.IsSend() && e.sendTarget == sendTarget) { var guid = e.GetGUIDForMixLevel(); if (ContainsExposedParameter(guid)) { Undo.RecordObjects(new Object[] { this, e }, "Clear Send target"); RemoveExposedParameter(guid); } else { Undo.RecordObject(e, "Clear Send target"); } e.sendTarget = null; } } } }
public void InsertEffect(AudioMixerEffectController effect, int index) { List<AudioMixerEffectController> effectControllerList = new List<AudioMixerEffectController>((IEnumerable<AudioMixerEffectController>) this.effects); effectControllerList.Add((AudioMixerEffectController) null); for (int index1 = effectControllerList.Count - 1; index1 > index; --index1) effectControllerList[index1] = effectControllerList[index1 - 1]; effectControllerList[index] = effect; this.effects = effectControllerList.ToArray(); }
public void InsertEffect(AudioMixerEffectController effect, int index) { List<AudioMixerEffectController> list = new List<AudioMixerEffectController>(this.effects) { null }; for (int i = list.Count - 1; i > index; i--) { list[i] = list[i - 1]; } list[index] = effect; this.effects = list.ToArray(); }
public BusConnection(float srcX, float srcY, AudioMixerEffectController targetEffect, float mixLevel, Color col, bool isSend, bool isSelected) { this.srcX = srcX; this.srcY = srcY; this.targetEffect = targetEffect; this.mixLevel = mixLevel; this.color = col; this.isSend = isSend; this.isSelected = isSelected; }
// Builds a graph over all connections going out of a group (the parent counts as one). // While building the map, the existing routing of effectSlotUnderTest are ignored and pretended it is connected to targetToTest instead. // Then checks are performed whether this setup would cause any loops in the graph. static Dictionary <object, ConnectionNode> BuildTemporaryGraph( List <AudioMixerGroupController> allGroups, AudioMixerGroupController groupWhoseEffectIsChanged, AudioMixerEffectController effectWhoseTargetIsChanged, AudioMixerEffectController targetToTest, AudioMixerGroupController modifiedGroup1, List <AudioMixerEffectController> modifiedGroupEffects1, AudioMixerGroupController modifiedGroup2, List <AudioMixerEffectController> modifiedGroupEffects2 ) { // First build the chains of groups and their contained effects var graph = new Dictionary <object, ConnectionNode>(); foreach (var group in allGroups) { var groupNode = new ConnectionNode(); groupNode.group = group; groupNode.effect = null; graph[group] = groupNode; object groupTail = group; var reorderedEffects = (group == modifiedGroup1) ? modifiedGroupEffects1 : (group == modifiedGroup2) ? modifiedGroupEffects2 : group.effects.ToList(); foreach (var effect in reorderedEffects) { if (!graph.ContainsKey(effect)) { graph[effect] = new ConnectionNode(); } graph[effect].group = group; graph[effect].effect = effect; if (!graph[groupTail].targets.Contains(effect)) { graph[groupTail].targets.Add(effect); } AudioMixerEffectController target = (group == groupWhoseEffectIsChanged && effectWhoseTargetIsChanged == effect) ? targetToTest : effect.sendTarget; if (target != null) { if (!graph.ContainsKey(target)) { graph[target] = new ConnectionNode(); graph[target].group = group; graph[target].effect = target; } if (!graph[effect].targets.Contains(target)) { graph[effect].targets.Add(target); } } groupTail = effect; } graph[group].groupTail = groupTail; } return(graph); }
public static bool InsertEffect(AudioMixerEffectController effect, ref List <AudioMixerEffectController> targetEffects, int targetIndex) { if (targetIndex < 0 || targetIndex > targetEffects.Count) { Debug.LogError("Inserting effect failed! size: " + targetEffects.Count + " at index: " + targetIndex); return(false); } targetEffects.Insert(targetIndex, effect); return(true); }
public void InsertEffect(AudioMixerEffectController effect, int index) { List <AudioMixerEffectController> list = new List <AudioMixerEffectController>(this.effects); list.Add(null); for (int i = list.Count - 1; i > index; i--) { list[i] = list[i - 1]; } list[index] = effect; this.effects = list.ToArray(); }
public void RemoveEffect(AudioMixerEffectController effect, AudioMixerGroupController group) { Undo.RecordObject(group, "Delete Effect"); var modifiedEffectsList = new List <AudioMixerEffectController>(group.effects); modifiedEffectsList.Remove(effect); group.effects = modifiedEffectsList.ToArray(); DestroyExposedParametersContainedInEffect(effect); Undo.DestroyObjectImmediate(effect); }
public void InsertEffect(AudioMixerEffectController effect, int index) { List <AudioMixerEffectController> effectControllerList = new List <AudioMixerEffectController>((IEnumerable <AudioMixerEffectController>) this.effects); effectControllerList.Add((AudioMixerEffectController)null); for (int index1 = effectControllerList.Count - 1; index1 > index; --index1) { effectControllerList[index1] = effectControllerList[index1 - 1]; } effectControllerList[index] = effect; this.effects = effectControllerList.ToArray(); }
public void InsertEffect(AudioMixerEffectController effect, int index) { var modifiedEffectsList = new List <AudioMixerEffectController>(effects); modifiedEffectsList.Add(null); for (int i = modifiedEffectsList.Count - 1; i > index; i--) { modifiedEffectsList[i] = modifiedEffectsList[i - 1]; } modifiedEffectsList[index] = effect; effects = modifiedEffectsList.ToArray(); }
public bool HasAttenuation() { AudioMixerEffectController[] effects = this.effects; for (int i = 0; i < effects.Length; i++) { AudioMixerEffectController audioMixerEffectController = effects[i]; if (audioMixerEffectController.IsAttenuation()) { return(true); } } return(false); }
private void DestroyExposedParametersContainedInEffect(AudioMixerEffectController effect) { Undo.RecordObject(this, "Changed Exposed Parameters"); //Cleanup exposed parameters that were in the effect var exposedParams = exposedParameters; foreach (var param in exposedParams) { if (effect.ContainsParameterGUID(param.guid)) { RemoveExposedParameter(param.guid); } } }
public void RemoveEffect(AudioMixerEffectController effect, AudioMixerGroupController group) { if (effect == null) { Debug.LogError("Effect is null."); return; } if (group == null) { Debug.LogError("Group is null."); return; } var effects = group.effects; var foundEffect = false; for (var i = 0; i < effects.Length; ++i) { if (effects[i] == effect) { foundEffect = true; break; } } if (!foundEffect) { Debug.LogError($"Group {group.name} does not contain effect {effect.name}"); return; } ClearSendConnectionsTo(effect); RemoveExposedParametersContainedInEffect(effect); var modifiedEffectsList = new List <AudioMixerEffectController>(group.effects); modifiedEffectsList.Remove(effect); const string undoGroupName = "Remove Effect"; Undo.RecordObject(group, undoGroupName); group.effects = modifiedEffectsList.ToArray(); Undo.DestroyObjectImmediate(effect); Undo.SetCurrentGroupName(undoGroupName); }
public void ClearSendConnectionsTo(AudioMixerEffectController sendTarget) { var allGroups = GetAllAudioGroupsSlow(); foreach (var g in allGroups) { foreach (var e in g.effects) { if (e.IsSend() && e.sendTarget == sendTarget) { Undo.RecordObject(e, "Clear Send target"); e.sendTarget = null; } } } }
public static Color GetEffectColor(AudioMixerEffectController effect) { if (effect.IsSend()) { if ((Object) effect.sendTarget != (Object) null) return AudioMixerDrawUtils.kSendColor; return Color.gray; } if (effect.IsReceive()) return AudioMixerDrawUtils.kReceiveColor; if (effect.IsDuckVolume()) return AudioMixerDrawUtils.kDuckVolumeColor; if (effect.IsAttenuation()) return AudioMixerDrawUtils.kAttenuationColor; return AudioMixerDrawUtils.kEffectColor; }
public AudioMixerGroupController CreateNewGroup(string name, bool storeUndoState) { var group = new AudioMixerGroupController(this); group.name = name; group.PreallocateGUIDs(); var effect = new AudioMixerEffectController("Attenuation"); AddNewSubAsset(effect, storeUndoState); effect.PreallocateGUIDs(); group.InsertEffect(effect, 0); AddNewSubAsset(group, storeUndoState); return(group); }
public string ResolveExposedParameterPath(GUID parameter, bool getOnlyBasePath) { //consult the cache of parameters first. if (exposedParamCache.ContainsKey(parameter)) { AudioParameterPath path = exposedParamCache[parameter]; return(path.ResolveStringPath(getOnlyBasePath)); } //Search through the whole mixer! List <AudioMixerGroupController> groups = GetAllAudioGroupsSlow(); foreach (AudioMixerGroupController group in groups) { if (group.GetGUIDForVolume() == parameter || group.GetGUIDForPitch() == parameter || group.GetGUIDForSend() == parameter) { AudioGroupParameterPath newPath = new AudioGroupParameterPath(group, parameter); exposedParamCache[parameter] = newPath; return(newPath.ResolveStringPath(getOnlyBasePath)); } else { for (int i = 0; i < group.effects.Length; i++) { AudioMixerEffectController effect = group.effects[i]; MixerParameterDefinition[] paramDefs = MixerEffectDefinitions.GetEffectParameters(effect.effectName); for (int j = 0; j < paramDefs.Length; j++) { GUID guid = effect.GetGUIDForParameter(paramDefs[j].name); if (guid == parameter) { AudioEffectParameterPath newPath = new AudioEffectParameterPath(group, effect, parameter); exposedParamCache[parameter] = newPath; return(newPath.ResolveStringPath(getOnlyBasePath)); } } } } } return("Error finding Parameter path"); }
public void CreateDefaultAsset(string path) { masterGroup = new AudioMixerGroupController(this); masterGroup.name = "Master"; masterGroup.PreallocateGUIDs(); var attenuation = new AudioMixerEffectController("Attenuation"); attenuation.PreallocateGUIDs(); masterGroup.InsertEffect(attenuation, 0); AudioMixerSnapshotController snapshot = new AudioMixerSnapshotController(this); snapshot.name = "Snapshot"; this.snapshots = new AudioMixerSnapshotController[] { snapshot }; this.startSnapshot = snapshot; Object[] objectArray = { this, masterGroup, attenuation, snapshot }; AssetDatabase.CreateAssetFromObjects(objectArray, path); }
public AudioMixerEffectController(string name) { AudioMixerEffectController.Internal_CreateAudioMixerEffectController(this, name); }
public static bool WillChangeOfEffectTargetCauseFeedback(List<AudioMixerGroupController> allGroups, AudioMixerGroupController groupWhoseEffectIsChanged, int effectWhoseTargetIsChanged, AudioMixerEffectController targetToTest, List<AudioMixerController.ConnectionNode> identifiedLoop) { Dictionary<object, AudioMixerController.ConnectionNode> dictionary = AudioMixerController.BuildTemporaryGraph(allGroups, groupWhoseEffectIsChanged, groupWhoseEffectIsChanged.effects[effectWhoseTargetIsChanged], targetToTest, null, null, null, null); foreach (AudioMixerGroupController current in allGroups) { AudioMixerGroupController[] children = current.children; for (int i = 0; i < children.Length; i++) { AudioMixerGroupController key = children[i]; object groupTail = dictionary[key].groupTail; if (!dictionary[groupTail].targets.Contains(current)) { dictionary[groupTail].targets.Add(current); } } } return AudioMixerController.DoesTheTemporaryGraphHaveAnyCycles(allGroups, identifiedLoop, dictionary); }
public static bool InsertEffect(AudioMixerEffectController effect, ref List<AudioMixerEffectController> targetEffects, int targetIndex) { if (targetIndex < 0 || targetIndex > targetEffects.Count) { Debug.LogError((object) ("Inserting effect failed! size: " + (object) targetEffects.Count + " at index: " + (object) targetIndex)); return false; } targetEffects.Insert(targetIndex, effect); return true; }
static public bool WillChangeOfEffectTargetCauseFeedback(List <AudioMixerGroupController> allGroups, AudioMixerGroupController groupWhoseEffectIsChanged, int effectWhoseTargetIsChanged, AudioMixerEffectController targetToTest, List <ConnectionNode> identifiedLoop) { var graph = BuildTemporaryGraph(allGroups, groupWhoseEffectIsChanged, groupWhoseEffectIsChanged.effects[effectWhoseTargetIsChanged], targetToTest, null, null, null, null); // Connect the chains up using the group hierarchy foreach (var group in allGroups) { foreach (var childGroup in group.children) { var tailOfChildGroup = graph[childGroup].groupTail; if (!graph[tailOfChildGroup].targets.Contains(group)) { graph[tailOfChildGroup].targets.Add(group); } } } //ListTemporaryGraph(graph); return(DoesTheTemporaryGraphHaveAnyCycles(allGroups, identifiedLoop, graph)); }
public static Color GetEffectColor(AudioMixerEffectController effect) { if (effect.IsSend()) { return ((effect.sendTarget == null) ? Color.gray : kSendColor); } if (effect.IsReceive()) { return kReceiveColor; } if (effect.IsDuckVolume()) { return kDuckVolumeColor; } if (effect.IsAttenuation()) { return kAttenuationColor; } return kEffectColor; }
private static void ShowEffectContextMenu(AudioMixerGroupController group, AudioMixerEffectController effect, int effectIndex, AudioMixerController controller, Rect buttonRect) { // ISSUE: object of a compiler-generated type is created // ISSUE: variable of a compiler-generated type AudioMixerEffectView.\u003CShowEffectContextMenu\u003Ec__AnonStorey63 menuCAnonStorey63 = new AudioMixerEffectView.\u003CShowEffectContextMenu\u003Ec__AnonStorey63(); // ISSUE: reference to a compiler-generated field menuCAnonStorey63.effect = effect; // ISSUE: reference to a compiler-generated field menuCAnonStorey63.controller = controller; // ISSUE: reference to a compiler-generated field menuCAnonStorey63.group = group; // ISSUE: reference to a compiler-generated field menuCAnonStorey63.effectIndex = effectIndex; GenericMenu pm = new GenericMenu(); // ISSUE: reference to a compiler-generated field if (!menuCAnonStorey63.effect.IsReceive()) { // ISSUE: reference to a compiler-generated field // ISSUE: reference to a compiler-generated field // ISSUE: reference to a compiler-generated field if (!menuCAnonStorey63.effect.IsAttenuation() && !menuCAnonStorey63.effect.IsSend() && !menuCAnonStorey63.effect.IsDuckVolume()) { // ISSUE: reference to a compiler-generated field // ISSUE: reference to a compiler-generated method pm.AddItem(new GUIContent("Allow Wet Mixing (causes higher memory usage)"), menuCAnonStorey63.effect.enableWetMix, new GenericMenu.MenuFunction(menuCAnonStorey63.\u003C\u003Em__AA)); // ISSUE: reference to a compiler-generated field // ISSUE: reference to a compiler-generated method pm.AddItem(new GUIContent("Bypass"), menuCAnonStorey63.effect.bypass, new GenericMenu.MenuFunction(menuCAnonStorey63.\u003C\u003Em__AB)); pm.AddSeparator(string.Empty); } // ISSUE: reference to a compiler-generated method pm.AddItem(new GUIContent("Copy effect settings to all snapshots"), false, new GenericMenu.MenuFunction(menuCAnonStorey63.\u003C\u003Em__AC)); // ISSUE: reference to a compiler-generated field // ISSUE: reference to a compiler-generated field // ISSUE: reference to a compiler-generated field // ISSUE: reference to a compiler-generated field if (!menuCAnonStorey63.effect.IsAttenuation() && !menuCAnonStorey63.effect.IsSend() && (!menuCAnonStorey63.effect.IsDuckVolume() && menuCAnonStorey63.effect.enableWetMix)) { // ISSUE: reference to a compiler-generated method pm.AddItem(new GUIContent("Copy effect settings to all snapshots, including wet level"), false, new GenericMenu.MenuFunction(menuCAnonStorey63.\u003C\u003Em__AD)); } pm.AddSeparator(string.Empty); } // ISSUE: reference to a compiler-generated field AudioMixerGroupController[] groups = new AudioMixerGroupController[1]{ menuCAnonStorey63.group }; // ISSUE: reference to a compiler-generated field // ISSUE: reference to a compiler-generated field AudioMixerChannelStripView.AddEffectItemsToMenu(menuCAnonStorey63.controller, groups, menuCAnonStorey63.effectIndex, "Add effect before/", pm); // ISSUE: reference to a compiler-generated field // ISSUE: reference to a compiler-generated field AudioMixerChannelStripView.AddEffectItemsToMenu(menuCAnonStorey63.controller, groups, menuCAnonStorey63.effectIndex + 1, "Add effect after/", pm); // ISSUE: reference to a compiler-generated field if (!menuCAnonStorey63.effect.IsAttenuation()) { pm.AddSeparator(string.Empty); // ISSUE: reference to a compiler-generated method pm.AddItem(new GUIContent("Remove this effect"), false, new GenericMenu.MenuFunction(menuCAnonStorey63.\u003C\u003Em__AE)); } pm.DropDown(buttonRect); }
public GUIStyle GetEffectBarStyle(AudioMixerEffectController effect) { if (effect.IsSend() || effect.IsReceive() || effect.IsDuckVolume()) { return this.styles.sendReturnBar; } if (effect.IsAttenuation()) { return this.styles.attenuationBar; } return this.styles.effectBar; }
private void DestroyExposedParametersContainedInEffect(AudioMixerEffectController effect) { Undo.RecordObject((UnityEngine.Object) this, "Changed Exposed Parameters"); foreach (ExposedAudioParameter exposedParameter in this.exposedParameters) { if (effect.ContainsParameterGUID(exposedParameter.guid)) this.RemoveExposedParameter(exposedParameter.guid); } }
public void CreateDefaultAsset(string path) { this.masterGroup = new AudioMixerGroupController((AudioMixer) this); this.masterGroup.name = "Master"; this.masterGroup.PreallocateGUIDs(); AudioMixerEffectController effect = new AudioMixerEffectController("Attenuation"); effect.PreallocateGUIDs(); this.masterGroup.InsertEffect(effect, 0); AudioMixerSnapshotController snapshotController = new AudioMixerSnapshotController((AudioMixer) this); snapshotController.name = "Snapshot"; this.snapshots = new AudioMixerSnapshotController[1] { snapshotController }; this.startSnapshot = (AudioMixerSnapshot) snapshotController; AssetDatabase.CreateAssetFromObjects(new UnityEngine.Object[4] { (UnityEngine.Object) this, (UnityEngine.Object) this.masterGroup, (UnityEngine.Object) effect, (UnityEngine.Object) snapshotController }, path); }
private static Dictionary<object, AudioMixerController.ConnectionNode> BuildTemporaryGraph(List<AudioMixerGroupController> allGroups, AudioMixerGroupController groupWhoseEffectIsChanged, AudioMixerEffectController effectWhoseTargetIsChanged, AudioMixerEffectController targetToTest, AudioMixerGroupController modifiedGroup1, List<AudioMixerEffectController> modifiedGroupEffects1, AudioMixerGroupController modifiedGroup2, List<AudioMixerEffectController> modifiedGroupEffects2) { Dictionary<object, AudioMixerController.ConnectionNode> dictionary = new Dictionary<object, AudioMixerController.ConnectionNode>(); foreach (AudioMixerGroupController current in allGroups) { dictionary[current] = new AudioMixerController.ConnectionNode { group = current, effect = null }; object obj = current; List<AudioMixerEffectController> list = (!(current == modifiedGroup1)) ? ((!(current == modifiedGroup2)) ? current.effects.ToList<AudioMixerEffectController>() : modifiedGroupEffects2) : modifiedGroupEffects1; foreach (AudioMixerEffectController current2 in list) { if (!dictionary.ContainsKey(current2)) { dictionary[current2] = new AudioMixerController.ConnectionNode(); } dictionary[current2].group = current; dictionary[current2].effect = current2; if (!dictionary[obj].targets.Contains(current2)) { dictionary[obj].targets.Add(current2); } AudioMixerEffectController audioMixerEffectController = (!(current == groupWhoseEffectIsChanged) || !(effectWhoseTargetIsChanged == current2)) ? current2.sendTarget : targetToTest; if (audioMixerEffectController != null) { if (!dictionary.ContainsKey(audioMixerEffectController)) { dictionary[audioMixerEffectController] = new AudioMixerController.ConnectionNode(); dictionary[audioMixerEffectController].group = current; dictionary[audioMixerEffectController].effect = audioMixerEffectController; } if (!dictionary[current2].targets.Contains(audioMixerEffectController)) { dictionary[current2].targets.Add(audioMixerEffectController); } } obj = current2; } dictionary[current].groupTail = obj; } return dictionary; }
public void RemoveEffect(AudioMixerEffectController effect, AudioMixerGroupController group) { Undo.RecordObject((UnityEngine.Object) group, "Delete Effect"); List<AudioMixerEffectController> effectControllerList = new List<AudioMixerEffectController>((IEnumerable<AudioMixerEffectController>) group.effects); effectControllerList.Remove(effect); group.effects = effectControllerList.ToArray(); this.DestroyExposedParametersContainedInEffect(effect); Undo.DestroyObjectImmediate((UnityEngine.Object) effect); }
public static extern bool EffectCanBeSidechainTarget(AudioMixerEffectController effect);
public AudioMixerGroupController CreateNewGroup(string name, bool storeUndoState) { AudioMixerGroupController mixerGroupController = new AudioMixerGroupController((AudioMixer) this); mixerGroupController.name = name; mixerGroupController.PreallocateGUIDs(); AudioMixerEffectController effect = new AudioMixerEffectController("Attenuation"); this.AddNewSubAsset((UnityEngine.Object) effect, storeUndoState); effect.PreallocateGUIDs(); mixerGroupController.InsertEffect(effect, 0); this.AddNewSubAsset((UnityEngine.Object) mixerGroupController, storeUndoState); return mixerGroupController; }
private static Dictionary<object, AudioMixerController.ConnectionNode> BuildTemporaryGraph(List<AudioMixerGroupController> allGroups, AudioMixerGroupController groupWhoseEffectIsChanged, AudioMixerEffectController effectWhoseTargetIsChanged, AudioMixerEffectController targetToTest, AudioMixerGroupController modifiedGroup1, List<AudioMixerEffectController> modifiedGroupEffects1, AudioMixerGroupController modifiedGroup2, List<AudioMixerEffectController> modifiedGroupEffects2) { Dictionary<object, AudioMixerController.ConnectionNode> dictionary = new Dictionary<object, AudioMixerController.ConnectionNode>(); using (List<AudioMixerGroupController>.Enumerator enumerator1 = allGroups.GetEnumerator()) { while (enumerator1.MoveNext()) { AudioMixerGroupController current1 = enumerator1.Current; dictionary[(object) current1] = new AudioMixerController.ConnectionNode() { group = current1, effect = (AudioMixerEffectController) null }; object index = (object) current1; using (List<AudioMixerEffectController>.Enumerator enumerator2 = (!((UnityEngine.Object) current1 == (UnityEngine.Object) modifiedGroup1) ? (!((UnityEngine.Object) current1 == (UnityEngine.Object) modifiedGroup2) ? ((IEnumerable<AudioMixerEffectController>) current1.effects).ToList<AudioMixerEffectController>() : modifiedGroupEffects2) : modifiedGroupEffects1).GetEnumerator()) { while (enumerator2.MoveNext()) { AudioMixerEffectController current2 = enumerator2.Current; if (!dictionary.ContainsKey((object) current2)) dictionary[(object) current2] = new AudioMixerController.ConnectionNode(); dictionary[(object) current2].group = current1; dictionary[(object) current2].effect = current2; if (!dictionary[index].targets.Contains((object) current2)) dictionary[index].targets.Add((object) current2); AudioMixerEffectController effectController = !((UnityEngine.Object) current1 == (UnityEngine.Object) groupWhoseEffectIsChanged) || !((UnityEngine.Object) effectWhoseTargetIsChanged == (UnityEngine.Object) current2) ? current2.sendTarget : targetToTest; if ((UnityEngine.Object) effectController != (UnityEngine.Object) null) { if (!dictionary.ContainsKey((object) effectController)) { dictionary[(object) effectController] = new AudioMixerController.ConnectionNode(); dictionary[(object) effectController].group = current1; dictionary[(object) effectController].effect = effectController; } if (!dictionary[(object) current2].targets.Contains((object) effectController)) dictionary[(object) current2].targets.Add((object) effectController); } index = (object) current2; } } dictionary[(object) current1].groupTail = index; } } return dictionary; }
private static extern void Internal_CreateAudioMixerEffectController(AudioMixerEffectController mono, string name);
private extern static void Internal_CreateAudioMixerEffectController([Writable] AudioMixerEffectController mono, string name);
public ConnectSendContext(AudioMixerEffectController sendEffect, AudioMixerEffectController targetEffect) { this.sendEffect = sendEffect; this.targetEffect = targetEffect; }
private static void ShowBusPopupMenu(int effectIndex, AudioMixerGroupController group, List<AudioMixerGroupController> allGroups, Dictionary<AudioMixerEffectController, AudioMixerGroupController> effectMap, AudioMixerEffectController effect, Rect buttonRect) { GenericMenu pm = new GenericMenu(); pm.AddItem(new GUIContent("None"), false, new GenericMenu.MenuFunction2(AudioMixerChannelStripView.ConnectSendPopupCallback), (object) new AudioMixerChannelStripView.ConnectSendContext(effect, (AudioMixerEffectController) null)); pm.AddSeparator(string.Empty); AudioMixerChannelStripView.AddMenuItemsForReturns(pm, string.Empty, effectIndex, group, allGroups, effectMap, effect, true); if (pm.GetItemCount() == 2) pm.AddDisabledItem(new GUIContent("No valid Receive targets found")); pm.DropDown(buttonRect); }
public void ClearSendConnectionsTo(AudioMixerEffectController sendTarget) { using (List<AudioMixerGroupController>.Enumerator enumerator = this.GetAllAudioGroupsSlow().GetEnumerator()) { while (enumerator.MoveNext()) { foreach (AudioMixerEffectController effect in enumerator.Current.effects) { if (effect.IsSend() && (UnityEngine.Object) effect.sendTarget == (UnityEngine.Object) sendTarget) { Undo.RecordObject((UnityEngine.Object) effect, "Clear Send target"); effect.sendTarget = (AudioMixerEffectController) null; } } } } }
//Change to use effect public extern static bool EffectCanBeSidechainTarget(AudioMixerEffectController effect);
public AudioEffectParameterPath(AudioMixerGroupController group, AudioMixerEffectController effect, GUID parameter) : base(group, parameter) { this.effect = effect; }
private void EffectSlotDragging(Rect r, AudioMixerSnapshotController snapshot, AudioMixerEffectController effect, bool showLevel, float level, int effectIndex, ref int highlightEffectIndex, AudioMixerChannelStripView.ChannelStripParams p) { Event current = Event.current; switch (current.GetTypeForControl(this.m_EffectInteractionControlID)) { case EventType.MouseDown: if (r.Contains(current.mousePosition) && current.button == 0 && GUIUtility.hotControl == 0) { GUIUtility.hotControl = this.m_EffectInteractionControlID; this.m_MouseDragStartX = current.mousePosition.x; this.m_MouseDragStartValue = level; highlightEffectIndex = effectIndex; this.m_MovingEffectSrcIndex = -1; this.m_MovingEffectDstIndex = -1; this.m_WaitingForDragEvent = true; this.m_MovingSrcRect = r; this.m_MovingDstRect = r; this.m_MovingSrcGroup = p.group; this.m_MovingDstGroup = p.group; this.m_MovingEffectAllowed = true; this.SetFocus(); Event.current.Use(); EditorGUIUtility.SetWantsMouseJumping(1); InspectorWindow.RepaintAllInspectors(); } break; case EventType.MouseUp: if (GUIUtility.hotControl == this.m_EffectInteractionControlID && current.button == 0 && p.stripRect.Contains(current.mousePosition)) { if (this.m_MovingEffectDstIndex != -1 && this.m_MovingEffectAllowed) { if (this.IsDuplicateKeyPressed() && this.CanDuplicateDraggedEffect()) { AudioMixerEffectController sourceEffect = this.m_MovingSrcGroup.effects[this.m_MovingEffectSrcIndex]; AudioMixerEffectController effect2 = this.m_MovingSrcGroup.controller.CopyEffect(sourceEffect); List<AudioMixerEffectController> list = this.m_MovingDstGroup.effects.ToList<AudioMixerEffectController>(); if (AudioMixerController.InsertEffect(effect2, ref list, this.m_MovingEffectDstIndex)) { this.m_MovingDstGroup.effects = list.ToArray(); } } else { if (this.m_MovingSrcGroup == this.m_MovingDstGroup) { List<AudioMixerEffectController> list2 = this.m_MovingSrcGroup.effects.ToList<AudioMixerEffectController>(); if (AudioMixerController.MoveEffect(ref list2, this.m_MovingEffectSrcIndex, ref list2, this.m_MovingEffectDstIndex)) { this.m_MovingSrcGroup.effects = list2.ToArray(); } } else { if (!this.m_MovingSrcGroup.effects[this.m_MovingEffectSrcIndex].IsAttenuation()) { List<AudioMixerEffectController> list3 = this.m_MovingSrcGroup.effects.ToList<AudioMixerEffectController>(); List<AudioMixerEffectController> list4 = this.m_MovingDstGroup.effects.ToList<AudioMixerEffectController>(); if (AudioMixerController.MoveEffect(ref list3, this.m_MovingEffectSrcIndex, ref list4, this.m_MovingEffectDstIndex)) { this.m_MovingSrcGroup.effects = list3.ToArray(); this.m_MovingDstGroup.effects = list4.ToArray(); } } } } } this.ClearEffectDragging(ref highlightEffectIndex); current.Use(); EditorGUIUtility.SetWantsMouseJumping(0); GUIUtility.ExitGUI(); } break; case EventType.MouseDrag: if (GUIUtility.hotControl == this.m_EffectInteractionControlID) { if (this.HasFocus() && this.m_WaitingForDragEvent) { this.m_ChangingWetMixIndex = -1; if (effectIndex < p.group.effects.Length) { if (Mathf.Abs(current.delta.y) > Mathf.Abs(current.delta.x)) { this.m_MovingEffectSrcIndex = effectIndex; this.ClearFocus(); } else { this.m_ChangingWetMixIndex = this.m_IndexCounter; } } this.m_WaitingForDragEvent = false; } if (this.IsMovingEffect() && p.stripRect.Contains(current.mousePosition)) { float num = r.height * 0.5f; float num2 = (effectIndex != 0) ? 0f : (-num); float num3 = (effectIndex != p.group.effects.Length - 1) ? r.height : (r.height + num); float num4 = current.mousePosition.y - r.y; if (num4 >= num2 && num4 <= num3 && effectIndex < p.group.effects.Length) { int num5 = (num4 >= num) ? (effectIndex + 1) : effectIndex; if (num5 != this.m_MovingEffectDstIndex || this.m_MovingDstGroup != p.group) { this.m_MovingDstRect.x = r.x; this.m_MovingDstRect.width = r.width; this.m_MovingDstRect.y = ((num4 >= num) ? (r.y + r.height) : r.y) - 1f; this.m_MovingEffectDstIndex = num5; this.m_MovingDstGroup = p.group; this.m_MovingEffectAllowed = ((!this.m_MovingSrcGroup.effects[this.m_MovingEffectSrcIndex].IsAttenuation() || !(this.m_MovingSrcGroup != this.m_MovingDstGroup)) && !AudioMixerController.WillMovingEffectCauseFeedback(p.allGroups, this.m_MovingSrcGroup, this.m_MovingEffectSrcIndex, this.m_MovingDstGroup, num5, null) && (!this.IsDuplicateKeyPressed() || this.CanDuplicateDraggedEffect())); } current.Use(); } } if (this.IsAdjustingWetMix() && this.HasFocus() && showLevel) { this.m_WaitingForDragEvent = false; float value = AudioMixerChannelStripView.kEffectScaleMouseDrag * HandleUtility.niceMouseDelta + level; float num6 = Mathf.Clamp(value, AudioMixerController.kMinVolume, AudioMixerController.kMaxEffect) - level; if (num6 != 0f) { Undo.RecordObject(this.m_Controller.TargetSnapshot, "Change effect level"); if (effect.IsSend() && this.m_Controller.CachedSelection.Count > 1 && this.m_Controller.CachedSelection.Contains(p.group)) { List<AudioMixerEffectController> list5 = new List<AudioMixerEffectController>(); foreach (AudioMixerGroupController current2 in this.m_Controller.CachedSelection) { AudioMixerEffectController[] effects = current2.effects; for (int i = 0; i < effects.Length; i++) { AudioMixerEffectController audioMixerEffectController = effects[i]; if (audioMixerEffectController.effectName == effect.effectName && audioMixerEffectController.sendTarget == effect.sendTarget) { list5.Add(audioMixerEffectController); } } } foreach (AudioMixerEffectController current3 in list5) { if (!current3.IsSend() || current3.sendTarget != null) { current3.SetValueForMixLevel(this.m_Controller, snapshot, Mathf.Clamp(current3.GetValueForMixLevel(this.m_Controller, snapshot) + num6, AudioMixerController.kMinVolume, AudioMixerController.kMaxEffect)); } } } else { if (!effect.IsSend() || effect.sendTarget != null) { effect.SetValueForMixLevel(this.m_Controller, snapshot, Mathf.Clamp(level + num6, AudioMixerController.kMinVolume, AudioMixerController.kMaxEffect)); } } InspectorWindow.RepaintAllInspectors(); } current.Use(); } } break; } }
public static bool WillChangeOfEffectTargetCauseFeedback(List<AudioMixerGroupController> allGroups, AudioMixerGroupController groupWhoseEffectIsChanged, int effectWhoseTargetIsChanged, AudioMixerEffectController targetToTest, List<AudioMixerController.ConnectionNode> identifiedLoop) { Dictionary<object, AudioMixerController.ConnectionNode> graph = AudioMixerController.BuildTemporaryGraph(allGroups, groupWhoseEffectIsChanged, groupWhoseEffectIsChanged.effects[effectWhoseTargetIsChanged], targetToTest, (AudioMixerGroupController) null, (List<AudioMixerEffectController>) null, (AudioMixerGroupController) null, (List<AudioMixerEffectController>) null); using (List<AudioMixerGroupController>.Enumerator enumerator = allGroups.GetEnumerator()) { while (enumerator.MoveNext()) { AudioMixerGroupController current = enumerator.Current; foreach (AudioMixerGroupController child in current.children) { object groupTail = graph[(object) child].groupTail; if (!graph[groupTail].targets.Contains((object) current)) graph[groupTail].targets.Add((object) current); } } } return AudioMixerController.DoesTheTemporaryGraphHaveAnyCycles(allGroups, identifiedLoop, graph); }
public static void InsertEffectPopupCallback(object obj) { AudioMixerChannelStripView.EffectContext effectContext = (AudioMixerChannelStripView.EffectContext)obj; Undo.RecordObject(effectContext.group, "Add effect"); AudioMixerEffectController audioMixerEffectController = new AudioMixerEffectController(effectContext.name); effectContext.group.InsertEffect(audioMixerEffectController, effectContext.index); AssetDatabase.AddObjectToAsset(audioMixerEffectController, effectContext.controller); audioMixerEffectController.PreallocateGUIDs(); AudioMixerUtility.RepaintAudioMixerAndInspectors(); }
private string GetEffectSlotTooltip(AudioMixerEffectController effect, Rect effectRect, AudioMixerChannelStripView.ChannelStripParams p) { if (!effectRect.Contains(Event.current.mousePosition)) { return string.Empty; } if (effect.IsSend()) { if (effect.sendTarget != null) { string sendTargetDisplayString = effect.GetSendTargetDisplayString(p.effectMap); return "Send to: " + sendTargetDisplayString; } return this.styles.emptySendSlotGUIContent.tooltip; } else { if (effect.IsReceive()) { return this.styles.returnSlotGUIContent.tooltip; } if (effect.IsDuckVolume()) { return this.styles.duckVolumeSlotGUIContent.tooltip; } if (effect.IsAttenuation()) { return this.styles.attenuationSlotGUIContent.tooltip; } return this.styles.effectSlotGUIContent.tooltip; } }
public static void AddMenuItemsForReturns(GenericMenu pm, string prefix, int effectIndex, AudioMixerGroupController group, List<AudioMixerGroupController> allGroups, Dictionary<AudioMixerEffectController, AudioMixerGroupController> effectMap, AudioMixerEffectController effect, bool showCurrent) { foreach (AudioMixerGroupController current in allGroups) { AudioMixerEffectController[] effects = current.effects; for (int i = 0; i < effects.Length; i++) { AudioMixerEffectController audioMixerEffectController = effects[i]; if (MixerEffectDefinitions.EffectCanBeSidechainTarget(audioMixerEffectController)) { List<AudioMixerController.ConnectionNode> list = new List<AudioMixerController.ConnectionNode>(); if (!AudioMixerController.WillChangeOfEffectTargetCauseFeedback(allGroups, group, effectIndex, audioMixerEffectController, list)) { if (showCurrent || effect.sendTarget != audioMixerEffectController) { pm.AddItem(new GUIContent(prefix + "'" + audioMixerEffectController.GetDisplayString(effectMap) + "'"), effect.sendTarget == audioMixerEffectController, new GenericMenu.MenuFunction2(AudioMixerChannelStripView.ConnectSendPopupCallback), new AudioMixerChannelStripView.ConnectSendContext(effect, audioMixerEffectController)); } } else { string text = "A connection to '" + AudioMixerController.FixNameForPopupMenu(audioMixerEffectController.GetDisplayString(effectMap)) + "' would result in a feedback loop/"; pm.AddDisabledItem(new GUIContent(text + "Loop: ")); int num = 1; foreach (AudioMixerController.ConnectionNode current2 in list) { pm.AddDisabledItem(new GUIContent(string.Concat(new object[] { text, num, ": ", current2.GetDisplayString(), "->" }))); num++; } pm.AddDisabledItem(new GUIContent(text + num + ": ...")); } } } } }
private string GetEffectSlotName(AudioMixerEffectController effect, bool showLevel, AudioMixerSnapshotController snapshot, AudioMixerChannelStripView.ChannelStripParams p) { if (this.m_ChangingWetMixIndex == this.m_IndexCounter && showLevel) { return string.Format("{0:F1} dB", effect.GetValueForMixLevel(this.m_Controller, snapshot)); } if (effect.IsSend() && effect.sendTarget != null) { return effect.GetSendTargetDisplayString(p.effectMap); } return effect.effectName; }
private static void ShowEffectContextMenu(AudioMixerGroupController group, AudioMixerEffectController effect, int effectIndex, AudioMixerController controller, Rect buttonRect) { GenericMenu genericMenu = new GenericMenu(); if (!effect.IsReceive()) { if (!effect.IsAttenuation() && !effect.IsSend() && !effect.IsDuckVolume()) { genericMenu.AddItem(new GUIContent("Allow Wet Mixing (causes higher memory usage)"), effect.enableWetMix, delegate { effect.enableWetMix = !effect.enableWetMix; }); genericMenu.AddItem(new GUIContent("Bypass"), effect.bypass, delegate { effect.bypass = !effect.bypass; controller.UpdateBypass(); AudioMixerUtility.RepaintAudioMixerAndInspectors(); }); genericMenu.AddSeparator(string.Empty); } genericMenu.AddItem(new GUIContent("Copy effect settings to all snapshots"), false, delegate { Undo.RecordObject(controller, "Copy effect settings to all snapshots"); if (effect.IsAttenuation()) { controller.CopyAttenuationToAllSnapshots(group, controller.TargetSnapshot); } else { controller.CopyEffectSettingsToAllSnapshots(group, effectIndex, controller.TargetSnapshot, effect.IsSend()); } AudioMixerUtility.RepaintAudioMixerAndInspectors(); }); if (!effect.IsAttenuation() && !effect.IsSend() && !effect.IsDuckVolume() && effect.enableWetMix) { genericMenu.AddItem(new GUIContent("Copy effect settings to all snapshots, including wet level"), false, delegate { Undo.RecordObject(controller, "Copy effect settings to all snapshots, including wet level"); controller.CopyEffectSettingsToAllSnapshots(group, effectIndex, controller.TargetSnapshot, true); AudioMixerUtility.RepaintAudioMixerAndInspectors(); }); } genericMenu.AddSeparator(string.Empty); } AudioMixerChannelStripView.AddEffectItemsToMenu(controller, group, effectIndex, "Add effect before/", genericMenu); AudioMixerChannelStripView.AddEffectItemsToMenu(controller, group, effectIndex + 1, "Add effect after/", genericMenu); if (!effect.IsAttenuation()) { genericMenu.AddSeparator(string.Empty); genericMenu.AddItem(new GUIContent("Remove this effect"), false, delegate { controller.ClearSendConnectionsTo(effect); controller.RemoveEffect(effect, group); AudioMixerUtility.RepaintAudioMixerAndInspectors(); }); } genericMenu.DropDown(buttonRect); }
private void EffectSlot(Rect effectRect, AudioMixerSnapshotController snapshot, AudioMixerEffectController effect, int effectIndex, ref int highlightEffectIndex, AudioMixerChannelStripView.ChannelStripParams p, ref Dictionary<AudioMixerEffectController, AudioMixerChannelStripView.PatchSlot> patchslots) { if (effect == null) { return; } Rect rect = effectRect; Event current = Event.current; if (current.type == EventType.Repaint && patchslots != null && (effect.IsSend() || MixerEffectDefinitions.EffectCanBeSidechainTarget(effect))) { AudioMixerChannelStripView.PatchSlot patchSlot = new AudioMixerChannelStripView.PatchSlot(); patchSlot.group = p.group; patchSlot.x = rect.xMax - (rect.yMax - rect.yMin) * 0.5f; patchSlot.y = (rect.yMin + rect.yMax) * 0.5f; patchslots[effect] = patchSlot; } bool flag = !effect.DisallowsBypass(); Rect position = rect; position.width = 10f; rect.xMin += 10f; if (flag && GUI.Button(position, this.bypassButtonContent, GUIStyle.none)) { effect.bypass = !effect.bypass; this.m_Controller.UpdateBypass(); InspectorWindow.RepaintAllInspectors(); } this.m_IndexCounter++; float num = (!(effect != null)) ? AudioMixerController.kMinVolume : Mathf.Clamp(effect.GetValueForMixLevel(this.m_Controller, snapshot), AudioMixerController.kMinVolume, AudioMixerController.kMaxEffect); bool flag2 = effect != null && ((effect.IsSend() && effect.sendTarget != null) || effect.enableWetMix); if (current.type == EventType.Repaint) { GUIStyle effectBarStyle = this.GetEffectBarStyle(effect); float num2 = (!flag2) ? 1f : ((num - AudioMixerController.kMinVolume) / (AudioMixerController.kMaxEffect - AudioMixerController.kMinVolume)); bool flag3 = (!p.group.bypassEffects && (effect == null || !effect.bypass)) || (effect != null && effect.DisallowsBypass()); Color color = (!(effect != null)) ? new Color(0f, 0f, 0f, 0.5f) : AudioMixerDrawUtils.GetEffectColor(effect); if (!flag3) { color = new Color(color.r * 0.5f, color.g * 0.5f, color.b * 0.5f); } if (flag3) { if (num2 < 1f) { float num3 = rect.width * num2; if (num3 < 4f) { num3 = Mathf.Max(num3, 2f); float num4 = 1f - num3 / 4f; Color color2 = GUI.color; if (!GUI.enabled) { GUI.color = new Color(1f, 1f, 1f, 0.5f); } GUI.DrawTextureWithTexCoords(new Rect(rect.x, rect.y, num3, rect.height), effectBarStyle.focused.background, new Rect(num4, 0f, 1f - num4, 1f)); GUI.color = color2; } else { effectBarStyle.Draw(new Rect(rect.x, rect.y, num3, rect.height), false, false, false, true); } GUI.DrawTexture(new Rect(rect.x + num3, rect.y, rect.width - num3, rect.height), effectBarStyle.onFocused.background, ScaleMode.StretchToFill); } else { effectBarStyle.Draw(rect, !flag2, false, false, flag2); } } else { effectBarStyle.Draw(rect, false, false, false, false); } if (flag) { this.styles.circularToggle.Draw(new Rect(position.x + 2f, position.y + 5f, position.width - 2f, position.width - 2f), false, false, !effect.bypass, false); } if (effect.IsSend() && effect.sendTarget != null) { position.y -= 1f; GUI.Label(position, this.styles.sendString, EditorStyles.miniLabel); } EditorGUI.BeginDisabledGroup(!flag3); string effectSlotName = this.GetEffectSlotName(effect, flag2, snapshot, p); string effectSlotTooltip = this.GetEffectSlotTooltip(effect, rect, p); GUI.Label(new Rect(rect.x, rect.y, rect.width - 10f, rect.height), GUIContent.Temp(effectSlotName, effectSlotTooltip), this.styles.effectName); EditorGUI.EndDisabledGroup(); } else { this.EffectSlotDragging(effectRect, snapshot, effect, flag2, num, effectIndex, ref highlightEffectIndex, p); } }
public AudioMixerEffectController CopyEffect(AudioMixerEffectController sourceEffect) { AudioMixerEffectController effectController = new AudioMixerEffectController(sourceEffect.effectName); effectController.name = sourceEffect.name; effectController.PreallocateGUIDs(); MixerParameterDefinition[] effectParameters = MixerEffectDefinitions.GetEffectParameters(sourceEffect.effectName); foreach (AudioMixerSnapshotController snapshot in this.snapshots) { float num; if (snapshot.GetValue(sourceEffect.GetGUIDForMixLevel(), out num)) snapshot.SetValue(effectController.GetGUIDForMixLevel(), num); foreach (MixerParameterDefinition parameterDefinition in effectParameters) { if (snapshot.GetValue(sourceEffect.GetGUIDForParameter(parameterDefinition.name), out num)) snapshot.SetValue(effectController.GetGUIDForParameter(parameterDefinition.name), num); } } AssetDatabase.AddObjectToAsset((UnityEngine.Object) effectController, (UnityEngine.Object) this); return effectController; }