556 lines
22 KiB
C#
556 lines
22 KiB
C#
using System.IO;
|
|
using System.Linq;
|
|
using System.Collections.Generic;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
using UnityEngine.Rendering;
|
|
using UnityEngine.Rendering.Universal;
|
|
|
|
namespace PotaToon.Editor
|
|
{
|
|
public class PotaToonEditorUtility : EditorWindow
|
|
{
|
|
private static readonly string k_PotaToonFeatureName = "PotaToonFeature";
|
|
|
|
internal static void PotaToonLog(object msg, bool isError = false)
|
|
{
|
|
if (isError)
|
|
{
|
|
Debug.LogError("<color=red>[PotaToon] " + msg + "</color>");
|
|
}
|
|
else
|
|
{
|
|
Debug.Log("<color=cyan>[PotaToon] " + msg +"</color>");
|
|
}
|
|
}
|
|
|
|
[MenuItem("PotaToon/Auto Setup for current scene", false, 1)]
|
|
private static void AutoSetupCurrentScene()
|
|
{
|
|
var currentPipeline = QualitySettings.renderPipeline as UniversalRenderPipelineAsset;
|
|
if (currentPipeline == null)
|
|
{
|
|
PotaToonLog("Current render pipeline is not using URP.", true);
|
|
return;
|
|
}
|
|
|
|
#if UNITY_6000_0_OR_NEWER
|
|
var rendererDataList = currentPipeline.rendererDataList;
|
|
if (rendererDataList.Length == 0)
|
|
{
|
|
PotaToonLog("Couldn't find URP RendererData.", true);
|
|
return;
|
|
}
|
|
#else
|
|
var rendererDataList = GetRendererDataList(currentPipeline);
|
|
if (rendererDataList == null || rendererDataList.Length == 0)
|
|
{
|
|
PotaToonLog("Couldn't find URP RendererData.", true);
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
bool allowToAddRendererFeature = EditorUtility.DisplayDialog("PotaToon Auto Setup",
|
|
$"This will add 'PotaToon' renderer feature to all linked renderers in [{currentPipeline.name}] asset.\n If you want to add it to a specific renderer, please add it manually.",
|
|
"OK", "Cancel");
|
|
|
|
if (allowToAddRendererFeature)
|
|
{
|
|
bool succeed = false;
|
|
foreach (var renderer in rendererDataList)
|
|
{
|
|
if (renderer is UniversalRendererData urpRendererData)
|
|
{
|
|
AddRendererFeature(urpRendererData);
|
|
succeed = true;
|
|
}
|
|
}
|
|
|
|
if (!succeed)
|
|
PotaToonLog("Couldn't find URP RendererData.", true);
|
|
}
|
|
|
|
AddPotaToonVolume();
|
|
|
|
PotaToonLog($"Auto setup for editor is completed. Add [PotaToonCharacter] component to your characters. Please note that you need to add [PotaToonFeature] to other UniversalRendererData assets manually if you use a different URP settings in the build.");
|
|
}
|
|
|
|
#if !UNITY_6000_0_OR_NEWER
|
|
private static ScriptableRendererData[] GetRendererDataList(UniversalRenderPipelineAsset urp)
|
|
{
|
|
var so = new SerializedObject(urp);
|
|
var prop = so.FindProperty("m_RendererDataList") ?? so.FindProperty("rendererDataList");
|
|
if (prop == null || !prop.isArray)
|
|
return null;
|
|
|
|
var list = new ScriptableRendererData[prop.arraySize];
|
|
for (int i = 0; i < prop.arraySize; i++)
|
|
list[i] = prop.GetArrayElementAtIndex(i).objectReferenceValue as ScriptableRendererData;
|
|
|
|
return list;
|
|
}
|
|
#endif
|
|
|
|
private static void AddRendererFeature(UniversalRendererData rendererData)
|
|
{
|
|
// Return if already setup
|
|
if (rendererData.rendererFeatures.Any(f => f.GetType().Name == k_PotaToonFeatureName))
|
|
{
|
|
PotaToonLog($"{k_PotaToonFeatureName} is already added in your renderer data.");
|
|
return;
|
|
}
|
|
|
|
// Create PotaToon Renderer Feature
|
|
ScriptableRendererFeature newFeature = (ScriptableRendererFeature)ScriptableObject.CreateInstance(k_PotaToonFeatureName);
|
|
if (newFeature == null)
|
|
{
|
|
PotaToonLog($"Failed to create instance of {k_PotaToonFeatureName}.", true);
|
|
return;
|
|
}
|
|
|
|
newFeature.name = k_PotaToonFeatureName;
|
|
rendererData.rendererFeatures.Add(newFeature);
|
|
rendererData.SetDirty();
|
|
|
|
AssetDatabase.AddObjectToAsset(newFeature, rendererData);
|
|
AssetDatabase.SaveAssets();
|
|
AssetDatabase.Refresh();
|
|
}
|
|
|
|
private static void AddPotaToonVolume()
|
|
{
|
|
// Find volume
|
|
Volume globalVolume = Object.FindObjectsByType<Volume>(FindObjectsInactive.Include, FindObjectsSortMode.None).FirstOrDefault(v => v.isGlobal);
|
|
|
|
// Create if needed
|
|
if (globalVolume == null)
|
|
{
|
|
GameObject volumeGO = new GameObject("Global Volume");
|
|
globalVolume = volumeGO.AddComponent<Volume>();
|
|
globalVolume.isGlobal = true;
|
|
|
|
Undo.RegisterCreatedObjectUndo(volumeGO, "Create Global Volume");
|
|
|
|
PotaToonLog("New Global Volume created.");
|
|
}
|
|
|
|
// Add PotaToon Volume Component
|
|
if (globalVolume.sharedProfile == null)
|
|
{
|
|
globalVolume.sharedProfile = ScriptableObject.CreateInstance<VolumeProfile>();
|
|
globalVolume.sharedProfile.name = "PotaToon Global Volume";
|
|
Undo.RegisterCompleteObjectUndo(globalVolume, "Create Volume Profile");
|
|
if (EditorUtility.IsPersistent(globalVolume))
|
|
{
|
|
AssetDatabase.AddObjectToAsset(globalVolume.sharedProfile, globalVolume);
|
|
EditorUtility.SetDirty(globalVolume);
|
|
AssetDatabase.SaveAssets();
|
|
}
|
|
}
|
|
|
|
var potaToonType = typeof(PotaToon);
|
|
if (!globalVolume.sharedProfile.TryGet(potaToonType, out VolumeComponent existingComponent))
|
|
{
|
|
var asset = globalVolume.sharedProfile;
|
|
var component = globalVolume.sharedProfile.Add(potaToonType);
|
|
|
|
if (EditorUtility.IsPersistent(asset))
|
|
AssetDatabase.AddObjectToAsset(component, asset);
|
|
|
|
if (EditorUtility.IsPersistent(asset))
|
|
{
|
|
EditorUtility.SetDirty(asset);
|
|
AssetDatabase.SaveAssets();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PotaToonLog($"PotaToon Volume is already added to Global Volume.");
|
|
}
|
|
}
|
|
|
|
[MenuItem("PotaToon/Duplicate selected character to PotaToon character prefab", false, 2)]
|
|
private static void DuplicateSelectedPrefab()
|
|
{
|
|
GameObject selectedObject = Selection.activeGameObject;
|
|
|
|
if (selectedObject == null)
|
|
{
|
|
PotaToonLog("No object selected! Please select a object or prefab in the Hierarchy/Project window.", true);
|
|
return;
|
|
}
|
|
|
|
string selectedPath = EditorUtility.SaveFolderPanel("Select Save Folder", Application.dataPath, "");
|
|
if (string.IsNullOrEmpty(selectedPath))
|
|
{
|
|
PotaToonLog("No folder selected. Operation cancelled.", true);
|
|
return;
|
|
}
|
|
|
|
if (!selectedPath.StartsWith(Application.dataPath))
|
|
{
|
|
PotaToonLog("Please select a folder inside the 'Assets' directory!", true);
|
|
return;
|
|
}
|
|
|
|
string savePath = "Assets" + selectedPath.Substring(Application.dataPath.Length);
|
|
|
|
if (!Directory.Exists(savePath))
|
|
{
|
|
Directory.CreateDirectory(savePath);
|
|
}
|
|
|
|
string newPrefabPath = $"{savePath}/{selectedObject.name}_PotaToon.prefab";
|
|
|
|
GameObject newPrefabInstance = Object.Instantiate(selectedObject);
|
|
newPrefabInstance.name = selectedObject.name + "_PotaToon";
|
|
|
|
// Remove existing component
|
|
var prevPotaToonCharacter = newPrefabInstance.GetComponent<PotaToonCharacter>();
|
|
if (prevPotaToonCharacter != null)
|
|
{
|
|
DestroyImmediate(prevPotaToonCharacter);
|
|
}
|
|
|
|
// Duplicate materials
|
|
var potaToonShader = Shader.Find(PotaToonGUIUtility.k_Paths[0]);
|
|
var potaToonEyeShader = Shader.Find(PotaToonGUIUtility.k_Paths[2]);
|
|
var materialMap = new Dictionary<Material, Material>();
|
|
|
|
var renderers = newPrefabInstance.GetComponentsInChildren<Renderer>();
|
|
foreach (Renderer renderer in renderers)
|
|
{
|
|
Material[] originalMaterials = renderer.sharedMaterials;
|
|
var newMaterials = new Material[originalMaterials.Length];
|
|
for (int i = 0; i < originalMaterials.Length; i++)
|
|
{
|
|
Material originalMaterial = renderer.sharedMaterials[i];
|
|
if (originalMaterial == null) continue;
|
|
|
|
if (materialMap.TryGetValue(originalMaterial, out Material existingMaterial))
|
|
{
|
|
newMaterials[i] = existingMaterial;
|
|
}
|
|
else
|
|
{
|
|
string materialPath = AssetDatabase.GetAssetPath(originalMaterial);
|
|
string materialName = Path.GetFileNameWithoutExtension(materialPath);
|
|
string newMaterialPath = $"{savePath}/{materialName}_PotaToon.mat";
|
|
|
|
var name = materialName.ToLower();
|
|
Material newMaterial = name.Equals("eye") ? new Material(potaToonEyeShader) : new Material(potaToonShader);
|
|
CopySettings(originalMaterial, newMaterial, IsSkin(name));
|
|
AssetDatabase.CreateAsset(newMaterial, newMaterialPath);
|
|
|
|
materialMap[originalMaterial] = newMaterial;
|
|
newMaterials[i] = newMaterial;
|
|
}
|
|
|
|
}
|
|
renderer.sharedMaterials = newMaterials;
|
|
}
|
|
|
|
// Add PotaToonCharacter Component
|
|
var potaToonCharacter = newPrefabInstance.AddComponent<PotaToonCharacter>();
|
|
potaToonCharacter.UpdateMaterials();
|
|
potaToonCharacter.LoadPropertyHistoryData();
|
|
|
|
var savedObject = PrefabUtility.SaveAsPrefabAsset(newPrefabInstance, newPrefabPath);
|
|
Object.DestroyImmediate(newPrefabInstance);
|
|
|
|
AssetDatabase.SaveAssets();
|
|
AssetDatabase.Refresh();
|
|
|
|
if (savedObject != null)
|
|
{
|
|
PotaToonLog($"Prefab duplicated successfully! Saved at: {newPrefabPath}");
|
|
}
|
|
else
|
|
{
|
|
PotaToonLog($"Couldn't duplicate the selected object. This could be caused because of the missing script in the prefab. Please Use the 'Convert selected character materials to PotaToon materials' instead after duplicating the object manually.", true);
|
|
}
|
|
}
|
|
|
|
[MenuItem("PotaToon/Convert selected character materials to PotaToon materials", false, 3)]
|
|
private static void ConvertSelectedCharacterMaterials()
|
|
{
|
|
GameObject selectedObject = Selection.activeGameObject;
|
|
|
|
if (selectedObject == null)
|
|
{
|
|
PotaToonLog("No object selected! Please select a object or prefab in the Hierarchy/Project window.", true);
|
|
return;
|
|
}
|
|
|
|
string selectedPath = EditorUtility.SaveFolderPanel("Select Save Folder", Application.dataPath, "");
|
|
if (string.IsNullOrEmpty(selectedPath))
|
|
{
|
|
PotaToonLog("No folder selected. Operation cancelled.", true);
|
|
return;
|
|
}
|
|
|
|
if (!selectedPath.StartsWith(Application.dataPath))
|
|
{
|
|
PotaToonLog("Please select a folder inside the 'Assets' directory!", true);
|
|
return;
|
|
}
|
|
|
|
string savePath = "Assets" + selectedPath.Substring(Application.dataPath.Length);
|
|
|
|
if (!Directory.Exists(savePath))
|
|
{
|
|
Directory.CreateDirectory(savePath);
|
|
}
|
|
|
|
// Remove existing component
|
|
var prevPotaToonCharacter = selectedObject.GetComponent<PotaToonCharacter>();
|
|
if (prevPotaToonCharacter != null)
|
|
{
|
|
DestroyImmediate(prevPotaToonCharacter);
|
|
}
|
|
|
|
// Convert materials
|
|
var potaToonShader = Shader.Find(PotaToonGUIUtility.k_Paths[0]);
|
|
var potaToonEyeShader = Shader.Find(PotaToonGUIUtility.k_Paths[2]);
|
|
|
|
var renderers = selectedObject.GetComponentsInChildren<Renderer>();
|
|
Dictionary<Material, Material> materialMap = new Dictionary<Material, Material>();
|
|
int undoGroup = Undo.GetCurrentGroup();
|
|
|
|
foreach (Renderer renderer in renderers)
|
|
{
|
|
Material[] originalMaterials = renderer.sharedMaterials;
|
|
Material[] newMaterials = new Material[originalMaterials.Length];
|
|
|
|
for (int i = 0; i < originalMaterials.Length; i++)
|
|
{
|
|
Material originalMaterial = originalMaterials[i];
|
|
if (originalMaterial == null) continue;
|
|
|
|
var name = originalMaterial.name.ToLower();
|
|
var targetShader = name.Equals("eye") ? potaToonEyeShader : potaToonShader;
|
|
if (materialMap.TryGetValue(originalMaterial, out Material existingMaterial))
|
|
{
|
|
newMaterials[i] = existingMaterial;
|
|
}
|
|
else
|
|
{
|
|
Material newMaterial = new Material(originalMaterial);
|
|
newMaterial.shader = targetShader;
|
|
|
|
Undo.RegisterCompleteObjectUndo(newMaterial, "Change Material Shader");
|
|
|
|
materialMap[originalMaterial] = newMaterial;
|
|
newMaterials[i] = newMaterial;
|
|
|
|
CopySettings(originalMaterial, newMaterial, IsSkin(name));
|
|
|
|
string materialPath = AssetDatabase.GetAssetPath(originalMaterial);
|
|
string materialName = Path.GetFileNameWithoutExtension(materialPath);
|
|
string newMaterialPath = $"{savePath}/{materialName}_PotaToon.mat";
|
|
AssetDatabase.CreateAsset(newMaterial, newMaterialPath);
|
|
}
|
|
}
|
|
|
|
Undo.RecordObject(renderer, "Assign New Materials");
|
|
renderer.sharedMaterials = newMaterials;
|
|
}
|
|
|
|
AssetDatabase.SaveAssets();
|
|
AssetDatabase.Refresh();
|
|
Undo.CollapseUndoOperations(undoGroup);
|
|
|
|
// Add PotaToon
|
|
var potaToonCharacter = selectedObject.AddComponent<PotaToonCharacter>();
|
|
potaToonCharacter.UpdateMaterials();
|
|
potaToonCharacter.LoadPropertyHistoryData();
|
|
|
|
PotaToonLog("Saved all converted materials into " + savePath);
|
|
}
|
|
|
|
private static bool IsSkin(string name)
|
|
{
|
|
return name.Contains("skin") || name.Contains("body") || name.Contains("face");
|
|
}
|
|
|
|
private static void CopySettings(Material original, Material copy, bool isSkin)
|
|
{
|
|
CopyTextures(original, copy);
|
|
CopyColors(original, copy, isSkin);
|
|
CopyRenderQueue(original, copy);
|
|
CopyNumericData(original, copy);
|
|
CopyBlendingMode(original, copy);
|
|
}
|
|
|
|
private static void CopyTextures(Material original, Material copy)
|
|
{
|
|
Shader shader = original.shader;
|
|
int propertyCount = shader.GetPropertyCount();
|
|
|
|
for (int i = 0; i < propertyCount; i++)
|
|
{
|
|
if (shader.GetPropertyType(i).Equals(ShaderPropertyType.Texture))
|
|
{
|
|
string propertyName = shader.GetPropertyName(i);
|
|
if (original.HasProperty(propertyName) && copy.HasProperty(propertyName))
|
|
{
|
|
Texture texture = original.GetTexture(propertyName);
|
|
if (texture != null)
|
|
copy.SetTexture(propertyName, texture);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set BaseMap to MainTex
|
|
if (original.HasProperty("_BaseMap"))
|
|
{
|
|
Texture texture = original.GetTexture("_BaseMap");
|
|
if (texture != null)
|
|
copy.SetTexture("_MainTex", texture);
|
|
}
|
|
|
|
// Set BumpMap to NormalMap
|
|
if (original.HasProperty("_BumpMap"))
|
|
{
|
|
Texture texture = original.GetTexture("_BumpMap");
|
|
if (texture != null)
|
|
copy.SetTexture("_NormalMap", texture);
|
|
}
|
|
|
|
// Set ShadowColorTex to ShadeMap
|
|
if (original.HasProperty("_ShadowColorTex"))
|
|
{
|
|
Texture texture = original.GetTexture("_ShadowColorTex");
|
|
if (texture != null)
|
|
copy.SetTexture("_ShadeMap", texture);
|
|
}
|
|
|
|
// Set UseShadeMap
|
|
if (copy.HasProperty("_ShadeMap") && copy.GetTexture("_ShadeMap") != null)
|
|
{
|
|
copy.SetInt("_UseShadeMap", 1);
|
|
}
|
|
|
|
// If normal map exists, use the normal map
|
|
if (copy.HasProperty("_NormalMap") && copy.GetTexture("_NormalMap") != null)
|
|
{
|
|
copy.SetInt("_UseNormalMap", 1);
|
|
}
|
|
|
|
// Set EmissionBlendMask to EmissionMask
|
|
if (original.HasProperty("_EmissionBlendMask"))
|
|
{
|
|
Texture texture = original.GetTexture("_EmissionBlendMask");
|
|
if (texture != null)
|
|
copy.SetTexture("_EmissionMask", texture);
|
|
}
|
|
|
|
// Set MatCapBlendMask to MatCapMask
|
|
if (original.HasProperty("_MatCapBlendMask"))
|
|
{
|
|
Texture texture = original.GetTexture("_MatCapBlendMask");
|
|
if (texture != null)
|
|
copy.SetTexture("_MatCapMask", texture);
|
|
}
|
|
}
|
|
|
|
private static void CopyColors(Material original, Material copy, bool isSkin)
|
|
{
|
|
Shader shader = original.shader;
|
|
int propertyCount = shader.GetPropertyCount();
|
|
|
|
// Set default shadow color for skin type
|
|
if (isSkin)
|
|
{
|
|
copy.SetColor("_ShadeColor", new Color(1f, 0.75f, 0.75f));
|
|
}
|
|
|
|
// Copy colors
|
|
for (int i = 0; i < propertyCount; i++)
|
|
{
|
|
if (shader.GetPropertyType(i).Equals(ShaderPropertyType.Color))
|
|
{
|
|
string propertyName = shader.GetPropertyName(i);
|
|
if (original.HasProperty(propertyName) && copy.HasProperty(propertyName))
|
|
{
|
|
var color = original.GetColor(propertyName);
|
|
copy.SetColor(propertyName, color);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set Color to BaseColor
|
|
if (original.HasProperty("_Color"))
|
|
{
|
|
var color = original.GetColor("_Color");
|
|
copy.SetColor("_BaseColor", color);
|
|
}
|
|
|
|
// Set ShadowColor to ShadeColor
|
|
if (original.HasProperty("_ShadowColor"))
|
|
{
|
|
var color = original.GetColor("_ShadowColor");
|
|
copy.SetColor("_ShadeColor", color);
|
|
}
|
|
}
|
|
|
|
private static void CopyRenderQueue(Material original, Material copy)
|
|
{
|
|
copy.renderQueue = original.renderQueue;
|
|
if (copy.HasProperty("_AutoRenderQueue"))
|
|
{
|
|
copy.SetInt("_AutoRenderQueue", 0);
|
|
}
|
|
|
|
if (copy.renderQueue < 2450)
|
|
copy.SetInt("_SurfaceType", (int)SurfaceType.Opaque);
|
|
else if (copy.renderQueue < 2501)
|
|
copy.SetInt("_SurfaceType", (int)SurfaceType.Cutout);
|
|
else
|
|
copy.SetInt("_SurfaceType", (int)SurfaceType.Transparent);
|
|
}
|
|
|
|
private static void CopyNumericData(Material original, Material copy)
|
|
{
|
|
Shader shader = original.shader;
|
|
int propertyCount = shader.GetPropertyCount();
|
|
|
|
for (int i = 0; i < propertyCount; i++)
|
|
{
|
|
var propertyType = shader.GetPropertyType(i);
|
|
if (propertyType.Equals(ShaderPropertyType.Float) || propertyType.Equals(ShaderPropertyType.Range))
|
|
{
|
|
string propertyName = shader.GetPropertyName(i);
|
|
if (original.HasProperty(propertyName) && copy.HasProperty(propertyName))
|
|
{
|
|
var data = original.GetFloat(propertyName);
|
|
copy.SetFloat(propertyName, data);
|
|
}
|
|
}
|
|
|
|
if (propertyType.Equals(ShaderPropertyType.Int))
|
|
{
|
|
string propertyName = shader.GetPropertyName(i);
|
|
if (original.HasProperty(propertyName) && copy.HasProperty(propertyName))
|
|
{
|
|
var data = original.GetInt(propertyName);
|
|
copy.SetInt(propertyName, data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void CopyBlendingMode(Material original, Material copy)
|
|
{
|
|
if (copy.renderQueue >= 2501)
|
|
copy.SetInt("_Blend", (int)AlphaMode.Custom);
|
|
}
|
|
|
|
[MenuItem("PotaToon/Toggle Guide Warning", false, 10)]
|
|
private static void TogglePotaToonGuideWarning()
|
|
{
|
|
PotaToon.guideWarningEnabled = !PotaToon.guideWarningEnabled;
|
|
}
|
|
}
|
|
}
|