private void DrawPreviewSettings()
        {
            using (new EditorGUI.DisabledScope(!SelectedTextureTypeNeedExposureControl()))
            {
                float labelWidth = EditorGUIUtility.labelWidth;
                EditorGUIUtility.labelWidth = 20;
                m_ExposureSliderValue       = EditorGUILayout.Slider(Styles.ExposureIcon, m_ExposureSliderValue, -m_ExposureSliderMax,
                                                                     m_ExposureSliderMax, -kExposureSliderAbsoluteMax, kExposureSliderAbsoluteMax, EditorStyles.toolbarSlider);

                // This will allow the user to set a new max value for the current session
                if (m_ExposureSliderValue >= 0)
                {
                    m_ExposureSliderMax = Mathf.Max(m_ExposureSliderMax, m_ExposureSliderValue);
                }
                else
                {
                    m_ExposureSliderMax = Mathf.Max(m_ExposureSliderMax, m_ExposureSliderValue * -1);
                }

                EditorGUIUtility.labelWidth = labelWidth;
            }

            m_ShowUVOverlay = GUILayout.Toggle(m_ShowUVOverlay, Styles.UVOverlayIcon, EditorStyles.toolbarButton);

            Rect dropRect = GUILayoutUtility.GetRect(14, 160, EditorGUI.kWindowToolbarHeight, EditorGUI.kWindowToolbarHeight);

            GUIContent[]    options = isRealtimeLightmap ? Styles.RealtimePreviewTextureOptions : Styles.BakedPreviewTextureOptions;
            GITextureType[] types   = isRealtimeLightmap ? kRealtimePreviewTextureTypes : kBakedPreviewTextureTypes;

            if ((m_SelectedPreviewTextureOptionIndex < 0 || m_SelectedPreviewTextureOptionIndex >= options.Length) || !LightmapVisualizationUtility.IsTextureTypeEnabled(types[m_SelectedPreviewTextureOptionIndex]))
            {
                m_SelectedPreviewTextureOptionIndex = 0;
            }

            if (EditorGUI.DropdownButton(dropRect, options[m_SelectedPreviewTextureOptionIndex], FocusType.Passive, EditorStyles.toolbarDropDownRight))
            {
                GenericMenu menu = new GenericMenu();

                for (int i = 0; i < options.Length; i++)
                {
                    if (LightmapVisualizationUtility.IsTextureTypeEnabled(types[i]))
                    {
                        menu.AddItem(options[i], m_SelectedPreviewTextureOptionIndex == i, SelectPreviewTextureIndex, options.ElementAt(i));
                    }
                    else
                    {
                        menu.AddDisabledItem(options.ElementAt(i));
                    }
                }
                menu.DropDown(dropRect);
            }
        }
        private void DrawPreviewSettings()
        {
            using (new EditorGUI.DisabledScope(!SelectedTextureTypeNeedsExposureControl()))
            {
                m_ExposureSliderValue = EditorGUIInternal.ExposureSlider(m_ExposureSliderValue, ref m_ExposureSliderMax, EditorStyles.toolbarSlider);
            }

            m_ShowUVOverlay = GUILayout.Toggle(m_ShowUVOverlay, Styles.UVOverlayIcon, EditorStyles.toolbarButton);

            Rect dropRect = GUILayoutUtility.GetRect(14, 160, EditorGUI.kWindowToolbarHeight, EditorGUI.kWindowToolbarHeight);

            GUIContent[]    options = isRealtimeLightmap ? Styles.RealtimePreviewTextureOptions : Styles.BakedPreviewTextureOptions;
            GITextureType[] types   = isRealtimeLightmap ? kRealtimePreviewTextureTypes : kBakedPreviewTextureTypes;

            if ((m_SelectedPreviewTextureOptionIndex < 0 || m_SelectedPreviewTextureOptionIndex >= options.Length) || !LightmapVisualizationUtility.IsTextureTypeEnabled(types[m_SelectedPreviewTextureOptionIndex]))
            {
                m_SelectedPreviewTextureOptionIndex = 0;
            }

            if (EditorGUI.DropdownButton(dropRect, options[m_SelectedPreviewTextureOptionIndex], FocusType.Passive, EditorStyles.toolbarDropDownRight))
            {
                GenericMenu menu = new GenericMenu();

                for (int i = 0; i < options.Length; i++)
                {
                    if (LightmapVisualizationUtility.IsTextureTypeEnabled(types[i]))
                    {
                        menu.AddItem(options[i], m_SelectedPreviewTextureOptionIndex == i, SelectPreviewTextureIndex, options.ElementAt(i));
                    }
                    else
                    {
                        menu.AddDisabledItem(options.ElementAt(i));
                    }
                }
                menu.DropDown(dropRect);
            }
        }
        private GITextureType GetSelectedTextureType()
        {
            GUIContent[]    options = isRealtimeLightmap ? Styles.RealtimePreviewTextureOptions : Styles.BakedPreviewTextureOptions;
            GITextureType[] types   = isRealtimeLightmap ? kRealtimePreviewTextureTypes : kBakedPreviewTextureTypes;

            if ((m_SelectedPreviewTextureOptionIndex < 0 || m_SelectedPreviewTextureOptionIndex >= options.Length) || !LightmapVisualizationUtility.IsTextureTypeEnabled(types[m_SelectedPreviewTextureOptionIndex]))
            {
                m_SelectedPreviewTextureOptionIndex = 0;
            }

            return(types[m_SelectedPreviewTextureOptionIndex]);
        }
 public void ObjectPreview(Rect r)
 {
     if (r.height > 0f)
     {
         if (this.m_ZoomablePreview == null)
         {
             this.m_ZoomablePreview           = new ZoomableArea(true);
             this.m_ZoomablePreview.hRangeMin = 0f;
             this.m_ZoomablePreview.vRangeMin = 0f;
             this.m_ZoomablePreview.hRangeMax = 1f;
             this.m_ZoomablePreview.vRangeMax = 1f;
             this.m_ZoomablePreview.SetShownHRange(0f, 1f);
             this.m_ZoomablePreview.SetShownVRange(0f, 1f);
             this.m_ZoomablePreview.uniformScale    = true;
             this.m_ZoomablePreview.scaleWithWindow = true;
         }
         GUI.Box(r, "", "PreBackground");
         Rect position = new Rect(r);
         position.y     += 1f;
         position.height = 18f;
         GUI.Box(position, "", EditorStyles.toolbar);
         Rect position2 = new Rect(r);
         position2.y     += 1f;
         position2.height = 18f;
         position2.width  = 120f;
         Rect rect = new Rect(r);
         rect.yMin  += position2.height;
         rect.yMax  -= 14f;
         rect.width -= 11f;
         int num = Array.IndexOf <GUIContent>(LightingWindowObjectTab.Styles.ObjectPreviewTextureOptions, this.m_SelectedObjectPreviewTexture);
         if (num < 0 || !LightmapVisualizationUtility.IsTextureTypeEnabled(this.kObjectPreviewTextureTypes[num]))
         {
             num = 0;
             this.m_SelectedObjectPreviewTexture = LightingWindowObjectTab.Styles.ObjectPreviewTextureOptions[num];
         }
         if (EditorGUI.DropdownButton(position2, this.m_SelectedObjectPreviewTexture, FocusType.Passive, EditorStyles.toolbarPopup))
         {
             GenericMenu genericMenu = new GenericMenu();
             for (int i = 0; i < LightingWindowObjectTab.Styles.ObjectPreviewTextureOptions.Length; i++)
             {
                 if (LightmapVisualizationUtility.IsTextureTypeEnabled(this.kObjectPreviewTextureTypes[i]))
                 {
                     genericMenu.AddItem(LightingWindowObjectTab.Styles.ObjectPreviewTextureOptions[i], num == i, new GenericMenu.MenuFunction2(this.SelectPreviewTextureOption), LightingWindowObjectTab.Styles.ObjectPreviewTextureOptions.ElementAt(i));
                 }
                 else
                 {
                     genericMenu.AddDisabledItem(LightingWindowObjectTab.Styles.ObjectPreviewTextureOptions.ElementAt(i));
                 }
             }
             genericMenu.DropDown(position2);
         }
         GITextureType gITextureType = this.kObjectPreviewTextureTypes[Array.IndexOf <GUIContent>(LightingWindowObjectTab.Styles.ObjectPreviewTextureOptions, this.m_SelectedObjectPreviewTexture)];
         if (this.m_CachedTexture.type != gITextureType || this.m_CachedTexture.contentHash != LightmapVisualizationUtility.GetSelectedObjectGITextureHash(gITextureType) || this.m_CachedTexture.contentHash == default(Hash128))
         {
             this.m_CachedTexture = LightmapVisualizationUtility.GetSelectedObjectGITexture(gITextureType);
         }
         if (this.m_CachedTexture.textureAvailability == GITextureAvailability.GITextureNotAvailable || this.m_CachedTexture.textureAvailability == GITextureAvailability.GITextureUnknown)
         {
             if (LightmapVisualizationUtility.IsBakedTextureType(gITextureType))
             {
                 if (gITextureType == GITextureType.BakedShadowMask)
                 {
                     GUI.Label(rect, LightingWindowObjectTab.Styles.TextureNotAvailableBakedShadowmask);
                 }
                 else
                 {
                     GUI.Label(rect, LightingWindowObjectTab.Styles.TextureNotAvailableBaked);
                 }
             }
             else
             {
                 GUI.Label(rect, LightingWindowObjectTab.Styles.TextureNotAvailableRealtime);
             }
         }
         else if (this.m_CachedTexture.textureAvailability == GITextureAvailability.GITextureLoading && this.m_CachedTexture.texture == null)
         {
             GUI.Label(rect, LightingWindowObjectTab.Styles.TextureLoading);
         }
         else
         {
             LightmapType lightmapType = LightmapVisualizationUtility.GetLightmapType(gITextureType);
             Event        current      = Event.current;
             EventType    type         = current.type;
             if (type != EventType.ValidateCommand && type != EventType.ExecuteCommand)
             {
                 if (type == EventType.Repaint)
                 {
                     Texture2D texture = this.m_CachedTexture.texture;
                     if (texture && Event.current.type == EventType.Repaint)
                     {
                         Rect rect2 = new Rect(0f, 0f, (float)texture.width, (float)texture.height);
                         rect2 = this.ResizeRectToFit(rect2, rect);
                         rect2 = this.CenterToRect(rect2, rect);
                         rect2 = this.ScaleRectByZoomableArea(rect2, this.m_ZoomablePreview);
                         Rect position3 = new Rect(rect2);
                         position3.x += 3f;
                         position3.y += rect.y + 20f;
                         Rect drawableArea = new Rect(rect);
                         drawableArea.y += position2.height + 3f;
                         float num2 = drawableArea.y - 14f;
                         position3.y    -= num2;
                         drawableArea.y -= num2;
                         FilterMode filterMode = texture.filterMode;
                         texture.filterMode = FilterMode.Point;
                         LightmapVisualizationUtility.DrawTextureWithUVOverlay(texture, Selection.activeGameObject, drawableArea, position3, gITextureType);
                         texture.filterMode = filterMode;
                     }
                 }
             }
             else if (Event.current.commandName == "FrameSelected")
             {
                 Vector4 lightmapTilingOffset = LightmapVisualizationUtility.GetLightmapTilingOffset(lightmapType);
                 Vector2 vector = new Vector2(lightmapTilingOffset.z, lightmapTilingOffset.w);
                 Vector2 lhs    = vector + new Vector2(lightmapTilingOffset.x, lightmapTilingOffset.y);
                 vector = Vector2.Max(vector, Vector2.zero);
                 lhs    = Vector2.Min(lhs, Vector2.one);
                 float y = 1f - vector.y;
                 vector.y = 1f - lhs.y;
                 lhs.y    = y;
                 Rect shownArea = new Rect(vector.x, vector.y, lhs.x - vector.x, lhs.y - vector.y);
                 shownArea.x -= Mathf.Clamp(shownArea.height - shownArea.width, 0f, 3.40282347E+38f) / 2f;
                 shownArea.y -= Mathf.Clamp(shownArea.width - shownArea.height, 0f, 3.40282347E+38f) / 2f;
                 float num3 = Mathf.Max(shownArea.width, shownArea.height);
                 shownArea.height = num3;
                 shownArea.width  = num3;
                 this.m_ZoomablePreview.shownArea = shownArea;
                 Event.current.Use();
             }
             if (this.m_PreviousSelection != Selection.activeInstanceID)
             {
                 this.m_PreviousSelection = Selection.activeInstanceID;
                 this.m_ZoomablePreview.SetShownHRange(0f, 1f);
                 this.m_ZoomablePreview.SetShownVRange(0f, 1f);
             }
             Rect rect3 = new Rect(r);
             rect3.yMin += position2.height;
             this.m_ZoomablePreview.rect = rect3;
             this.m_ZoomablePreview.BeginViewGUI();
             this.m_ZoomablePreview.EndViewGUI();
             GUILayoutUtility.GetRect(r.width, r.height);
         }
     }
 }
        public void ObjectPreview(Rect r)
        {
            if (r.height <= 0)
            {
                return;
            }

            if (m_ZoomablePreview == null)
            {
                m_ZoomablePreview = new ZoomableArea(true);

                m_ZoomablePreview.hRangeMin = 0.0f;
                m_ZoomablePreview.vRangeMin = 0.0f;

                m_ZoomablePreview.hRangeMax = 1.0f;
                m_ZoomablePreview.vRangeMax = 1.0f;

                m_ZoomablePreview.SetShownHRange(0, 1);
                m_ZoomablePreview.SetShownVRange(0, 1);

                m_ZoomablePreview.uniformScale    = true;
                m_ZoomablePreview.scaleWithWindow = true;
            }

            // Draw background
            GUI.Box(r, "", "PreBackground");

            // Top menu rect
            Rect menuRect = new Rect(r);

            menuRect.y     += 1;
            menuRect.height = 18;
            GUI.Box(menuRect, "", EditorStyles.toolbar);

            // Top menu dropdown
            Rect dropRect = new Rect(r);

            dropRect.y     += 1;
            dropRect.height = 18;
            dropRect.width  = 120;

            // Drawable area
            Rect drawableArea = new Rect(r);

            drawableArea.yMin  += dropRect.height;
            drawableArea.yMax  -= 14;
            drawableArea.width -= 11;

            int index = Array.IndexOf(Styles.ObjectPreviewTextureOptions, m_SelectedObjectPreviewTexture);

            if (index < 0 || !LightmapVisualizationUtility.IsTextureTypeEnabled(kObjectPreviewTextureTypes[index]))
            {
                index = 0;
                m_SelectedObjectPreviewTexture = Styles.ObjectPreviewTextureOptions[index];
            }

            if (EditorGUI.DropdownButton(dropRect, m_SelectedObjectPreviewTexture, FocusType.Passive, EditorStyles.toolbarPopup))
            {
                GenericMenu menu = new GenericMenu();

                for (int i = 0; i < Styles.ObjectPreviewTextureOptions.Length; i++)
                {
                    if (LightmapVisualizationUtility.IsTextureTypeEnabled(kObjectPreviewTextureTypes[i]))
                    {
                        menu.AddItem(Styles.ObjectPreviewTextureOptions[i], index == i, SelectPreviewTextureOption, Styles.ObjectPreviewTextureOptions.ElementAt(i));
                    }
                    else
                    {
                        menu.AddDisabledItem(Styles.ObjectPreviewTextureOptions.ElementAt(i));
                    }
                }
                menu.DropDown(dropRect);
            }

            GITextureType textureType = kObjectPreviewTextureTypes[Array.IndexOf(Styles.ObjectPreviewTextureOptions, m_SelectedObjectPreviewTexture)];

            if (m_CachedTexture.type != textureType || m_CachedTexture.contentHash != LightmapVisualizationUtility.GetSelectedObjectGITextureHash(textureType) || m_CachedTexture.contentHash == new Hash128())
            {
                m_CachedTexture = LightmapVisualizationUtility.GetSelectedObjectGITexture(textureType);
            }

            if (m_CachedTexture.textureAvailability == GITextureAvailability.GITextureNotAvailable || m_CachedTexture.textureAvailability == GITextureAvailability.GITextureUnknown)
            {
                if (LightmapVisualizationUtility.IsBakedTextureType(textureType))
                {
                    if (textureType == GITextureType.BakedShadowMask)
                    {
                        GUI.Label(drawableArea, Styles.TextureNotAvailableBakedShadowmask);
                    }
                    else
                    {
                        GUI.Label(drawableArea, Styles.TextureNotAvailableBaked);
                    }
                }
                else
                {
                    GUI.Label(drawableArea, Styles.TextureNotAvailableRealtime);
                }

                return;
            }

            if (m_CachedTexture.textureAvailability == GITextureAvailability.GITextureLoading && m_CachedTexture.texture == null)
            {
                GUI.Label(drawableArea, Styles.TextureLoading);

                return;
            }

            LightmapType lightmapType = LightmapVisualizationUtility.GetLightmapType(textureType);

            // Framing and drawing
            var evt = Event.current;

            switch (evt.type)
            {
            // 'F' will zoom to uv bounds
            case EventType.ValidateCommand:
            case EventType.ExecuteCommand:

                if (Event.current.commandName == EventCommandNames.FrameSelected)
                {
                    Vector4 lightmapTilingOffset = LightmapVisualizationUtility.GetLightmapTilingOffset(lightmapType);

                    Vector2 min = new Vector2(lightmapTilingOffset.z, lightmapTilingOffset.w);
                    Vector2 max = min + new Vector2(lightmapTilingOffset.x, lightmapTilingOffset.y);

                    min = Vector2.Max(min, Vector2.zero);
                    max = Vector2.Min(max, Vector2.one);

                    float swap = 1f - min.y;
                    min.y = 1f - max.y;
                    max.y = swap;

                    // Make sure that the focus rectangle is a even square
                    Rect rect = new Rect(min.x, min.y, max.x - min.x, max.y - min.y);
                    rect.x    -= Mathf.Clamp(rect.height - rect.width, 0, float.MaxValue) / 2;
                    rect.y    -= Mathf.Clamp(rect.width - rect.height, 0, float.MaxValue) / 2;
                    rect.width = rect.height = Mathf.Max(rect.width, rect.height);

                    m_ZoomablePreview.shownArea = rect;
                    Event.current.Use();
                }
                break;

            // Scale and draw texture and uv's
            case EventType.Repaint:

                Texture2D texture = m_CachedTexture.texture;
                if (texture && Event.current.type == EventType.Repaint)
                {
                    Rect textureRect = new Rect(0, 0, texture.width, texture.height);
                    textureRect = ResizeRectToFit(textureRect, drawableArea);
                    //textureRect.x = -textureRect.width / 2;
                    //textureRect.y = -textureRect.height / 2;
                    textureRect = CenterToRect(textureRect, drawableArea);
                    textureRect = ScaleRectByZoomableArea(textureRect, m_ZoomablePreview);

                    // Draw texture and UV
                    Rect uvRect = new Rect(textureRect);
                    uvRect.x += 3;
                    uvRect.y += drawableArea.y + 20;

                    Rect clipRect = new Rect(drawableArea);
                    clipRect.y += dropRect.height + 3;

                    // fix 635838 - We need to offset the rects for rendering.
                    {
                        float offset = clipRect.y - 14;
                        uvRect.y   -= offset;
                        clipRect.y -= offset;
                    }

                    // Texture shouldn't be filtered since it will make previewing really blurry
                    FilterMode prevMode = texture.filterMode;
                    texture.filterMode = FilterMode.Point;

                    LightmapVisualizationUtility.DrawTextureWithUVOverlay(texture, Selection.activeGameObject, clipRect, uvRect, textureType);
                    texture.filterMode = prevMode;
                }
                break;
            }

            // Reset zoom if selection is changed
            if (m_PreviousSelection != Selection.activeInstanceID)
            {
                m_PreviousSelection = Selection.activeInstanceID;
                m_ZoomablePreview.SetShownHRange(0, 1);
                m_ZoomablePreview.SetShownVRange(0, 1);
            }

            // Handle zoomable area
            Rect zoomRect = new Rect(r);

            zoomRect.yMin         += dropRect.height;
            m_ZoomablePreview.rect = zoomRect;

            m_ZoomablePreview.BeginViewGUI();
            m_ZoomablePreview.EndViewGUI();

            GUILayoutUtility.GetRect(r.width, r.height);
        }