com.jaimecamachodev.unityfolders 1.5.3

package/Editor/FolderIconRecolorUtility.cs

@@ -0,0 +1,71 @@
+using UnityEngine;
+using UnityEditor;
+using System.IO;
+
+public static class FolderIconRecolorUtility
+{
+    public static Texture2D Recolor(Texture2D baseTex, Color tint, Texture2D overlay = null)
+    {
+        if (baseTex == null || !baseTex.isReadable)
+        {
+            Debug.LogWarning($"Texture '{baseTex?.name}' is not readable.");
+            return baseTex;
+        }
+
+        Texture2D newTex = new Texture2D(baseTex.width, baseTex.height);
+        Color[] basePixels = baseTex.GetPixels();
+
+        for (int i = 0; i < basePixels.Length; i++)
+        {
+            Color c = basePixels[i];
+            basePixels[i] = new Color(c.r * tint.r, c.g * tint.g, c.b * tint.b, c.a);
+        }
+        newTex.SetPixels(basePixels);
+
+        if (overlay != null && overlay.isReadable)
+        {
+            int size = baseTex.width / 2;
+            int startX = (baseTex.width - size) / 2;
+            int startY = (baseTex.height - size) / 2;
+
+            for (int y = 0; y < size; y++)
+            {
+                for (int x = 0; x < size; x++)
+                {
+                    int destX = startX + x;
+                    int destY = startY + y;
+                    Color overlayPixel = overlay.GetPixelBilinear(x / (float)size, y / (float)size);
+                    Color basePixel = newTex.GetPixel(destX, destY);
+                    newTex.SetPixel(destX, destY, Color.Lerp(basePixel, overlayPixel, overlayPixel.a));
+                }
+            }
+        }
+
+        newTex.Apply();
+        return newTex;
+    }
+
+    public static Texture2D RecolorAndSave(Texture2D baseTex, Color tint, string name, Texture2D overlay = null)
+    {
+        var newTex = Recolor(baseTex, tint, overlay);
+        if (newTex == null) return baseTex;
+
+        byte[] pngData = newTex.EncodeToPNG();
+        string path = $"Packages/com.jaimecamacho.unityfolders/Folders/{name}_tint.png";
+
+        Directory.CreateDirectory(Path.GetDirectoryName(path));
+        File.WriteAllBytes(path, pngData);
+
+        AssetDatabase.ImportAsset(path);
+        var importer = (TextureImporter)AssetImporter.GetAtPath(path);
+        if (importer != null)
+        {
+            importer.textureType = TextureImporterType.GUI;
+            importer.maxTextureSize = 256;
+            importer.isReadable = true;
+            importer.SaveAndReimport();
+        }
+
+        return AssetDatabase.LoadAssetAtPath<Texture2D>(path);
+    }
+}

package/Editor/FolderIconRecolorUtility.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 779463401747b0c438640d20c2f4e597

package/Editor/FolderIconsManager.cs

@@ -0,0 +1,168 @@
+using UnityEditor;
+using UnityEngine;
+using System.IO;
+using System.Linq;
+using System;
+using System.Reflection;
+
+[InitializeOnLoad]
+public static class FolderIconsManager
+{
+    static FolderIconsSettings settings;
+    static System.Collections.Generic.List<FolderIconRule> sortedRules;
+    static Texture2D gradientTex;
+    static Type projectBrowserType;
+    static FieldInfo lastInteractedProjectBrowserField;
+    static FieldInfo viewModeField;
+
+    static FolderIconsManager()
+    {
+        EditorApplication.projectWindowItemOnGUI += DrawCustomIcons;
+        LoadSettings();
+        CreateGradient();
+        InitReflection();
+    }
+
+    static void InitReflection()
+    {
+        projectBrowserType = typeof(Editor).Assembly.GetType("UnityEditor.ProjectBrowser");
+        lastInteractedProjectBrowserField = projectBrowserType?.GetField("s_LastInteractedProjectBrowser", BindingFlags.Static | BindingFlags.NonPublic);
+        viewModeField = projectBrowserType?.GetField("m_ViewMode", BindingFlags.Instance | BindingFlags.NonPublic);
+    }
+
+    internal static void LoadSettings()
+    {
+        var guid = AssetDatabase.FindAssets("t:FolderIconsSettings").FirstOrDefault();
+        if (!string.IsNullOrEmpty(guid))
+        {
+            string path = AssetDatabase.GUIDToAssetPath(guid);
+            settings = AssetDatabase.LoadAssetAtPath<FolderIconsSettings>(path);
+        }
+        UpdateSortedRules();
+    }
+
+    static void UpdateSortedRules()
+    {
+        sortedRules = settings == null
+            ? new System.Collections.Generic.List<FolderIconRule>()
+            : settings.rules.Where(r => r.enabled).OrderByDescending(r => r.priority).ToList();
+    }
+
+    static void CreateGradient()
+    {
+        gradientTex = new Texture2D(128, 1, TextureFormat.ARGB32, false);
+        gradientTex.wrapMode = TextureWrapMode.Clamp;
+        for (int x = 0; x < 128; x++)
+        {
+            float t = x / 127f;
+            Color c = new Color(1, 1, 1, Mathf.Lerp(0.25f, 0f, t));
+            gradientTex.SetPixel(x, 0, c);
+        }
+        gradientTex.Apply();
+    }
+
+    static bool IsInLeftColumn(Rect selectionRect)
+    {
+        if (projectBrowserType == null || lastInteractedProjectBrowserField == null || viewModeField == null)
+            return false;
+
+        var browser = lastInteractedProjectBrowserField.GetValue(null);
+        if (browser == null) return false;
+
+        int viewMode = (int)viewModeField.GetValue(browser);
+        return viewMode == 1 && selectionRect.xMax < 200f && selectionRect.height <= EditorGUIUtility.singleLineHeight + 4;
+    }
+
+    static void DrawCustomIcons(string guid, Rect selectionRect)
+    {
+        if (settings == null || sortedRules == null) return;
+
+        string path = AssetDatabase.GUIDToAssetPath(guid);
+        if (!AssetDatabase.IsValidFolder(path)) return;
+
+        string folderName = Path.GetFileName(path);
+
+        foreach (var rule in sortedRules)
+        {
+            if (!Match(rule, path, folderName)) continue;
+
+            bool isGrid = selectionRect.height > 25f && selectionRect.width > 25f;
+            bool isInLeftColumn = !isGrid && IsInLeftColumn(selectionRect);
+            Texture2D icon = isGrid ? rule.iconLarge : rule.iconSmall;
+
+            // Gradiente
+            if (rule.background.a > 0.01f)
+            {
+                Rect labelRect;
+                if (isGrid)
+                {
+                    float textHeight = EditorGUIUtility.singleLineHeight;
+                    float labelY = selectionRect.yMax - textHeight + 2f;
+                    labelRect = new Rect(selectionRect.x, labelY, selectionRect.width, textHeight);
+                }
+                else
+                {
+                    float xStart = selectionRect.x + selectionRect.height;
+                    float width = selectionRect.width - (xStart - selectionRect.x);
+                    width = Mathf.Max(48f, width);
+                    labelRect = new Rect(xStart, selectionRect.y, width, selectionRect.height);
+                }
+
+                GUI.color = rule.background;
+                if (gradientTex != null)
+                GUI.DrawTexture(labelRect, gradientTex, ScaleMode.StretchToFill);
+                GUI.color = Color.white;
+            }
+
+            // Dibujo del icono base
+            if (icon != null)
+            {
+                Rect iconRect;
+                if (isGrid)
+                {
+                    float size = selectionRect.height - EditorGUIUtility.singleLineHeight;
+                    float iconX = selectionRect.x + (selectionRect.width - size) * 0.5f;
+                    iconRect = new Rect(iconX - 3, selectionRect.y - 1, size + 6, size + 6);
+                }
+                else if (isInLeftColumn)
+                {
+                    iconRect = new Rect(selectionRect.x, selectionRect.y, selectionRect.height, selectionRect.height);
+                }
+                else
+                {
+                    iconRect = new Rect(selectionRect.x + 1, selectionRect.y - 1, selectionRect.height, selectionRect.height);
+                }
+
+                Color prevColor = GUI.color;
+                GUI.color = new Color(0.2196f, 0.2196f, 0.2196f, 0f);
+                GUI.DrawTexture(iconRect, Texture2D.whiteTexture);
+                GUI.color = prevColor;
+
+                GUI.DrawTexture(iconRect, icon, ScaleMode.ScaleToFit, true);
+
+                // 🟡 Dibujo del overlay centrado solo en iconos grandes
+                if (rule.overlayIcon != null && isGrid)
+                {
+                    float overlaySize = iconRect.width * 0.5f;
+                    float overlayX = iconRect.x + (iconRect.width - overlaySize) * 0.5f;
+                    float overlayY = iconRect.y + (iconRect.height - overlaySize) * 0.5f;
+                    Rect overlayRect = new Rect(overlayX, overlayY, overlaySize, overlaySize);
+                    GUI.DrawTexture(overlayRect, rule.overlayIcon, ScaleMode.ScaleToFit, true);
+                }
+            }
+
+            break;
+        }
+    }
+
+    static bool Match(FolderIconRule rule, string path, string name)
+    {
+        return rule.matchType switch
+        {
+            MatchType.Name => name.Equals(rule.match, StringComparison.OrdinalIgnoreCase),
+            MatchType.Path => path.Replace("\\", " / ").Contains(rule.match),
+            MatchType.Regex => System.Text.RegularExpressions.Regex.IsMatch(path, rule.match),
+            _ => false,
+        };
+    }
+}

package/Editor/FolderIconsManager.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: d143cd173c600f24cacff95ee0e34cc2

package/Editor/FolderIconsPostprocessor.cs

@@ -0,0 +1,14 @@
+using System.Linq;
+using UnityEditor;
+
+class FolderIconsPostprocessor : AssetPostprocessor
+{
+    static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
+    {
+        if (importedAssets.Concat(deletedAssets).Concat(movedAssets).Concat(movedFromAssetPaths)
+            .Any(p => p.EndsWith("FolderIconsSettings.asset")))
+        {
+            FolderIconsManager.LoadSettings();
+        }
+    }
+}

package/Editor/FolderIconsPostprocessor.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 069fbe5ddd8e5a84899db3d796feabf1

package/Editor/FolderIconsSettings.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class FolderIconsSettings : ScriptableObject
+{
+    public List<FolderIconRule> rules = new();
+
+#if UNITY_EDITOR
+    public bool showPreview = true;  // A�adido para la vista previa
+    private void OnValidate()
+    {
+        FolderIconsManager.LoadSettings();
+    }
+#endif
+}
+
+[Serializable]
+public class FolderIconRule
+{
+    public string ruleName = "Nueva regla";
+    public MatchType matchType = MatchType.Name;
+    public string match = "";
+    public Texture2D iconSmall;
+    public Texture2D iconLarge;
+    public Texture2D overlayIcon;
+    [HideInInspector] public Texture2D previewSmall;
+    [HideInInspector] public Texture2D previewLarge;
+    public Color background = new(1f, 1f, 1f, 0.25f);
+    public bool enabled = true;
+    public bool eraseDefault = true;
+    public int priority = 0;
+}
+
+public enum MatchType
+{
+    Name,
+    Path,
+    Regex
+}

package/Editor/FolderIconsSettings.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 2d7e1e9c1cb5623408935e6e25e3256a

package/Editor/FolderIconsSettingsEditor.cs

@@ -0,0 +1,147 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditorInternal;
+using UnityEngine;
+//using JaimeCamachoDev.UnityFolders;
+
+[CustomEditor(typeof(FolderIconsSettings))]
+public class FolderIconsSettingsEditor : Editor
+{
+    private ReorderableList list;
+    private readonly Dictionary<Color, Texture2D> gradientCache = new();
+
+    private Texture2D GetGradient(Color baseColor)
+    {
+        if (gradientCache.TryGetValue(baseColor, out var cached))
+            return cached;
+
+        var top = baseColor;
+        var bottom = Color.Lerp(baseColor, Color.black, 0.25f);
+
+        Texture2D tex = new Texture2D(1, 2) { wrapMode = TextureWrapMode.Clamp };
+        tex.SetPixels(new[] { top, bottom });
+        tex.Apply();
+
+        gradientCache[baseColor] = tex;
+        return tex;
+    }
+
+    private void OnEnable()
+    {
+        list = new ReorderableList(serializedObject,
+                                    serializedObject.FindProperty("rules"),
+                                    draggable: true, displayHeader: true,
+                                    displayAddButton: true, displayRemoveButton: true);
+
+        list.drawHeaderCallback = rect =>
+        {
+            EditorGUI.LabelField(rect, "Folder Icon Rules");
+        };
+
+        list.elementHeightCallback = index =>
+        {
+
+            float h = EditorGUIUtility.singleLineHeight + 4;
+            float preview = h * 2.5f;
+            return h * 7 + preview + 4; // fields + button + margin
+
+        };
+
+        list.drawElementCallback = (rect, index, isActive, isFocused) =>
+        {
+            var element = list.serializedProperty.GetArrayElementAtIndex(index);
+            float lineHeight = EditorGUIUtility.singleLineHeight + 4;
+            float y = rect.y;
+
+            var backgroundProp = element.FindPropertyRelative("background");
+            var iconSmallProp = element.FindPropertyRelative("iconSmall");
+            var iconLargeProp = element.FindPropertyRelative("iconLarge");
+            var overlayProp = element.FindPropertyRelative("overlayIcon");
+            var previewSmallProp = element.FindPropertyRelative("previewSmall");
+            var previewLargeProp = element.FindPropertyRelative("previewLarge");
+
+            bool updatePreview = false;
+
+            EditorGUI.PropertyField(new Rect(rect.x, y, rect.width, lineHeight), element.FindPropertyRelative("match"), new GUIContent("Match Path"));
+            y += lineHeight;
+            EditorGUI.PropertyField(new Rect(rect.x, y, rect.width, lineHeight), element.FindPropertyRelative("matchType"), new GUIContent("Match Type"));
+            y += lineHeight;
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.PropertyField(new Rect(rect.x, y, rect.width, lineHeight), backgroundProp, new GUIContent("Tint Color"));
+            if (EditorGUI.EndChangeCheck()) updatePreview = true;
+            y += lineHeight;
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.PropertyField(new Rect(rect.x, y, rect.width, lineHeight), iconSmallProp, new GUIContent("Icon Small"));
+            if (EditorGUI.EndChangeCheck()) updatePreview = true;
+            y += lineHeight;
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.PropertyField(new Rect(rect.x, y, rect.width, lineHeight), iconLargeProp, new GUIContent("Icon Large"));
+            if (EditorGUI.EndChangeCheck()) updatePreview = true;
+            y += lineHeight;
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.PropertyField(new Rect(rect.x, y, rect.width, lineHeight), overlayProp, new GUIContent("Overlay Icon"));
+            if (EditorGUI.EndChangeCheck()) updatePreview = true;
+            y += lineHeight;
+
+            if (updatePreview)
+            {
+                Texture2D small = iconSmallProp.objectReferenceValue as Texture2D;
+                Texture2D large = iconLargeProp.objectReferenceValue as Texture2D;
+                Texture2D overlay = overlayProp.objectReferenceValue as Texture2D;
+                Color bg = backgroundProp.colorValue;
+
+                previewSmallProp.objectReferenceValue = small != null ? FolderIconRecolorUtility.Recolor(small, bg) : null;
+                previewLargeProp.objectReferenceValue = large != null ? FolderIconRecolorUtility.Recolor(large, bg, overlay) : null;
+            }
+
+            var settings = (FolderIconsSettings)target;
+            if (settings.showPreview)
+            {
+                float previewSize = 32f; // Tama�o fijo a 32px
+                Rect smallRect = new Rect(rect.x, y, previewSize, previewSize);
+                Rect largeRect = new Rect(rect.x + previewSize + 4, y, previewSize, previewSize);
+
+                Texture2D smallTex = previewSmallProp.objectReferenceValue as Texture2D;
+                Texture2D largeTex = previewLargeProp.objectReferenceValue as Texture2D;
+
+                if (smallTex != null)
+                {
+                    if (backgroundProp.colorValue.a > 0.01f)
+                        GUI.DrawTexture(smallRect, GetGradient(backgroundProp.colorValue), ScaleMode.StretchToFill);
+                    GUI.DrawTexture(smallRect, smallTex, ScaleMode.ScaleToFit, true);
+                }
+
+                if (largeTex != null)
+                {
+                    if (backgroundProp.colorValue.a > 0.01f)
+                        GUI.DrawTexture(largeRect, GetGradient(backgroundProp.colorValue), ScaleMode.StretchToFill);
+                    GUI.DrawTexture(largeRect, largeTex, ScaleMode.ScaleToFit, true);
+                }
+
+                y += previewSize + 14;
+            }
+
+            if (GUI.Button(new Rect(rect.x, y, rect.width, lineHeight), "Apply Color & Generate Icons"))
+            {
+                if (iconSmallProp.objectReferenceValue != null)
+                    iconSmallProp.objectReferenceValue = FolderIconRecolorUtility.RecolorAndSave((Texture2D)iconSmallProp.objectReferenceValue, backgroundProp.colorValue, element.FindPropertyRelative("match").stringValue + "_Small");
+                if (iconLargeProp.objectReferenceValue != null)
+                    iconLargeProp.objectReferenceValue = FolderIconRecolorUtility.RecolorAndSave((Texture2D)iconLargeProp.objectReferenceValue, backgroundProp.colorValue, element.FindPropertyRelative("match").stringValue + "_Large", overlayProp.objectReferenceValue as Texture2D);
+
+                previewSmallProp.objectReferenceValue = iconSmallProp.objectReferenceValue as Texture2D;
+                previewLargeProp.objectReferenceValue = iconLargeProp.objectReferenceValue as Texture2D;
+            }
+
+            // Keep height in sync with elementHeightCallback
+            y += lineHeight + 4;
+        };
+    }
+
+    public override void OnInspectorGUI()
+    {
+        serializedObject.Update();
+        EditorGUILayout.PropertyField(serializedObject.FindProperty("showPreview"));
+        list.DoLayoutList();
+        serializedObject.ApplyModifiedProperties();
+    }
+}

package/Editor/FolderIconsSettingsEditor.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8961af3846ed80f4ab5089486027f8fd

package/Editor/FolderIconsSettingsMenu.cs

@@ -0,0 +1,35 @@
+using UnityEditor;
+using UnityEngine;
+using System.IO;
+
+public static class FolderIconsSettingsMenu
+{
+    [MenuItem("Tools/JaimeCamachoDev/UnityFolders/Crear configuraci�n")]
+    [MenuItem("Assets/JaimeCamachoDev/UnityFolders/Crear configuraci�n")]
+    public static void CreateAsset()
+    {
+        var asset = ScriptableObject.CreateInstance<FolderIconsSettings>();
+        string path = GetSelectedPathOrFallback();
+        string assetPath = AssetDatabase.GenerateUniqueAssetPath(Path.Combine(path, "FolderIconsSettings.asset"));
+
+        AssetDatabase.CreateAsset(asset, assetPath);
+        AssetDatabase.SaveAssets();
+        AssetDatabase.Refresh();
+
+        EditorUtility.FocusProjectWindow();
+        Selection.activeObject = asset;
+    }
+
+    private static string GetSelectedPathOrFallback()
+    {
+        string path = "Assets";
+        foreach (Object obj in Selection.GetFiltered(typeof(Object), SelectionMode.Assets))
+        {
+            string selected = AssetDatabase.GetAssetPath(obj);
+            if (File.Exists(selected)) path = Path.GetDirectoryName(selected);
+            else if (Directory.Exists(selected)) path = selected;
+            break;
+        }
+        return path;
+    }
+}

package/Editor/FolderIconsSettingsMenu.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 11249005e70aefb47b0470b92549e459

package/Editor/UnityAssetsRenamer.cs

@@ -0,0 +1,70 @@
+using UnityEditor;
+using UnityEngine;
+using System.IO;
+
+public static class UnityAssetsRenamer
+{
+    [MenuItem("Tools/JaimeCamachoDev/UnityFolders/Renombrar Assets", false, 21)]
+    [MenuItem("Assets/JaimeCamachoDev/UnityFolders/Renombrar Assets", false, 21)]
+    private static void RenameAssetsMenu()
+    {
+        string folderPath = GetSelectedPathOrFallback();
+
+        if (!AssetDatabase.IsValidFolder(folderPath))
+        {
+            Debug.LogWarning("Por favor selecciona una carpeta válida para renombrar sus assets.");
+            return;
+        }
+
+        RenameAssetsInFolder(folderPath);
+    }
+
+    internal static void RenameAssetsInFolder(string folderPath)
+    {
+        string rootName = Path.GetFileName(folderPath);
+        string[] guids = AssetDatabase.FindAssets(string.Empty, new[] { folderPath });
+
+        foreach (string guid in guids)
+        {
+            string assetPath = AssetDatabase.GUIDToAssetPath(guid);
+            if (AssetDatabase.IsValidFolder(assetPath))
+                continue;
+
+            string directory = Path.GetDirectoryName(assetPath);
+            string extension = Path.GetExtension(assetPath);
+            string nameNoExt = Path.GetFileNameWithoutExtension(assetPath);
+
+            if (nameNoExt == rootName || nameNoExt.StartsWith(rootName + "_"))
+                continue;
+
+            int underscoreIndex = nameNoExt.IndexOf('_');
+            string suffix = underscoreIndex >= 0 ? nameNoExt.Substring(underscoreIndex + 1) : nameNoExt;
+
+            string newName = rootName + "_" + suffix;
+            string newPath = Path.Combine(directory, newName + extension);
+            newPath = AssetDatabase.GenerateUniqueAssetPath(newPath);
+            AssetDatabase.MoveAsset(assetPath, newPath);
+        }
+
+        AssetDatabase.SaveAssets();
+        AssetDatabase.Refresh();
+        Debug.Log($"Assets en la carpeta {folderPath} han sido renombrados.");
+    }
+
+    private static string GetSelectedPathOrFallback()
+    {
+        string path = "Assets";
+
+        foreach (Object obj in Selection.GetFiltered(typeof(Object), SelectionMode.Assets))
+        {
+            path = AssetDatabase.GetAssetPath(obj);
+            if (!string.IsNullOrEmpty(path) && File.Exists(path))
+            {
+                path = Path.GetDirectoryName(path);
+                break;
+            }
+        }
+        return path;
+    }
+}
+

package/Editor/UnityAssetsRenamer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bbb270554a4e4dd0ada2800282ea34ee
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: