// ReSharper disable once FunctionComplexityOverflow
    public override void OnInspectorGUI()
    {
        EditorGUI.indentLevel = 1;
        var isDirty = false;

        _variation = (DynamicGroupVariation)target;

        if (MasterAudioInspectorResources.LogoTexture != null)
        {
            DTGUIHelper.ShowHeaderTexture(MasterAudioInspectorResources.LogoTexture);
        }

        EditorGUI.indentLevel = 0;  // Space will handle this for the header
        var        previewLang = SystemLanguage.English;
        GameObject dgscGO      = null;

        if (_variation.transform.parent != null && _variation.transform.parent.parent != null)
        {
            var parentParent = _variation.transform.parent.parent;

            dgscGO = parentParent.gameObject;

            var dgsc = dgscGO.GetComponent <DynamicSoundGroupCreator>();
            if (dgsc != null)
            {
                previewLang = dgsc.previewLanguage;
            }
        }

        if (dgscGO == null)
        {
            DTGUIHelper.ShowRedError("This prefab must have a GameObject 2 parents up. Prefab broken.");
            return;
        }

        AudioSource previewer;

        EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);
        GUI.contentColor = DTGUIHelper.BrightButtonColor;
        if (GUILayout.Button(new GUIContent("Back to Group", "Select Group in Hierarchy"), EditorStyles.toolbarButton, GUILayout.Width(120)))
        {
            // ReSharper disable once PossibleNullReferenceException
            Selection.activeObject = _variation.transform.parent.gameObject;
        }
        GUILayout.FlexibleSpace();
        GUI.contentColor = Color.white;

        var buttonPressed = DTGUIHelper.AddDynamicVariationButtons();

        switch (buttonPressed)
        {
        case DTGUIHelper.DTFunctionButtons.Play:
            isDirty = true;

            previewer = MasterAudioInspector.GetPreviewer();

            var randPitch = SoundGroupVariationInspector.GetRandomPreviewPitch(_variation);
            var varVol    = SoundGroupVariationInspector.GetRandomPreviewVolume(_variation);

            if (_variation.audLocation != MasterAudio.AudioLocation.FileOnInternet)
            {
                if (previewer != null)
                {
                    MasterAudioInspector.StopPreviewer();
                    previewer.pitch = randPitch;
                }
            }

            var calcVolume = varVol * _variation.ParentGroup.groupMasterVolume;

            switch (_variation.audLocation)
            {
            case MasterAudio.AudioLocation.ResourceFile:
                var fileName = AudioResourceOptimizer.GetLocalizedDynamicSoundGroupFileName(previewLang, _variation.useLocalization, _variation.resourceFileName);

                var clip = Resources.Load(fileName) as AudioClip;
                if (clip != null)
                {
                    if (previewer != null)
                    {
                        previewer.PlayOneShot(clip, calcVolume);
                    }
                }
                else
                {
                    DTGUIHelper.ShowAlert("Could not find Resource file: " + fileName);
                }
                break;

            case MasterAudio.AudioLocation.Clip:
                if (previewer != null)
                {
                    previewer.PlayOneShot(_variation.VarAudio.clip, calcVolume);
                }
                break;

            case MasterAudio.AudioLocation.FileOnInternet:
                if (!string.IsNullOrEmpty(_variation.internetFileUrl))
                {
                    Application.OpenURL(_variation.internetFileUrl);
                }
                break;
            }

            break;

        case DTGUIHelper.DTFunctionButtons.Stop:
            if (_variation.audLocation != MasterAudio.AudioLocation.FileOnInternet)
            {
                MasterAudioInspector.StopPreviewer();
            }
            break;
        }

        EditorGUILayout.EndHorizontal();

        DTGUIHelper.HelpHeader("http://www.dtdevtools.com/docs/masteraudio/SoundGroupVariations.htm");

        if (!Application.isPlaying)
        {
            DTGUIHelper.ShowColorWarning(MasterAudio.PreviewText);
        }

        var oldLocation = _variation.audLocation;

        EditorGUILayout.BeginHorizontal();
        var newLocation = (MasterAudio.AudioLocation)EditorGUILayout.EnumPopup("Audio Origin", _variation.audLocation);

        DTGUIHelper.AddHelpIcon("http://www.dtdevtools.com/docs/masteraudio/SoundGroupVariations.htm#AudioOrigin");
        EditorGUILayout.EndHorizontal();

        if (newLocation != oldLocation)
        {
            AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change Audio Origin");
            _variation.audLocation = newLocation;
        }

        switch (_variation.audLocation)
        {
        case MasterAudio.AudioLocation.Clip:
            var newClip = (AudioClip)EditorGUILayout.ObjectField("Audio Clip", _variation.VarAudio.clip, typeof(AudioClip), false);

            if (newClip != _variation.VarAudio.clip)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation.VarAudio, "assign Audio Clip");
                _variation.VarAudio.clip = newClip;
            }
            break;

        case MasterAudio.AudioLocation.FileOnInternet:
            if (oldLocation != _variation.audLocation)
            {
                if (_variation.VarAudio.clip != null)
                {
                    Debug.Log("Audio clip removed to prevent unnecessary memory usage on File On Internet Variation.");
                }
                _variation.VarAudio.clip = null;
            }

            if (!Application.isPlaying)
            {
                var newUrl = EditorGUILayout.TextField("Internet File URL", _variation.internetFileUrl);
                if (newUrl != _variation.internetFileUrl)
                {
                    AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change Internet File URL");
                    _variation.internetFileUrl = newUrl;
                }
            }

            if (string.IsNullOrEmpty(_variation.internetFileUrl))
            {
                DTGUIHelper.ShowLargeBarAlert("You have not specified a URL for the File On Internet. This Variation will not be available to play without one.");
            }
            break;

        case MasterAudio.AudioLocation.ResourceFile:
            if (oldLocation != _variation.audLocation)
            {
                if (_variation.VarAudio.clip != null)
                {
                    Debug.Log("Audio clip removed to prevent unnecessary memory usage on Resource file Variation.");
                }
                _variation.VarAudio.clip = null;
            }

            EditorGUILayout.BeginVertical();
            var anEvent = Event.current;

            GUI.color = DTGUIHelper.DragAreaColor;
            var dragArea = GUILayoutUtility.GetRect(0f, 20f, GUILayout.ExpandWidth(true));
            GUI.Box(dragArea, "Drag Resource Audio clip here to use its name!");
            GUI.color = Color.white;

            string newFilename;

            switch (anEvent.type)
            {
            case EventType.DragUpdated:
            case EventType.DragPerform:
                if (!dragArea.Contains(anEvent.mousePosition))
                {
                    break;
                }

                DragAndDrop.visualMode = DragAndDropVisualMode.Copy;

                if (anEvent.type == EventType.DragPerform)
                {
                    DragAndDrop.AcceptDrag();

                    foreach (var dragged in DragAndDrop.objectReferences)
                    {
                        var aClip = dragged as AudioClip;
                        if (aClip == null)
                        {
                            continue;
                        }

                        AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change Resource filename");

                        var useLocalization = false;
                        newFilename = DTGUIHelper.GetResourcePath(aClip, ref useLocalization);
                        if (string.IsNullOrEmpty(newFilename))
                        {
                            newFilename = aClip.name;
                        }

                        _variation.resourceFileName = newFilename;
                        _variation.useLocalization  = useLocalization;
                        break;
                    }
                }
                Event.current.Use();
                break;
            }
            EditorGUILayout.EndVertical();

            newFilename = EditorGUILayout.TextField("Resource Filename", _variation.resourceFileName);
            if (newFilename != _variation.resourceFileName)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change Resource filename");
                _variation.resourceFileName = newFilename;
            }

            EditorGUI.indentLevel = 1;

            var newLocal = EditorGUILayout.Toggle("Use Localized Folder", _variation.useLocalization);
            if (newLocal != _variation.useLocalization)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "toggle Use Localized Folder");
                _variation.useLocalization = newLocal;
            }

            break;
        }

        EditorGUI.indentLevel = 0;

        var newProbability = EditorGUILayout.IntSlider("Probability to Play (%)", _variation.probabilityToPlay, 0, 100);

        if (newProbability != _variation.probabilityToPlay)
        {
            AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change Probability to Play (%)");
            _variation.probabilityToPlay = newProbability;
        }

        if (_variation.probabilityToPlay < 100)
        {
            DTGUIHelper.ShowLargeBarAlert("Since Probability to Play is less than 100%, you will not always hear this Variation when it's selected to play.");
        }

        var newVolume = EditorGUILayout.Slider("Volume", _variation.VarAudio.volume, 0f, 1f);

        if (newVolume != _variation.VarAudio.volume)
        {
            AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation.VarAudio, "change Volume");
            _variation.VarAudio.volume = newVolume;
        }

        var newPitch = DTGUIHelper.DisplayPitchField(_variation.VarAudio.pitch);

        if (newPitch != _variation.VarAudio.pitch)
        {
            AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation.VarAudio, "change Pitch");
            _variation.VarAudio.pitch = newPitch;
        }

        if (_variation.ParentGroup.curVariationMode == MasterAudioGroup.VariationMode.LoopedChain)
        {
            DTGUIHelper.ShowLargeBarAlert(MasterAudio.LoopDisabledLoopedChain);
        }
        else if (_variation.useRandomStartTime && _variation.randomEndPercent != 100f)
        {
            DTGUIHelper.ShowLargeBarAlert(MasterAudio.LoopDisabledCustomEnd);
        }
        else
        {
            var newLoop = EditorGUILayout.Toggle("Loop Clip", _variation.VarAudio.loop);
            if (newLoop != _variation.VarAudio.loop)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation.VarAudio, "toggle Loop");
                _variation.VarAudio.loop = newLoop;
            }
        }

        EditorGUILayout.BeginHorizontal();
        var newWeight = EditorGUILayout.IntSlider("Voices (Weight)", _variation.weight, 0, 100);

        DTGUIHelper.AddHelpIcon("http://www.dtdevtools.com/docs/masteraudio/SoundGroupVariations.htm#Voices");
        EditorGUILayout.EndHorizontal();
        if (newWeight != _variation.weight)
        {
            AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change Voices (Weight)");
            _variation.weight = newWeight;
        }


        DTGUIHelper.StartGroupHeader();

        var newUseRndPitch = EditorGUILayout.BeginToggleGroup(" Use Random Pitch", _variation.useRandomPitch);

        if (newUseRndPitch != _variation.useRandomPitch)
        {
            AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "toggle Use Random Pitch");
            _variation.useRandomPitch = newUseRndPitch;
        }
        DTGUIHelper.EndGroupHeader();

        if (_variation.useRandomPitch)
        {
            var newMode = (SoundGroupVariation.RandomPitchMode)EditorGUILayout.EnumPopup("Pitch Compute Mode", _variation.randomPitchMode);
            if (newMode != _variation.randomPitchMode)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change Pitch Compute Mode");
                _variation.randomPitchMode = newMode;
            }

            var newPitchMin = DTGUIHelper.DisplayPitchField(_variation.randomPitchMin, "Random Pitch Min");
            if (newPitchMin != _variation.randomPitchMin)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change Random Pitch Min");
                _variation.randomPitchMin = newPitchMin;
                if (_variation.randomPitchMax <= _variation.randomPitchMin)
                {
                    _variation.randomPitchMax = _variation.randomPitchMin;
                }
            }

            var newPitchMax = DTGUIHelper.DisplayPitchField(_variation.randomPitchMax, "Random Pitch Max");
            if (newPitchMax != _variation.randomPitchMax)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change Random Pitch Max");
                _variation.randomPitchMax = newPitchMax;
                if (_variation.randomPitchMin > _variation.randomPitchMax)
                {
                    _variation.randomPitchMin = _variation.randomPitchMax;
                }
            }
        }

        EditorGUILayout.EndToggleGroup();
        DTGUIHelper.AddSpaceForNonU5(2);

        DTGUIHelper.StartGroupHeader();

        var newUseRndVol = EditorGUILayout.BeginToggleGroup(" Use Random Volume", _variation.useRandomVolume);

        if (newUseRndVol != _variation.useRandomVolume)
        {
            AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "toggle Use Random Volume");
            _variation.useRandomVolume = newUseRndVol;
        }
        DTGUIHelper.EndGroupHeader();

        if (_variation.useRandomVolume)
        {
            var newMode = (SoundGroupVariation.RandomVolumeMode)EditorGUILayout.EnumPopup("Volume Compute Mode", _variation.randomVolumeMode);
            if (newMode != _variation.randomVolumeMode)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change Volume Compute Mode");
                _variation.randomVolumeMode = newMode;
            }

            var volMin = 0f;
            if (_variation.randomVolumeMode == SoundGroupVariation.RandomVolumeMode.AddToClipVolume)
            {
                volMin = -1f;
            }

            var newVolMin = DTGUIHelper.DisplayVolumeField(_variation.randomVolumeMin, DTGUIHelper.VolumeFieldType.None, MasterAudio.MixerWidthMode.Normal, volMin, true, "Random Volume Min");
            if (newVolMin != _variation.randomVolumeMin)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change Random Volume Min");
                _variation.randomVolumeMin = newVolMin;
                if (_variation.randomVolumeMax <= _variation.randomVolumeMin)
                {
                    _variation.randomVolumeMax = _variation.randomVolumeMin;
                }
            }

            var newVolMax = DTGUIHelper.DisplayVolumeField(_variation.randomVolumeMax, DTGUIHelper.VolumeFieldType.None, MasterAudio.MixerWidthMode.Normal, volMin, true, "Random Volume Max");
            if (newVolMax != _variation.randomVolumeMax)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change Random Volume Max");
                _variation.randomVolumeMax = newVolMax;
                if (_variation.randomVolumeMin > _variation.randomVolumeMax)
                {
                    _variation.randomVolumeMin = _variation.randomVolumeMax;
                }
            }
        }

        EditorGUILayout.EndToggleGroup();
        DTGUIHelper.AddSpaceForNonU5(2);

        DTGUIHelper.StartGroupHeader();

        var newSilence = EditorGUILayout.BeginToggleGroup(" Use Random Delay", _variation.useIntroSilence);

        if (newSilence != _variation.useIntroSilence)
        {
            AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "toggle Use Random Delay");
            _variation.useIntroSilence = newSilence;
        }
        DTGUIHelper.EndGroupHeader();

        if (_variation.useIntroSilence)
        {
            var newSilenceMin = EditorGUILayout.Slider("Delay Min (sec)", _variation.introSilenceMin, 0f, 100f);
            if (newSilenceMin != _variation.introSilenceMin)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change Delay Min (sec)");
                _variation.introSilenceMin = newSilenceMin;
                if (_variation.introSilenceMin > _variation.introSilenceMax)
                {
                    _variation.introSilenceMax = newSilenceMin;
                }
            }

            var newSilenceMax = EditorGUILayout.Slider("Delay Max (sec)", _variation.introSilenceMax, 0f, 100f);
            if (newSilenceMax != _variation.introSilenceMax)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change Delay Max (sec)");
                _variation.introSilenceMax = newSilenceMax;
                if (_variation.introSilenceMax < _variation.introSilenceMin)
                {
                    _variation.introSilenceMin = newSilenceMax;
                }
            }
        }
        EditorGUILayout.EndToggleGroup();
        DTGUIHelper.AddSpaceForNonU5(2);

        DTGUIHelper.StartGroupHeader();

        var newStart = EditorGUILayout.BeginToggleGroup(" Use Custom Start/End Position", _variation.useRandomStartTime);

        if (newStart != _variation.useRandomStartTime)
        {
            AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "toggle Use Custom Start/End Position");
            _variation.useRandomStartTime = newStart;
        }
        DTGUIHelper.EndGroupHeader();

        if (_variation.useRandomStartTime)
        {
            var newMin = EditorGUILayout.Slider("Start Min (%)", _variation.randomStartMinPercent, 0f, 100f);
            if (newMin != _variation.randomStartMinPercent)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change Start Min (%)");
                _variation.randomStartMinPercent = newMin;
                if (_variation.randomStartMaxPercent <= _variation.randomStartMinPercent)
                {
                    _variation.randomStartMaxPercent = _variation.randomStartMinPercent;
                }
            }

            var newMax = EditorGUILayout.Slider("Start Max (%)", _variation.randomStartMaxPercent, 0f, 100f);
            if (newMax != _variation.randomStartMaxPercent)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change Start Max (%)");
                _variation.randomStartMaxPercent = newMax;
                if (_variation.randomStartMinPercent > _variation.randomStartMaxPercent)
                {
                    _variation.randomStartMinPercent = _variation.randomStartMaxPercent;
                }
            }

            var newEnd = EditorGUILayout.Slider("End (%)", _variation.randomEndPercent, 0f, 100f);
            if (newEnd != _variation.randomEndPercent || _variation.randomEndPercent < _variation.randomStartMaxPercent)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change End (%)");
                _variation.randomEndPercent = newEnd;
                if (_variation.randomEndPercent < _variation.randomStartMaxPercent)
                {
                    _variation.randomEndPercent = _variation.randomStartMaxPercent;
                }
            }
        }

        EditorGUILayout.EndToggleGroup();
        DTGUIHelper.AddSpaceForNonU5(2);

        if (_variation.VarAudio.loop)
        {
            DTGUIHelper.StartGroupHeader();

            newStart = EditorGUILayout.BeginToggleGroup(" Use Finite Looping", _variation.useCustomLooping);
            if (newStart != _variation.useCustomLooping)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation,
                                                            "toggle Use Finite Looping");
                _variation.useCustomLooping = newStart;
            }
            DTGUIHelper.EndGroupHeader();

            if (_variation.useCustomLooping)
            {
                var newMin = EditorGUILayout.IntSlider("Min Loops", _variation.minCustomLoops, 1, 100);
                if (newMin != _variation.minCustomLoops)
                {
                    AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change Min Loops");
                    _variation.minCustomLoops = newMin;
                    if (_variation.maxCustomLoops <= _variation.minCustomLoops)
                    {
                        _variation.maxCustomLoops = _variation.minCustomLoops;
                    }
                }

                var newMax = EditorGUILayout.IntSlider("Max Loops", _variation.maxCustomLoops, 1, 100);
                if (newMax != _variation.maxCustomLoops)
                {
                    AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change Max Loops");
                    _variation.maxCustomLoops = newMax;
                    if (_variation.minCustomLoops > _variation.maxCustomLoops)
                    {
                        _variation.minCustomLoops = _variation.maxCustomLoops;
                    }
                }
            }

            EditorGUILayout.EndToggleGroup();
            DTGUIHelper.AddSpaceForNonU5(2);
        }

        DTGUIHelper.StartGroupHeader();

        var newUseFades = EditorGUILayout.BeginToggleGroup(" Use Custom Fading", _variation.useFades);

        if (newUseFades != _variation.useFades)
        {
            AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "toggle Use Custom Fading");
            _variation.useFades = newUseFades;
        }
        DTGUIHelper.EndGroupHeader();

        if (_variation.useFades)
        {
            var newFadeIn = EditorGUILayout.Slider("Fade In Time (sec)", _variation.fadeInTime, 0f, 10f);
            if (newFadeIn != _variation.fadeInTime)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change Fade In Time");
                _variation.fadeInTime = newFadeIn;
            }

            if (_variation.VarAudio.loop)
            {
                DTGUIHelper.ShowColorWarning("Looped clips cannot have a custom fade out.");
            }
            else
            {
                var newFadeOut = EditorGUILayout.Slider("Fade Out time (sec)", _variation.fadeOutTime, 0f, 10f);
                if (newFadeOut != _variation.fadeOutTime)
                {
                    AudioUndoHelper.RecordObjectPropertyForUndo(ref isDirty, _variation, "change Fade Out Time");
                    _variation.fadeOutTime = newFadeOut;
                }
            }
        }

        EditorGUILayout.EndToggleGroup();

        if (GUI.changed || isDirty)
        {
            EditorUtility.SetDirty(target);
        }

        //DrawDefaultInspector();
    }
    public override void OnInspectorGUI()
    {
        EditorGUIUtility.LookLikeControls();

        EditorGUI.indentLevel = 1;
        var isDirty = false;

        _variation = (DynamicGroupVariation)target;

        if (MasterAudioInspectorResources.logoTexture != null)
        {
            DTGUIHelper.ShowHeaderTexture(MasterAudioInspectorResources.logoTexture);
        }

        EditorGUI.indentLevel = 0;  // Space will handle this for the header

        DynamicSoundGroupCreator creator = null;

        if (_variation.transform.parent != null && _variation.transform.parent.parent != null)
        {
            creator = _variation.transform.parent.parent.GetComponent <DynamicSoundGroupCreator>();
        }

        if (creator == null)
        {
            DTGUIHelper.ShowRedError("This prefab must have DynamicSoundGroupCreator 2 parents up.");
            return;
        }

        EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);
        GUI.contentColor = Color.green;
        if (GUILayout.Button(new GUIContent("Back to Group", "Select Group in Hierarchy"), EditorStyles.toolbarButton, GUILayout.Width(120)))
        {
            Selection.activeObject = _variation.transform.parent.gameObject;
        }
        GUILayout.FlexibleSpace();
        GUI.contentColor = Color.white;

        var buttonPressed = DTGUIHelper.AddDynamicVariationButtons();

        switch (buttonPressed)
        {
        case DTGUIHelper.DTFunctionButtons.Play:
            isDirty = true;
            if (_variation.audLocation == MasterAudio.AudioLocation.ResourceFile)
            {
                creator.PreviewerInstance.Stop();
                creator.PreviewerInstance.PlayOneShot(Resources.Load(_variation.resourceFileName) as AudioClip);
            }
            else
            {
                PlaySound(_variation.audio);
            }
            break;

        case DTGUIHelper.DTFunctionButtons.Stop:
            if (_variation.audLocation == MasterAudio.AudioLocation.ResourceFile)
            {
                creator.PreviewerInstance.Stop();
            }
            else
            {
                StopSound(_variation.audio);
            }
            break;
        }

        EditorGUILayout.EndHorizontal();

        if (!Application.isPlaying)
        {
            DTGUIHelper.ShowColorWarning("*Fading & random settings are ignored by preview in edit mode.");
        }

        var oldLocation = _variation.audLocation;
        var newLocation = (MasterAudio.AudioLocation)EditorGUILayout.EnumPopup("Audio Origin", _variation.audLocation);

        if (newLocation != oldLocation)
        {
            UndoHelper.RecordObjectPropertyForUndo(_variation, "change Audio Origin");
            _variation.audLocation = newLocation;
        }

        switch (_variation.audLocation)
        {
        case MasterAudio.AudioLocation.Clip:
            var newClip = (AudioClip)EditorGUILayout.ObjectField("Audio Clip", _variation.audio.clip, typeof(AudioClip), false);

            if (newClip != _variation.audio.clip)
            {
                UndoHelper.RecordObjectPropertyForUndo(_variation.audio, "assign Audio Clip");
                _variation.audio.clip = newClip;
            }
            break;

        case MasterAudio.AudioLocation.ResourceFile:
            if (oldLocation != _variation.audLocation)
            {
                if (_variation.audio.clip != null)
                {
                    Debug.Log("Audio clip removed to prevent unnecessary memory usage on Resource file Variation.");
                }
                _variation.audio.clip = null;
            }

            EditorGUILayout.BeginVertical();
            var anEvent = Event.current;

            GUI.color = Color.yellow;
            var dragArea = GUILayoutUtility.GetRect(0f, 20f, GUILayout.ExpandWidth(true));
            GUI.Box(dragArea, "Drag Resource Audio clip here to use its name!");
            GUI.color = Color.white;

            var newFilename = string.Empty;

            switch (anEvent.type)
            {
            case EventType.DragUpdated:
            case EventType.DragPerform:
                if (!dragArea.Contains(anEvent.mousePosition))
                {
                    break;
                }

                DragAndDrop.visualMode = DragAndDropVisualMode.Copy;

                if (anEvent.type == EventType.DragPerform)
                {
                    DragAndDrop.AcceptDrag();

                    foreach (var dragged in DragAndDrop.objectReferences)
                    {
                        var aClip = dragged as AudioClip;
                        if (aClip == null)
                        {
                            continue;
                        }

                        newFilename = DTGUIHelper.GetResourcePath(aClip);
                        if (string.IsNullOrEmpty(newFilename))
                        {
                            newFilename = aClip.name;
                        }

                        if (newFilename != _variation.resourceFileName)
                        {
                            UndoHelper.RecordObjectPropertyForUndo(_variation, "change Resource filename");
                            _variation.resourceFileName = aClip.name;
                        }
                        break;
                    }
                }
                Event.current.Use();
                break;
            }
            EditorGUILayout.EndVertical();

            newFilename = EditorGUILayout.TextField("Resource Filename", _variation.resourceFileName);
            if (newFilename != _variation.resourceFileName)
            {
                UndoHelper.RecordObjectPropertyForUndo(_variation, "change Resource filename");
                _variation.resourceFileName = newFilename;
            }
            break;
        }

        var newVolume = EditorGUILayout.Slider("Volume", _variation.audio.volume, 0f, 1f);

        if (newVolume != _variation.audio.volume)
        {
            UndoHelper.RecordObjectPropertyForUndo(_variation.audio, "change Volume");
            _variation.audio.volume = newVolume;
        }

        var newPitch = EditorGUILayout.Slider("Pitch", _variation.audio.pitch, -3f, 3f);

        if (newPitch != _variation.audio.pitch)
        {
            UndoHelper.RecordObjectPropertyForUndo(_variation.audio, "change Pitch");
            _variation.audio.pitch = newPitch;
        }

        var newLoop = EditorGUILayout.Toggle("Loop Clip", _variation.audio.loop);

        if (newLoop != _variation.audio.loop)
        {
            UndoHelper.RecordObjectPropertyForUndo(_variation.audio, "toggle Loop");
            _variation.audio.loop = newLoop;
        }

        var newRandomPitch = EditorGUILayout.Slider("Random Pitch", _variation.randomPitch, 0f, 3f);

        if (newRandomPitch != _variation.randomPitch)
        {
            UndoHelper.RecordObjectPropertyForUndo(_variation, "change Random Pitch");
            _variation.randomPitch = newRandomPitch;
        }

        var newRandomVolume = EditorGUILayout.Slider("Random Volume", _variation.randomVolume, 0f, 1f);

        if (newRandomVolume != _variation.randomVolume)
        {
            UndoHelper.RecordObjectPropertyForUndo(_variation, "change Random Volume");
            _variation.randomVolume = newRandomVolume;
        }

        var newWeight = EditorGUILayout.IntSlider("Weight (Instances)", _variation.weight, 0, 100);

        if (newWeight != _variation.weight)
        {
            UndoHelper.RecordObjectPropertyForUndo(_variation, "change Weight");
            _variation.weight = newWeight;
        }

        if (_variation.HasActiveFXFilter)
        {
            var newFxTailTime = EditorGUILayout.Slider("FX Tail Time", _variation.fxTailTime, 0f, 10f);
            if (newFxTailTime != _variation.fxTailTime)
            {
                UndoHelper.RecordObjectPropertyForUndo(_variation, "change FX Tail Time");
                _variation.fxTailTime = newFxTailTime;
            }
        }

        var newSilence = EditorGUILayout.BeginToggleGroup("Use Random Delay", _variation.useIntroSilence);

        if (newSilence != _variation.useIntroSilence)
        {
            UndoHelper.RecordObjectPropertyForUndo(_variation, "toggle Use Random Delay");
            _variation.useIntroSilence = newSilence;
        }

        if (_variation.useIntroSilence)
        {
            var newSilenceMin = EditorGUILayout.Slider("Delay Min (sec)", _variation.introSilenceMin, 0f, 100f);
            if (newSilenceMin != _variation.introSilenceMin)
            {
                UndoHelper.RecordObjectPropertyForUndo(_variation, "change Delay Min (sec)");
                _variation.introSilenceMin = newSilenceMin;
                if (_variation.introSilenceMin > _variation.introSilenceMax)
                {
                    _variation.introSilenceMax = newSilenceMin;
                }
            }

            var newSilenceMax = EditorGUILayout.Slider("Delay Max (sec)", _variation.introSilenceMax, 0f, 100f);
            if (newSilenceMax != _variation.introSilenceMax)
            {
                UndoHelper.RecordObjectPropertyForUndo(_variation, "change Delay Max (sec)");
                _variation.introSilenceMax = newSilenceMax;
                if (_variation.introSilenceMax < _variation.introSilenceMin)
                {
                    _variation.introSilenceMin = newSilenceMax;
                }
            }
        }
        EditorGUILayout.EndToggleGroup();

        var newUseFades = EditorGUILayout.BeginToggleGroup("Use Custom Fading", _variation.useFades);

        if (newUseFades != _variation.useFades)
        {
            UndoHelper.RecordObjectPropertyForUndo(_variation, "toggle Use Custom Fading");
            _variation.useFades = newUseFades;
        }

        if (_variation.useFades)
        {
            var newFadeIn = EditorGUILayout.Slider("Fade In Time (sec)", _variation.fadeInTime, 0f, 10f);
            if (newFadeIn != _variation.fadeInTime)
            {
                UndoHelper.RecordObjectPropertyForUndo(_variation, "change Fade In Time");
                _variation.fadeInTime = newFadeIn;
            }

            if (_variation.audio.loop)
            {
                DTGUIHelper.ShowColorWarning("*Looped clips cannot have a custom fade out.");
            }
            else
            {
                var newFadeOut = EditorGUILayout.Slider("Fade Out time (sec)", _variation.fadeOutTime, 0f, 10f);
                if (newFadeOut != _variation.fadeOutTime)
                {
                    UndoHelper.RecordObjectPropertyForUndo(_variation, "change Fade Out Time");
                    _variation.fadeOutTime = newFadeOut;
                }
            }
        }

        EditorGUILayout.EndToggleGroup();

        var filterList = new List <string>()
        {
            MasterAudio.NO_GROUP_NAME,
            "Low Pass",
            "High Pass",
            "Distortion",
            "Chorus",
            "Echo",
            "Reverb"
        };

        var newFilterIndex = EditorGUILayout.Popup("Add Filter Effect", 0, filterList.ToArray());

        switch (newFilterIndex)
        {
        case 1:
            AddFilterComponent(typeof(AudioLowPassFilter));
            break;

        case 2:
            AddFilterComponent(typeof(AudioHighPassFilter));
            break;

        case 3:
            AddFilterComponent(typeof(AudioDistortionFilter));
            break;

        case 4:
            AddFilterComponent(typeof(AudioChorusFilter));
            break;

        case 5:
            AddFilterComponent(typeof(AudioEchoFilter));
            break;

        case 6:
            AddFilterComponent(typeof(AudioReverbFilter));
            break;
        }

        if (GUI.changed || isDirty)
        {
            EditorUtility.SetDirty(target);
        }

        this.Repaint();

        //DrawDefaultInspector();
    }
Esempio n. 3
0
        public override void OnInspectorGUI()
        {
            MasterAudio.Instance = null;

            var _ma        = MasterAudio.Instance;
            var _maInScene = _ma != null;

            if (_maInScene)
            {
                DTGUIHelper.ShowHeaderTexture(MasterAudioInspectorResources.LogoTexture);
            }

            DTGUIHelper.HelpHeader("http://www.dtdevtools.com/docs/masteraudio/AmbientSound.htm");

            var canUse = true;

#if !PHY3D_ENABLED
            canUse = false;
#endif
            if (!canUse)
            {
                DTGUIHelper.ShowLargeBarAlert("You must enable 3D Physics support for your Collider or Trigger or this script will not function. Use the Welcome Window to do that, then this Inspector will show its controls.");
                return;
            }

            var _isDirty = false;

            var _sounds = (DarkTonic.MasterAudio.AmbientSound)target;

            var _groupNames = new List <string>();

            if (_maInScene)
            {
                // ReSharper disable once PossibleNullReferenceException
                _groupNames = _ma.GroupNames;
            }

            PopulateItemNames(_groupNames);

            if (GUI.changed || _isDirty)
            {
                EditorUtility.SetDirty(target);
            }

            if (_maInScene)
            {
                var existingIndex = _groupNames.IndexOf(_sounds.AmbientSoundGroup);

                int?groupIndex = null;

                var noGroup = false;
                var noMatch = false;

                if (existingIndex >= 1)
                {
                    EditorGUILayout.BeginHorizontal();
                    groupIndex = EditorGUILayout.Popup("Ambient Sound Group", existingIndex, _groupNames.ToArray());
                    if (existingIndex == 1)
                    {
                        noGroup = true;
                    }

                    var isUsingVideoPlayersGroup = false;

                    if (_groupNames[groupIndex.Value] == MasterAudio.VideoPlayerSoundGroupName)
                    {
                        isUsingVideoPlayersGroup = true;
                    }

                    if (groupIndex > MasterAudio.HardCodedBusOptions - 1)
                    {
                        var button = DTGUIHelper.AddSettingsButton("Ambient Sound Group");
                        switch (button)
                        {
                        case DTGUIHelper.DTFunctionButtons.Go:
                            var grp = _groupNames[existingIndex];
                            var trs = MasterAudio.FindGroupTransform(grp);
                            if (trs != null)
                            {
                                Selection.activeObject = trs;
                            }
                            break;
                        }

                        var buttonPress = DTGUIHelper.AddDynamicVariationButtons();
                        var sType       = _groupNames[existingIndex];

                        switch (buttonPress)
                        {
                        case DTGUIHelper.DTFunctionButtons.Play:
                            DTGUIHelper.PreviewSoundGroup(sType);
                            break;

                        case DTGUIHelper.DTFunctionButtons.Stop:
                            DTGUIHelper.StopPreview(sType);
                            break;
                        }
                    }

                    EditorGUILayout.EndHorizontal();
                    if (isUsingVideoPlayersGroup)
                    {
                        DTGUIHelper.ShowRedError(MasterAudio.VideoPlayersSoundGroupSelectedError);
                    }
                }
                else if (existingIndex == -1 && _sounds.AmbientSoundGroup == MasterAudio.NoGroupName)
                {
                    groupIndex = EditorGUILayout.Popup("Ambient Sound Group", existingIndex, _groupNames.ToArray());
                }
                else
                { // non-match
                    noMatch = true;
                    var newSound = EditorGUILayout.TextField("Ambient Sound Group", _sounds.AmbientSoundGroup);
                    if (newSound != _sounds.AmbientSoundGroup)
                    {
                        AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "change Ambient Sound Group");
                        _sounds.AmbientSoundGroup = newSound;
                        _sounds.CalculateRadius();
                    }

                    var newIndex = EditorGUILayout.Popup("All Sound Groups", -1, _groupNames.ToArray());
                    if (newIndex >= 0)
                    {
                        groupIndex = newIndex;
                    }
                }

                if (noGroup)
                {
                    DTGUIHelper.ShowRedError("No Ambient Sound Group specified.");
                }
                else if (noMatch)
                {
                    DTGUIHelper.ShowRedError("Ambient Sound Group found no match. Type in or choose one.");
                }

                if (groupIndex.HasValue)
                {
                    if (existingIndex != groupIndex.Value)
                    {
                        AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "change Ambient Sound Group");
                    }
                    switch (groupIndex.Value)
                    {
                    case -1:
                        _sounds.AmbientSoundGroup = MasterAudio.NoGroupName;
                        break;

                    default:
                        _sounds.AmbientSoundGroup = _groupNames[groupIndex.Value];
                        break;
                    }
                    _sounds.CalculateRadius();
                }
            }
            else
            {
                var newSType = EditorGUILayout.TextField("Ambient Sound Group", _sounds.AmbientSoundGroup);
                if (newSType != _sounds.AmbientSoundGroup)
                {
                    AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "change Ambient Sound Group");
                    _sounds.CalculateRadius();
                    _sounds.AmbientSoundGroup = newSType;
                }
            }

            var newVol = DTGUIHelper.DisplayVolumeField(_sounds.playVolume, DTGUIHelper.VolumeFieldType.None, MasterAudio.MixerWidthMode.Normal, 0f, true);
            if (newVol != _sounds.playVolume)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "change Volume");
                _sounds.playVolume = newVol;
            }

            var newVarType = (EventSounds.VariationType)EditorGUILayout.EnumPopup("Variation Mode", _sounds.variationType);
            if (newVarType != _sounds.variationType)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "change Variation Mode");
                _sounds.CalculateRadius();
                _sounds.variationType = newVarType;
            }

            if (_sounds.variationType == EventSounds.VariationType.PlaySpecific)
            {
                var newVarName = EditorGUILayout.TextField("Variation Name", _sounds.variationName);
                if (newVarName != _sounds.variationName)
                {
                    AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "change Variation Name");
                    _sounds.CalculateRadius();
                    _sounds.variationName = newVarName;
                }

                if (string.IsNullOrEmpty(_sounds.variationName))
                {
                    DTGUIHelper.ShowRedError("Variation Name is empty. No sound will play.");
                }
            }

            var newExitMode = (MasterAudio.AmbientSoundExitMode)EditorGUILayout.EnumPopup("Trigger Exit Behavior", _sounds.exitMode);
            if (newExitMode != _sounds.exitMode)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "change Trigger Exit Behavior");
                _sounds.exitMode = newExitMode;
            }

            if (_sounds.exitMode == MasterAudio.AmbientSoundExitMode.FadeSound)
            {
                var newFadeTime = EditorGUILayout.Slider("Fade Time (sec)", _sounds.exitFadeTime, .2f, 10f);
                if (newFadeTime != _sounds.exitFadeTime)
                {
                    AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "change Fade Time (sec)");
                    _sounds.exitFadeTime = newFadeTime;
                }

                var reEnterMode = (MasterAudio.AmbientSoundReEnterMode)EditorGUILayout.EnumPopup("Trigger Re-Enter Behavior", _sounds.reEnterMode);
                if (reEnterMode != _sounds.reEnterMode)
                {
                    AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "change Trigger Re-Enter Behavior");
                    _sounds.reEnterMode = reEnterMode;
                }

                if (_sounds.reEnterMode == MasterAudio.AmbientSoundReEnterMode.FadeInSameSound)
                {
                    var newFadeIn = EditorGUILayout.Slider("Fade In Time (sec)", _sounds.reEnterFadeTime, .2f, 10f);
                    if (newFadeIn != _sounds.reEnterFadeTime)
                    {
                        AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "change Fade In Time (sec)");
                        _sounds.reEnterFadeTime = newFadeIn;
                    }
                }
            }

            var aud = _sounds.GetNamedOrFirstAudioSource();
            if (aud != null)
            {
                var newMin = EditorGUILayout.Slider("Min Distance", aud.minDistance, .1f, aud.maxDistance);
                if (newMin != aud.minDistance)
                {
                    AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, aud, "change Min Distance");

                    switch (_sounds.variationType)
                    {
                    case EventSounds.VariationType.PlayRandom:
                        var sources = _sounds.GetAllVariationAudioSources();
                        if (sources != null)
                        {
                            for (var i = 0; i < sources.Count; i++)
                            {
                                var src = sources[i];
                                src.minDistance = newMin;
                                EditorUtility.SetDirty(src);
                            }
                        }
                        break;

                    case EventSounds.VariationType.PlaySpecific:
                        aud.minDistance = newMin;
                        EditorUtility.SetDirty(aud);
                        break;
                    }
                }

                var newMax = EditorGUILayout.Slider("Max Distance", aud.maxDistance, aud.minDistance, 1000000f);
                if (newMax != aud.maxDistance)
                {
                    AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, aud, "change Max Distance");

                    switch (_sounds.variationType)
                    {
                    case EventSounds.VariationType.PlayRandom:
                        var sources = _sounds.GetAllVariationAudioSources();
                        if (sources != null)
                        {
                            for (var i = 0; i < sources.Count; i++)
                            {
                                var src = sources[i];
                                src.maxDistance = newMax;
                                EditorUtility.SetDirty(src);
                            }
                        }
                        break;

                    case EventSounds.VariationType.PlaySpecific:
                        aud.maxDistance = newMax;
                        EditorUtility.SetDirty(aud);
                        break;
                    }
                }
                switch (_sounds.variationType)
                {
                case EventSounds.VariationType.PlayRandom:
                    DTGUIHelper.ShowLargeBarAlert("Adjusting the Min/Max Distance field will change the Min/Max Distance field(s) on the Audio Source of every Variation in the selected Sound Group.");
                    break;

                case EventSounds.VariationType.PlaySpecific:
                    DTGUIHelper.ShowLargeBarAlert("Adjusting the Min/Max Distance field will change the Min/Max Distance field(s) on the Audio Source for the selected Variation in the selected Sound Group.");
                    break;
                }
                DTGUIHelper.ShowColorWarning("You can also bulk apply Min/Max Distance and other Audio Source properties with Audio Source Templates using the Master Audio Mixer.");
            }

            DTGUIHelper.StartGroupHeader();
            var newClosest = GUILayout.Toggle(_sounds.UseClosestColliderPosition, new GUIContent(" Use Closest Collider Position", "Using this option, the Audio Source will be updated every frame to the closest position on the caller's collider(s)."));
            if (newClosest != _sounds.UseClosestColliderPosition)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "toggle Follow Caller");
                _sounds.UseClosestColliderPosition = newClosest;
            }

            EditorGUILayout.EndVertical();
            if (_sounds.UseClosestColliderPosition)
            {
                var newTop = EditorGUILayout.Toggle("Use Top Collider", _sounds.UseTopCollider);
                if (newTop != _sounds.UseTopCollider)
                {
                    AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "toggle Use Top Collider");
                    _sounds.UseTopCollider = newTop;
                }
                var newChild = EditorGUILayout.Toggle("Use Child G.O. Colliders", _sounds.IncludeChildColliders);
                if (newChild != _sounds.IncludeChildColliders)
                {
                    AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "toggle Use Child G.O. Colliders");
                    _sounds.IncludeChildColliders = newChild;
                }

                var colliderObjects = new List <GameObject>();

                if (_sounds.UseTopCollider)
                {
                    var collider   = _sounds.GetComponent <Collider>();
                    var collider2d = _sounds.GetComponent <Collider2D>();
                    if (collider != null)
                    {
                        colliderObjects.Add(collider.gameObject);
                    }
                    else if (collider2d != null)
                    {
                        colliderObjects.Add(collider2d.gameObject);
                    }
                }
                if (_sounds.IncludeChildColliders)
                {
                    for (var i = 0; i < _sounds.transform.childCount; i++)
                    {
                        var child      = _sounds.transform.GetChild(i);
                        var collider   = child.GetComponent <Collider>();
                        var collider2d = child.GetComponent <Collider2D>();
                        if (collider != null)
                        {
                            colliderObjects.Add(collider.gameObject);
                        }
                        else if (collider2d != null)
                        {
                            colliderObjects.Add(collider2d.gameObject);
                        }
                    }
                }

                if (colliderObjects.Count == 0)
                {
                    DTGUIHelper.ShowRedError("You have zero Colliders selected, so this functionality will not work.");
                }
                else
                {
                    EditorGUILayout.BeginHorizontal();
                    DTGUIHelper.ShowColorWarning("Colliders used: " + colliderObjects.Count);
                    if (GUILayout.Button("Select\nColliders", GUILayout.Width(70)))
                    {
                        Selection.objects = colliderObjects.ToArray();
                    }
                    EditorGUILayout.EndHorizontal();
                }

                EditorGUILayout.EndVertical();
            }
            else
            {
                EditorGUILayout.EndVertical();

                DTGUIHelper.StartGroupHeader();
                var newFollow =
                    GUILayout.Toggle(_sounds.FollowCaller, new GUIContent(" Follow Caller",
                                                                          "This option is useful if your caller ever moves, as it will make the Audio Source follow to the location of the caller every frame."));
                if (newFollow != _sounds.FollowCaller)
                {
                    AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "toggle Follow Caller");
                    _sounds.FollowCaller = newFollow;
                }
                EditorGUILayout.EndVertical();
                if (_sounds.FollowCaller)
                {
                    DTGUIHelper.ShowColorWarning("Will follow caller at runtime.");
                }
                EditorGUILayout.EndVertical();
            }

            if (Application.isPlaying)
            {
                EditorGUILayout.BeginHorizontal();
                GUILayout.Label("Follower Object");
                EditorGUILayout.ObjectField(_sounds.RuntimeFollower, typeof(Transform), false);
                EditorGUILayout.EndHorizontal();
            }

            //DrawDefaultInspector();
        }
    public override void OnInspectorGUI()
    {
        MasterAudio.Instance = null;

        var _ma        = MasterAudio.Instance;
        var _maInScene = _ma != null;

        if (_maInScene)
        {
            DTGUIHelper.ShowHeaderTexture(MasterAudioInspectorResources.LogoTexture);
        }

        _isDirty = false;

        DTGUIHelper.HelpHeader("http://www.dtdevtools.com/docs/masteraudio/AmbientSound.htm");

        var _sounds = (AmbientSound)target;

        var _groupNames = new List <string>();

        if (_maInScene)
        {
            // ReSharper disable once PossibleNullReferenceException
            _groupNames = _ma.GroupNames;
        }

        PopulateItemNames(_groupNames);

        if (GUI.changed || _isDirty)
        {
            EditorUtility.SetDirty(target);
        }

        if (_maInScene)
        {
            var existingIndex = _groupNames.IndexOf(_sounds.AmbientSoundGroup);

            int?groupIndex = null;

            var noGroup = false;
            var noMatch = false;

            if (existingIndex >= 1)
            {
                EditorGUILayout.BeginHorizontal();
                groupIndex = EditorGUILayout.Popup("Ambient Sound Group", existingIndex, _groupNames.ToArray());
                if (existingIndex == 1)
                {
                    noGroup = true;
                }

                if (groupIndex > MasterAudio.HardCodedBusOptions - 1)
                {
                    var button = DTGUIHelper.AddSettingsButton("Ambient Sound Group");
                    switch (button)
                    {
                    case DTGUIHelper.DTFunctionButtons.Go:
                        var grp = _groupNames[existingIndex];
                        var trs = MasterAudio.FindGroupTransform(grp);
                        if (trs != null)
                        {
                            Selection.activeObject = trs;
                        }
                        break;
                    }

                    var buttonPress = DTGUIHelper.AddDynamicVariationButtons();
                    var sType       = _groupNames[existingIndex];

                    switch (buttonPress)
                    {
                    case DTGUIHelper.DTFunctionButtons.Play:
                        DTGUIHelper.PreviewSoundGroup(sType);
                        break;

                    case DTGUIHelper.DTFunctionButtons.Stop:
                        DTGUIHelper.StopPreview(sType);
                        break;
                    }
                }

                EditorGUILayout.EndHorizontal();
            }
            else if (existingIndex == -1 && _sounds.AmbientSoundGroup == MasterAudio.NoGroupName)
            {
                groupIndex = EditorGUILayout.Popup("Ambient Sound Group", existingIndex, _groupNames.ToArray());
            }
            else     // non-match
            {
                noMatch = true;
                var newSound = EditorGUILayout.TextField("Ambient Sound Group", _sounds.AmbientSoundGroup);
                if (newSound != _sounds.AmbientSoundGroup)
                {
                    AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "change Ambient Sound Group");
                    _sounds.AmbientSoundGroup = newSound;
                }

                var newIndex = EditorGUILayout.Popup("All Sound Groups", -1, _groupNames.ToArray());
                if (newIndex >= 0)
                {
                    groupIndex = newIndex;
                }
            }

            if (noGroup)
            {
                DTGUIHelper.ShowRedError("No Ambient Sound Group specified.");
            }
            else if (noMatch)
            {
                DTGUIHelper.ShowRedError("Ambient Sound Group found no match. Type in or choose one.");
            }

            if (groupIndex.HasValue)
            {
                if (existingIndex != groupIndex.Value)
                {
                    AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "change Ambient Sound Group");
                }
                switch (groupIndex.Value)
                {
                case -1:
                    _sounds.AmbientSoundGroup = MasterAudio.NoGroupName;
                    break;

                default:
                    _sounds.AmbientSoundGroup = _groupNames[groupIndex.Value];
                    break;
                }
            }
        }
        else
        {
            var newSType = EditorGUILayout.TextField("Ambient Sound Group", _sounds.AmbientSoundGroup);
            if (newSType != _sounds.AmbientSoundGroup)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "change Ambient Sound Group");
                _sounds.AmbientSoundGroup = newSType;
            }
        }

                #if UNITY_5_6_OR_NEWER
        DTGUIHelper.StartGroupHeader();
        var newClosest = GUILayout.Toggle(_sounds.UseClosestColliderPosition, new GUIContent(" Use Closest Collider Position", "Using this option, the Audio Source will be updated every frame to the closest position on the caller's collider(s)."));
        if (newClosest != _sounds.UseClosestColliderPosition)
        {
            AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "toggle Follow Caller");
            _sounds.UseClosestColliderPosition = newClosest;
        }

        EditorGUILayout.EndVertical();
        if (_sounds.UseClosestColliderPosition)
        {
            var newTop = EditorGUILayout.Toggle("Use Top Collider", _sounds.UseTopCollider);
            if (newTop != _sounds.UseTopCollider)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "toggle Use Top Collider");
                _sounds.UseTopCollider = newTop;
            }
            var newChild = EditorGUILayout.Toggle("Use Child G.O. Colliders", _sounds.IncludeChildColliders);
            if (newChild != _sounds.IncludeChildColliders)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "toggle Use Child G.O. Colliders");
                _sounds.IncludeChildColliders = newChild;
            }

            var colliderObjects = new List <GameObject>();

            if (_sounds.UseTopCollider)
            {
                var collider   = _sounds.GetComponent <Collider>();
                var collider2d = _sounds.GetComponent <Collider2D>();
                if (collider != null)
                {
                    colliderObjects.Add(collider.gameObject);
                }
                else if (collider2d != null)
                {
                    colliderObjects.Add(collider2d.gameObject);
                }
            }
            if (_sounds.IncludeChildColliders)
            {
                for (var i = 0; i < _sounds.transform.childCount; i++)
                {
                    var child      = _sounds.transform.GetChild(i);
                    var collider   = child.GetComponent <Collider>();
                    var collider2d = child.GetComponent <Collider2D>();
                    if (collider != null)
                    {
                        colliderObjects.Add(collider.gameObject);
                    }
                    else if (collider2d != null)
                    {
                        colliderObjects.Add(collider2d.gameObject);
                    }
                }
            }

            if (colliderObjects.Count == 0)
            {
                DTGUIHelper.ShowRedError("You have zero Colliders selected, so this functionality will not work.");
            }
            else
            {
                EditorGUILayout.BeginHorizontal();
                DTGUIHelper.ShowColorWarning("Colliders used: " + colliderObjects.Count);
                if (GUILayout.Button("Select\nColliders", GUILayout.Width(70)))
                {
                    Selection.objects = colliderObjects.ToArray();
                }
                EditorGUILayout.EndHorizontal();
            }

            EditorGUILayout.EndVertical();
            //DTGUIHelper.ShowColorWarning("Use Closest Collider Position takes precedence over Follow Caller, so that option is hidden.");
        }
        else
        {
            EditorGUILayout.EndVertical();
            DTGUIHelper.StartGroupHeader();
            var newFollow =
                GUILayout.Toggle(_sounds.FollowCaller, new GUIContent(" Follow Caller",
                                                                      "This option is useful if your caller ever moves, as it will make the Audio Source follow to the location of the caller every frame."));
            if (newFollow != _sounds.FollowCaller)
            {
                AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "toggle Follow Caller");
                _sounds.FollowCaller = newFollow;
            }
            EditorGUILayout.EndVertical();
            if (_sounds.FollowCaller)
            {
                DTGUIHelper.ShowColorWarning("Will follow caller at runtime.");
            }
            EditorGUILayout.EndVertical();
        }
#else
        DTGUIHelper.StartGroupHeader();
        var newFollow =
            GUILayout.Toggle(_sounds.FollowCaller, new GUIContent(" Follow Caller",
                                                                  "This option is useful if your caller ever moves, as it will make the Audio Source follow to the location of the caller every frame."));
        if (newFollow != _sounds.FollowCaller)
        {
            AudioUndoHelper.RecordObjectPropertyForUndo(ref _isDirty, _sounds, "toggle Follow Caller");
            _sounds.FollowCaller = newFollow;
        }
        EditorGUILayout.EndVertical();
        if (_sounds.FollowCaller)
        {
            DTGUIHelper.ShowColorWarning("Will follow caller at runtime.");
        }
        EditorGUILayout.EndVertical();
#endif

        if (Application.isPlaying)
        {
            EditorGUILayout.BeginHorizontal();
            GUILayout.Label("Follower Object");
            EditorGUILayout.ObjectField(_sounds.RuntimeFollower, typeof(Transform), false);
            EditorGUILayout.EndHorizontal();
        }

        //DrawDefaultInspector();
    }