void Awake()
        {
            m_bloomWeightsLabelGCArr = new GUIContent[AmplifyBloomBase.MaxDownscales];
            for (int i = 0; i < m_bloomWeightsLabelGCArr.Length; i++)
            {
                m_bloomWeightsLabelGCArr[i] = new GUIContent("Mip " + (i + 1), m_bloomWeightsFoldoutGC.tooltip);
            }

            m_mainLabelStyle           = new GUIStyle(EditorStyles.label);
            m_mainLabelStyle.fontStyle = FontStyle.Bold;

            m_disabledToggleStyle        = new GUIStyle(EditorStyles.toggle);
            m_disabledToggleStyle.normal = m_disabledToggleStyle.onActive;

            m_foldoutClosed           = new GUIStyle(EditorStyles.foldout);
            m_foldoutClosed.fontStyle = FontStyle.Bold;

            m_foldoutOpened           = new GUIStyle(EditorStyles.foldout);
            m_foldoutOpened.normal    = m_foldoutOpened.onActive;
            m_foldoutOpened.fontStyle = FontStyle.Bold;

            m_mainFoldoutStyle           = new GUIStyle(EditorStyles.foldout);
            m_mainFoldoutStyle.fontStyle = FontStyle.Bold;

            m_toggleStyle           = new GUIStyle(EditorStyles.toggle);
            m_toggleStyle.fontStyle = FontStyle.Bold;

            m_lensWeightGCArr = new GUIContent[AmplifyBloomBase.MaxDownscales];
            for (int i = 0; i < m_lensWeightGCArr.Length; i++)
            {
                m_lensWeightGCArr[i]       = new GUIContent(m_lensWeightGC);
                m_lensWeightGCArr[i].text += (i + 1).ToString();
            }
            AmplifyBloomBase bloom = ( AmplifyBloomBase )target;

            if (bloom.LensDirtTexture == null)
            {
                bloom.LensDirtTexture = AssetDatabase.LoadAssetAtPath <Texture>("Assets/AmplifyBloom/Samples/Textures/Dirt/DirtHighContrast.png");
            }

            if (bloom.LensStardurstTex == null)
            {
                bloom.LensStardurstTex = AssetDatabase.LoadAssetAtPath <Texture>("Assets/AmplifyBloom/Samples/Textures/Starburst/Starburst.png");
            }
        }
        override public void OnInspectorGUI()
        {
            Undo.RecordObject(target, "AmplifyBloomInspector");
            AmplifyBloomBase bloom    = ( AmplifyBloomBase )target;
            SerializedObject bloomObj = new SerializedObject(bloom);

            GUILayout.BeginVertical();
            {
                EditorGUI.BeginChangeCheck();
                EditorGUILayout.Separator();
                bool applyBloom = true;
                ToggleFoldout(m_bloomFoldoutGC, ref m_bloomFoldout, ref applyBloom, true, -8, true);
                if (m_bloomFoldout)
                {
                    bloom.UpscaleQuality    = ( UpscaleQualityEnum )EditorGUILayout.EnumPopup(m_upscaleQualityGC, bloom.UpscaleQuality);
                    bloom.MainThresholdSize = ( MainThresholdSizeEnum )EditorGUILayout.EnumPopup(m_mainThresholdSizeGC, bloom.MainThresholdSize);

                    GUILayout.BeginHorizontal();
                    float originalLabelWidth = EditorGUIUtility.labelWidth;

                    bloom.CurrentPrecisionMode = ( PrecisionModes )EditorGUILayout.EnumPopup(m_highPrecisionGC, bloom.CurrentPrecisionMode);
                    GUI.enabled = !bloom.HighPrecision;
                    {
                        EditorGUIUtility.labelWidth = 45;
                        bloom.BloomRange            = EditorGUILayout.FloatField(m_ldrRangeGC, bloom.BloomRange, GUILayout.MaxWidth(1300));
                    }
                    EditorGUIUtility.labelWidth = originalLabelWidth;
                    GUI.enabled = true;

                    GUILayout.EndHorizontal();

                    bloom.OverallIntensity = EditorGUILayout.FloatField(m_overallIntensityGC, bloom.OverallIntensity);

                    bloom.OverallThreshold = EditorGUILayout.FloatField(m_thresholdGC, bloom.OverallThreshold);

                    SerializedProperty maskTextureField = bloomObj.FindProperty("m_maskTexture");
                    EditorGUI.BeginChangeCheck();
                    EditorGUILayout.PropertyField(maskTextureField, m_maskTextureGC);
                    if (EditorGUI.EndChangeCheck())
                    {
                        bloomObj.ApplyModifiedProperties();
                    }

                    SerializedProperty targetTextureField = bloomObj.FindProperty("m_targetTexture");
                    EditorGUI.BeginChangeCheck();
                    EditorGUILayout.PropertyField(targetTextureField, m_targetTextureGC);
                    if (EditorGUI.EndChangeCheck())
                    {
                        bloomObj.ApplyModifiedProperties();
                    }
                    //bloom.TargetTexture = EditorGUILayout.ObjectField( m_targetTextureGC, bloom.TargetTexture, typeof( RenderTexture ),false ) as RenderTexture;
                    bloom.DebugToScreen     = ( DebugToScreenEnum )EditorGUILayout.EnumPopup(m_debugToScreenGC, bloom.DebugToScreen);
                    bloom.ShowDebugMessages = EditorGUILayout.Toggle(m_showDebugMessagesGC, bloom.ShowDebugMessages);
                    int weightMaxDowsampleCount = Mathf.Max(1, bloom.BloomDownsampleCount);
                    {
                        EditorGUI.indentLevel++;
                        m_mipSettingsFoldout = CustomFoldout(m_mipSettingsFoldout, m_mipSettingGC);
                        if (m_mipSettingsFoldout)
                        {
                            EditorGUI.indentLevel++;
                            bloom.BloomDownsampleCount = EditorGUILayout.IntSlider(m_downscaleAmountGC, bloom.BloomDownsampleCount, AmplifyBloomBase.MinDownscales, bloom.SoftMaxdownscales);
                            bool guiState = bloom.BloomDownsampleCount != 0;

                            GUI.enabled = (bloom.UpscaleQuality == UpscaleQualityEnum.Realistic) && guiState;
                            {
                                bloom.UpscaleBlurRadius = EditorGUILayout.Slider(m_upscaleScaleRadiusGC, bloom.UpscaleBlurRadius, 1f, 3.0f);
                            }
                            GUI.enabled = guiState;

                            int featuresSourceId = bloom.FeaturesSourceId + 1;
                            featuresSourceId       = EditorGUILayout.IntSlider(m_featuresSourceIdGC, featuresSourceId, 1, bloom.BloomDownsampleCount);
                            bloom.FeaturesSourceId = featuresSourceId - 1;
                            EditorGUI.indentLevel--;
                        }
                        GUI.enabled = true;

                        m_bloomWeightsFoldout = CustomFoldout(m_bloomWeightsFoldout, m_bloomWeightsFoldoutGC);
                        if (m_bloomWeightsFoldout)
                        {
                            EditorGUI.indentLevel++;

                            float blurStepSize   = 15;
                            float blurRadiusSize = 15;
                            float weightSize     = 25;

                            GUILayout.BeginHorizontal();
                            GUILayout.Space(41);
                            EditorGUILayout.LabelField(m_blurStepGC, GUILayout.MinWidth(blurStepSize));
                            GUILayout.Space(-26);
                            EditorGUILayout.LabelField(m_blurRadiusGC, GUILayout.MinWidth(blurRadiusSize));
                            GUILayout.Space(-27);
                            EditorGUILayout.LabelField(m_upscaleWeightGC, GUILayout.MinWidth(weightSize));
                            GUILayout.EndHorizontal();
                            for (int i = 0; i < weightMaxDowsampleCount; i++)
                            {
                                GUILayout.BeginHorizontal();
                                EditorGUILayout.LabelField(m_bloomWeightsLabelGCArr[i], GUILayout.Width(65));
                                GUILayout.Space(-30);

                                bloom.GaussianSteps[i] = EditorGUILayout.IntField(string.Empty, bloom.GaussianSteps[i], GUILayout.MinWidth(blurStepSize));
                                bloom.GaussianSteps[i] = Mathf.Clamp(bloom.GaussianSteps[i], 0, AmplifyBloomBase.MaxGaussian);

                                GUILayout.Space(-27);
                                bloom.GaussianRadius[i] = EditorGUILayout.FloatField(string.Empty, bloom.GaussianRadius[i], GUILayout.MinWidth(blurRadiusSize));
                                bloom.GaussianRadius[i] = Mathf.Max(bloom.GaussianRadius[i], 0f);

                                GUILayout.Space(-27);
                                int id = weightMaxDowsampleCount - 1 - i;
                                bloom.UpscaleWeights[id] = EditorGUILayout.FloatField(string.Empty, bloom.UpscaleWeights[id], GUILayout.MinWidth(weightSize));
                                bloom.UpscaleWeights[id] = Mathf.Max(bloom.UpscaleWeights[id], 0f);

                                GUILayout.EndHorizontal();
                            }
                            EditorGUI.indentLevel--;
                        }
                    }
                    GUI.enabled = true;

                    bool applyTemporalFilter = bloom.TemporalFilteringActive;
                    ToggleFoldout(m_temporalFilterFoldoutGC, ref m_temporalFilterFoldout, ref applyTemporalFilter, false, 4);
                    bloom.TemporalFilteringActive = applyTemporalFilter;
                    if (m_temporalFilterFoldout)
                    {
                        GUI.enabled = bloom.TemporalFilteringActive;
                        {
                            bloom.TemporalFilteringCurve = EditorGUILayout.CurveField(m_filterCurveGC, bloom.TemporalFilteringCurve, TemporalCurveColor, TemporalCurveRanges);
                            bloom.TemporalFilteringValue = EditorGUILayout.Slider(m_filterValueGC, bloom.TemporalFilteringValue, 0.01f, 1f);
                        }
                        GUI.enabled = true;
                    }

                    bool applySeparateFeatures = bloom.SeparateFeaturesThreshold;
                    ToggleFoldout(m_sepFeaturesThresholdFoldoutGC, ref m_featuresFoldout, ref applySeparateFeatures, false, 4);
                    bloom.SeparateFeaturesThreshold = applySeparateFeatures;

                    if (m_featuresFoldout)
                    {
                        GUI.enabled = bloom.SeparateFeaturesThreshold;
                        {
                            bloom.FeaturesThreshold = EditorGUILayout.FloatField(m_separateThresholdGC, bloom.FeaturesThreshold);
                        }
                        GUI.enabled = true;
                    }
                    EditorGUI.indentLevel--;
                }

                bool applyLensDirt = bloom.ApplyLensDirt;
                ToggleFoldout(m_lensDirtFoldoutGC, ref m_lensDirtFoldout, ref applyLensDirt, true);
                bloom.ApplyLensDirt = applyLensDirt;
                if (m_lensDirtFoldout)
                {
                    GUI.enabled            = bloom.ApplyLensDirt;
                    bloom.LensDirtStrength = EditorGUILayout.FloatField(m_lensDirtIntensityGC, bloom.LensDirtStrength);


                    EditorGUI.indentLevel++;
                    m_lensDirtWeightsFoldout = CustomFoldout(m_lensDirtWeightsFoldout, m_lensWeightsFoldoutGC);
                    if (m_lensDirtWeightsFoldout)
                    {
                        for (int i = 0; i < bloom.BloomDownsampleCount; i++)
                        {
                            int id = bloom.BloomDownsampleCount - 1 - i;
                            bloom.LensDirtWeights[id] = EditorGUILayout.FloatField(m_lensWeightGCArr[i], bloom.LensDirtWeights[id]);
                            bloom.LensDirtWeights[id] = Mathf.Max(bloom.LensDirtWeights[id], 0f);
                        }
                    }
                    EditorGUI.indentLevel--;
                    bloom.LensDirtTexture = EditorGUILayout.ObjectField(m_lensDirtTextureGC, bloom.LensDirtTexture, typeof(Texture), false) as Texture;
                    GUI.enabled           = true;
                }

                bool applyStarburst = bloom.ApplyLensStardurst;
                ToggleFoldout(m_lensStarburstFoldoutGC, ref m_lensStarburstFoldout, ref applyStarburst, true);
                bloom.ApplyLensStardurst = applyStarburst;
                if (m_lensStarburstFoldout)
                {
                    GUI.enabled = bloom.ApplyLensStardurst;
                    {
                        bloom.LensStarburstStrength = EditorGUILayout.FloatField(m_lensStarburstIntensityGC, bloom.LensStarburstStrength);
                        EditorGUI.indentLevel++;
                        m_lensStarburstWeightsFoldout = CustomFoldout(m_lensStarburstWeightsFoldout, m_lensWeightsFoldoutGC);
                        if (m_lensStarburstWeightsFoldout)
                        {
                            for (int i = 0; i < bloom.BloomDownsampleCount; i++)
                            {
                                int id = bloom.BloomDownsampleCount - 1 - i;
                                bloom.LensStarburstWeights[id] = EditorGUILayout.FloatField(m_lensWeightGCArr[i], bloom.LensStarburstWeights[id]);
                                bloom.LensStarburstWeights[id] = Mathf.Max(bloom.LensStarburstWeights[id], 0f);
                            }
                        }
                        EditorGUI.indentLevel--;
                        bloom.LensStardurstTex = EditorGUILayout.ObjectField(m_lensStarburstTextureGC, bloom.LensStardurstTex, typeof(Texture), false) as Texture;
                    }
                    GUI.enabled = true;
                }

                bool applyBokeh = bloom.BokehFilterInstance.ApplyBokeh;
                ToggleFoldout(m_bokehFilterFoldoutGC, ref m_bokehFilterFoldout, ref applyBokeh, true);
                bloom.BokehFilterInstance.ApplyBokeh = applyBokeh;
                if (m_bokehFilterFoldout)
                {
                    GUI.enabled = bloom.BokehFilterInstance.ApplyBokeh;
                    {
                        bloom.BokehFilterInstance.ApplyOnBloomSource = EditorGUILayout.Toggle(m_bokehApplyOnBloomSourceGC, bloom.BokehFilterInstance.ApplyOnBloomSource);
                        bloom.BokehFilterInstance.ApertureShape      = ( ApertureShape )EditorGUILayout.EnumPopup(m_bokehApertureShapeGC, bloom.BokehFilterInstance.ApertureShape);
                        EditorGUI.indentLevel++;
                        m_bokehAdvancedSettingsFoldout = CustomFoldout(m_bokehAdvancedSettingsFoldout, m_advancedSettingsBokehFoldoutGC);
                        if (m_bokehAdvancedSettingsFoldout)
                        {
                            bloom.BokehFilterInstance.OffsetRotation    = EditorGUILayout.Slider(m_bokehRotationGC, bloom.BokehFilterInstance.OffsetRotation, 0, 360);
                            bloom.BokehFilterInstance.BokehSampleRadius = EditorGUILayout.Slider(m_bokehSampleRadiusGC, bloom.BokehFilterInstance.BokehSampleRadius, 0.01f, 1f);
                            bloom.BokehFilterInstance.Aperture          = EditorGUILayout.Slider(m_bokehApertureGC, bloom.BokehFilterInstance.Aperture, 0.01f, 0.05f);
                            bloom.BokehFilterInstance.FocalLength       = EditorGUILayout.Slider(m_bokehFocalLengthGC, bloom.BokehFilterInstance.FocalLength, 0.018f, 0.055f);
                            bloom.BokehFilterInstance.FocalDistance     = EditorGUILayout.Slider(m_bokehFocalDistanceGC, bloom.BokehFilterInstance.FocalDistance, 0.055f, 3f);
                            bloom.BokehFilterInstance.MaxCoCDiameter    = EditorGUILayout.Slider(m_bokehMaxCoCDiameterGC, bloom.BokehFilterInstance.MaxCoCDiameter, 0f, 2f);
                        }
                        EditorGUI.indentLevel--;
                    }
                    GUI.enabled = true;
                }

                bool applyLensFlare = bloom.LensFlareInstance.ApplyLensFlare;
                ToggleFoldout(m_lensFlareFoldoutGC, ref m_lensFlareFoldout, ref applyLensFlare, true);
                bloom.LensFlareInstance.ApplyLensFlare = applyLensFlare;
                if (m_lensFlareFoldout)
                {
                    GUI.enabled = bloom.LensFlareInstance.ApplyLensFlare;
                    {
                        bloom.LensFlareInstance.OverallIntensity            = EditorGUILayout.FloatField(m_lensFlareIntensityGC, bloom.LensFlareInstance.OverallIntensity);
                        bloom.LensFlareInstance.LensFlareGaussianBlurAmount = EditorGUILayout.IntSlider(m_lensFlareBlurAmountGC, bloom.LensFlareInstance.LensFlareGaussianBlurAmount, 0, 3);

                        EditorGUI.BeginChangeCheck();
                        SerializedProperty gradientField = bloomObj.FindProperty("m_lensFlare.m_lensGradient");
                        EditorGUILayout.PropertyField(gradientField, m_lensFlareRadialTintGC);
                        if (EditorGUI.EndChangeCheck())
                        {
                            bloomObj.ApplyModifiedProperties();
                            bloom.LensFlareInstance.TextureFromGradient();
                        }

                        EditorGUI.indentLevel++;
                        m_ghostsFoldout = CustomFoldout(m_ghostsFoldout, m_ghostsFoldoutGC);
                        if (m_ghostsFoldout)
                        {
                            bloom.LensFlareInstance.LensFlareNormalizedGhostsIntensity = EditorGUILayout.FloatField(m_lensFlareGhostsInstensityGC, bloom.LensFlareInstance.LensFlareNormalizedGhostsIntensity);
                            bloom.LensFlareInstance.LensFlareGhostAmount        = EditorGUILayout.IntSlider(m_lensFlareGhostAmountGC, bloom.LensFlareInstance.LensFlareGhostAmount, 0, AmplifyBloomBase.MaxGhosts);
                            bloom.LensFlareInstance.LensFlareGhostsDispersal    = EditorGUILayout.Slider(m_lensFlareGhostDispersalGC, bloom.LensFlareInstance.LensFlareGhostsDispersal, 0.01f, 1.0f);
                            bloom.LensFlareInstance.LensFlareGhostChrDistortion = EditorGUILayout.Slider(m_lensFlareGhostChrmDistortGC, bloom.LensFlareInstance.LensFlareGhostChrDistortion, 0, 10);
                            EditorGUI.indentLevel++;
                            m_ghostsAdvancedSettingsFoldout = CustomFoldout(m_ghostsAdvancedSettingsFoldout, m_advancedSettingsGhostsFoldoutGC, 19);
                            if (m_ghostsAdvancedSettingsFoldout)
                            {
                                bloom.LensFlareInstance.LensFlareGhostsPowerFactor  = EditorGUILayout.Slider(m_lensFlareGhostPowerFactorGC, bloom.LensFlareInstance.LensFlareGhostsPowerFactor, 0, 2);
                                bloom.LensFlareInstance.LensFlareGhostsPowerFalloff = EditorGUILayout.Slider(m_lensFlareGhostPowerFalloffGC, bloom.LensFlareInstance.LensFlareGhostsPowerFalloff, 1, 128);
                            }
                            EditorGUI.indentLevel--;
                        }

                        m_haloFoldout = CustomFoldout(m_haloFoldout, m_halosFoldoutGC);
                        if (m_haloFoldout)
                        {
                            bloom.LensFlareInstance.LensFlareNormalizedHaloIntensity = EditorGUILayout.FloatField(m_lensFlareHalosIntensityGC, bloom.LensFlareInstance.LensFlareNormalizedHaloIntensity);
                            bloom.LensFlareInstance.LensFlareHaloWidth         = EditorGUILayout.Slider(m_lensFlareHaloWidthGC, bloom.LensFlareInstance.LensFlareHaloWidth, 0, 1);
                            bloom.LensFlareInstance.LensFlareHaloChrDistortion = EditorGUILayout.Slider(m_lensFlareHaloChrmDistGC, bloom.LensFlareInstance.LensFlareHaloChrDistortion, 0, 10);
                            EditorGUI.indentLevel++;
                            m_haloAdvancedSettingsFoldout = CustomFoldout(m_haloAdvancedSettingsFoldout, m_advancedSettingsHalosFoldoutGC, 19);
                            if (m_haloAdvancedSettingsFoldout)
                            {
                                bloom.LensFlareInstance.LensFlareHaloPowerFactor  = EditorGUILayout.Slider(m_lensFlareHaloPowerFactorGC, bloom.LensFlareInstance.LensFlareHaloPowerFactor, 1, 2);
                                bloom.LensFlareInstance.LensFlareHaloPowerFalloff = EditorGUILayout.Slider(m_lensFlareHaloPowerFalloffGC, bloom.LensFlareInstance.LensFlareHaloPowerFalloff, 1, 128);
                            }
                            EditorGUI.indentLevel--;
                        }
                        EditorGUI.indentLevel--;
                    }
                    GUI.enabled = true;
                }

                bool applyGlare = bloom.LensGlareInstance.ApplyLensGlare;
                ToggleFoldout(m_lensGlareFoldoutGC, ref m_lensGlareFoldout, ref applyGlare, true);
                bloom.LensGlareInstance.ApplyLensGlare = applyGlare;
                if (m_lensGlareFoldout)
                {
                    GUI.enabled = bloom.LensGlareInstance.ApplyLensGlare;
                    {
                        bloom.LensGlareInstance.Intensity          = EditorGUILayout.FloatField(m_lensGlareIntensityGC, bloom.LensGlareInstance.Intensity);
                        bloom.LensGlareInstance.OverallStreakScale = EditorGUILayout.Slider(m_lensGlareOverallStreakScaleGC, bloom.LensGlareInstance.OverallStreakScale, 0, 2);
                        bloom.LensGlareInstance.OverallTint        = EditorGUILayout.ColorField(m_lensGlareOverallTintGC, bloom.LensGlareInstance.OverallTint);

                        EditorGUI.BeginChangeCheck();
                        SerializedProperty gradientField = bloomObj.FindProperty("m_anamorphicGlare.m_cromaticAberrationGrad");
                        EditorGUILayout.PropertyField(gradientField, m_lensGlareTintAlongGlareGC);
                        if (EditorGUI.EndChangeCheck())
                        {
                            bloomObj.ApplyModifiedProperties();
                            bloom.LensGlareInstance.SetDirty();
                        }

                        bloom.LensGlareInstance.CurrentGlare = ( GlareLibType )EditorGUILayout.EnumPopup(m_lensGlareTypeGC, bloom.LensGlareInstance.CurrentGlare);
                        if (bloom.LensGlareInstance.CurrentGlare == GlareLibType.Custom)
                        {
                            EditorGUI.indentLevel++;
                            bloom.LensGlareInstance.CustomGlareDefAmount = EditorGUILayout.IntSlider(m_customGlareSizeGC, bloom.LensGlareInstance.CustomGlareDefAmount, 0, AmplifyGlare.MaxCustomGlare);
                            if (bloom.LensGlareInstance.CustomGlareDefAmount > 0)
                            {
                                bloom.LensGlareInstance.CustomGlareDefIdx = EditorGUILayout.IntSlider(m_customGlareIdxGC, bloom.LensGlareInstance.CustomGlareDefIdx, 0, bloom.LensGlareInstance.CustomGlareDef.Length - 1);
                                for (int i = 0; i < bloom.LensGlareInstance.CustomGlareDef.Length; i++)
                                {
                                    EditorGUI.indentLevel++;
                                    m_customGlareFoldoutGC.text = "[" + i + "] " + bloom.LensGlareInstance.CustomGlareDef[i].CustomStarData.StarName;
                                    bloom.LensGlareInstance.CustomGlareDef[i].FoldoutValue = CustomFoldout(bloom.LensGlareInstance.CustomGlareDef[i].FoldoutValue, m_customGlareFoldoutGC);
                                    if (bloom.LensGlareInstance.CustomGlareDef[i].FoldoutValue)
                                    {
                                        bloom.LensGlareInstance.CustomGlareDef[i].CustomStarData.StarName           = EditorGUILayout.TextField(m_customGlareNameGC, bloom.LensGlareInstance.CustomGlareDef[i].CustomStarData.StarName);
                                        bloom.LensGlareInstance.CustomGlareDef[i].StarInclinationDeg                = EditorGUILayout.Slider(m_customGlareStarInclinationGC, bloom.LensGlareInstance.CustomGlareDef[i].StarInclinationDeg, 0, 180);
                                        bloom.LensGlareInstance.CustomGlareDef[i].ChromaticAberration               = EditorGUILayout.Slider(m_customGlareChromaticAberrationGC, bloom.LensGlareInstance.CustomGlareDef[i].ChromaticAberration, 0, 1);
                                        bloom.LensGlareInstance.CustomGlareDef[i].CustomStarData.StarlinesCount     = EditorGUILayout.IntSlider(m_customGlareStarlinesCountGC, bloom.LensGlareInstance.CustomGlareDef[i].CustomStarData.StarlinesCount, 1, AmplifyGlare.MaxStarLines);
                                        bloom.LensGlareInstance.CustomGlareDef[i].CustomStarData.PassCount          = EditorGUILayout.IntSlider(m_customGlarePassCountGC, bloom.LensGlareInstance.CustomGlareDef[i].CustomStarData.PassCount, 1, AmplifyGlare.MaxPasses);
                                        bloom.LensGlareInstance.CustomGlareDef[i].CustomStarData.SampleLength       = EditorGUILayout.Slider(m_customGlareSampleLengthGC, bloom.LensGlareInstance.CustomGlareDef[i].CustomStarData.SampleLength, 0, 2);
                                        bloom.LensGlareInstance.CustomGlareDef[i].CustomStarData.Attenuation        = EditorGUILayout.Slider(m_customGlareAttenuationGC, bloom.LensGlareInstance.CustomGlareDef[i].CustomStarData.Attenuation, 0, 1);
                                        bloom.LensGlareInstance.CustomGlareDef[i].CustomStarData.CameraRotInfluence = EditorGUILayout.FloatField(m_customGlareRotationGC, bloom.LensGlareInstance.CustomGlareDef[i].CustomStarData.CameraRotInfluence);;
                                        bloom.LensGlareInstance.CustomGlareDef[i].CustomStarData.CustomIncrement    = EditorGUILayout.Slider(m_customGlareCustomIncrementGC, bloom.LensGlareInstance.CustomGlareDef[i].CustomStarData.CustomIncrement, 0, 180);
                                        bloom.LensGlareInstance.CustomGlareDef[i].CustomStarData.LongAttenuation    = EditorGUILayout.Slider(m_customGlareLongAttenuationGC, bloom.LensGlareInstance.CustomGlareDef[i].CustomStarData.LongAttenuation, 0, 1);
                                    }
                                    EditorGUI.indentLevel--;
                                }
                            }
                            EditorGUI.indentLevel--;
                        }

                        EditorGUI.indentLevel++;
                        m_lensGlareAdvancedSettingsFoldout = CustomFoldout(m_lensGlareAdvancedSettingsFoldout, m_advancedSettingsLensGlareFoldoutGC);
                        if (m_lensGlareAdvancedSettingsFoldout)
                        {
                            bloom.LensGlareInstance.PerPassDisplacement = EditorGUILayout.Slider(m_lensGlarePerPassDispGC, bloom.LensGlareInstance.PerPassDisplacement, 1, 8);
                            bloom.LensGlareInstance.GlareMaxPassCount   = EditorGUILayout.IntSlider(m_lensGlareMaxPerRayGC, bloom.LensGlareInstance.GlareMaxPassCount, 1, AmplifyGlare.MaxPasses);
                        }
                        EditorGUI.indentLevel--;
                    }
                    GUI.enabled = true;
                }

                if (EditorGUI.EndChangeCheck())
                {
                    EditorUtility.SetDirty(bloom);
#if !UNITY_PRE_5_3
                    if (!Application.isPlaying)
                    {
                        EditorSceneManager.MarkSceneDirty(bloom.gameObject.scene);
                    }
#endif
                }
            }
            GUILayout.EndVertical();
        }