public static void DrawDaydreamLightingToggle(DaydreamRenderer renderer)
        {
            if (renderer == null)
            {
                return;
            }

            // determine lighting system in use
            const int kDaydreamLighting = 0;
            const int kUnityLighting    = 1;
            int       selectedIndex     = renderer.m_daydreamLighting ? kDaydreamLighting : kUnityLighting;

            EditorGUI.BeginChangeCheck();

            // draw section separator
            DrawSection(500, 1);
            EditorGUILayout.BeginHorizontal();
            if (selectedIndex == kDaydreamLighting)
            {
                EditorGUILayout.LabelField("Lighting System", Styles.sectionLabel, GUILayout.Width(105), GUILayout.Height(25));
                GUILayout.Button("", Styles.daydreamLightingStyle, GUILayout.Width(25), GUILayout.Height(25));
            }
            else
            {
                EditorGUILayout.LabelField("Lighting System", Styles.sectionLabel, GUILayout.Width(105), GUILayout.Height(25));
                GUILayout.Button("", Styles.unityLightingStyle, GUILayout.Width(25), GUILayout.Height(25));
            }

            EditorGUILayout.EndHorizontal();
            GUILayout.Space(5);

            EditorGUI.BeginChangeCheck();
            DREditorUtility.RadioButtonOutput selected = DREditorUtility.DrawRadioButton(selectedIndex, Styles.m_lightingSystemUI, Styles.m_buttonUnselected, Styles.m_buttonSelected, 20, 32, 150, new bool[] { true, false });
            if (EditorGUI.EndChangeCheck())
            {
                if (selected.m_selectedIndex == kDaydreamLighting)
                {
                    if (renderer.m_daydreamLighting == false)
                    {
                        renderer.m_daydreamLighting = true;
                        if (!renderer.m_enableManualLightingComponents)
                        {
                            DaydreamRendererImportManager.ApplyLightingComponents();
                        }
                        renderer.EnableEnlighten(false);
                    }
                }
                else
                {
                    if (renderer.m_daydreamLighting == true)
                    {
                        renderer.m_daydreamLighting = false;
                        if (!renderer.m_enableManualLightingComponents)
                        {
                            DaydreamRendererImportManager.RemoveAllLightingComponents();
                        }
                        renderer.EnableEnlighten(true);
                    }
                }

                // display advanced settings
                if (selected.m_dropDownSelected == kDaydreamLighting)
                {
                    LightSystemDialog.ShowDialog(null);
                }
            }
            GUILayout.Space(5);
        }
        public override void OnInspectorGUI()
        {
            bool             settingsChanged = false;
            DaydreamRenderer renderer        = target as DaydreamRenderer;

            Styles.Init();

            //This will add the material to the undo list, at the end of the frame Unity will check if its really changed and if so add it to the undo stack.
            //Since Unity does a binary comparison between the copied data and the original material - it should accurately determine if it has changed.
            //And since we're editing one material at a time, the extra memory (one extra copy of the Material) - the memory cost is reasonable.
            Undo.RecordObject(renderer, "Daydream Renderer Settings");

            if (GUILayout.Button(Styles.m_convertMtlUI, Styles.m_convertMtlLayout))
            {
                StandardToDaydream();
            }
            if (GUILayout.Button(Styles.m_enableEnlightenUI, Styles.m_enlightenLayout))
            {
                renderer.EnableEnlighten(true);
            }
            if (GUILayout.Button(Styles.m_enableDaydreamUI, Styles.m_drLightingLayout))
            {
                renderer.EnableEnlighten(false);
            }

            renderer.m_shadowSettings = EditorGUILayout.Foldout(renderer.m_shadowSettings, Styles.m_shadowSettingsUI);
            if (renderer.m_shadowSettings)
            {
                EditorGUI.indentLevel = 1;

                EditorGUI.BeginChangeCheck();
                renderer.m_shadowWidth      = EditorGUILayout.IntField(Styles.m_shadowWidthUI, renderer.m_shadowWidth);
                renderer.m_shadowHeight     = EditorGUILayout.IntField(Styles.m_shadowHeightUI, renderer.m_shadowHeight);
                renderer.m_sharpness        = EditorGUILayout.Slider(Styles.m_shadowSharpnessUI, renderer.m_sharpness, 0.0f, 1.0f);
                renderer.m_maxShadowCasters = EditorGUILayout.IntSlider(Styles.m_maxShadowCastersUI, renderer.m_maxShadowCasters, 0, 4);
                if (EditorGUI.EndChangeCheck())
                {
                    settingsChanged = true;
                }

                EditorGUI.indentLevel = 0;

                renderer.UpdateFilterParam();
            }

            renderer.m_ambientSettings = EditorGUILayout.Foldout(renderer.m_ambientSettings, Styles.m_ambientSettingsUI);
            if (renderer.m_ambientSettings)
            {
                EditorGUI.indentLevel = 1;

                EditorGUI.BeginChangeCheck();
                renderer.m_globalAmbientUp = EditorGUILayout.ColorField(Styles.m_ambientUpUI, renderer.m_globalAmbientUp);
                renderer.m_globalAmbientDn = EditorGUILayout.ColorField(Styles.m_ambientDownUI, renderer.m_globalAmbientDn);
                if (EditorGUI.EndChangeCheck())
                {
                    settingsChanged = true;
                    renderer.UpdateAmbientParam();
                    EditorUtility.SetDirty(renderer);
                }

                EditorGUI.indentLevel = 0;
            }

            renderer.m_fogSettings = EditorGUILayout.Foldout(renderer.m_fogSettings, Styles.m_fogSettingsUI);
            if (renderer.m_fogSettings)
            {
                EditorGUI.indentLevel = 1;

                EditorGUI.BeginChangeCheck();
                renderer.m_fogEnable       = EditorGUILayout.Toggle(Styles.m_fogEnable, renderer.m_fogEnable);
                renderer.m_heightFogEnable = EditorGUILayout.Toggle(Styles.m_fogHeightEnable, renderer.m_heightFogEnable);
                renderer.m_fogMode         = EditorGUILayout.Popup(Styles.m_fogModeLabel, renderer.m_fogMode, Styles.m_fogModes);

                EditorGUILayout.Space();

                if (renderer.m_fogMode == DaydreamRenderer.FogMode.Linear)
                {
                    renderer.m_fogLinear.x = EditorGUILayout.Slider(Styles.m_fogNear, renderer.m_fogLinear.x, 0.0f, 1000.0f);
                    renderer.m_fogLinear.y = EditorGUILayout.Slider(Styles.m_fogFar, renderer.m_fogLinear.y, 0.0f, 10000.0f);
                }
                if (renderer.m_fogMode != DaydreamRenderer.FogMode.Linear)
                {
                    renderer.m_fogHeight.w = EditorGUILayout.Slider(Styles.m_fogDensity, renderer.m_fogHeight.w, 0.0f, 1.0f);
                }

                renderer.m_fogLinear.z = EditorGUILayout.Slider(Styles.m_fogOpacity, renderer.m_fogLinear.z, 0.0f, 1.0f);
                renderer.m_fogLinear.w = EditorGUILayout.Slider(Styles.m_fogColorScale, renderer.m_fogLinear.w, 0.0f, 4.0f);

                if (renderer.m_heightFogEnable)
                {
                    renderer.m_fogHeight.x = EditorGUILayout.Slider(Styles.m_fogMinHeight, renderer.m_fogHeight.x, -100.0f, 100.0f);
                    renderer.m_fogHeight.y = EditorGUILayout.Slider(Styles.m_fogMaxHeight, renderer.m_fogHeight.y, -100.0f, 100.0f);
                    renderer.m_fogHeight.z = EditorGUILayout.Slider(Styles.m_fogThickness, renderer.m_fogHeight.z, 0.0f, 100.0f);
                }

                renderer.m_fogColorNear = EditorGUILayout.ColorField(Styles.m_fogColorNear, renderer.m_fogColorNear);
                renderer.m_fogColorFar  = EditorGUILayout.ColorField(Styles.m_fogColorFar, renderer.m_fogColorFar);
                if (EditorGUI.EndChangeCheck())
                {
                    settingsChanged = true;
                    renderer.UpdateFogParam();
                    EditorUtility.SetDirty(renderer);
                }

                EditorGUI.indentLevel = 0;
            }

            renderer.m_showFPS = EditorGUILayout.Toggle(Styles.m_showFpsUI, renderer.m_showFPS);

    #if UNITY_EDITOR
            if (settingsChanged && !Application.isPlaying)
            {
                EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
            }
    #endif
        }
        void OnGUI()
        {
            DaydreamRendererImportSettings settings = BakeData.Instance().GetImportSettings();

            EditorGUILayout.HelpBox(Styles.kWelcomeMsg, MessageType.Info);

            if (s_staticMaterialHistory == null || s_dynamicMaterialHistory == null)
            {
                Configure();
            }

            EditorGUI.BeginChangeCheck();
            GUILayout.Space(20);
            EditorGUILayout.HelpBox(Styles.kToggleComponentsHelp, MessageType.Info);

            EditorGUI.BeginChangeCheck();
            settings.m_daydreamLightinSystemEnabled = EditorGUILayout.BeginToggleGroup(Styles.toggleLightingSystem, settings.m_daydreamLightinSystemEnabled);
            if (EditorGUI.EndChangeCheck())
            {
                if (!settings.m_daydreamLightinSystemEnabled)
                {
                    RemoveAllLightingComponents();
                }

                DaydreamRenderer renderer = FindObjectOfType <DaydreamRenderer>();
                if (renderer)
                {
                    renderer.EnableEnlighten(!settings.m_daydreamLightinSystemEnabled);
                }
            }

            EditorGUILayout.BeginHorizontal();
            GUILayout.Space(20);
            settings.m_enableLightingComponentsAutoAdd = EditorGUILayout.ToggleLeft(Styles.toggleComponents, settings.m_enableLightingComponentsAutoAdd);
            EditorGUILayout.EndHorizontal();
            if (!settings.m_enableLightingComponentsAutoAdd)
            {
                EditorGUILayout.BeginHorizontal();
                GUILayout.Space(20);
                if (GUILayout.Button(Styles.addComponents))
                {
                    ApplyLightingComponents();
                }
                if (GUILayout.Button(Styles.removeComponents))
                {
                    RemoveAllLightingComponents();
                }
                EditorGUILayout.EndHorizontal();
            }


            EditorGUILayout.EndToggleGroup();

            GUILayout.Space(50);
            if (EditorGUI.EndChangeCheck())
            {
                EditorUtility.SetDirty(settings);
            }

            if (GUILayout.Button("Scan Materials") || m_convertableMaterials == null || m_convertableMaterials.Count == 0 || s_gatherMetrics)
            {
                List <GameObject> roots = Utilities.GetAllRoots();
                GatherMaterials(roots.ToArray());
            }

            EditorGUILayout.Separator();

            EditorGUILayout.HelpBox(String.Format(Styles.kObjectsWaiting, m_dynamicConvertableCount, m_staticConvertableCount), MessageType.Info);

            if (GUILayout.Button("Convert Materials Now"))
            {
                DoDynamicLightingConversion();
                DoStaticLightingConversion();
            }

            string[] text = new string[] { "Dynamic Converted Materials", "Static Converted Materials", "List All Daydream Materials" };
            s_importType = GUILayout.SelectionGrid(s_importType, text, 3, EditorStyles.radioButton);

            if (s_importType == 0)
            {
                DrawDynamicRevertMaterials();
            }
            else if (s_importType == 1)
            {
                DrawStaticRevertMaterials();
            }
            else if (m_convertedCount > 0)
            {
                DrawDaydreamMaterialList();
            }
        }