Made editor icons use shaders instead of slow color filters

Changing textures with shaders is much more faster than using custom C# methods to manage pixels. New GetTextureWithMaterial method is 16x faster than GetColorizedTexture.

Author: SolidAlloy

Editor/HierarchyFolderIcon.cs

@@ -13,7 +13,7 @@
 
 namespace UnityHierarchyFolders.Editor
 {
-    public class HierarchyFolderIcon
+    public static class HierarchyFolderIcon
     {
 #if UNITY_2020_1_OR_NEWER
         private const string _openedFolderPrefix = "FolderOpened";
@@ -30,7 +30,6 @@ public class HierarchyFolderIcon
         private static bool _isInitialized;
         private static bool _hasProcessedFrame = true;
 
-
         // Reflected members
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "Special naming scheme")]
         private static PropertyInfo prop_sceneHierarchy;
@@ -75,41 +74,43 @@ private static void Startup()
             EditorApplication.hierarchyWindowItemOnGUI += RefreshFolderIcons;
         }
 
-        private static Texture2D GetTintedTexture(Texture2D original, Color tint, string name = "") =>
-            GetColorizedTexture(original, c => c * tint, name);
+        private static Texture2D GetTintedTexture(Texture2D original, Color tint, string name)
+        {
+            var material = new Material(Shader.Find("UI/Default")) { color = tint };
+            return GetTextureWithMaterial(original, material, name);
+        }
 
-        private static Texture2D GetWhiteTexture(Texture2D original, string name = "") =>
-            GetColorizedTexture(original, c => new Color(255, 255, 255, c.a), name);
+        private static Texture2D GetWhiteTexture(Texture2D original, string name)
+        {
+            var material = new Material(Shader.Find("UI/Replace color")) { color = Color.white };
+            return GetTextureWithMaterial(original, material, name);
+        }
 
-        private static Texture2D GetColorizedTexture(Texture2D original, Func<Color32, Color32> colorFilter, string name = "")
+        private static Texture2D GetTextureWithMaterial(Texture2D original, Material material, string name)
         {
-            var tinted = new Texture2D(original.width, original.height,
-                original.graphicsFormat, original.mipmapCount, TextureCreationFlags.MipChain)
+            Texture2D newTexture;
+
+            using (new TextureHelper.SRGBWriteScope(true))
             {
-                name = name
-            };
+                using (var temporary = new TextureHelper.TemporaryActiveTexture(original.width, original.height, 0))
+                {
+                    GL.Clear(false, true, new Color(1f, 1f, 1f, 0f));
 
-            Graphics.CopyTexture(original, tinted);
+                    Graphics.Blit(original, temporary, material);
 
-            var data = tinted.GetRawTextureData<Color32>();
-            for (int index = 0, len = data.Length; index < len; index++)
-            {
-                data[index] = colorFilter(data[index]);
-            }
+                    newTexture = new Texture2D(original.width, original.width, TextureFormat.ARGB32, false, true)
+                    {
+                        name = name,
+                        filterMode = FilterMode.Bilinear
+                    };
 
-            int mipmapSize = tinted.width * tinted.height * 4;
-            int offset = 0;
-            for (int index = 0; index < tinted.mipmapCount; index++)
-            {
-                tinted.SetPixelData(data, index, offset);
-                mipmapSize >>= 2;
-                offset += mipmapSize;
+                    newTexture.ReadPixels(new Rect(0.0f, 0.0f, original.width, original.width), 0, 0);
+                    newTexture.alphaIsTransparency = true;
+                    newTexture.Apply();
+                }
             }
 
-            tinted.hideFlags = HideFlags.DontSave;
-            tinted.Apply();
-
-            return tinted;
+            return newTexture;
         }
 
         private static void InitIfNeeded()

Editor/TextureHelper.cs

@@ -0,0 +1,130 @@
+// This software includes third-party software subject to the associated copyrights, as follows:
+//
+// Name: SolidUtilities
+// Repo: https://github.com/SolidAlloy/SolidUtilities
+// License: MIT (https://github.com/SolidAlloy/SolidUtilities/blob/master/LICENSE)
+// Copyright (c) 2020 SolidAlloy
+
+namespace UnityHierarchyFolders.Editor
+{
+    using System;
+    using JetBrains.Annotations;
+    using UnityEngine;
+
+    /// <summary>Helps to create new textures.</summary>
+    public static class TextureHelper
+    {
+        /// <summary>
+        /// Temporarily sets <see cref="GL.sRGBWrite"/> to the passed value, then returns it back.
+        /// </summary>
+        [PublicAPI]
+        public readonly struct SRGBWriteScope : IDisposable
+        {
+            private readonly bool _previousValue;
+
+            /// <summary>Temporarily sets <see cref="GL.sRGBWrite"/> to <paramref name=""/>, then executes the action.</summary>
+            /// <param name="enableWrite"> Temporary value of <see cref="GL.sRGBWrite"/>. </param>
+            /// <example><code>
+            /// using (new SRGBWriteScope(true))
+            /// {
+            ///     GL.Clear(false, true, new Color(1f, 1f, 1f, 0f));
+            ///     Graphics.Blit(Default, temporary, material);
+            /// });
+            /// </code></example>
+            public SRGBWriteScope(bool enableWrite)
+            {
+                _previousValue = GL.sRGBWrite;
+                GL.sRGBWrite = enableWrite;
+            }
+
+            public void Dispose()
+            {
+                GL.sRGBWrite = _previousValue;
+            }
+        }
+
+        /// <summary>
+        /// Creates a temporary texture, sets it as active in <see cref="RenderTexture.active"/>, then removes the changes
+        /// and sets the previous active texture back automatically.
+        /// </summary>
+        /// <seealso cref="TemporaryRenderTexture"/>
+        /// <example><code>
+        /// using (var temporaryActiveTexture = new TemporaryActiveTexture(icon.width, icon.height, 0))
+        /// {
+        ///     Graphics.Blit(icon, temporary, material);
+        /// });
+        /// </code></example>
+        [PublicAPI]
+        public class TemporaryActiveTexture : IDisposable
+        {
+            private readonly RenderTexture _previousActiveTexture;
+            private readonly TemporaryRenderTexture _value;
+
+            /// <summary>
+            /// Creates a temporary texture, sets it as active in <see cref="RenderTexture.active"/>, then removes it
+            /// and sets the previous active texture back automatically.
+            /// </summary>
+            /// <param name="width">Width of the temporary texture in pixels.</param>
+            /// <param name="height">Height of the temporary texture in pixels.</param>
+            /// <param name="depthBuffer">Depth buffer of the temporary texture.</param>
+            /// <seealso cref="TemporaryRenderTexture"/>
+            /// <example><code>
+            /// using (var temporaryActiveTexture = new TemporaryActiveTexture(icon.width, icon.height, 0))
+            /// {
+            ///     Graphics.Blit(icon, temporary, material);
+            /// });
+            /// </code></example>
+            public TemporaryActiveTexture(int width, int height, int depthBuffer)
+            {
+                _previousActiveTexture = RenderTexture.active;
+                _value = new TemporaryRenderTexture(width, height, depthBuffer);
+                RenderTexture.active = _value;
+            }
+
+            public static implicit operator RenderTexture(TemporaryActiveTexture temporaryTexture) => temporaryTexture._value;
+
+            public void Dispose()
+            {
+                _value.Dispose();
+                RenderTexture.active = _previousActiveTexture;
+            }
+        }
+
+        /// <summary>Creates a temporary texture that can be used and then removed automatically.</summary>
+        /// <seealso cref="TemporaryActiveTexture"/>
+        /// <example><code>
+        /// using (var temporaryTexture = new TemporaryRenderTexture(icon.width, icon.height, 0))
+        /// {
+        ///     Graphics.Blit(icon, temporaryTexture, material);
+        /// });
+        /// </code></example>
+        [PublicAPI]
+        public class TemporaryRenderTexture : IDisposable
+        {
+            private readonly RenderTexture _value;
+
+            /// <summary>Creates a temporary texture that can be used and then removed automatically.</summary>
+            /// <param name="width">Width of the temporary texture in pixels.</param>
+            /// <param name="height">Height of the temporary texture in pixels.</param>
+            /// <param name="depthBuffer">Depth buffer of the temporary texture.</param>
+            /// <seealso cref="TemporaryActiveTexture"/>
+            /// <example><code>
+            /// using (var temporaryTexture = new TemporaryRenderTexture(icon.width, icon.height, 0))
+            /// {
+            ///     Graphics.Blit(icon, temporaryTexture, material);
+            /// });
+            /// </code></example>
+            public TemporaryRenderTexture(int width, int height, int depthBuffer)
+            {
+                _value = RenderTexture.GetTemporary(width, height, depthBuffer);
+            }
+
+            public static implicit operator RenderTexture(TemporaryRenderTexture temporaryRenderTexture) => temporaryRenderTexture._value;
+
+            public void Dispose()
+            {
+                RenderTexture.ReleaseTemporary(_value);
+            }
+        }
+    }
+}