コード例 #1
0
        internal static VisualisationGITexture GetSelectedObjectGITexture(GITextureType textureType)
        {
            VisualisationGITexture result = default(VisualisationGITexture);

            LightmapVisualizationUtility.GetSelectedObjectGITextureInternal(textureType, ref result);
            return(result);
        }
コード例 #2
0
        internal static Hash128 GetSelectedObjectGITextureHash(GITextureType textureType)
        {
            Hash128 result = default(Hash128);

            LightmapVisualizationUtility.GetSelectedObjectGITextureHashInternal(textureType, ref result);
            return(result);
        }
コード例 #3
0
 public LightingWindowObjectTab()
 {
     GITextureType[] typeArray1 = new GITextureType[7];
     typeArray1[1] = GITextureType.Albedo;
     typeArray1[2] = GITextureType.Emissive;
     typeArray1[3] = GITextureType.Irradiance;
     typeArray1[4] = GITextureType.Directionality;
     typeArray1[5] = GITextureType.Baked;
     typeArray1[6] = GITextureType.BakedDirectional;
     this.kObjectPreviewTextureTypes = typeArray1;
     this.m_ShowClampedSize          = new AnimBool();
 }
コード例 #4
0
 public LightingWindowObjectTab()
 {
     GITextureType[] typeArray1 = new GITextureType[7];
     typeArray1[1] = GITextureType.Albedo;
     typeArray1[2] = GITextureType.Emissive;
     typeArray1[3] = GITextureType.Irradiance;
     typeArray1[4] = GITextureType.Directionality;
     typeArray1[5] = GITextureType.Baked;
     typeArray1[6] = GITextureType.BakedDirectional;
     this.kObjectPreviewTextureTypes = typeArray1;
     this.m_ShowClampedSize = new AnimBool();
 }
コード例 #5
0
        private bool IsActiveGameObjectInLightmap(GITextureType textureType)
        {
            if (isRealtimeLightmap)
            {
                return(m_ActiveGameObjectTextureHash == m_RealtimeTextureHash);
            }

            if (LightmapVisualizationUtility.IsAtlasTextureType(textureType))
            {
                return(m_ActiveGameObjectLightmapIndex == m_LightmapIndex);
            }

            return(m_ActiveGameObjectInstanceId == m_InstanceID);
        }
コード例 #6
0
		public static void DrawTextureWithUVOverlay(Texture2D texture, GameObject gameObject, Rect drawableArea, Rect position, GITextureType textureType, bool drawSpecularUV)
		{
			LightmapVisualizationUtility.INTERNAL_CALL_DrawTextureWithUVOverlay(texture, gameObject, ref drawableArea, ref position, textureType, drawSpecularUV);
		}
コード例 #7
0
		public static extern Texture2D GetGITexture(GITextureType textureType);
コード例 #8
0
 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);
         }
     }
 }
コード例 #9
0
 private static extern void INTERNAL_CALL_DrawTextureWithUVOverlay(Texture2D texture, GameObject gameObject, ref Rect drawableArea, ref Rect position, GITextureType textureType, bool drawSpecularUV);
コード例 #10
0
 public static extern bool IsBakedTextureType(GITextureType textureType);
コード例 #11
0
        public void ObjectPreview(Rect r)
        {
            if (r.height > 0f)
            {
                if (s_Styles == null)
                {
                    s_Styles = new Styles();
                }
                List <Texture2D> list = new List <Texture2D>();
                foreach (GITextureType type in this.kObjectPreviewTextureTypes)
                {
                    list.Add(LightmapVisualizationUtility.GetGITexture(type));
                }
                if (list.Count != 0)
                {
                    Rect rect3;
                    Rect rect9;
                    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, string.Empty, "PreBackground");
                    Rect position = new Rect(r);
                    position.y++;
                    position.height = 18f;
                    GUI.Box(position, string.Empty, EditorStyles.toolbar);
                    Rect rect2 = new Rect(r);
                    rect2.y++;
                    rect2.height = 18f;
                    rect2.width  = 120f;
                    rect3        = new Rect(r)
                    {
                        yMin  = rect3.yMin + rect2.height,
                        yMax  = rect3.yMax - 14f,
                        width = rect3.width - 11f
                    };
                    int index = Array.IndexOf <GUIContent>(kObjectPreviewTextureOptions, this.m_SelectedObjectPreviewTexture);
                    if (index < 0)
                    {
                        index = 0;
                    }
                    index = EditorGUI.Popup(rect2, index, kObjectPreviewTextureOptions, EditorStyles.toolbarPopup);
                    if (index >= kObjectPreviewTextureOptions.Length)
                    {
                        index = 0;
                    }
                    this.m_SelectedObjectPreviewTexture = kObjectPreviewTextureOptions[index];
                    LightmapType       lightmapType = ((this.kObjectPreviewTextureTypes[index] != GITextureType.Baked) && (this.kObjectPreviewTextureTypes[index] != GITextureType.BakedDirectional)) ? LightmapType.DynamicLightmap : LightmapType.StaticLightmap;
                    SerializedProperty property     = new SerializedObject(LightmapEditorSettings.GetLightmapSettings()).FindProperty("m_LightmapsMode");
                    bool flag = ((this.kObjectPreviewTextureTypes[index] == GITextureType.Baked) || (this.kObjectPreviewTextureTypes[index] == GITextureType.BakedDirectional)) && (property.intValue == 2);
                    if (flag)
                    {
                        GUIContent content = GUIContent.Temp("Indirect");
                        Rect       rect4   = rect2;
                        rect4.x    += rect2.width;
                        rect4.width = EditorStyles.toolbarButton.CalcSize(content).x;
                        this.m_HasSeparateIndirectUV = GUI.Toggle(rect4, this.m_HasSeparateIndirectUV, content.text, EditorStyles.toolbarButton);
                    }
                    switch (Event.current.type)
                    {
                    case EventType.ValidateCommand:
                    case EventType.ExecuteCommand:
                        if (Event.current.commandName == "FrameSelected")
                        {
                            Rect    rect5;
                            Vector4 lightmapTilingOffset = LightmapVisualizationUtility.GetLightmapTilingOffset(lightmapType);
                            Vector2 lhs     = new Vector2(lightmapTilingOffset.z, lightmapTilingOffset.w);
                            Vector2 vector3 = lhs + new Vector2(lightmapTilingOffset.x, lightmapTilingOffset.y);
                            lhs     = Vector2.Max(lhs, Vector2.zero);
                            vector3 = Vector2.Min(vector3, Vector2.one);
                            float num3 = 1f - lhs.y;
                            lhs.y     = 1f - vector3.y;
                            vector3.y = num3;
                            rect5     = new Rect(lhs.x, lhs.y, vector3.x - lhs.x, vector3.y - lhs.y)
                            {
                                x = rect5.x - (Mathf.Clamp(rect5.height - rect5.width, 0f, float.MaxValue) / 2f),
                                y = rect5.y - (Mathf.Clamp(rect5.width - rect5.height, 0f, float.MaxValue) / 2f)
                            };
                            float num5 = Mathf.Max(rect5.width, rect5.height);
                            rect5.height = num5;
                            rect5.width  = num5;
                            if (flag && this.m_HasSeparateIndirectUV)
                            {
                                rect5.x += 0.5f;
                            }
                            this.m_ZoomablePreview.shownArea = rect5;
                            Event.current.Use();
                        }
                        break;

                    case EventType.Repaint:
                    {
                        Texture2D texture = list[index];
                        if ((texture != null) && (Event.current.type == EventType.Repaint))
                        {
                            Rect rect7;
                            Rect rect8;
                            Rect rect = new Rect(0f, 0f, (float)texture.width, (float)texture.height);
                            rect  = this.ResizeRectToFit(rect, rect3);
                            rect  = this.CenterToRect(rect, rect3);
                            rect  = this.ScaleRectByZoomableArea(rect, this.m_ZoomablePreview);
                            rect7 = new Rect(rect)
                            {
                                x = rect7.x + 3f,
                                y = rect7.y + (rect3.y + 20f)
                            };
                            rect8 = new Rect(rect3)
                            {
                                y = rect8.y + (rect2.height + 3f)
                            };
                            float num4 = rect8.y - 14f;
                            rect7.y -= num4;
                            rect8.y -= num4;
                            UnityEngine.FilterMode filterMode = texture.filterMode;
                            texture.filterMode = UnityEngine.FilterMode.Point;
                            GITextureType textureType    = this.kObjectPreviewTextureTypes[index];
                            bool          drawSpecularUV = flag && this.m_HasSeparateIndirectUV;
                            LightmapVisualizationUtility.DrawTextureWithUVOverlay(texture, Selection.activeGameObject, rect8, rect7, textureType, drawSpecularUV);
                            texture.filterMode = filterMode;
                        }
                        break;
                    }
                    }
                    if (this.m_PreviousSelection != Selection.activeInstanceID)
                    {
                        this.m_PreviousSelection = Selection.activeInstanceID;
                        this.m_ZoomablePreview.SetShownHRange(0f, 1f);
                        this.m_ZoomablePreview.SetShownVRange(0f, 1f);
                    }
                    rect9 = new Rect(r)
                    {
                        yMin = rect9.yMin + rect2.height
                    };
                    this.m_ZoomablePreview.rect = rect9;
                    this.m_ZoomablePreview.BeginViewGUI();
                    this.m_ZoomablePreview.EndViewGUI();
                    GUILayoutUtility.GetRect(r.width, r.height);
                }
            }
        }
コード例 #12
0
 public static extern LightmapType GetLightmapType(GITextureType textureType);
コード例 #13
0
 private static void GetSelectedObjectGITextureHashInternal(GITextureType textureType, ref Hash128 result)
 {
     LightmapVisualizationUtility.INTERNAL_CALL_GetSelectedObjectGITextureHashInternal(textureType, ref result);
 }
コード例 #14
0
 private static extern void INTERNAL_CALL_GetSelectedObjectGITextureHashInternal(GITextureType textureType, ref Hash128 result);
コード例 #15
0
        public void ObjectPreview(Rect r)
        {
            if (r.height <= 0f)
            {
                return;
            }
            if (LightingWindowObjectTab.s_Styles == null)
            {
                LightingWindowObjectTab.s_Styles = new LightingWindowObjectTab.Styles();
            }
            List <Texture2D> list = new List <Texture2D>();

            GITextureType[] array = this.kObjectPreviewTextureTypes;
            for (int i = 0; i < array.Length; i++)
            {
                GITextureType textureType = array[i];
                list.Add(LightmapVisualizationUtility.GetGITexture(textureType));
            }
            if (list.Count == 0)
            {
                return;
            }
            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, string.Empty, "PreBackground");
            Rect position = new Rect(r);

            position.y     += 1f;
            position.height = 18f;
            GUI.Box(position, string.Empty, EditorStyles.toolbar);
            Rect rect = new Rect(r);

            rect.y     += 1f;
            rect.height = 18f;
            rect.width  = 120f;
            Rect rect2 = new Rect(r);

            rect2.yMin  += rect.height;
            rect2.yMax  -= 14f;
            rect2.width -= 11f;
            int num = Array.IndexOf <GUIContent>(LightingWindowObjectTab.kObjectPreviewTextureOptions, this.m_SelectedObjectPreviewTexture);

            if (num < 0)
            {
                num = 0;
            }
            num = EditorGUI.Popup(rect, num, LightingWindowObjectTab.kObjectPreviewTextureOptions, EditorStyles.toolbarPopup);
            if (num >= LightingWindowObjectTab.kObjectPreviewTextureOptions.Length)
            {
                num = 0;
            }
            this.m_SelectedObjectPreviewTexture = LightingWindowObjectTab.kObjectPreviewTextureOptions[num];
            LightmapType       lightmapType       = (this.kObjectPreviewTextureTypes[num] != GITextureType.Baked && this.kObjectPreviewTextureTypes[num] != GITextureType.BakedDirectional) ? LightmapType.DynamicLightmap : LightmapType.StaticLightmap;
            SerializedObject   serializedObject   = new SerializedObject(LightmapEditorSettings.GetLightmapSettings());
            SerializedProperty serializedProperty = serializedObject.FindProperty("m_LightmapsMode");
            bool flag = (this.kObjectPreviewTextureTypes[num] == GITextureType.Baked || this.kObjectPreviewTextureTypes[num] == GITextureType.BakedDirectional) && serializedProperty.intValue == 2;

            if (flag)
            {
                GUIContent gUIContent = GUIContent.Temp("Indirect");
                Rect       position2  = rect;
                position2.x    += rect.width;
                position2.width = EditorStyles.toolbarButton.CalcSize(gUIContent).x;
                this.m_HasSeparateIndirectUV = GUI.Toggle(position2, this.m_HasSeparateIndirectUV, gUIContent.text, EditorStyles.toolbarButton);
            }
            Event     current = Event.current;
            EventType type    = current.type;

            if (type != EventType.ValidateCommand && type != EventType.ExecuteCommand)
            {
                if (type == EventType.Repaint)
                {
                    Texture2D texture2D = list[num];
                    if (texture2D && Event.current.type == EventType.Repaint)
                    {
                        Rect rect3 = new Rect(0f, 0f, (float)texture2D.width, (float)texture2D.height);
                        rect3 = this.ResizeRectToFit(rect3, rect2);
                        rect3 = this.CenterToRect(rect3, rect2);
                        rect3 = this.ScaleRectByZoomableArea(rect3, this.m_ZoomablePreview);
                        Rect position3 = new Rect(rect3);
                        position3.x += 3f;
                        position3.y += rect2.y + 20f;
                        Rect drawableArea = new Rect(rect2);
                        drawableArea.y += rect.height + 3f;
                        float num2 = drawableArea.y - 14f;
                        position3.y         -= num2;
                        drawableArea.y      -= num2;
                        texture2D.filterMode = FilterMode.Point;
                        GITextureType textureType2   = this.kObjectPreviewTextureTypes[num];
                        bool          drawSpecularUV = flag && this.m_HasSeparateIndirectUV;
                        LightmapVisualizationUtility.DrawTextureWithUVOverlay(texture2D, Selection.activeGameObject, drawableArea, position3, textureType2, drawSpecularUV);
                    }
                }
            }
            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;
                    if (flag && this.m_HasSeparateIndirectUV)
                    {
                        shownArea.x += 0.5f;
                    }
                    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 rect4 = new Rect(r);

            rect4.yMin += rect.height;
            this.m_ZoomablePreview.rect = rect4;
            this.m_ZoomablePreview.BeginViewGUI();
            this.m_ZoomablePreview.EndViewGUI();
            GUILayoutUtility.GetRect(r.width, r.height);
        }
コード例 #16
0
 private static extern void INTERNAL_CALL_GetSelectedObjectGITextureInternal(GITextureType textureType, ref VisualisationGITexture result);
コード例 #17
0
 public void ObjectPreview(Rect r)
 {
     if (r.height > 0f)
     {
         List <Texture2D> list  = new List <Texture2D>();
         GITextureType[]  array = this.kObjectPreviewTextureTypes;
         for (int i = 0; i < array.Length; i++)
         {
             GITextureType textureType = array[i];
             list.Add(LightmapVisualizationUtility.GetGITexture(textureType));
         }
         if (list.Count != 0)
         {
             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.kObjectPreviewTextureOptions, this.m_SelectedObjectPreviewTexture);
             if (num < 0)
             {
                 num = 0;
             }
             num = EditorGUI.Popup(position2, num, LightingWindowObjectTab.kObjectPreviewTextureOptions, EditorStyles.toolbarPopup);
             if (num >= LightingWindowObjectTab.kObjectPreviewTextureOptions.Length)
             {
                 num = 0;
             }
             this.m_SelectedObjectPreviewTexture = LightingWindowObjectTab.kObjectPreviewTextureOptions[num];
             LightmapType lightmapType = (this.kObjectPreviewTextureTypes[num] != GITextureType.BakedShadowMask && this.kObjectPreviewTextureTypes[num] != GITextureType.Baked && this.kObjectPreviewTextureTypes[num] != GITextureType.BakedDirectional && this.kObjectPreviewTextureTypes[num] != GITextureType.BakedCharting) ? LightmapType.DynamicLightmap : LightmapType.StaticLightmap;
             Event        current      = Event.current;
             EventType    type         = current.type;
             if (type != EventType.ValidateCommand && type != EventType.ExecuteCommand)
             {
                 if (type == EventType.Repaint)
                 {
                     Texture2D texture2D = list[num];
                     if (texture2D && Event.current.type == EventType.Repaint)
                     {
                         Rect rect2 = new Rect(0f, 0f, (float)texture2D.width, (float)texture2D.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 = texture2D.filterMode;
                         texture2D.filterMode = FilterMode.Point;
                         GITextureType textureType2 = this.kObjectPreviewTextureTypes[num];
                         LightmapVisualizationUtility.DrawTextureWithUVOverlay(texture2D, Selection.activeGameObject, drawableArea, position3, textureType2);
                         texture2D.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);
         }
     }
 }
コード例 #18
0
		private static extern void INTERNAL_CALL_DrawTextureWithUVOverlay(Texture2D texture, GameObject gameObject, ref Rect drawableArea, ref Rect position, GITextureType textureType, bool drawSpecularUV);
コード例 #19
0
        public void ObjectPreview(Rect r)
        {
            if ((double)r.height <= 0.0)
            {
                return;
            }
            if (LightingWindowObjectTab.s_Styles == null)
            {
                LightingWindowObjectTab.s_Styles = new LightingWindowObjectTab.Styles();
            }
            List <Texture2D> texture2DList = new List <Texture2D>();

            foreach (GITextureType previewTextureType in this.kObjectPreviewTextureTypes)
            {
                texture2DList.Add(LightmapVisualizationUtility.GetGITexture(previewTextureType));
            }
            if (texture2DList.Count == 0)
            {
                return;
            }
            if (this.m_ZoomablePreview == null)
            {
                this.m_ZoomablePreview           = new ZoomableArea(true);
                this.m_ZoomablePreview.hRangeMin = 0.0f;
                this.m_ZoomablePreview.vRangeMin = 0.0f;
                this.m_ZoomablePreview.hRangeMax = 1f;
                this.m_ZoomablePreview.vRangeMax = 1f;
                this.m_ZoomablePreview.SetShownHRange(0.0f, 1f);
                this.m_ZoomablePreview.SetShownVRange(0.0f, 1f);
                this.m_ZoomablePreview.uniformScale    = true;
                this.m_ZoomablePreview.scaleWithWindow = true;
            }
            GUI.Box(r, string.Empty, (GUIStyle)"PreBackground");
            Rect position1 = new Rect(r);

            ++position1.y;
            position1.height = 18f;
            GUI.Box(position1, string.Empty, EditorStyles.toolbar);
            Rect position2 = new Rect(r);

            ++position2.y;
            position2.height = 18f;
            position2.width  = 120f;
            Rect rect1 = new Rect(r);

            rect1.yMin  += position2.height;
            rect1.yMax  -= 14f;
            rect1.width -= 11f;
            int selectedIndex = Array.IndexOf <GUIContent>(LightingWindowObjectTab.kObjectPreviewTextureOptions, this.m_SelectedObjectPreviewTexture);

            if (selectedIndex < 0)
            {
                selectedIndex = 0;
            }
            int index = EditorGUI.Popup(position2, selectedIndex, LightingWindowObjectTab.kObjectPreviewTextureOptions, EditorStyles.toolbarPopup);

            if (index >= LightingWindowObjectTab.kObjectPreviewTextureOptions.Length)
            {
                index = 0;
            }
            this.m_SelectedObjectPreviewTexture = LightingWindowObjectTab.kObjectPreviewTextureOptions[index];
            LightmapType       lightmapType = this.kObjectPreviewTextureTypes[index] == GITextureType.Baked || this.kObjectPreviewTextureTypes[index] == GITextureType.BakedDirectional ? LightmapType.StaticLightmap : LightmapType.DynamicLightmap;
            SerializedProperty property     = new SerializedObject(LightmapEditorSettings.GetLightmapSettings()).FindProperty("m_LightmapsMode");
            bool flag = (this.kObjectPreviewTextureTypes[index] == GITextureType.Baked || this.kObjectPreviewTextureTypes[index] == GITextureType.BakedDirectional) && property.intValue == 2;

            if (flag)
            {
                GUIContent content   = GUIContent.Temp("Indirect");
                Rect       position3 = position2;
                position3.x    += position2.width;
                position3.width = EditorStyles.toolbarButton.CalcSize(content).x;
                this.m_HasSeparateIndirectUV = GUI.Toggle(position3, this.m_HasSeparateIndirectUV, content.text, EditorStyles.toolbarButton);
            }
            switch (Event.current.type)
            {
            case EventType.ValidateCommand:
            case EventType.ExecuteCommand:
                if (Event.current.commandName == "FrameSelected")
                {
                    Vector4 lightmapTilingOffset = LightmapVisualizationUtility.GetLightmapTilingOffset(lightmapType);
                    Vector2 lhs1 = new Vector2(lightmapTilingOffset.z, lightmapTilingOffset.w);
                    Vector2 lhs2 = lhs1 + new Vector2(lightmapTilingOffset.x, lightmapTilingOffset.y);
                    lhs1 = Vector2.Max(lhs1, Vector2.zero);
                    Vector2 vector2 = Vector2.Min(lhs2, Vector2.one);
                    float   num1    = 1f - lhs1.y;
                    lhs1.y    = 1f - vector2.y;
                    vector2.y = num1;
                    Rect rect2 = new Rect(lhs1.x, lhs1.y, vector2.x - lhs1.x, vector2.y - lhs1.y);
                    rect2.x -= Mathf.Clamp(rect2.height - rect2.width, 0.0f, float.MaxValue) / 2f;
                    rect2.y -= Mathf.Clamp(rect2.width - rect2.height, 0.0f, float.MaxValue) / 2f;
                    // ISSUE: explicit reference operation
                    // ISSUE: variable of a reference type
                    Rect& local = @rect2;
                    float num2  = Mathf.Max(rect2.width, rect2.height);
                    rect2.height = num2;
                    double num3 = (double)num2;
                    // ISSUE: explicit reference operation
                    (^ local).width = (float)num3;
                    if (flag && this.m_HasSeparateIndirectUV)
                    {
                        rect2.x += 0.5f;
                    }
                    this.m_ZoomablePreview.shownArea = rect2;
                    Event.current.Use();
                    break;
                }
                break;

            case EventType.Repaint:
                Texture2D texture = texture2DList[index];
                if ((bool)((UnityEngine.Object)texture) && Event.current.type == EventType.Repaint)
                {
                    Rect position3 = new Rect(this.ScaleRectByZoomableArea(this.CenterToRect(this.ResizeRectToFit(new Rect(0.0f, 0.0f, (float)texture.width, (float)texture.height), rect1), rect1), this.m_ZoomablePreview));
                    position3.x += 3f;
                    position3.y += rect1.y + 20f;
                    Rect drawableArea = new Rect(rect1);
                    drawableArea.y += position2.height + 3f;
                    float num = drawableArea.y - 14f;
                    position3.y    -= num;
                    drawableArea.y -= num;
                    UnityEngine.FilterMode filterMode = texture.filterMode;
                    texture.filterMode = UnityEngine.FilterMode.Point;
                    GITextureType previewTextureType = this.kObjectPreviewTextureTypes[index];
                    bool          drawSpecularUV     = flag && this.m_HasSeparateIndirectUV;
                    LightmapVisualizationUtility.DrawTextureWithUVOverlay(texture, Selection.activeGameObject, drawableArea, position3, previewTextureType, drawSpecularUV);
                    texture.filterMode = filterMode;
                    break;
                }
                break;
            }
            if (this.m_PreviousSelection != Selection.activeInstanceID)
            {
                this.m_PreviousSelection = Selection.activeInstanceID;
                this.m_ZoomablePreview.SetShownHRange(0.0f, 1f);
                this.m_ZoomablePreview.SetShownVRange(0.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);
        }
コード例 #20
0
        private void DrawPreview(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;
            }

            m_ZoomablePreview.rect = r;

            m_ZoomablePreview.BeginViewGUI();

            m_ZoomablePreview.hSlider = m_ZoomablePreview.shownArea.width < 1;
            m_ZoomablePreview.vSlider = m_ZoomablePreview.shownArea.height < 1;

            Rect          drawableArea = m_ZoomablePreview.drawRect;
            GITextureType textureType  = GetSelectedTextureType();

            UpdateCachedTexture(textureType);

            if (m_CachedTexture.textureAvailability == GITextureAvailability.GITextureNotAvailable || m_CachedTexture.textureAvailability == GITextureAvailability.GITextureUnknown)
            {
                if (!isRealtimeLightmap)
                {
                    if (!LightmapVisualizationUtility.IsAtlasTextureType(textureType) && isIndexBased)
                    {
                        GUI.Label(drawableArea, Styles.TextureNotAvailableBakedAlbedoEmissive, Styles.PreviewLabel);
                    }
                    else if (textureType == GITextureType.BakedShadowMask)
                    {
                        GUI.Label(drawableArea, Styles.TextureNotAvailableBakedShadowmask, Styles.PreviewLabel);
                    }
                    else
                    {
                        GUI.Label(drawableArea, Styles.TextureNotAvailableBaked, Styles.PreviewLabel);
                    }
                }
                else
                {
                    GUI.Label(drawableArea, Styles.TextureNotAvailableRealtime, Styles.PreviewLabel);
                }

                return;
            }

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

            LightmapType lightmapType = LightmapVisualizationUtility.GetLightmapType(textureType);

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

                if (Event.current.commandName == EventCommandNames.FrameSelected && IsActiveGameObjectInLightmap(textureType))
                {
                    // There are instance based baked textures where we don't get any STs and can't do the framing
                    if (!isRealtimeLightmap && !LightmapVisualizationUtility.IsAtlasTextureType(textureType))
                    {
                        break;
                    }

                    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);

                    Texture2D texture     = m_CachedTexture.texture;
                    Rect      textureRect = new Rect(r.x, r.y, texture.width, texture.height);
                    textureRect = ResizeRectToFit(textureRect, drawableArea);

                    float offsetX = 0.0f, offsetY = 0.0f;

                    if (textureRect.height == drawableArea.height)
                    {
                        offsetX = (drawableArea.width - textureRect.width) / drawableArea.width;
                    }
                    else
                    {
                        offsetY = (drawableArea.height - textureRect.height) / drawableArea.height;
                    }

                    // 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.width = rect.height = Mathf.Max(rect.width, rect.height);
                    rect.x    -= (offsetX * min.x);
                    rect.y    += (offsetY * (1 - max.y));

                    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)
                {
                    Rect textureRect = new Rect(r.x, r.y, texture.width, texture.height);
                    textureRect = ResizeRectToFit(textureRect, drawableArea);
                    textureRect = ScaleRectByZoomableArea(textureRect, m_ZoomablePreview);

                    const int padding = 5;
                    textureRect.x      += padding;
                    textureRect.width  -= padding * 2;
                    textureRect.height -= padding;

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

                    LightmapVisualizationUtility.DrawTextureWithUVOverlay(texture,
                                                                          (m_ShowUVOverlay && IsActiveGameObjectInLightmap(textureType)) ? Selection.activeGameObject : null,
                                                                          m_ShowUVOverlay ? m_CachedTextureObjects : new GameObject[] {}, drawableArea, textureRect, textureType, exposure);
                    texture.filterMode = prevMode;
                }
            }
            break;
            }

            m_ZoomablePreview.EndViewGUI();
        }
コード例 #21
0
 public static extern Texture2D GetGITexture(GITextureType textureType);
コード例 #22
0
        private void UpdateCachedTexture(GITextureType textureType)
        {
            if (isIndexBased)
            {
                if (isRealtimeLightmap)
                {
                    Hash128[] mainHashes = Lightmapping.GetMainSystemHashes();

                    if (!m_RealtimeTextureHash.isValid || !mainHashes.Contains(m_RealtimeTextureHash))
                    {
                        m_RealtimeTextureHash = mainHashes.ElementAtOrDefault(m_LightmapIndex);
                    }
                }
            }
            else // instance based
            {
                if (isRealtimeLightmap)
                {
                    Hash128 systemHash;

                    if (!Lightmapping.GetInputSystemHash(m_InstanceID, out systemHash))
                    {
                        m_CachedTexture.textureAvailability = GITextureAvailability.GITextureNotAvailable;
                        return;
                    }
                    m_RealtimeTextureHash = systemHash;
                }
                else
                {
                    int lightmapIndex;

                    if (!Lightmapping.GetLightmapIndex(m_InstanceID, out lightmapIndex))
                    {
                        m_CachedTexture.textureAvailability = GITextureAvailability.GITextureNotAvailable;
                        return;
                    }

                    m_LightmapIndex = lightmapIndex;
                }
            }

            Hash128 contentHash = isRealtimeLightmap ? LightmapVisualizationUtility.GetRealtimeGITextureHash(m_RealtimeTextureHash, textureType) :
                                  LightmapVisualizationUtility.GetBakedGITextureHash(m_LightmapIndex, m_InstanceID, textureType);

            // if we need to fetch a new texture
            if (m_CachedTexture.texture == null || m_CachedTexture.type != textureType || m_CachedTexture.contentHash != contentHash || m_CachedTexture.contentHash == new Hash128())
            {
                m_CachedTexture = isRealtimeLightmap ?
                                  LightmapVisualizationUtility.GetRealtimeGITexture(m_RealtimeTextureHash, textureType) :
                                  LightmapVisualizationUtility.GetBakedGITexture(m_LightmapIndex, m_InstanceID, textureType);
            }

            if (!m_ShowUVOverlay)
            {
                return; // if we don't wanna show any overlay
            }
            if (m_CachedTexture.texture == null || m_CachedTexture.textureAvailability == GITextureAvailability.GITextureNotAvailable || m_CachedTexture.textureAvailability == GITextureAvailability.GITextureUnknown)
            {
                return; // if we dont have a texture
            }
            // fetch Renderers

            if (isRealtimeLightmap)
            {
                m_CachedTextureObjects = LightmapVisualizationUtility.GetRealtimeGITextureRenderers(m_RealtimeTextureHash);
            }
            else if (LightmapVisualizationUtility.IsAtlasTextureType(textureType))
            {
                m_CachedTextureObjects = LightmapVisualizationUtility.GetBakedGITextureRenderers(m_LightmapIndex);
            }
            else // if it's an instance based baked lightmap, we only have 1 object in it
            {
                m_CachedTextureObjects = new GameObject[] {}
            };
        }
コード例 #23
0
 public static void DrawTextureWithUVOverlay(Texture2D texture, GameObject gameObject, Rect drawableArea, Rect position, GITextureType textureType, bool drawSpecularUV)
 {
     LightmapVisualizationUtility.INTERNAL_CALL_DrawTextureWithUVOverlay(texture, gameObject, ref drawableArea, ref position, textureType, drawSpecularUV);
 }
コード例 #24
0
        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);
        }
コード例 #25
0
 internal static extern bool IsTextureTypeEnabled(GITextureType textureType);