551 lines
28 KiB
C#
551 lines
28 KiB
C#
#if UNITY_EDITOR
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using lilToon;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
|
|
public class lilToonPreset : ScriptableObject
|
|
{
|
|
public lilPresetBase[] bases;
|
|
public lilPresetCategory category;
|
|
public string renderingMode;
|
|
public Shader shader;
|
|
public lilPresetColor[] colors;
|
|
public lilPresetVector4[] vectors;
|
|
public lilPresetFloat[] floats;
|
|
public lilPresetTexture[] textures;
|
|
public int renderQueue;
|
|
public int outline;
|
|
public bool outlineMainTex;
|
|
public int tessellation;
|
|
|
|
[Serializable]
|
|
public struct lilPresetBase
|
|
{
|
|
public string language;
|
|
public string name;
|
|
}
|
|
|
|
[Serializable]
|
|
public struct lilPresetColor
|
|
{
|
|
public string name;
|
|
public Color value;
|
|
}
|
|
|
|
[Serializable]
|
|
public struct lilPresetVector4
|
|
{
|
|
public string name;
|
|
public Vector4 value;
|
|
}
|
|
|
|
[Serializable]
|
|
public struct lilPresetFloat
|
|
{
|
|
public string name;
|
|
public float value;
|
|
}
|
|
|
|
[Serializable]
|
|
public struct lilPresetTexture
|
|
{
|
|
public string name;
|
|
public Texture value;
|
|
public Vector2 offset;
|
|
public Vector2 scale;
|
|
}
|
|
|
|
public static void ApplyPreset(Material material, lilToonPreset preset, bool ismulti)
|
|
{
|
|
if(material == null || preset == null) return;
|
|
Undo.RecordObject(material, "Apply Preset");
|
|
foreach(var f in preset.floats.Where(f => f.name == "_StencilPass"))
|
|
{
|
|
material.SetFloat(f.name, f.value);
|
|
}
|
|
if(preset.shader != null) material.shader = preset.shader;
|
|
bool isoutl = preset.outline == -1 ? material.shader.name.Contains("Outline") : (preset.outline == 1);
|
|
bool istess = preset.tessellation == -1 ? material.shader.name.Contains("Tessellation") : (preset.tessellation == 1);
|
|
|
|
bool islite = material.shader.name.Contains("Lite");
|
|
bool iscutout = material.shader.name.Contains("Cutout");
|
|
bool istransparent = material.shader.name.Contains("Transparent");
|
|
bool isrefr = material.shader.name.Contains("Refraction");
|
|
bool isblur = material.shader.name.Contains("Blur");
|
|
bool isfur = material.shader.name.Contains("Fur");
|
|
bool isonepass = material.shader.name.Contains("OnePass");
|
|
bool istwopass = material.shader.name.Contains("TwoPass");
|
|
|
|
var renderingMode = RenderingMode.Opaque;
|
|
|
|
//if(string.IsNullOrEmpty(preset.renderingMode) || !Enum.TryParse(preset.renderingMode, out renderingMode))
|
|
if(string.IsNullOrEmpty(preset.renderingMode) || !Enum.IsDefined(typeof(RenderingMode), preset.renderingMode))
|
|
{
|
|
if(iscutout) renderingMode = RenderingMode.Cutout;
|
|
if(istransparent) renderingMode = RenderingMode.Transparent;
|
|
if(isrefr) renderingMode = RenderingMode.Refraction;
|
|
if(isrefr && isblur) renderingMode = RenderingMode.RefractionBlur;
|
|
if(isfur) renderingMode = RenderingMode.Fur;
|
|
if(isfur && iscutout) renderingMode = RenderingMode.FurCutout;
|
|
if(isfur && istwopass) renderingMode = RenderingMode.FurTwoPass;
|
|
}
|
|
else
|
|
{
|
|
renderingMode = (RenderingMode)Enum.Parse(typeof(RenderingMode), preset.renderingMode);
|
|
}
|
|
|
|
var transparentMode = TransparentMode.Normal;
|
|
if(isonepass) transparentMode = TransparentMode.OnePass;
|
|
if(!isfur && istwopass) transparentMode = TransparentMode.TwoPass;
|
|
|
|
lilMaterialUtils.SetupMaterialWithRenderingMode(material, renderingMode, transparentMode, isoutl, islite, istess, ismulti);
|
|
if(preset.renderQueue != -2) material.renderQueue = preset.renderQueue;
|
|
|
|
foreach(var c in preset.colors ) material.SetColor(c.name, c.value);
|
|
foreach(var v in preset.vectors) material.SetVector(v.name, v.value);
|
|
foreach(var f in preset.floats ) material.SetFloat(f.name, f.value);
|
|
foreach(var t in preset.textures)
|
|
{
|
|
material.SetTexture(t.name, t.value);
|
|
material.SetTextureOffset(t.name, t.offset);
|
|
material.SetTextureScale(t.name, t.scale);
|
|
}
|
|
|
|
if(preset.outlineMainTex) material.SetTexture("_OutlineTex", material.GetTexture("_MainTex"));
|
|
}
|
|
|
|
public static lilToonPreset[] LoadPresets()
|
|
{
|
|
return lilDirectoryManager.FindAssets<lilToonPreset>("t:lilToonPreset").ToArray();
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------------------------------------
|
|
// Save Preset Window
|
|
#region
|
|
public class lilPresetWindow : EditorWindow
|
|
{
|
|
private Vector2 scrollPosition = Vector2.zero;
|
|
|
|
private bool shouldSaveRenderingMode = false;
|
|
private bool shouldSaveQueue = false;
|
|
private bool shouldSaveMainTex2Outline = false;
|
|
|
|
// Feature
|
|
private bool shouldSaveBase = true;
|
|
private bool shouldSaveLighting = true;
|
|
private bool shouldSaveUV = true;
|
|
private bool shouldSaveMain = true;
|
|
private bool shouldSaveMain2nd = true;
|
|
private bool shouldSaveMain3rd = true;
|
|
private bool shouldSaveAlphaMask = true;
|
|
private bool shouldSaveShadow = true;
|
|
private bool shouldSaveEmission = true;
|
|
private bool shouldSaveEmission2nd = true;
|
|
private bool shouldSaveNormalMap = true;
|
|
private bool shouldSaveNormalMap2nd = true;
|
|
private bool shouldSaveAnisotropy = true;
|
|
private bool shouldSaveRimShade = true;
|
|
private bool shouldSaveBacklight = true;
|
|
private bool shouldSaveReflection = true;
|
|
private bool shouldSaveMatCap = true;
|
|
private bool shouldSaveMatCap2nd = true;
|
|
private bool shouldSaveRim = true;
|
|
private bool shouldSaveGlitter = true;
|
|
private bool shouldSaveParallax = true;
|
|
private bool shouldSaveDistanceFade = true;
|
|
private bool shouldSaveAudioLink = true;
|
|
private bool shouldSaveDissolve = true;
|
|
private bool shouldSaveRefraction = true;
|
|
private bool shouldSaveGem = true;
|
|
private bool shouldSaveTessellation = true;
|
|
private bool shouldSaveOutline = true;
|
|
private bool shouldSaveFur = true;
|
|
private bool shouldSaveStencil = true;
|
|
private bool shouldSaveRendering = true;
|
|
private bool shouldSaveOutlineRendering = true;
|
|
private bool shouldSaveFurRendering = true;
|
|
|
|
// Texture
|
|
private HashSet<string> shouldSaveTexs = new HashSet<string>();
|
|
|
|
private lilToonPreset preset;
|
|
private string[] presetName;
|
|
private string filename = "";
|
|
private RenderingMode renderingMode;
|
|
private bool isOutl = false;
|
|
private bool isTess = false;
|
|
private bool isShowFeatures = false;
|
|
private bool isShowTextures = false;
|
|
|
|
#pragma warning disable CS0612
|
|
private void OnGUI()
|
|
{
|
|
if(!(Selection.activeObject is Material)){
|
|
EditorGUILayout.LabelField(GetLoc("sPresetIsMaterial"));
|
|
return;
|
|
}
|
|
|
|
string[] sCategorys = { GetLoc("sPresetCategorySkin"),
|
|
GetLoc("sPresetCategoryHair"),
|
|
GetLoc("sPresetCategoryCloth"),
|
|
GetLoc("sPresetCategoryNature"),
|
|
GetLoc("sPresetCategoryInorganic"),
|
|
GetLoc("sPresetCategoryEffect"),
|
|
GetLoc("sPresetCategoryOther") };
|
|
scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);
|
|
|
|
var material = (Material)Selection.activeObject;
|
|
if(preset == null) preset = CreateInstance<lilToonPreset>();
|
|
|
|
// load language
|
|
var langName = lilLanguageManager.langSet.languageNames.Split('\t');
|
|
Array.Resize(ref presetName, langName.Length);
|
|
|
|
// Initialize
|
|
Array.Resize(ref preset.bases, 0);
|
|
Array.Resize(ref preset.colors, 0);
|
|
Array.Resize(ref preset.vectors, 0);
|
|
Array.Resize(ref preset.floats, 0);
|
|
Array.Resize(ref preset.textures, 0);
|
|
if(material.shader != null && !string.IsNullOrEmpty(material.shader.name))
|
|
{
|
|
isOutl = material.shader.name.Contains("Outline");
|
|
isTess = material.shader.name.Contains("Tessellation");
|
|
renderingMode = RenderingMode.Opaque;
|
|
if(material.shader.name.Contains("Cutout")) renderingMode = RenderingMode.Cutout;
|
|
if(material.shader.name.Contains("Transparent")) renderingMode = RenderingMode.Transparent;
|
|
if(material.shader.name.Contains("Refraction")) renderingMode = RenderingMode.Refraction;
|
|
if(material.shader.name.Contains("RefractionBlur")) renderingMode = RenderingMode.RefractionBlur;
|
|
if(material.shader.name.Contains("Fur")) renderingMode = RenderingMode.Fur;
|
|
if(material.shader.name.Contains("FurCutout")) renderingMode = RenderingMode.FurCutout;
|
|
if(material.shader.name.Contains("FurTwoPass")) renderingMode = RenderingMode.FurTwoPass;
|
|
if(material.shader.name.Contains("Gem")) renderingMode = RenderingMode.Gem;
|
|
}
|
|
else
|
|
{
|
|
isOutl = false;
|
|
isTess = false;
|
|
renderingMode = RenderingMode.Opaque;
|
|
}
|
|
|
|
// Name
|
|
EditorGUILayout.LabelField(GetLoc("sPresetName"));
|
|
for(int i = 0; i < langName.Length; i++)
|
|
{
|
|
presetName[i] = EditorGUILayout.TextField(langName[i], presetName[i]);
|
|
}
|
|
|
|
preset.category = (lilPresetCategory)EditorGUILayout.Popup(GetLoc("sPresetCategory"), (int)preset.category, sCategorys);
|
|
|
|
// Features
|
|
EditorGUILayout.Space();
|
|
isShowFeatures = lilEditorGUI.DrawSimpleFoldout(GetLoc("sPresetSaveTarget"), isShowFeatures);
|
|
if(isShowFeatures)
|
|
{
|
|
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
|
|
shouldSaveRenderingMode = EditorGUILayout.ToggleLeft(GetLoc("sRenderingMode"), shouldSaveRenderingMode);
|
|
shouldSaveQueue = EditorGUILayout.ToggleLeft("Render Queue", shouldSaveQueue);
|
|
shouldSaveMainTex2Outline = EditorGUILayout.ToggleLeft(GetLoc("sPresetMainTex2Outline"), shouldSaveMainTex2Outline);
|
|
|
|
EditorGUILayout.Space();
|
|
EditorGUILayout.BeginHorizontal();
|
|
if(GUILayout.Button("Select All")) ToggleAllFeatures(true);
|
|
if(GUILayout.Button("Deselect All")) ToggleAllFeatures(false);
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
EditorGUILayout.LabelField(GetLoc("sBaseSetting"), EditorStyles.boldLabel);
|
|
EditorGUI.indentLevel++;
|
|
shouldSaveBase = EditorGUILayout.ToggleLeft(GetLoc("sBaseSetting"), shouldSaveBase);
|
|
shouldSaveLighting = EditorGUILayout.ToggleLeft(GetLoc("sLightingSettings"), shouldSaveLighting);
|
|
shouldSaveUV = EditorGUILayout.ToggleLeft(GetLoc("sMainUV"), shouldSaveUV);
|
|
EditorGUI.indentLevel--;
|
|
|
|
EditorGUILayout.LabelField(GetLoc("sColors"), EditorStyles.boldLabel);
|
|
EditorGUI.indentLevel++;
|
|
shouldSaveMain = EditorGUILayout.ToggleLeft(GetLoc("sMainColor"), shouldSaveMain);
|
|
shouldSaveMain2nd = EditorGUILayout.ToggleLeft(GetLoc("sMainColor2nd"), shouldSaveMain2nd);
|
|
shouldSaveMain3rd = EditorGUILayout.ToggleLeft(GetLoc("sMainColor3rd"), shouldSaveMain3rd);
|
|
shouldSaveAlphaMask = EditorGUILayout.ToggleLeft(GetLoc("sAlphaMask"), shouldSaveAlphaMask);
|
|
shouldSaveShadow = EditorGUILayout.ToggleLeft(GetLoc("sShadow"), shouldSaveShadow);
|
|
shouldSaveEmission = EditorGUILayout.ToggleLeft(GetLoc("sEmission"), shouldSaveEmission);
|
|
shouldSaveEmission2nd = EditorGUILayout.ToggleLeft(GetLoc("sEmission2nd"), shouldSaveEmission2nd);
|
|
EditorGUI.indentLevel--;
|
|
|
|
EditorGUILayout.LabelField(GetLoc("sNormalMapReflection"), EditorStyles.boldLabel);
|
|
EditorGUI.indentLevel++;
|
|
shouldSaveNormalMap = EditorGUILayout.ToggleLeft(GetLoc("sNormalMap"), shouldSaveNormalMap);
|
|
shouldSaveNormalMap2nd = EditorGUILayout.ToggleLeft(GetLoc("sNormalMap2nd"), shouldSaveNormalMap2nd);
|
|
shouldSaveAnisotropy = EditorGUILayout.ToggleLeft(GetLoc("sAnisotropy"), shouldSaveAnisotropy);
|
|
shouldSaveRimShade = EditorGUILayout.ToggleLeft(GetLoc("sRimShade"), shouldSaveRimShade);
|
|
shouldSaveBacklight = EditorGUILayout.ToggleLeft(GetLoc("sBacklight"), shouldSaveBacklight);
|
|
shouldSaveReflection = EditorGUILayout.ToggleLeft(GetLoc("sReflection"), shouldSaveReflection);
|
|
shouldSaveMatCap = EditorGUILayout.ToggleLeft(GetLoc("sMatCap"), shouldSaveMatCap);
|
|
shouldSaveMatCap2nd = EditorGUILayout.ToggleLeft(GetLoc("sMatCap2nd"), shouldSaveMatCap2nd);
|
|
shouldSaveRim = EditorGUILayout.ToggleLeft(GetLoc("sRimLight"), shouldSaveRim);
|
|
shouldSaveGlitter = EditorGUILayout.ToggleLeft(GetLoc("sGlitter"), shouldSaveGlitter);
|
|
shouldSaveGem = EditorGUILayout.ToggleLeft(GetLoc("sGem"), shouldSaveGem);
|
|
EditorGUI.indentLevel--;
|
|
|
|
EditorGUILayout.LabelField(GetLoc("sAdvanced"), EditorStyles.boldLabel);
|
|
EditorGUI.indentLevel++;
|
|
shouldSaveParallax = EditorGUILayout.ToggleLeft(GetLoc("sParallax"), shouldSaveParallax);
|
|
shouldSaveDistanceFade = EditorGUILayout.ToggleLeft(GetLoc("sDistanceFade"), shouldSaveDistanceFade);
|
|
shouldSaveAudioLink = EditorGUILayout.ToggleLeft(GetLoc("sAudioLink"), shouldSaveAudioLink);
|
|
shouldSaveDissolve = EditorGUILayout.ToggleLeft(GetLoc("sDissolve"), shouldSaveDissolve);
|
|
shouldSaveRefraction = EditorGUILayout.ToggleLeft(GetLoc("sRefraction"), shouldSaveRefraction);
|
|
shouldSaveTessellation = EditorGUILayout.ToggleLeft(GetLoc("sTessellation"), shouldSaveTessellation);
|
|
shouldSaveOutline = EditorGUILayout.ToggleLeft(GetLoc("sOutline"), shouldSaveOutline);
|
|
if(
|
|
renderingMode == RenderingMode.Fur ||
|
|
renderingMode == RenderingMode.FurCutout ||
|
|
renderingMode == RenderingMode.FurTwoPass
|
|
)
|
|
{
|
|
shouldSaveFur = EditorGUILayout.ToggleLeft(GetLoc("sFur"), shouldSaveFur);
|
|
shouldSaveFurRendering = EditorGUILayout.ToggleLeft(GetLoc("sRenderingSetting") + " - " + GetLoc("sFur"), shouldSaveFurRendering);
|
|
}
|
|
else
|
|
{
|
|
shouldSaveFur = false;
|
|
shouldSaveFurRendering = false;
|
|
}
|
|
shouldSaveStencil = EditorGUILayout.ToggleLeft(GetLoc("sStencilSetting"), shouldSaveStencil);
|
|
shouldSaveRendering = EditorGUILayout.ToggleLeft(GetLoc("sRenderingSetting"), shouldSaveRendering);
|
|
shouldSaveOutlineRendering = EditorGUILayout.ToggleLeft(GetLoc("sOutline") + " - " + GetLoc("sRenderingSetting"), shouldSaveOutlineRendering);
|
|
EditorGUI.indentLevel--;
|
|
EditorGUILayout.EndVertical();
|
|
}
|
|
|
|
// Textures
|
|
EditorGUILayout.Space();
|
|
isShowTextures = lilEditorGUI.DrawSimpleFoldout(GetLoc("sPresetTexture"), isShowTextures);
|
|
if(isShowTextures)
|
|
{
|
|
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
|
|
EditorGUILayout.BeginHorizontal();
|
|
if(GUILayout.Button("Select All")) ToggleAllTextures(material, true);
|
|
if(GUILayout.Button("Deselect All")) ToggleAllTextures(material, false);
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
int propCount = ShaderUtil.GetPropertyCount(material.shader);
|
|
for(int i = 0; i < propCount; i++)
|
|
{
|
|
var propType = ShaderUtil.GetPropertyType(material.shader, i);
|
|
if(propType != ShaderUtil.ShaderPropertyType.TexEnv) continue;
|
|
|
|
string propName = ShaderUtil.GetPropertyName(material.shader, i);
|
|
bool shouldSave = shouldSaveTexs.Contains(propName);
|
|
EditorGUI.BeginChangeCheck();
|
|
shouldSave = EditorGUILayout.ToggleLeft(propName, shouldSave);
|
|
if(EditorGUI.EndChangeCheck())
|
|
{
|
|
if(shouldSave) shouldSaveTexs.Add(propName);
|
|
else shouldSaveTexs.Remove(propName);
|
|
}
|
|
}
|
|
EditorGUILayout.EndVertical();
|
|
}
|
|
|
|
EditorGUILayout.Space();
|
|
if(GUILayout.Button("Save"))
|
|
{
|
|
// Preset Name
|
|
for(int i = 0; i < langName.Length; i++)
|
|
{
|
|
if(!string.IsNullOrEmpty(presetName[i]))
|
|
{
|
|
Array.Resize(ref preset.bases, preset.bases.Length+1);
|
|
preset.bases[preset.bases.Length-1].language = langName[i];
|
|
preset.bases[preset.bases.Length-1].name = presetName[i];
|
|
if(string.IsNullOrEmpty(filename) || langName[i] == "English") filename = preset.category.ToString() + "-" + presetName[i];
|
|
}
|
|
}
|
|
|
|
// Copy properties
|
|
CopyPropertiesToPreset(material);
|
|
CopyTexturesToPreset(material);
|
|
preset.renderingMode = shouldSaveRenderingMode ? renderingMode.ToString() : "";
|
|
preset.shader = null;
|
|
preset.renderQueue = shouldSaveQueue ? material.renderQueue : -2;
|
|
preset.outline = shouldSaveOutline ? (isOutl?1:0) : -1;
|
|
preset.tessellation = shouldSaveTessellation ? (isTess?1:0) : -1;
|
|
preset.outlineMainTex = shouldSaveMainTex2Outline;
|
|
|
|
EditorUtility.SetDirty(preset);
|
|
string presetFolderPath = lilDirectoryManager.GetPresetsFolderPath();
|
|
if(presetFolderPath.Contains("Packages")) presetFolderPath = "Assets/";
|
|
string savePath = EditorUtility.SaveFilePanel("Save Preset", presetFolderPath, filename, "asset");
|
|
if(!string.IsNullOrEmpty(savePath))
|
|
{
|
|
AssetDatabase.CreateAsset(preset, FileUtil.GetProjectRelativePath(savePath));
|
|
AssetDatabase.SaveAssets();
|
|
AssetDatabase.Refresh();
|
|
AssetDatabase.ImportAsset(FileUtil.GetProjectRelativePath(savePath), ImportAssetOptions.ForceUpdate);
|
|
lilToonInspector.presets = LoadPresets();
|
|
Close();
|
|
}
|
|
}
|
|
|
|
EditorGUILayout.EndScrollView();
|
|
}
|
|
#pragma warning restore CS0612
|
|
|
|
private void CopyPropertiesToPreset(Material material)
|
|
{
|
|
int propCount = ShaderUtil.GetPropertyCount(material.shader);
|
|
for(int i = 0; i < propCount; i++)
|
|
{
|
|
string propName = ShaderUtil.GetPropertyName(material.shader, i);
|
|
|
|
if(!(
|
|
shouldSaveBase && lilPropertyNameChecker.IsBaseProperty(propName) ||
|
|
shouldSaveLighting && lilPropertyNameChecker.IsLightingProperty(propName) ||
|
|
shouldSaveUV && lilPropertyNameChecker.IsUVProperty(propName) ||
|
|
shouldSaveMain && lilPropertyNameChecker.IsMainProperty(propName) ||
|
|
shouldSaveMain2nd && lilPropertyNameChecker.IsMain2ndProperty(propName) ||
|
|
shouldSaveMain3rd && lilPropertyNameChecker.IsMain3rdProperty(propName) ||
|
|
shouldSaveAlphaMask && lilPropertyNameChecker.IsAlphaMaskProperty(propName) ||
|
|
shouldSaveShadow && lilPropertyNameChecker.IsShadowProperty(propName) ||
|
|
shouldSaveEmission && lilPropertyNameChecker.IsEmissionProperty(propName) ||
|
|
shouldSaveEmission2nd && lilPropertyNameChecker.IsEmission2ndProperty(propName) ||
|
|
shouldSaveNormalMap && lilPropertyNameChecker.IsNormalMapProperty(propName) ||
|
|
shouldSaveNormalMap2nd && lilPropertyNameChecker.IsNormalMap2ndProperty(propName) ||
|
|
shouldSaveAnisotropy && lilPropertyNameChecker.IsAnisotropyProperty(propName) ||
|
|
shouldSaveRimShade && lilPropertyNameChecker.IsRimShadeProperty(propName) ||
|
|
shouldSaveBacklight && lilPropertyNameChecker.IsBacklightProperty(propName) ||
|
|
shouldSaveReflection && lilPropertyNameChecker.IsReflectionProperty(propName) ||
|
|
shouldSaveMatCap && lilPropertyNameChecker.IsMatCapProperty(propName) ||
|
|
shouldSaveMatCap2nd && lilPropertyNameChecker.IsMatCap2ndProperty(propName) ||
|
|
shouldSaveRim && lilPropertyNameChecker.IsRimProperty(propName) ||
|
|
shouldSaveGlitter && lilPropertyNameChecker.IsGlitterProperty(propName) ||
|
|
shouldSaveParallax && lilPropertyNameChecker.IsParallaxProperty(propName) ||
|
|
shouldSaveDistanceFade && lilPropertyNameChecker.IsDistanceFadeProperty(propName) ||
|
|
shouldSaveAudioLink && lilPropertyNameChecker.IsAudioLinkProperty(propName) ||
|
|
shouldSaveDissolve && lilPropertyNameChecker.IsDissolveProperty(propName) ||
|
|
shouldSaveRefraction && lilPropertyNameChecker.IsRefractionProperty(propName) ||
|
|
shouldSaveGem && lilPropertyNameChecker.IsGemProperty(propName) ||
|
|
shouldSaveTessellation && lilPropertyNameChecker.IsTessellationProperty(propName) ||
|
|
shouldSaveOutline && lilPropertyNameChecker.IsOutlineProperty(propName) ||
|
|
shouldSaveFur && lilPropertyNameChecker.IsFurProperty(propName) ||
|
|
shouldSaveStencil && lilPropertyNameChecker.IsStencilProperty(propName) ||
|
|
shouldSaveRendering && lilPropertyNameChecker.IsRenderingProperty(propName) ||
|
|
shouldSaveOutlineRendering && lilPropertyNameChecker.IsOutlineRenderingProperty(propName) ||
|
|
shouldSaveFurRendering && lilPropertyNameChecker.IsFurRenderingProperty(propName)
|
|
)) continue;
|
|
|
|
var propType = ShaderUtil.GetPropertyType(material.shader, i);
|
|
if(propType == ShaderUtil.ShaderPropertyType.Color)
|
|
{
|
|
Array.Resize(ref preset.colors, preset.colors.Length + 1);
|
|
preset.colors[preset.colors.Length-1].name = propName;
|
|
preset.colors[preset.colors.Length-1].value = material.GetColor(propName);
|
|
}
|
|
if(propType == ShaderUtil.ShaderPropertyType.Vector)
|
|
{
|
|
Array.Resize(ref preset.vectors, preset.vectors.Length + 1);
|
|
preset.vectors[preset.vectors.Length-1].name = propName;
|
|
preset.vectors[preset.vectors.Length-1].value = material.GetVector(propName);
|
|
}
|
|
if(propType == ShaderUtil.ShaderPropertyType.Float || propType == ShaderUtil.ShaderPropertyType.Range)
|
|
{
|
|
if(!(!shouldSaveStencil && propName == "_StencilRef" && propName == "_StencilComp" && propName == "_StencilPass" && propName == "_StencilFail" && propName == "_StencilZFail"))
|
|
{
|
|
Array.Resize(ref preset.floats, preset.floats.Length + 1);
|
|
preset.floats[preset.floats.Length-1].name = propName;
|
|
preset.floats[preset.floats.Length-1].value = material.GetFloat(propName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CopyTexturesToPreset(Material material)
|
|
{
|
|
foreach(var name in shouldSaveTexs)
|
|
{
|
|
CopyTextureToPreset(material, name);
|
|
}
|
|
}
|
|
|
|
private void CopyTextureToPreset(Material material, string propName)
|
|
{
|
|
if(!material.HasProperty(propName)) return;
|
|
Array.Resize(ref preset.textures, preset.textures.Length + 1);
|
|
preset.textures[preset.textures.Length-1].name = propName;
|
|
preset.textures[preset.textures.Length-1].value = material.GetTexture(propName);
|
|
preset.textures[preset.textures.Length-1].offset = material.GetTextureOffset(propName);
|
|
preset.textures[preset.textures.Length-1].scale = material.GetTextureScale(propName);
|
|
}
|
|
|
|
private void ToggleAllFeatures(bool val)
|
|
{
|
|
shouldSaveBase = val;
|
|
shouldSaveLighting = val;
|
|
shouldSaveUV = val;
|
|
shouldSaveMain = val;
|
|
shouldSaveMain2nd = val;
|
|
shouldSaveMain3rd = val;
|
|
shouldSaveAlphaMask = val;
|
|
shouldSaveShadow = val;
|
|
shouldSaveEmission = val;
|
|
shouldSaveEmission2nd = val;
|
|
shouldSaveNormalMap = val;
|
|
shouldSaveNormalMap2nd = val;
|
|
shouldSaveAnisotropy = val;
|
|
shouldSaveRimShade = val;
|
|
shouldSaveBacklight = val;
|
|
shouldSaveReflection = val;
|
|
shouldSaveMatCap = val;
|
|
shouldSaveMatCap2nd = val;
|
|
shouldSaveRim = val;
|
|
shouldSaveGlitter = val;
|
|
shouldSaveParallax = val;
|
|
shouldSaveDistanceFade = val;
|
|
shouldSaveAudioLink = val;
|
|
shouldSaveDissolve = val;
|
|
shouldSaveRefraction = val;
|
|
shouldSaveGem = val;
|
|
shouldSaveTessellation = val;
|
|
shouldSaveOutline = val;
|
|
shouldSaveFur = val;
|
|
shouldSaveStencil = val;
|
|
shouldSaveRendering = val;
|
|
shouldSaveOutlineRendering = val;
|
|
shouldSaveFurRendering = val;
|
|
}
|
|
|
|
private void ToggleAllTextures(Material material, bool val)
|
|
{
|
|
int propCount = ShaderUtil.GetPropertyCount(material.shader);
|
|
for(int i = 0; i < propCount; i++)
|
|
{
|
|
var propType = ShaderUtil.GetPropertyType(material.shader, i);
|
|
if(propType != ShaderUtil.ShaderPropertyType.TexEnv) continue;
|
|
|
|
string propName = ShaderUtil.GetPropertyName(material.shader, i);
|
|
if(val && !shouldSaveTexs.Contains(propName)) shouldSaveTexs.Add(propName);
|
|
if(!val && shouldSaveTexs.Contains(propName)) shouldSaveTexs.Remove(propName);
|
|
}
|
|
}
|
|
|
|
[Obsolete] public static string GetLoc(string value) { return lilLanguageManager.GetLoc(value); }
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
namespace lilToon
|
|
{
|
|
public enum lilPresetCategory
|
|
{
|
|
Skin,
|
|
Hair,
|
|
Cloth,
|
|
Nature,
|
|
Inorganic,
|
|
Effect,
|
|
Other
|
|
}
|
|
}
|
|
#endif |