327 lines
13 KiB
C#
327 lines
13 KiB
C#
#if UNITY_EDITOR
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using Unity.VisualScripting;
|
|
using UnityEditor;
|
|
using UnityEditor.AddressableAssets;
|
|
using UnityEditor.AddressableAssets.Settings;
|
|
using UnityEngine;
|
|
using Object = UnityEngine.Object;
|
|
|
|
namespace DDD
|
|
{
|
|
public static class AssetPostprocessorEnvironment
|
|
{
|
|
private const string ShaderName = "Universal Render Pipeline/LitEnvironment";
|
|
private const string BaseMapPropertyName = "_BaseMap";
|
|
private const string NormalMapPropertyName = "_NormalMap";
|
|
|
|
private static readonly Dictionary<EnvPrefabType, HashSet<string>> PrefabTargetPaths = new()
|
|
{
|
|
{EnvPrefabType.Prop, new HashSet<string>()},
|
|
{EnvPrefabType.Item, new HashSet<string>() },
|
|
{EnvPrefabType.Geometry, new HashSet<string>() },
|
|
{EnvPrefabType.Ground, new HashSet<string>() },
|
|
};
|
|
|
|
private static readonly Dictionary<EnvPrefabType, string> BasePrefabPaths = new()
|
|
{
|
|
{ EnvPrefabType.Prop, "Assets/_DDD/_Raw/Environments/Env_Mesh_Prop.prefab" },
|
|
{ EnvPrefabType.Item, "Assets/_DDD/_Raw/Environments/Env_Unlit_Item.prefab" },
|
|
{ EnvPrefabType.Geometry, "Assets/_DDD/_Raw/Environments/Env_Mesh_Geometry.prefab" },
|
|
{ EnvPrefabType.Ground, "Assets/_DDD/_Raw/Environments/Env_Mesh_Ground.prefab" },
|
|
};
|
|
|
|
public enum EnvPrefabType : uint
|
|
{
|
|
Prop,
|
|
Item,
|
|
Geometry,
|
|
Ground,
|
|
}
|
|
|
|
public static void OnPreprocessTexture(TextureImporter importer)
|
|
{
|
|
var path = importer.assetPath;
|
|
string fileNameUpper = Utils.FileName(path).ToUpper();
|
|
|
|
if (IsTextureMatchingPropertyBySuffix(fileNameUpper, NormalMapPropertyName))
|
|
{
|
|
importer.textureType = TextureImporterType.NormalMap;
|
|
}
|
|
else if (IsTextureMatchingPropertyBySuffix(fileNameUpper, BaseMapPropertyName))
|
|
{
|
|
importer.textureType = TextureImporterType.Sprite;
|
|
importer.spriteImportMode = SpriteImportMode.Single;
|
|
}
|
|
else
|
|
{
|
|
importer.textureType = TextureImporterType.Default;
|
|
importer.sRGBTexture = true;
|
|
}
|
|
|
|
importer.mipmapEnabled = true;
|
|
}
|
|
|
|
public static void OnAdd(string path)
|
|
{
|
|
AddTargetPath(path);
|
|
}
|
|
|
|
public static void OnRemove(string path, string movePath = "")
|
|
{
|
|
AddTargetPath(path);
|
|
|
|
}
|
|
|
|
private static string GetEnvironmentPath(EnvPrefabType prefabType)
|
|
{
|
|
string prefabPath = PathConstants.RawEnvironmentsPathUpper + prefabType.ToString();
|
|
prefabPath = prefabPath.ToUpper();
|
|
return prefabPath;
|
|
}
|
|
|
|
private static void AddTargetPath(string path)
|
|
{
|
|
string upperPath = path.ToUpper();
|
|
if (upperPath.Contains(ExtenstionConstants.PngExtensionUpper) == false)
|
|
{
|
|
// Not a texture.
|
|
return;
|
|
}
|
|
for (uint i = 0; i < PrefabTargetPaths.Count; i++)
|
|
{
|
|
var prefabType = (EnvPrefabType)i;
|
|
var targetPaths = PrefabTargetPaths[prefabType];
|
|
if (upperPath.Contains(GetEnvironmentPath(prefabType)))
|
|
{
|
|
targetPaths.Add(path);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static string GetPrefabPrefix(EnvPrefabType prefabType)
|
|
{
|
|
return prefabType.ToString() + "_";
|
|
}
|
|
|
|
private static string GetMaterialPrefix()
|
|
{
|
|
return "Mat_";
|
|
}
|
|
|
|
public static void BuildMaterialAndPrefab(string path, EnvPrefabType prefabType)
|
|
{
|
|
var di = new DirectoryInfo(path);
|
|
if (!di.Exists) return;
|
|
|
|
string folderName = di.Name;
|
|
string rawRoot = PathConstants.RawFolderPath; // "/_Raw"
|
|
string addrRoot = PathConstants.AddressablesFolderPath; // "/_Addressables"
|
|
|
|
string destDir = path.Replace(rawRoot, addrRoot);
|
|
string materialPath = $"{destDir}/{GetMaterialPrefix()}{folderName}{ExtenstionConstants.MaterialExtenstionLower}";
|
|
string prefabPath = $"{destDir}/{GetPrefabPrefix(prefabType)}{folderName}{ExtenstionConstants.PrefabExtenstionLower}";
|
|
|
|
Utils.MakeFolderFromFilePath(materialPath);
|
|
|
|
bool bShouldCreateMaterial = false;
|
|
bShouldCreateMaterial = prefabType != EnvPrefabType.Item; // Add conditions if needed.
|
|
if (bShouldCreateMaterial)
|
|
{
|
|
// 머티리얼 생성 또는 로드
|
|
var mat = CreateOrLoadMaterial(path, materialPath, out var files, out var shader);
|
|
MatchTexturesToShaderProperties(shader, files, mat);
|
|
AssetDatabase.ImportAsset(materialPath, ImportAssetOptions.ForceUpdate);
|
|
AssetDatabase.SaveAssets();
|
|
CreateMaterialPrefabVariantIfNotExist(folderName, mat, prefabPath, prefabType);
|
|
}
|
|
else // Set sprite to renderer
|
|
{
|
|
var files = Directory.GetFiles(path, $"*{ExtenstionConstants.PngExtensionLower}",
|
|
SearchOption.TopDirectoryOnly);
|
|
foreach (var file in files)
|
|
{
|
|
string texName = Path.GetFileNameWithoutExtension(file).ToUpper();
|
|
Sprite tex = AssetDatabase.LoadAssetAtPath<Sprite>(file);
|
|
if (tex == null) continue;
|
|
// 셰이더 프로퍼티명과 텍스처 파일명의 접미사 매칭
|
|
if (IsTextureMatchingPropertyBySuffix(texName, BaseMapPropertyName))
|
|
{
|
|
CreateSpritePrefabVariantIfNotExist(folderName, tex, prefabPath, prefabType);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static Material CreateOrLoadMaterial(string path, string materialPath, out string[] files, out Shader shader)
|
|
{
|
|
Material mat = AssetDatabase.LoadAssetAtPath<Material>(materialPath);
|
|
if (mat == null)
|
|
{
|
|
mat = new Material(Shader.Find(ShaderName));
|
|
AssetDatabase.CreateAsset(mat, materialPath);
|
|
}
|
|
|
|
// PNG 텍스처 매핑 - 셰이더 프로퍼티와 텍스처 접미사 매칭
|
|
files = Directory.GetFiles(path, $"*{ExtenstionConstants.PngExtensionLower}", SearchOption.TopDirectoryOnly);
|
|
shader = mat.shader;
|
|
return mat;
|
|
}
|
|
|
|
private static void MatchTexturesToShaderProperties(Shader shader, string[] files, Material mat)
|
|
{
|
|
for (int i = 0; i < ShaderUtil.GetPropertyCount(shader); i++)
|
|
{
|
|
if (ShaderUtil.GetPropertyType(shader, i) != ShaderUtil.ShaderPropertyType.TexEnv)
|
|
continue;
|
|
|
|
string propertyName = ShaderUtil.GetPropertyName(shader, i);
|
|
|
|
foreach (var file in files)
|
|
{
|
|
string texName = Path.GetFileNameWithoutExtension(file).ToUpper();
|
|
var tex = AssetDatabase.LoadAssetAtPath<Texture>(file);
|
|
if (tex == null) continue;
|
|
|
|
// 셰이더 프로퍼티명과 텍스처 파일명의 접미사 매칭
|
|
if (IsTextureMatchingPropertyBySuffix(texName, propertyName))
|
|
{
|
|
mat.SetTexture(propertyName, tex);
|
|
break; // 매칭되면 다음 프로퍼티로
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static string[] GetPropertyAliases(string propertyName)
|
|
{
|
|
if (propertyName == "_BaseMap")
|
|
{
|
|
return new[] {"_Base", "_BC", "BaseColor"};
|
|
}
|
|
if (propertyName == "_NormalMap")
|
|
{
|
|
return new[] {"_Normal", "_Bump", "_BumpMap", "_N"};
|
|
}
|
|
if (propertyName == "_MOHS")
|
|
{
|
|
return new[] {"_Mask"};
|
|
}
|
|
if (propertyName == "_Emiss")
|
|
{
|
|
return new[] {"_Emissive", "_Emission", "_E"};
|
|
}
|
|
return Array.Empty<string>();
|
|
}
|
|
private static bool IsTextureMatchingPropertyBySuffix(string textureName, string propertyName)
|
|
{
|
|
string[] aliases = GetPropertyAliases(propertyName);
|
|
foreach (var alias in aliases)
|
|
{
|
|
if (textureName.ToUpper().EndsWith(alias.ToUpper()))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// 셰이더 프로퍼티명에서 접미사 추출 (예: _BaseMap -> BASEMAP)
|
|
string propertySuffix = propertyName.TrimStart('_').ToUpper();
|
|
// 텍스처 파일명이 해당 접미사로 끝나는지 확인
|
|
return textureName.EndsWith($"_{propertySuffix}");
|
|
}
|
|
|
|
private static void CreateMaterialPrefabVariantIfNotExist(string folderName, Material mat, string prefabPath, EnvPrefabType prefabType)
|
|
{
|
|
if (AssetDatabase.LoadAssetAtPath<GameObject>(prefabPath) != null) return;
|
|
|
|
if (InstantiatePrefabByType(folderName, prefabPath, prefabType, out var instancePrefab)) return;
|
|
|
|
if (mat != null)
|
|
{
|
|
var renderer = instancePrefab.GetComponentInChildren<Renderer>();
|
|
if (renderer != null) renderer.sharedMaterial = mat;
|
|
}
|
|
|
|
SavePrefabInstance(prefabPath, instancePrefab);
|
|
}
|
|
|
|
private static void CreateSpritePrefabVariantIfNotExist(string folderName, Sprite sprite, string prefabPath,
|
|
EnvPrefabType prefabType)
|
|
{
|
|
if (AssetDatabase.LoadAssetAtPath<GameObject>(prefabPath) != null) return;
|
|
|
|
if (InstantiatePrefabByType(folderName, prefabPath, prefabType, out var instancePrefab)) return;
|
|
|
|
if (sprite != null)
|
|
{
|
|
var renderer = instancePrefab.GetComponentInChildren<SpriteRenderer>();
|
|
if (renderer != null) renderer.sprite = sprite;
|
|
}
|
|
|
|
SavePrefabInstance(prefabPath, instancePrefab);
|
|
}
|
|
|
|
private static void SavePrefabInstance(string prefabPath, GameObject instancePrefab)
|
|
{
|
|
Utils.MakeFolderFromFilePath(prefabPath);
|
|
PrefabUtility.SaveAsPrefabAssetAndConnect(instancePrefab, prefabPath, InteractionMode.AutomatedAction);
|
|
Object.DestroyImmediate(instancePrefab);
|
|
|
|
AssetDatabase.ImportAsset(prefabPath, ImportAssetOptions.ForceUpdate);
|
|
AssetDatabase.SaveAssets();
|
|
AssetDatabase.Refresh();
|
|
}
|
|
|
|
private static bool InstantiatePrefabByType(string folderName, string prefabPath, EnvPrefabType prefabType,
|
|
out GameObject instancePrefab)
|
|
{
|
|
// EnvPrefabType에 따라 베이스 프리팹 결정
|
|
string basePrefabPath = GetBasePrefabPath(prefabType);
|
|
|
|
var basePrefab = AssetDatabase.LoadAssetAtPath<GameObject>(basePrefabPath);
|
|
if (basePrefab == null)
|
|
{
|
|
Debug.LogWarning($"Base prefab not found: {basePrefabPath}");
|
|
instancePrefab = null;
|
|
return true;
|
|
}
|
|
|
|
string prefix = prefabType.ToString() + "_";
|
|
instancePrefab = AssetDatabase.LoadAssetAtPath<GameObject>(prefabPath);
|
|
if (instancePrefab == null)
|
|
{
|
|
instancePrefab = (GameObject)PrefabUtility.InstantiatePrefab(basePrefab);
|
|
instancePrefab.name = $"{prefix}{folderName}";
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static string GetBasePrefabPath(EnvPrefabType prefabType)
|
|
{
|
|
if (BasePrefabPaths.TryGetValue(prefabType, out var path))
|
|
{
|
|
return path;
|
|
}
|
|
Debug.LogError($"Base prefab path not found: {prefabType}");
|
|
return "";
|
|
}
|
|
|
|
public static void BuildTarget()
|
|
{
|
|
foreach (var envTargets in PrefabTargetPaths)
|
|
{
|
|
var envType = envTargets.Key;
|
|
var TargetPaths= envTargets.Value;
|
|
foreach (var path in TargetPaths)
|
|
{
|
|
BuildMaterialAndPrefab(Utils.FolderPath(path), envType);
|
|
}
|
|
TargetPaths.Clear();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif |