private void OnAudioImporterGUI(bool selectionContainsTrackerFile)
        {
            if (!selectionContainsTrackerFile)
            {
                EditorGUILayout.PropertyField(m_ForceToMono);
                EditorGUI.indentLevel++;
                using (new EditorGUI.DisabledScope(!m_ForceToMono.boolValue))
                {
                    EditorGUILayout.PropertyField(m_Normalize);
                }
                EditorGUI.indentLevel--;
                EditorGUILayout.PropertyField(m_LoadInBackground);
                EditorGUILayout.PropertyField(m_Ambisonic);
            }

            BuildPlatform[] validPlatforms = BuildPlatforms.instance.GetValidPlatforms().ToArray();
            GUILayout.Space(10);
            int shownSettingsPage = EditorGUILayout.BeginPlatformGrouping(validPlatforms, GUIContent.Temp("Default"));

            if (shownSettingsPage == -1)
            {
                // If the loadtype is streaming on the selected platform, gray out the "Preload Audio Data" option and show the checkbox as unchecked.
                bool disablePreloadAudioDataOption = (m_DefaultSampleSettings.settings.loadType == AudioClipLoadType.Streaming);

                MultiValueStatus multiStatus = GetMultiValueStatus(BuildTargetGroup.Unknown);
                OnSampleSettingGUI(BuildTargetGroup.Unknown, multiStatus, selectionContainsTrackerFile, ref m_DefaultSampleSettings, disablePreloadAudioDataOption);
            }
            else
            {
                BuildTargetGroup        platform   = validPlatforms[shownSettingsPage].targetGroup;
                SampleSettingProperties properties = m_SampleSettingOverrides[platform];
                OverrideStatus          status     = GetOverrideStatus(platform);

                // Define the UI state of the override here.
                EditorGUI.BeginChangeCheck();
                EditorGUI.showMixedValue = (status == OverrideStatus.MixedOverrides) && !properties.overrideIsForced;
                bool overrideState = (properties.overrideIsForced && properties.forcedOverrideState) ||
                                     (!properties.overrideIsForced && status != OverrideStatus.NoOverrides);
                overrideState            = EditorGUILayout.ToggleLeft("Override for " + validPlatforms[shownSettingsPage].title.text, overrideState);
                EditorGUI.showMixedValue = false;
                if (EditorGUI.EndChangeCheck())
                {
                    properties.forcedOverrideState = overrideState;
                    properties.overrideIsForced    = true;
                }

                // If the loadtype is streaming on the selected platform, gray out the "Preload Audio Data" option and show the checkbox as unchecked.
                bool disablePreloadAudioDataOption = ((properties.overrideIsForced && properties.forcedOverrideState) || GetOverrideStatus(platform) == OverrideStatus.AllOverrides) && properties.settings.loadType == AudioClipLoadType.Streaming;

                MultiValueStatus multiStatus = GetMultiValueStatus(platform);
                bool             platformSettingsDisabled = !((properties.overrideIsForced && properties.forcedOverrideState) || status == OverrideStatus.AllOverrides);

                using (new EditorGUI.DisabledScope(platformSettingsDisabled))
                {
                    OnSampleSettingGUI(platform, multiStatus, selectionContainsTrackerFile, ref properties, disablePreloadAudioDataOption);
                }

                m_SampleSettingOverrides[platform] = properties;
            }

            EditorGUILayout.EndPlatformGrouping();
        }
        private void OnSampleSettingGUI(BuildTargetGroup platform, MultiValueStatus status, bool selectionContainsTrackerFile, ref SampleSettingProperties properties, bool disablePreloadAudioDataOption)
        {
            //Load Type
            EditorGUI.showMixedValue = status.multiLoadType && !properties.loadTypeChanged;
            EditorGUI.BeginChangeCheck();
            AudioClipLoadType newLoadType = (AudioClipLoadType)EditorGUILayout.EnumPopup("Load Type", properties.settings.loadType);

            if (EditorGUI.EndChangeCheck())
            {
                properties.settings.loadType = newLoadType;
                properties.loadTypeChanged   = true;
            }

            using (new EditorGUI.DisabledScope(disablePreloadAudioDataOption))
            {
                if (disablePreloadAudioDataOption)
                {
                    EditorGUILayout.Toggle("Preload Audio Data", false);
                }
                else
                {
                    EditorGUILayout.PropertyField(m_PreloadAudioData);
                }
            }

            if (!selectionContainsTrackerFile)
            {
                //Compression format
                AudioCompressionFormat[] allowedFormats = GetFormatsForPlatform(platform);
                EditorGUI.showMixedValue = status.multiCompressionFormat && !properties.compressionFormatChanged;
                EditorGUI.BeginChangeCheck();
                AudioCompressionFormat newFormat = (AudioCompressionFormat)EditorGUILayout.IntPopup("Compression Format",
                                                                                                    (int)properties.settings.compressionFormat,
                                                                                                    Array.ConvertAll(allowedFormats, value => value.ToString()),
                                                                                                    Array.ConvertAll(allowedFormats, value => (int)value));
                if (EditorGUI.EndChangeCheck())
                {
                    properties.settings.compressionFormat = newFormat;
                    properties.compressionFormatChanged   = true;
                }

                //Quality
                if (CompressionFormatHasQuality(properties.settings.compressionFormat))
                {
                    EditorGUI.showMixedValue = status.multiQuality && !properties.qualityChanged;
                    EditorGUI.BeginChangeCheck();
                    int newQuality = EditorGUILayout.IntSlider("Quality", (int)Mathf.Clamp(properties.settings.quality * 100.0f, 1.0f, 100.0f), 1, 100);
                    if (EditorGUI.EndChangeCheck())
                    {
                        properties.settings.quality = 0.01f * newQuality;
                        properties.qualityChanged   = true;
                    }
                }

                if (platform != BuildTargetGroup.WebGL)
                {
                    //Sample rate settings
                    EditorGUI.showMixedValue = status.multiSampleRateSetting && !properties.sampleRateSettingChanged;
                    EditorGUI.BeginChangeCheck();
                    AudioSampleRateSetting newSetting = (AudioSampleRateSetting)EditorGUILayout.EnumPopup("Sample Rate Setting", properties.settings.sampleRateSetting);
                    if (EditorGUI.EndChangeCheck())
                    {
                        properties.settings.sampleRateSetting = newSetting;
                        properties.sampleRateSettingChanged   = true;
                    }

                    //Sample rate settings
                    if (properties.settings.sampleRateSetting == AudioSampleRateSetting.OverrideSampleRate)
                    {
                        EditorGUI.showMixedValue = status.multiSampleRateOverride && !properties.sampleRateOverrideChanged;
                        EditorGUI.BeginChangeCheck();
                        int newRate = EditorGUILayout.IntPopup("Sample Rate", (int)properties.settings.sampleRateOverride,
                                                               Styles.kSampleRateStrings, Styles.kSampleRateValues);
                        if (EditorGUI.EndChangeCheck())
                        {
                            properties.settings.sampleRateOverride = (uint)newRate;
                            properties.sampleRateOverrideChanged   = true;
                        }
                    }
                }

                //TODO include the settings for things like HEVAG
                EditorGUI.showMixedValue = false;
            }
        }