Exemple #1
0
        private static void ObjectSettings()
        {
            bool emptySelection = true;

            GameObject[] gos;
            SceneModeUtility.SearchBar(typeof(MeshRenderer), typeof(Terrain));
            EditorGUILayout.Space();

            MeshRenderer[] renderers = SceneModeUtility.GetSelectedObjectsOfType <MeshRenderer>(out gos);
            if (gos.Length > 0)
            {
                emptySelection = false;
                ObjectSettings(renderers, gos);
            }

            Terrain[] terrains = SceneModeUtility.GetSelectedObjectsOfType <Terrain>(out gos);
            if (gos.Length > 0)
            {
                emptySelection = false;
                ObjectSettings(terrains, gos);
            }

            if (emptySelection)
            {
                GUILayout.Label("Select a MeshRenderer or a Terrain from the scene.", EditorStyles.helpBox);
            }
        }
Exemple #2
0
        private static void ObjectSettings()
        {
            GameObject[] objArray;
            bool         flag = true;

            Type[] types = new Type[] { typeof(MeshRenderer), typeof(Terrain) };
            SceneModeUtility.SearchBar(types);
            EditorGUILayout.Space();
            MeshRenderer[] selectedObjectsOfType = SceneModeUtility.GetSelectedObjectsOfType <MeshRenderer>(out objArray, new Type[0]);
            if (objArray.Length > 0)
            {
                flag = false;
                ObjectSettings(selectedObjectsOfType, objArray);
            }
            Terrain[] components = SceneModeUtility.GetSelectedObjectsOfType <Terrain>(out objArray, new Type[0]);
            if (objArray.Length > 0)
            {
                flag = false;
                ObjectSettings(components, objArray);
            }
            if (flag)
            {
                GUILayout.Label("Select a MeshRenderer or a Terrain from the scene.", EditorStyles.helpBox, new GUILayoutOption[0]);
            }
        }
Exemple #3
0
        private static void ObjectSettings()
        {
            bool flag = true;

            SceneModeUtility.SearchBar(new Type[]
            {
                typeof(MeshRenderer),
                typeof(Terrain)
            });
            EditorGUILayout.Space();
            GameObject[]   array;
            MeshRenderer[] selectedObjectsOfType = SceneModeUtility.GetSelectedObjectsOfType <MeshRenderer>(out array, new Type[0]);
            if (array.Length > 0)
            {
                flag = false;
                NavMeshEditorWindow.ObjectSettings(selectedObjectsOfType, array);
            }
            Terrain[] selectedObjectsOfType2 = SceneModeUtility.GetSelectedObjectsOfType <Terrain>(out array, new Type[0]);
            if (array.Length > 0)
            {
                flag = false;
                NavMeshEditorWindow.ObjectSettings(selectedObjectsOfType2, array);
            }
            if (flag)
            {
                GUILayout.Label("Select a MeshRenderer or a Terrain from the scene.", EditorStyles.helpBox, new GUILayoutOption[0]);
            }
        }
Exemple #4
0
        public bool EditRenderers()
        {
            GameObject[] array;
            Renderer[]   selectedObjectsOfType = SceneModeUtility.GetSelectedObjectsOfType <Renderer>(out array, new Type[]
            {
                typeof(MeshRenderer),
                typeof(SkinnedMeshRenderer)
            });
            if (array.Length == 0)
            {
                return(false);
            }
            EditorGUILayout.InspectorTitlebar(selectedObjectsOfType);
            SerializedObject serializedObject = new SerializedObject(array);

            EditorGUI.BeginDisabledGroup(!SceneModeUtility.StaticFlagField("Lightmap Static", serializedObject.FindProperty("m_StaticEditorFlags"), 1));
            SerializedObject serializedObject2 = new SerializedObject(selectedObjectsOfType);
            float            num = LightmapVisualization.GetLightmapLODLevelScale(selectedObjectsOfType[0]);

            for (int i = 1; i < selectedObjectsOfType.Length; i++)
            {
                if (!Mathf.Approximately(num, LightmapVisualization.GetLightmapLODLevelScale(selectedObjectsOfType[i])))
                {
                    num = 1f;
                }
            }
            float lightmapScale     = this.LightmapScaleGUI(serializedObject2, num) * LightmapVisualization.GetLightmapLODLevelScale(selectedObjectsOfType[0]);
            float cachedSurfaceArea = (!(selectedObjectsOfType[0] is MeshRenderer)) ? InternalMeshUtil.GetCachedSkinnedMeshSurfaceArea(selectedObjectsOfType[0] as SkinnedMeshRenderer) : InternalMeshUtil.GetCachedMeshSurfaceArea(selectedObjectsOfType[0] as MeshRenderer);

            this.ShowClampedSizeInLightmapGUI(lightmapScale, cachedSurfaceArea);
            this.RendererUVSettings(serializedObject2);
            LightingWindowObjectTab.LightmapParametersGUI(serializedObject2.FindProperty("m_LightmapParameters"), LightingWindowObjectTab.s_Styles.LightmapParameters);
            this.m_ShowBakedLM = EditorGUILayout.Foldout(this.m_ShowBakedLM, LightingWindowObjectTab.s_Styles.Atlas);
            if (this.m_ShowBakedLM)
            {
                this.ShowAtlasGUI(serializedObject2);
            }
            this.m_ShowRealtimeLM = EditorGUILayout.Foldout(this.m_ShowRealtimeLM, LightingWindowObjectTab.s_Styles.RealtimeLM);
            if (this.m_ShowRealtimeLM)
            {
                this.ShowRealtimeLMGUI(serializedObject2, selectedObjectsOfType[0]);
            }
            if (LightmapEditorSettings.HasZeroAreaMesh(selectedObjectsOfType[0]))
            {
                EditorGUILayout.HelpBox(LightingWindowObjectTab.s_Styles.ZeroAreaPackingMesh.text, MessageType.Warning);
            }
            if (LightmapEditorSettings.HasClampedResolution(selectedObjectsOfType[0]))
            {
                EditorGUILayout.HelpBox(LightingWindowObjectTab.s_Styles.ClampedPackingResolution.text, MessageType.Warning);
            }
            if (!LightingWindowObjectTab.HasNormals(selectedObjectsOfType[0]))
            {
                EditorGUILayout.HelpBox(LightingWindowObjectTab.s_Styles.NoNormalsNoLightmapping.text, MessageType.Warning);
            }
            serializedObject.ApplyModifiedProperties();
            serializedObject2.ApplyModifiedProperties();
            EditorGUI.EndDisabledGroup();
            GUILayout.Space(10f);
            return(true);
        }
Exemple #5
0
        private static void ObjectSettings()
        {
            bool flag = true;

            SceneModeUtility.SearchBar(typeof(MeshRenderer), typeof(Terrain));
            EditorGUILayout.Space();
            GameObject[]   gameObjects;
            MeshRenderer[] selectedObjectsOfType1 = SceneModeUtility.GetSelectedObjectsOfType <MeshRenderer>(out gameObjects);
            if (gameObjects.Length > 0)
            {
                flag = false;
                NavMeshEditorWindow.ObjectSettings((UnityEngine.Object[])selectedObjectsOfType1, gameObjects);
            }
            Terrain[] selectedObjectsOfType2 = SceneModeUtility.GetSelectedObjectsOfType <Terrain>(out gameObjects);
            if (gameObjects.Length > 0)
            {
                flag = false;
                NavMeshEditorWindow.ObjectSettings((UnityEngine.Object[])selectedObjectsOfType2, gameObjects);
            }
            if (!flag)
            {
                return;
            }
            GUILayout.Label("Select a MeshRenderer or a Terrain from the scene.", EditorStyles.helpBox, new GUILayoutOption[0]);
        }
        public bool EditRenderers()
        {
            GameObject[]  objArray;
            System.Type[] types = new System.Type[] { typeof(MeshRenderer), typeof(SkinnedMeshRenderer) };
            Renderer[]    selectedObjectsOfType = SceneModeUtility.GetSelectedObjectsOfType <Renderer>(out objArray, types);
            if (objArray.Length == 0)
            {
                return(false);
            }
            EditorGUILayout.InspectorTitlebar(selectedObjectsOfType);
            SerializedObject obj2 = new SerializedObject(objArray);

            using (new EditorGUI.DisabledScope(!SceneModeUtility.StaticFlagField("Lightmap Static", obj2.FindProperty("m_StaticEditorFlags"), 1)))
            {
                SerializedObject so = new SerializedObject(selectedObjectsOfType);
                float            lightmapLODLevelScale = LightmapVisualization.GetLightmapLODLevelScale(selectedObjectsOfType[0]);
                for (int i = 1; i < selectedObjectsOfType.Length; i++)
                {
                    if (!Mathf.Approximately(lightmapLODLevelScale, LightmapVisualization.GetLightmapLODLevelScale(selectedObjectsOfType[i])))
                    {
                        lightmapLODLevelScale = 1f;
                    }
                }
                float lightmapScale     = this.LightmapScaleGUI(so, lightmapLODLevelScale) * LightmapVisualization.GetLightmapLODLevelScale(selectedObjectsOfType[0]);
                float cachedSurfaceArea = !(selectedObjectsOfType[0] is MeshRenderer) ? InternalMeshUtil.GetCachedSkinnedMeshSurfaceArea(selectedObjectsOfType[0] as SkinnedMeshRenderer) : InternalMeshUtil.GetCachedMeshSurfaceArea(selectedObjectsOfType[0] as MeshRenderer);
                this.ShowClampedSizeInLightmapGUI(lightmapScale, cachedSurfaceArea);
                EditorGUILayout.PropertyField(so.FindProperty("m_ImportantGI"), s_Styles.ImportantGI, new GUILayoutOption[0]);
                LightmapParametersGUI(so.FindProperty("m_LightmapParameters"), s_Styles.LightmapParameters, true);
                GUILayout.Space(10f);
                this.RendererUVSettings(so);
                GUILayout.Space(10f);
                this.m_ShowBakedLM = EditorGUILayout.Foldout(this.m_ShowBakedLM, s_Styles.Atlas, true);
                if (this.m_ShowBakedLM)
                {
                    this.ShowAtlasGUI(so);
                }
                this.m_ShowRealtimeLM = EditorGUILayout.Foldout(this.m_ShowRealtimeLM, s_Styles.RealtimeLM, true);
                if (this.m_ShowRealtimeLM)
                {
                    this.ShowRealtimeLMGUI(so, selectedObjectsOfType[0]);
                }
                if (LightmapEditorSettings.HasZeroAreaMesh(selectedObjectsOfType[0]))
                {
                    EditorGUILayout.HelpBox(s_Styles.ZeroAreaPackingMesh.text, MessageType.Warning);
                }
                if (LightmapEditorSettings.HasClampedResolution(selectedObjectsOfType[0]))
                {
                    EditorGUILayout.HelpBox(s_Styles.ClampedPackingResolution.text, MessageType.Warning);
                }
                if (!HasNormals(selectedObjectsOfType[0]))
                {
                    EditorGUILayout.HelpBox(s_Styles.NoNormalsNoLightmapping.text, MessageType.Warning);
                }
                obj2.ApplyModifiedProperties();
                so.ApplyModifiedProperties();
            }
            GUILayout.Space(10f);
            return(true);
        }
        private void AreaSelectionGUI()
        {
            bool flag = true;
            Type type = SceneModeUtility.SearchBar(new Type[]
            {
                typeof(Renderer),
                typeof(OcclusionArea)
            });

            EditorGUILayout.Space();
            GameObject[]    array;
            OcclusionArea[] selectedObjectsOfType = SceneModeUtility.GetSelectedObjectsOfType <OcclusionArea>(out array, new Type[0]);
            if (array.Length > 0)
            {
                flag = false;
                EditorGUILayout.MultiSelectionObjectTitleBar(selectedObjectsOfType);
                SerializedObject serializedObject = new SerializedObject(selectedObjectsOfType);
                EditorGUILayout.PropertyField(serializedObject.FindProperty("m_IsViewVolume"), new GUILayoutOption[0]);
                serializedObject.ApplyModifiedProperties();
            }
            Renderer[] selectedObjectsOfType2 = SceneModeUtility.GetSelectedObjectsOfType <Renderer>(out array, new Type[]
            {
                typeof(MeshRenderer),
                typeof(SkinnedMeshRenderer)
            });
            if (array.Length > 0)
            {
                flag = false;
                EditorGUILayout.MultiSelectionObjectTitleBar(selectedObjectsOfType2);
                SerializedObject serializedObject2 = new SerializedObject(array);
                SceneModeUtility.StaticFlagField("Occluder Static", serializedObject2.FindProperty("m_StaticEditorFlags"), 2);
                SceneModeUtility.StaticFlagField("Occludee Static", serializedObject2.FindProperty("m_StaticEditorFlags"), 16);
                serializedObject2.ApplyModifiedProperties();
            }
            if (flag)
            {
                GUILayout.Label(OcclusionCullingWindow.s_Styles.emptyAreaSelection, EditorStyles.helpBox, new GUILayoutOption[0]);
                if (type == typeof(OcclusionArea))
                {
                    EditorGUIUtility.labelWidth = 80f;
                    EditorGUILayout.Space();
                    EditorGUILayout.BeginHorizontal(new GUILayoutOption[0]);
                    EditorGUILayout.PrefixLabel("Create New");
                    if (GUILayout.Button("Occlusion Area", EditorStyles.miniButton, new GUILayoutOption[]
                    {
                        GUILayout.ExpandWidth(false)
                    }))
                    {
                        this.CreateNewArea();
                    }
                    EditorGUILayout.EndHorizontal();
                }
            }
        }
        void AreaSelectionGUI()
        {
            bool emptySelection = true;

            GameObject[] gos;
            Type         focusType = SceneModeUtility.SearchBar(typeof(Renderer), typeof(OcclusionArea));

            EditorGUILayout.Space();

            // Occlusion Areas
            OcclusionArea[] oas = SceneModeUtility.GetSelectedObjectsOfType <OcclusionArea>(out gos);
            if (gos.Length > 0)
            {
                emptySelection = false;
                EditorGUILayout.MultiSelectionObjectTitleBar(oas);
                using (var so = new SerializedObject(oas))
                {
                    EditorGUILayout.PropertyField(so.FindProperty("m_IsViewVolume"));
                    so.ApplyModifiedProperties();
                }
            }

            // Renderers
            Renderer[] renderers = SceneModeUtility.GetSelectedObjectsOfType <Renderer>(out gos, typeof(MeshRenderer), typeof(SkinnedMeshRenderer));
            if (gos.Length > 0)
            {
                emptySelection = false;
                EditorGUILayout.MultiSelectionObjectTitleBar(renderers);
                using (var goso = new SerializedObject(gos))
                {
                    SceneModeUtility.StaticFlagField("Occluder Static", goso.FindProperty("m_StaticEditorFlags"), (int)StaticEditorFlags.OccluderStatic);
                    SceneModeUtility.StaticFlagField("Occludee Static", goso.FindProperty("m_StaticEditorFlags"), (int)StaticEditorFlags.OccludeeStatic);
                    goso.ApplyModifiedProperties();
                }
            }

            if (emptySelection)
            {
                GUILayout.Label(s_Styles.emptyAreaSelection, EditorStyles.helpBox);
                if (focusType == typeof(OcclusionArea))
                {
                    EditorGUIUtility.labelWidth = 80;
                    EditorGUILayout.Space();
                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.PrefixLabel("Create New");
                    if (GUILayout.Button("Occlusion Area", EditorStyles.miniButton, GUILayout.ExpandWidth(false)))
                    {
                        CreateNewArea();
                    }
                    EditorGUILayout.EndHorizontal();
                }
            }
        }
 public bool EditLights()
 {
     GameObject[] objArray;
     Light[]      selectedObjectsOfType = SceneModeUtility.GetSelectedObjectsOfType <Light>(out objArray, new System.Type[0]);
     if (objArray.Length == 0)
     {
         return(false);
     }
     EditorGUILayout.InspectorTitlebar(selectedObjectsOfType);
     this.GetLightEditor(selectedObjectsOfType).OnInspectorGUI();
     GUILayout.Space(10f);
     return(true);
 }
 public bool EditLights()
 {
     GameObject[] gameObjects;
     Light[]      selectedObjectsOfType = SceneModeUtility.GetSelectedObjectsOfType <Light>(out gameObjects);
     if (gameObjects.Length == 0)
     {
         return(false);
     }
     EditorGUILayout.InspectorTitlebar((UnityEngine.Object[])selectedObjectsOfType);
     this.GetLightEditor(selectedObjectsOfType).OnInspectorGUI();
     GUILayout.Space(10f);
     return(true);
 }
Exemple #11
0
        public bool EditTerrains()
        {
            GameObject[] array;
            Terrain[]    selectedObjectsOfType = SceneModeUtility.GetSelectedObjectsOfType <Terrain>(out array, new Type[0]);
            bool         result;

            if (array.Length == 0)
            {
                result = false;
            }
            else
            {
                EditorGUILayout.InspectorTitlebar(selectedObjectsOfType);
                SerializedObject serializedObject = new SerializedObject(array);
                using (new EditorGUI.DisabledScope(!SceneModeUtility.StaticFlagField("Lightmap Static", serializedObject.FindProperty("m_StaticEditorFlags"), 1)))
                {
                    if (GUI.enabled)
                    {
                        this.ShowTerrainChunks(selectedObjectsOfType);
                    }
                    SerializedObject serializedObject2 = new SerializedObject(selectedObjectsOfType.ToArray <Terrain>());
                    float            lightmapScale     = this.LightmapScaleGUI(serializedObject2, 1f);
                    TerrainData      terrainData       = selectedObjectsOfType[0].terrainData;
                    float            cachedSurfaceArea = (!(terrainData != null)) ? 0f : (terrainData.size.x * terrainData.size.z);
                    this.ShowClampedSizeInLightmapGUI(lightmapScale, cachedSurfaceArea);
                    LightingWindowObjectTab.LightmapParametersGUI(serializedObject2.FindProperty("m_LightmapParameters"), LightingWindowObjectTab.s_Styles.LightmapParameters, true);
                    if (GUI.enabled && selectedObjectsOfType.Length == 1 && selectedObjectsOfType[0].terrainData != null)
                    {
                        this.ShowBakePerformanceWarning(serializedObject2, selectedObjectsOfType[0]);
                    }
                    this.m_ShowBakedLM = EditorGUILayout.Foldout(this.m_ShowBakedLM, LightingWindowObjectTab.s_Styles.Atlas);
                    if (this.m_ShowBakedLM)
                    {
                        this.ShowAtlasGUI(serializedObject2);
                    }
                    this.m_ShowRealtimeLM = EditorGUILayout.Foldout(this.m_ShowRealtimeLM, LightingWindowObjectTab.s_Styles.RealtimeLM);
                    if (this.m_ShowRealtimeLM)
                    {
                        this.ShowRealtimeLMGUI(selectedObjectsOfType[0]);
                    }
                    serializedObject.ApplyModifiedProperties();
                    serializedObject2.ApplyModifiedProperties();
                }
                GUILayout.Space(10f);
                result = true;
            }
            return(result);
        }
Exemple #12
0
        private void AreaSelectionGUI()
        {
            GameObject[] objArray;
            bool         flag = true;

            Type[] types = new Type[] { typeof(Renderer), typeof(OcclusionArea) };
            Type   type  = SceneModeUtility.SearchBar(types);

            EditorGUILayout.Space();
            OcclusionArea[] selectedObjectsOfType = SceneModeUtility.GetSelectedObjectsOfType <OcclusionArea>(out objArray, new Type[0]);
            if (objArray.Length > 0)
            {
                flag = false;
                EditorGUILayout.MultiSelectionObjectTitleBar(selectedObjectsOfType);
                SerializedObject obj2 = new SerializedObject(selectedObjectsOfType);
                EditorGUILayout.PropertyField(obj2.FindProperty("m_IsViewVolume"), new GUILayoutOption[0]);
                obj2.ApplyModifiedProperties();
            }
            Type[]     typeArray2 = new Type[] { typeof(MeshRenderer), typeof(SkinnedMeshRenderer) };
            Renderer[] objects    = SceneModeUtility.GetSelectedObjectsOfType <Renderer>(out objArray, typeArray2);
            if (objArray.Length > 0)
            {
                flag = false;
                EditorGUILayout.MultiSelectionObjectTitleBar(objects);
                SerializedObject obj3 = new SerializedObject(objArray);
                SceneModeUtility.StaticFlagField("Occluder Static", obj3.FindProperty("m_StaticEditorFlags"), 2);
                SceneModeUtility.StaticFlagField("Occludee Static", obj3.FindProperty("m_StaticEditorFlags"), 0x10);
                obj3.ApplyModifiedProperties();
            }
            if (flag)
            {
                GUILayout.Label(s_Styles.emptyAreaSelection, EditorStyles.helpBox, new GUILayoutOption[0]);
                if (type == typeof(OcclusionArea))
                {
                    EditorGUIUtility.labelWidth = 80f;
                    EditorGUILayout.Space();
                    EditorGUILayout.BeginHorizontal(new GUILayoutOption[0]);
                    EditorGUILayout.PrefixLabel("Create New");
                    GUILayoutOption[] options = new GUILayoutOption[] { GUILayout.ExpandWidth(false) };
                    if (GUILayout.Button("Occlusion Area", EditorStyles.miniButton, options))
                    {
                        this.CreateNewArea();
                    }
                    EditorGUILayout.EndHorizontal();
                }
            }
        }
        public bool EditTerrains()
        {
            GameObject[] objArray;
            Terrain[]    selectedObjectsOfType = SceneModeUtility.GetSelectedObjectsOfType <Terrain>(out objArray, new System.Type[0]);
            if (objArray.Length == 0)
            {
                return(false);
            }
            EditorGUILayout.InspectorTitlebar(selectedObjectsOfType);
            SerializedObject obj2 = new SerializedObject(objArray);

            EditorGUI.BeginDisabledGroup(!SceneModeUtility.StaticFlagField("Lightmap Static", obj2.FindProperty("m_StaticEditorFlags"), 1));
            if (GUI.enabled)
            {
                this.ShowTerrainChunks(selectedObjectsOfType);
            }
            SerializedObject so                = new SerializedObject(selectedObjectsOfType.ToArray <Terrain>());
            float            lightmapScale     = this.LightmapScaleGUI(so, 1f);
            TerrainData      terrainData       = selectedObjectsOfType[0].terrainData;
            float            cachedSurfaceArea = (terrainData == null) ? 0f : (terrainData.size.x * terrainData.size.z);

            this.ShowClampedSizeInLightmapGUI(lightmapScale, cachedSurfaceArea);
            LightmapParametersGUI(so.FindProperty("m_LightmapParameters"), s_Styles.LightmapParameters);
            if ((GUI.enabled && (selectedObjectsOfType.Length == 1)) && (selectedObjectsOfType[0].terrainData != null))
            {
                this.ShowBakePerformanceWarning(so, selectedObjectsOfType[0]);
            }
            this.m_ShowBakedLM = EditorGUILayout.Foldout(this.m_ShowBakedLM, s_Styles.Atlas);
            if (this.m_ShowBakedLM)
            {
                this.ShowAtlasGUI(so);
            }
            this.m_ShowRealtimeLM = EditorGUILayout.Foldout(this.m_ShowRealtimeLM, s_Styles.RealtimeLM);
            if (this.m_ShowRealtimeLM)
            {
                this.ShowRealtimeLMGUI(selectedObjectsOfType[0]);
            }
            obj2.ApplyModifiedProperties();
            so.ApplyModifiedProperties();
            EditorGUI.EndDisabledGroup();
            GUILayout.Space(10f);
            return(true);
        }
Exemple #14
0
        public bool EditLights()
        {
            GameObject[] array;
            Light[]      selectedObjectsOfType = SceneModeUtility.GetSelectedObjectsOfType <Light>(out array, new Type[0]);
            bool         result;

            if (array.Length == 0)
            {
                result = false;
            }
            else
            {
                EditorGUILayout.InspectorTitlebar(selectedObjectsOfType);
                this.GetLightEditor(selectedObjectsOfType).OnInspectorGUI();
                GUILayout.Space(10f);
                result = true;
            }
            return(result);
        }
        public bool EditTerrains()
        {
            GameObject[] gameObjects;
            Terrain[]    selectedObjectsOfType = SceneModeUtility.GetSelectedObjectsOfType <Terrain>(out gameObjects);
            if (gameObjects.Length == 0)
            {
                return(false);
            }
            EditorGUILayout.InspectorTitlebar((UnityEngine.Object[])selectedObjectsOfType);
            SerializedObject serializedObject = new SerializedObject((UnityEngine.Object[])gameObjects);

            EditorGUI.BeginDisabledGroup(!SceneModeUtility.StaticFlagField("Lightmap Static", serializedObject.FindProperty("m_StaticEditorFlags"), 1));
            if (GUI.enabled)
            {
                this.ShowTerrainChunks(selectedObjectsOfType);
            }
            SerializedObject so                = new SerializedObject((UnityEngine.Object[])((IEnumerable <Terrain>)selectedObjectsOfType).ToArray <Terrain>());
            float            lightmapScale     = this.LightmapScaleGUI(so, 1f);
            TerrainData      terrainData       = selectedObjectsOfType[0].terrainData;
            float            cachedSurfaceArea = !((UnityEngine.Object)terrainData != (UnityEngine.Object)null) ? 0.0f : terrainData.size.x * terrainData.size.z;

            this.ShowClampedSizeInLightmapGUI(lightmapScale, cachedSurfaceArea);
            LightingWindowObjectTab.LightmapParametersGUI(so.FindProperty("m_LightmapParameters"), LightingWindowObjectTab.s_Styles.LightmapParameters);
            if (GUI.enabled && selectedObjectsOfType.Length == 1 && (UnityEngine.Object)selectedObjectsOfType[0].terrainData != (UnityEngine.Object)null)
            {
                this.ShowBakePerformanceWarning(so, selectedObjectsOfType[0]);
            }
            this.m_ShowBakedLM = EditorGUILayout.Foldout(this.m_ShowBakedLM, LightingWindowObjectTab.s_Styles.Atlas);
            if (this.m_ShowBakedLM)
            {
                this.ShowAtlasGUI(so);
            }
            this.m_ShowRealtimeLM = EditorGUILayout.Foldout(this.m_ShowRealtimeLM, LightingWindowObjectTab.s_Styles.RealtimeLM);
            if (this.m_ShowRealtimeLM)
            {
                this.ShowRealtimeLMGUI(selectedObjectsOfType[0]);
            }
            serializedObject.ApplyModifiedProperties();
            so.ApplyModifiedProperties();
            EditorGUI.EndDisabledGroup();
            GUILayout.Space(10f);
            return(true);
        }