HauntedBloodlines/Assets/Editor/HDRPMaterialReplacer.cs

using UnityEngine;
using UnityEditor;
using System.Collections.Generic;

public class HDRPMaterialReplacer : EditorWindow
{
    private string materialsFolderPath = "Assets/HDRP_Materials/";
    private Dictionary<string, Material> hdrpMaterials = new Dictionary<string, Material>();

    [MenuItem("Tools/HDRP Material Replacer")]
    public static void ShowWindow()
    {
        GetWindow<HDRPMaterialReplacer>("HDRP Material Replacer");
    }

    private void OnGUI()
    {
        GUILayout.Label("HDRP Material Replacer", EditorStyles.boldLabel);
        materialsFolderPath = EditorGUILayout.TextField("HDRP Material Folder", materialsFolderPath);

        if (GUILayout.Button("Load HDRP Materials"))
        {
            LoadMaterialsFromFolder();
        }

        if (GUILayout.Button("Replace in Selected Objects and Children"))
        {
            ReplaceInSelectedObjects();
        }
    }

    void LoadMaterialsFromFolder()
    {
        hdrpMaterials.Clear();
        string[] materialGuids = AssetDatabase.FindAssets("t:Material", new[] { materialsFolderPath });

        foreach (string guid in materialGuids)
        {
            string path = AssetDatabase.GUIDToAssetPath(guid);
            Material mat = AssetDatabase.LoadAssetAtPath<Material>(path);
            if (mat != null && !hdrpMaterials.ContainsKey(mat.name))
            {
                hdrpMaterials[mat.name] = mat;
            }
        }

        Debug.Log("[HDRP Replacer] Loaded " + hdrpMaterials.Count + " HDRP materials from: " + materialsFolderPath);
    }

    void ReplaceInSelectedObjects()
    {
        int replacedCount = 0;

        foreach (GameObject rootObj in Selection.gameObjects)
        {
            Renderer[] renderers = rootObj.GetComponentsInChildren<Renderer>(true);

            foreach (Renderer renderer in renderers)
            {
                Material[] originalMats = renderer.sharedMaterials;
                bool changed = false;

                for (int i = 0; i < originalMats.Length; i++)
                {
                    Material original = originalMats[i];
                    Material matchedHDRP = null;

                    if (original == null)
                    {
                        matchedHDRP = FindMatchingHDRPMaterial(null, renderer.gameObject.name);
                    }
                    else
                    {
                        matchedHDRP = FindMatchingHDRPMaterial(original.name, renderer.gameObject.name);
                    }

                    if (matchedHDRP != null)
                    {
                        originalMats[i] = matchedHDRP;
                        changed = true;
                        replacedCount++;
                        Debug.Log("[HDRP] Replaced on '" + renderer.gameObject.name + "' -> '" + matchedHDRP.name + "'");
                    }
                    else
                    {
                        Debug.LogWarning("[HDRP] No match found for: '" + (original != null ? original.name : "null") + "' on '" + renderer.gameObject.name + "'");
                    }
                }

                if (originalMats.Length == 0)
                {
                    Material fallback = FindMatchingHDRPMaterial(null, renderer.gameObject.name);
                    if (fallback != null)
                    {
                        renderer.sharedMaterial = fallback;
                        changed = true;
                        replacedCount++;
                        Debug.Log("[HDRP] Assigned fallback to empty renderer '" + renderer.gameObject.name + "' -> '" + fallback.name + "'");
                    }
                }

                if (changed)
                {
                    renderer.sharedMaterials = originalMats;
                }
            }
        }

        Debug.Log("[HDRP Replacer] Done. Total materials replaced or assigned: " + replacedCount);
    }

    private Material FindMatchingHDRPMaterial(string originalName, string fallbackName = null)
    {
        // Step 1: Try originalName + "_HDRP"
        if (!string.IsNullOrEmpty(originalName))
        {
            string withSuffix = originalName + "_HDRP";
            if (hdrpMaterials.TryGetValue(withSuffix, out Material suffixMatch))
                return suffixMatch;

            // Step 2: Exact match on original name (non-HDRP)
            if (hdrpMaterials.TryGetValue(originalName, out Material exactMatch))
                return exactMatch;
        }

        // Step 3: Try based on GameObject name (auto-match)
        if (!string.IsNullOrEmpty(fallbackName))
        {
            string simplified = fallbackName.Replace("SM_", "").Replace("M_", "").ToLower();

            // First prefer any _HDRP match
            foreach (var kvp in hdrpMaterials)
            {
                string matName = kvp.Key.ToLower();
                if (matName.Contains(simplified) && matName.Contains("_hdrp"))
                    return kvp.Value;
            }

            // Then try ANY match (non-HDRP also accepted)
            foreach (var kvp in hdrpMaterials)
            {
                if (kvp.Key.ToLower().Contains(simplified))
                    return kvp.Value;
            }
        }

        // Step 4: Fuzzy match from originalName (try HDRP first)
        if (!string.IsNullOrEmpty(originalName))
        {
            foreach (var kvp in hdrpMaterials)
            {
                if (kvp.Key.Contains(originalName) && kvp.Key.Contains("_HDRP"))
                    return kvp.Value;
            }

            foreach (var kvp in hdrpMaterials)
            {
                if (kvp.Key.Contains(originalName))
                    return kvp.Value;
            }
        }

        return null;
    }

}