UnityEditor.SpriteInspector.BuildPreviewTexture C# (CSharp) Method

        public static Texture2D BuildPreviewTexture(int width, int height, Sprite sprite, Material spriteRendererMaterial, bool isPolygon)
        {
            if (!ShaderUtil.hardwareSupportsRectRenderTexture)
            {
                return null;
            }
            float num = sprite.rect.width;
            float num2 = sprite.rect.height;
            Texture2D spriteTexture = SpriteUtility.GetSpriteTexture(sprite, false);
            if (!isPolygon)
            {
                PreviewHelpers.AdjustWidthAndHeightForStaticPreview((int) num, (int) num2, ref width, ref height);
            }
            SavedRenderTargetState state = new SavedRenderTargetState();
            RenderTexture temp = RenderTexture.GetTemporary(width, height, 0, RenderTextureFormat.Default, RenderTextureReadWrite.Default);
            RenderTexture.active = temp;
            GL.sRGBWrite = QualitySettings.activeColorSpace == ColorSpace.Linear;
            GL.Clear(true, true, new Color(0f, 0f, 0f, 0f));
            Texture texture = null;
            Vector4 vector = new Vector4(0f, 0f, 0f, 0f);
            bool flag = false;
            bool flag2 = false;
            if (spriteRendererMaterial != null)
            {
                flag = spriteRendererMaterial.HasProperty("_MainTex");
                flag2 = spriteRendererMaterial.HasProperty("_MainTex_TexelSize");
            }
            Material material = null;
            if (spriteRendererMaterial != null)
            {
                if (flag)
                {
                    texture = spriteRendererMaterial.GetTexture("_MainTex");
                    spriteRendererMaterial.SetTexture("_MainTex", spriteTexture);
                }
                if (flag2)
                {
                    vector = spriteRendererMaterial.GetVector("_MainTex_TexelSize");
                    spriteRendererMaterial.SetVector("_MainTex_TexelSize", TextureUtil.GetTexelSizeVector(spriteTexture));
                }
                spriteRendererMaterial.SetPass(0);
            }
            else
            {
                material = new Material(Shader.Find("Hidden/BlitCopy")) {
                    mainTexture = spriteTexture,
                    mainTextureScale = Vector2.one,
                    mainTextureOffset = Vector2.zero
                };
                material.SetPass(0);
            }
            float num3 = sprite.rect.width / sprite.bounds.size.x;
            Vector2[] vertices = sprite.vertices;
            Vector2[] uv = sprite.uv;
            ushort[] triangles = sprite.triangles;
            Vector2 pivot = sprite.pivot;
            GL.PushMatrix();
            GL.LoadOrtho();
            GL.Color(new Color(1f, 1f, 1f, 1f));
            GL.Begin(4);
            for (int i = 0; i < triangles.Length; i++)
            {
                ushort index = triangles[i];
                Vector2 vector4 = vertices[index];
                Vector2 vector5 = uv[index];
                GL.TexCoord(new Vector3(vector5.x, vector5.y, 0f));
                GL.Vertex3(((vector4.x * num3) + pivot.x) / num, ((vector4.y * num3) + pivot.y) / num2, 0f);
            }
            GL.End();
            GL.PopMatrix();
            GL.sRGBWrite = false;
            if (spriteRendererMaterial != null)
            {
                if (flag)
                {
                    spriteRendererMaterial.SetTexture("_MainTex", texture);
                }
                if (flag2)
                {
                    spriteRendererMaterial.SetVector("_MainTex_TexelSize", vector);
                }
            }
            Texture2D textured3 = new Texture2D(width, height, TextureFormat.RGBA32, false) {
                hideFlags = HideFlags.HideAndDontSave,
                filterMode = spriteTexture.filterMode,
                anisoLevel = spriteTexture.anisoLevel,
                wrapMode = spriteTexture.wrapMode
            };
            textured3.ReadPixels(new Rect(0f, 0f, (float) width, (float) height), 0, 0);
            textured3.Apply();
            RenderTexture.ReleaseTemporary(temp);
            state.Restore();
            if (material != null)
            {
                Object.DestroyImmediate(material);
            }
            return textured3;
        }

        public override Texture2D RenderStaticPreview(string assetPath, UnityEngine.Object[] subAssets, int width, int height)
        {
            if (!ShaderUtil.hardwareSupportsRectRenderTexture)
            {
                return((Texture2D)null);
            }
            Texture target1 = this.target as Texture;

            if (this.IsCubemap())
            {
                return(this.m_CubemapPreview.RenderStaticPreview(target1, width, height));
            }
            TextureImporter atPath = AssetImporter.GetAtPath(assetPath) as TextureImporter;

            if ((UnityEngine.Object)atPath != (UnityEngine.Object)null && atPath.spriteImportMode == SpriteImportMode.Polygon)
            {
                Sprite subAsset = subAssets[0] as Sprite;
                if ((bool)((UnityEngine.Object)subAsset))
                {
                    return(SpriteInspector.BuildPreviewTexture(width, height, subAsset, (Material)null, true));
                }
            }
            PreviewHelpers.AdjustWidthAndHeightForStaticPreview(target1.width, target1.height, ref width, ref height);
            RenderTexture active          = RenderTexture.active;
            Rect          rawViewportRect = ShaderUtil.rawViewportRect;
            bool          flag            = !TextureUtil.GetLinearSampled(target1);
            RenderTexture temporary       = RenderTexture.GetTemporary(width, height, 0, RenderTextureFormat.Default, !flag ? RenderTextureReadWrite.Linear : RenderTextureReadWrite.sRGB);
            Material      material        = EditorGUI.GetMaterialForSpecialTexture(target1);

            GL.sRGBWrite = QualitySettings.activeColorSpace == ColorSpace.Linear;
            if ((bool)((UnityEngine.Object)material))
            {
                if (Unsupported.IsDeveloperBuild())
                {
                    material = new Material(material);
                }
                Graphics.Blit(target1, temporary, material);
            }
            else
            {
                Graphics.Blit(target1, temporary);
            }
            GL.sRGBWrite         = false;
            RenderTexture.active = temporary;
            Texture2D target2   = this.target as Texture2D;
            Texture2D texture2D = !((UnityEngine.Object)target2 != (UnityEngine.Object)null) || !target2.alphaIsTransparency ? new Texture2D(width, height, TextureFormat.RGB24, false) : new Texture2D(width, height, TextureFormat.ARGB32, false);

            texture2D.ReadPixels(new Rect(0.0f, 0.0f, (float)width, (float)height), 0, 0);
            texture2D.Apply();
            RenderTexture.ReleaseTemporary(temporary);
            EditorGUIUtility.SetRenderTextureNoViewport(active);
            ShaderUtil.rawViewportRect = rawViewportRect;
            if ((bool)((UnityEngine.Object)material) && Unsupported.IsDeveloperBuild())
            {
                UnityEngine.Object.DestroyImmediate((UnityEngine.Object)material);
            }
            return(texture2D);
        }