private static Texture2D GetCustomTexture(string name)
{
var uiName = name + (EditorGUIUtility.isProSkin ? "pro" : "");
if (CustomEditorTextures.ContainsKey(uiName))
{
return(CustomEditorTextures[uiName]);
}
var rootPath = TCP2_Utils.FindReadmePath(true);
Texture2D texture = null;
//load pro version
if (EditorGUIUtility.isProSkin)
{
texture = AssetDatabase.LoadAssetAtPath("Assets" + rootPath + "/Editor/Icons/" + name + "_Pro.png", typeof(Texture2D)) as Texture2D;
}
//load default version
if (texture == null)
{
texture = AssetDatabase.LoadAssetAtPath("Assets" + rootPath + "/Editor/Icons/" + name + ".png", typeof(Texture2D)) as Texture2D;
}
if (texture != null)
{
CustomEditorTextures.Add(uiName, texture);
return(texture);
}
return(null);
}
//Get a PackedFile from a system file path
static public PackedFile PackFile(string windowsPath)
{
if (!File.Exists(windowsPath))
{
EditorApplication.Beep();
Debug.LogError("[TCP2 PackFile] File doesn't exist:" + windowsPath);
return(null);
}
//Get properties
// Content
string content = File.ReadAllText(windowsPath, System.Text.Encoding.UTF8);
// File relative path
string tcpRoot = TCP2_Utils.FindReadmePath();
if (tcpRoot == null)
{
EditorApplication.Beep();
Debug.LogError("[TCP2 PackFile] Can't find TCP2 Readme file!\nCan't determine root folder to pack/unpack files.");
return(null);
}
tcpRoot = UnityToSystemPath(tcpRoot);
string relativePath = windowsPath.Replace(tcpRoot, "");
PackedFile pf = new PackedFile(relativePath, content);
return(pf);
}
static public string OpenFolderPanel_ProjectPath(string label)
{
string output = null;
string path = EditorUtility.OpenFolderPanel(label, Application.dataPath, "");
if (!string.IsNullOrEmpty(path))
{
bool validPath = TCP2_Utils.SystemToUnityPath(ref path);
if (validPath)
{
if (path == "Assets")
{
output = "/";
}
else
{
output = path.Substring("Assets/".Length);
}
}
else
{
EditorApplication.Beep();
EditorUtility.DisplayDialog("Invalid Path", "The selected path is invalid.\n\nPlease select a folder inside the \"Assets\" folder of your project!", "Ok");
}
}
return(output);
}
private TextAsset[] LoadAllTemplates()
{
var list = new List <TextAsset>();
var systemPath = Application.dataPath + @"/JMO Assets/Toony Colors Pro/Editor/Shader Templates/";
if (!Directory.Exists(systemPath))
{
var rootDir = TCP2_Utils.FindReadmePath();
systemPath = rootDir.Replace(@"\", "/") + "/Editor/Shader Templates/";
}
if (Directory.Exists(systemPath))
{
var txtFiles = Directory.GetFiles(systemPath, "*.txt", SearchOption.AllDirectories);
foreach (var sysPath in txtFiles)
{
var unityPath = sysPath;
if (TCP2_Utils.SystemToUnityPath(ref unityPath))
{
var textAsset = AssetDatabase.LoadAssetAtPath <TextAsset>(unityPath);
if (textAsset != null && !list.Contains(textAsset))
{
list.Add(textAsset);
}
}
}
list.Sort((x, y) => x.name.CompareTo(y.name));
return(list.ToArray());
}
return(null);
}
//Process #KEYWORDS section from Template
private static string ProcessKeywords(string line, TCP2_Config config, ref List <string> features, ref List <string> flags, ref Dictionary <string, string> keywords, ref int i, ref int depth, ref List <bool> stack, ref List <bool> done)
{
if (line.Contains("///"))
{
ProcessCondition(line, ref features, ref i, ref depth, ref stack, ref done);
}
//Regular line
else
{
if (string.IsNullOrEmpty(line))
{
return(null);
}
//Inside valid block
if ((depth >= 0 && stack[depth]) || depth < 0)
{
var parts = line.Split(new[] { "\t" }, StringSplitOptions.RemoveEmptyEntries);
switch (parts[0])
{
case "set":
if (keywords.ContainsKey(parts[1]))
{
keywords[parts[1]] = parts[2];
}
else
{
keywords.Add(parts[1], parts[2]);
}
break;
case "enable_kw": TCP2_Utils.AddIfMissing(features, parts[1]); break;
case "disable_kw": TCP2_Utils.RemoveIfExists(features, parts[1]); break;
case "enable_flag": TCP2_Utils.AddIfMissing(flags, parts[1]); break;
case "disable_flag": TCP2_Utils.RemoveIfExists(flags, parts[1]); break;
//Keywords that will also be modified in the Config
case "enable_kw_config":
TCP2_Utils.AddIfMissing(features, parts[1]);
TCP2_Utils.AddIfMissing(config.Features, parts[1]);
break;
case "disable_kw_config":
TCP2_Utils.RemoveIfExists(features, parts[1]);
TCP2_Utils.RemoveIfExists(config.Features, parts[1]);
break;
}
}
}
return(null);
}
private static void UnpackShaders(string filter)
{
const string packedShadersGuid = "552f9a41dd13c0c44a9bb1aad0ec3598";
var path = AssetDatabase.GUIDToAssetPath(packedShadersGuid);
if (string.IsNullOrEmpty(path))
{
EditorApplication.Beep();
Debug.LogError("[TCP2 Unpack Shaders] Couldn't find file: \"TCP2 Packed Shaders.tcp2data\"\nPlease reimport Toony Colors Pro 2.");
return;
}
var fullPath = Application.dataPath + path.Substring("Assets".Length);
if (File.Exists(fullPath))
{
var files = TCP2_Utils.ExtractArchive(fullPath, filter);
var @continue = 0;
if (files.Length > 8)
{
do
{
@continue = EditorUtility.DisplayDialogComplex("TCP2 : Unpack Shaders", "You are about to import " + files.Length + " shaders in Unity.\nIt could take a few minutes!\nContinue?", "Yes", "No", "Help");
if (@continue == 2)
{
TCP2_GUI.OpenHelpFor("Unpack Shaders");
}
}while(@continue == 2);
}
if (@continue == 0 && files.Length > 0)
{
var tcpRoot = TCP2_Utils.FindReadmePath();
foreach (var f in files)
{
var filePath = tcpRoot + f.path;
var fileDir = Path.GetDirectoryName(filePath);
if (!Directory.Exists(fileDir))
{
Directory.CreateDirectory(fileDir);
}
File.WriteAllText(filePath, f.content);
}
Debug.Log("Toony Colors Pro 2 - Unpack Shaders:\n" + files.Length + (files.Length > 1 ? " shaders extracted." : " shader extracted."));
AssetDatabase.Refresh();
}
if (files.Length == 0)
{
Debug.Log("Toony Colors Pro 2 - Unpack Shaders:\nNothing to unpack. Shaders are probably already unpacked!");
}
}
}
private static void UnpackShaders(string filter)
{
var archFiles = Directory.GetFiles(TCP2_Utils.UnityToSystemPath(Application.dataPath), "TCP2 Packed Shaders.tcp2data", SearchOption.AllDirectories);
if (archFiles == null || archFiles.Length == 0)
{
EditorApplication.Beep();
Debug.LogError("[TCP2 Unpack Shaders] Couldn't find file: \"TCP2 Packed Shaders.tcp2data\"\nPlease reimport Toony Colors Pro 2.");
return;
}
var archivePath = archFiles[0];
if (archivePath.EndsWith(".tcp2data"))
{
var files = TCP2_Utils.ExtractArchive(archivePath, filter);
var @continue = 0;
if (files.Length > 8)
{
do
{
@continue = EditorUtility.DisplayDialogComplex("TCP2 : Unpack Shaders", "You are about to import " + files.Length + " shaders in Unity.\nIt could take a few minutes!\nContinue?", "Yes", "No", "Help");
if (@continue == 2)
{
TCP2_GUI.OpenHelpFor("Unpack Shaders");
}
}while(@continue == 2);
}
if (@continue == 0 && files.Length > 0)
{
var tcpRoot = TCP2_Utils.FindReadmePath();
foreach (var f in files)
{
var filePath = tcpRoot + f.path;
var fileDir = Path.GetDirectoryName(filePath);
if (!Directory.Exists(fileDir))
{
Directory.CreateDirectory(fileDir);
}
File.WriteAllText(filePath, f.content);
}
Debug.Log("Toony Colors Pro 2 - Unpack Shaders:\n" + files.Length + (files.Length > 1 ? " shaders extracted." : " shader extracted."));
AssetDatabase.Refresh();
}
if (files.Length == 0)
{
Debug.Log("Toony Colors Pro 2 - Unpack Shaders:\nNothing to unpack. Shaders are probably already unpacked!");
}
}
}
Texture2D TryFindDefaultRampTexture()
{
string rootPath = TCP2_Utils.FindReadmePath(true);
if (!string.IsNullOrEmpty(rootPath))
{
string defaultTexPath = "Assets" + rootPath + "/Textures/TCP2_Ramp_3Levels.png";
return(AssetDatabase.LoadAssetAtPath <Texture2D>(defaultTexPath));
}
return(null);
}
static public Texture2D GetHelpBoxIcon(MessageType msgType)
{
string iconName = null;
switch (msgType)
{
case MessageType.Error:
if (errorIconCached != null)
{
return(errorIconCached);
}
iconName = "TCP2_ErrorIcon";
break;
case MessageType.Warning:
if (warningIconCached != null)
{
return(warningIconCached);
}
iconName = "TCP2_WarningIcon";
break;
case MessageType.Info:
if (infoIconCached != null)
{
return(infoIconCached);
}
iconName = "TCP2_InfoIcon";
break;
}
if (string.IsNullOrEmpty(iconName))
{
return(null);
}
string rootPath = TCP2_Utils.FindReadmePath(true);
Texture2D icon = AssetDatabase.LoadAssetAtPath("Assets" + rootPath + "/Editor/Icons/" + iconName + ".png", typeof(Texture2D)) as Texture2D;
switch (msgType)
{
case MessageType.Error: errorIconCached = icon; break;
case MessageType.Warning: warningIconCached = icon; break;
case MessageType.Info: infoIconCached = icon; break;
}
return(icon);
}
static public void OpenHelp()
{
string rootDir = TCP2_Utils.FindReadmePath();
if (rootDir == null)
{
EditorUtility.DisplayDialog("TCP2 Documentation", "Couldn't find TCP2 root folder! (the readme file is missing)\nYou can still access the documentation manually in the Documentation folder.", "Ok");
}
else
{
string helpLink = "file:///" + rootDir.Replace(@"\", "/") + "/Documentation/TCP2 Documentation.html";
Application.OpenURL(helpLink);
}
}
static public void OpenHelpFor(string helpTopic)
{
string rootDir = TCP2_Utils.FindReadmePath();
if (rootDir == null)
{
EditorUtility.DisplayDialog("TCP2 Documentation", "Couldn't find TCP2 root folder! (the readme file is missing)\nYou can still access the documentation manually in the Documentation folder.", "Ok");
}
else
{
string helpAnchor = helpTopic.Replace("/", "_").Replace(@"\", "_").Replace(" ", "_").ToLowerInvariant() + ".htm";
string topicLink = "file:///" + rootDir.Replace(@"\", "/") + "/Documentation/Documentation Data/Anchors/" + helpAnchor;
Application.OpenURL(topicLink);
}
}
//Process #KEYWORDS section from Template
static private string ProcessKeywords(string line, ref List <string> features, ref List <string> flags, ref Dictionary <string, string> keywords, ref int i, ref int depth, ref List <bool> stack, ref List <bool> done, bool useNewEvaluationSystem)
{
if (line.Contains("///"))
{
ProcessCondition(line, ref features, ref i, ref depth, ref stack, ref done, useNewEvaluationSystem);
}
//Regular line
else
{
if (string.IsNullOrEmpty(line))
{
return(null);
}
//Inside valid block
if ((depth >= 0 && stack[depth]) || depth < 0)
{
string[] parts = line.Split(new string[] { "\t" }, System.StringSplitOptions.RemoveEmptyEntries);
switch (parts[0])
{
case "set":
if (keywords.ContainsKey(parts[1]))
{
keywords[parts[1]] = parts[2];
}
else
{
keywords.Add(parts[1], parts[2]);
}
break;
case "enable_kw": TCP2_Utils.AddIfMissing(features, parts[1]); break;
case "disable_kw": TCP2_Utils.RemoveIfExists(features, parts[1]); break;
case "enable_flag": TCP2_Utils.AddIfMissing(flags, parts[1]); break;
case "disable_flag": TCP2_Utils.RemoveIfExists(flags, parts[1]); break;
}
}
}
return(null);
}
public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] properties)
{
mMaterialEditor = materialEditor;
#if SHOW_DEFAULT_INSPECTOR
base.OnGUI();
return;
#else
if (mJustChangedShader)
{
mJustChangedShader = false;
mVariantError = null;
Event.current.Use(); //Avoid layout mismatch error
SceneView.RepaintAll();
}
UpdateFeaturesFromShader();
//Get material keywords
List <string> keywordsList = new List <string>(targetMaterial.shaderKeywords);
bool updateKeywords = false;
bool updateVariant = false;
//Header
EditorGUILayout.BeginHorizontal();
TCP2_GUI.HeaderBig("TOONY COLORS PRO 2 - INSPECTOR");
if (isGeneratedShader && TCP2_GUI.Button(TCP2_GUI.CogIcon, "O", "Open in Shader Generator"))
{
if (targetMaterial.shader != null)
{
TCP2_ShaderGenerator.OpenWithShader(targetMaterial.shader);
}
}
TCP2_GUI.HelpButton("Unified Shader");
EditorGUILayout.EndHorizontal();
TCP2_GUI.Separator();
if (!string.IsNullOrEmpty(mVariantError))
{
EditorGUILayout.HelpBox(mVariantError, MessageType.Error);
EditorGUILayout.HelpBox("Some of the shaders are packed to avoid super long loading times when you import Toony Colors Pro 2 into Unity.\n\n" +
"You can unpack them by category in the menu:\n\"Tools > Toony Colors Pro 2 > Unpack Shaders > ...\"",
MessageType.Info);
}
//Iterate Shader properties
materialEditor.serializedObject.Update();
SerializedProperty mShader = materialEditor.serializedObject.FindProperty("m_Shader");
if (materialEditor.isVisible && !mShader.hasMultipleDifferentValues && mShader.objectReferenceValue != null)
{
//Retina display fix
EditorGUIUtility.labelWidth = TCP2_Utils.ScreenWidthRetina - 120f;
EditorGUIUtility.fieldWidth = 64f;
EditorGUI.BeginChangeCheck();
MaterialProperty[] props = properties;
//UNFILTERED PARAMETERS ==============================================================
TCP2_GUI.HeaderAndHelp("BASE", "Base Properties");
if (ShowFilteredProperties(null, props))
{
if (!isGeneratedShader)
{
TCP2_Utils.ShaderKeywordToggle("TCP2_DISABLE_WRAPPED_LIGHT", "Disable Wrapped Lighting", "Disable wrapped lighting, reducing intensity received from lights", keywordsList, ref updateKeywords, "Disable Wrapped Lighting");
}
TCP2_GUI.Separator();
}
//FILTERED PARAMETERS ================================================================
//RAMP TYPE --------------------------------------------------------------------------
if (CategoryFilter("TEXTURE_RAMP"))
{
if (isGeneratedShader)
{
ShowFilteredProperties("#RAMPT#", props);
}
else
{
if (TCP2_Utils.ShaderKeywordToggle("TCP2_RAMPTEXT", "Texture Toon Ramp", "Make the toon ramp based on a texture", keywordsList, ref updateKeywords, "Ramp Style"))
{
ShowFilteredProperties("#RAMPT#", props);
}
else
{
ShowFilteredProperties("#RAMPF#", props);
}
}
}
else
{
ShowFilteredProperties("#RAMPF#", props);
}
TCP2_GUI.Separator();
//BUMP/NORMAL MAPPING ----------------------------------------------------------------
if (CategoryFilter("BUMP"))
{
if (isGeneratedShader)
{
TCP2_GUI.HeaderAndHelp("BUMP/NORMAL MAPPING", "Normal/Bump map");
ShowFilteredProperties("#NORM#", props);
ShowFilteredProperties("#PLLX#", props);
}
else
{
if (TCP2_Utils.ShaderKeywordToggle("TCP2_BUMP", "BUMP/NORMAL MAPPING", "Enable bump mapping using normal maps", keywordsList, ref updateKeywords, "Normal/Bump map"))
{
ShowFilteredProperties("#NORM#", props);
}
}
TCP2_GUI.Separator();
}
//SPECULAR ---------------------------------------------------------------------------
if (CategoryFilter("SPECULAR", "SPECULAR_ANISOTROPIC"))
{
if (isGeneratedShader)
{
TCP2_GUI.HeaderAndHelp("SPECULAR", "Specular");
ShowFilteredProperties("#SPEC#", props);
if (HasFlags("SPECULAR_ANISOTROPIC"))
{
ShowFilteredProperties("#SPECA#", props);
}
if (HasFlags("SPECULAR_TOON"))
{
ShowFilteredProperties("#SPECT#", props);
}
}
else
{
bool specular = TCP2_Utils.HasKeywords(keywordsList, "TCP2_SPEC", "TCP2_SPEC_TOON");
TCP2_Utils.ShaderVariantUpdate("Specular", ShaderVariants, ShaderVariantsEnabled, specular, ref updateVariant);
specular |= TCP2_Utils.ShaderKeywordRadio("SPECULAR", new string[] { "TCP2_SPEC_OFF", "TCP2_SPEC", "TCP2_SPEC_TOON" }, new GUIContent[]
{
new GUIContent("Off", "No Specular"),
new GUIContent("Regular", "Default Blinn-Phong Specular"),
new GUIContent("Cartoon", "Specular with smoothness control")
},
keywordsList, ref updateKeywords);
if (specular)
{
ShowFilteredProperties("#SPEC#", props);
bool specr = TCP2_Utils.HasKeywords(keywordsList, "TCP2_SPEC_TOON");
if (specr)
{
ShowFilteredProperties("#SPECT#", props);
}
}
}
TCP2_GUI.Separator();
}
//REFLECTION -------------------------------------------------------------------------
if (CategoryFilter("REFLECTION") && !isMobileShader)
{
if (isGeneratedShader)
{
TCP2_GUI.HeaderAndHelp("REFLECTION", "Reflection");
ShowFilteredProperties("#REFL#", props);
#if UNITY_5
if (HasFlags("U5_REFLPROBE"))
{
ShowFilteredProperties("#REFL_U5#", props);
}
#endif
if (HasFlags("REFL_COLOR"))
{
ShowFilteredProperties("#REFLC#", props);
}
if (HasFlags("REFL_ROUGH"))
{
ShowFilteredProperties("#REFLR#", props);
EditorGUILayout.HelpBox("Cubemap Texture needs to have MipMaps enabled for Roughness to work!", MessageType.Info);
}
}
else
{
bool reflection = TCP2_Utils.HasKeywords(keywordsList, "TCP2_REFLECTION", "TCP2_REFLECTION_MASKED");
TCP2_Utils.ShaderVariantUpdate("Reflection", ShaderVariants, ShaderVariantsEnabled, reflection, ref updateVariant);
reflection |= TCP2_Utils.ShaderKeywordRadio("REFLECTION", new string[] { "TCP2_REFLECTION_OFF", "TCP2_REFLECTION", "TCP2_REFLECTION_MASKED" }, new GUIContent[]
{
new GUIContent("Off", "No Cubemap Reflection"),
new GUIContent("Global", "Global Cubemap Reflection"),
new GUIContent("Masked", "Masked Cubemap Reflection (using the main texture's alpha channel)")
},
keywordsList, ref updateKeywords);
if (reflection)
{
#if UNITY_5
//Reflection Probes toggle
if (TCP2_Utils.ShaderKeywordToggle("TCP2_U5_REFLPROBE", "Use Reflection Probes", "Use Unity 5's Reflection Probes", keywordsList, ref updateKeywords))
{
ShowFilteredProperties("#REFL_U5#", props);
}
#endif
ShowFilteredProperties("#REFL#", props);
}
}
TCP2_GUI.Separator();
}
//MATCAP -----------------------------------------------------------------------------
if (CategoryFilter("MATCAP"))
{
if (isGeneratedShader)
{
TCP2_GUI.Header("MATCAP");
ShowFilteredProperties("#MC#", props);
TCP2_GUI.Separator();
}
else if (isMobileShader)
{
bool matcap = TCP2_Utils.HasKeywords(keywordsList, "TCP2_MC", "TCP2_MCMASK");
TCP2_Utils.ShaderVariantUpdate("Matcap", ShaderVariants, ShaderVariantsEnabled, matcap, ref updateVariant);
matcap |= TCP2_Utils.ShaderKeywordRadio("MATCAP", new string[] { "TCP2_MC_OFF", "TCP2_MC", "TCP2_MCMASK" }, new GUIContent[]
{
new GUIContent("Off", "No MatCap reflection"),
new GUIContent("Global", "Global additive MatCap"),
new GUIContent("Masked", "Masked additive MatCap (using the main texture's alpha channel)")
},
keywordsList, ref updateKeywords);
if (matcap)
{
ShowFilteredProperties("#MC#", props);
}
TCP2_GUI.Separator();
}
}
//SUBSURFACE SCATTERING --------------------------------------------------------------------------------
if (CategoryFilter("SUBSURFACE_SCATTERING") && isGeneratedShader)
{
TCP2_GUI.HeaderAndHelp("SUBSURFACE SCATTERING", "Subsurface Scattering");
ShowFilteredProperties("#SUBS#", props);
TCP2_GUI.Separator();
}
//RIM --------------------------------------------------------------------------------
if (CategoryFilter("RIM", "RIM_OUTLINE"))
{
if (isGeneratedShader)
{
TCP2_GUI.HeaderAndHelp("RIM", "Rim");
ShowFilteredProperties("#RIM#", props);
if (HasFlags("RIMDIR"))
{
ShowFilteredProperties("#RIMDIR#", props);
if (HasFlags("PARALLAX"))
{
EditorGUILayout.HelpBox("Because it affects the view direction vector, Rim Direction may distort Parallax effect.", MessageType.Warning);
}
}
}
else
{
bool rim = TCP2_Utils.HasKeywords(keywordsList, "TCP2_RIM");
bool rimOutline = TCP2_Utils.HasKeywords(keywordsList, "TCP2_RIMO");
TCP2_Utils.ShaderVariantUpdate("Rim", ShaderVariants, ShaderVariantsEnabled, rim, ref updateVariant);
TCP2_Utils.ShaderVariantUpdate("RimOutline", ShaderVariants, ShaderVariantsEnabled, rimOutline, ref updateVariant);
rim |= rimOutline |= TCP2_Utils.ShaderKeywordRadio("RIM", new string[] { "TCP2_RIM_OFF", "TCP2_RIM", "TCP2_RIMO" }, new GUIContent[]
{
new GUIContent("Off", "No Rim effect"),
new GUIContent("Lighting", "Rim lighting (additive)"),
new GUIContent("Outline", "Rim outline (blended)")
},
keywordsList, ref updateKeywords);
if (rim || rimOutline)
{
ShowFilteredProperties("#RIM#", props);
if (CategoryFilter("RIMDIR"))
{
if (TCP2_Utils.ShaderKeywordToggle("TCP2_RIMDIR", "Directional Rim", "Enable directional rim control (rim calculation is approximated if enabled)", keywordsList, ref updateKeywords))
{
ShowFilteredProperties("#RIMDIR#", props);
}
}
}
}
TCP2_GUI.Separator();
}
//CUBEMAP AMBIENT --------------------------------------------------------------------
if (CategoryFilter("CUBE_AMBIENT") && isGeneratedShader)
{
TCP2_GUI.HeaderAndHelp("CUBEMAP AMBIENT", "Cubemap Ambient");
ShowFilteredProperties("#CUBEAMB#", props);
TCP2_GUI.Separator();
}
//DIRECTIONAL AMBIENT --------------------------------------------------------------------
if (CategoryFilter("DIRAMBIENT") && isGeneratedShader)
{
TCP2_GUI.HeaderAndHelp("DIRECTIONAL AMBIENT", "Directional Ambient");
DirectionalAmbientGUI("#DAMB#", props);
TCP2_GUI.Separator();
}
//SKETCH --------------------------------------------------------------------------------
if (CategoryFilter("SKETCH", "SKETCH_GRADIENT") && isGeneratedShader)
{
TCP2_GUI.HeaderAndHelp("SKETCH", "Sketch");
bool sketch = HasFlags("SKETCH");
bool sketchG = HasFlags("SKETCH_GRADIENT");
if (sketch || sketchG)
{
ShowFilteredProperties("#SKETCH#", props);
}
if (sketchG)
{
ShowFilteredProperties("#SKETCHG#", props);
}
TCP2_GUI.Separator();
}
//OUTLINE --------------------------------------------------------------------------------
if (CategoryFilter("OUTLINE", "OUTLINE_BLENDING"))
{
bool hasOutlineOpaque = false;
bool hasOutlineBlending = false;
bool hasOutline = false;
if (isGeneratedShader)
{
TCP2_GUI.HeaderAndHelp("OUTLINE", "Outline");
hasOutlineOpaque = HasFlags("OUTLINE");
hasOutlineBlending = HasFlags("OUTLINE_BLENDING");
hasOutline = hasOutlineOpaque || hasOutlineBlending;
}
else
{
hasOutlineOpaque = TCP2_Utils.HasKeywords(keywordsList, "OUTLINES");
hasOutlineBlending = TCP2_Utils.HasKeywords(keywordsList, "OUTLINE_BLENDING");
hasOutline = hasOutlineOpaque || hasOutlineBlending;
TCP2_Utils.ShaderVariantUpdate("Outline", ShaderVariants, ShaderVariantsEnabled, hasOutlineOpaque, ref updateVariant);
TCP2_Utils.ShaderVariantUpdate("OutlineBlending", ShaderVariants, ShaderVariantsEnabled, hasOutlineBlending, ref updateVariant);
hasOutline |= TCP2_Utils.ShaderKeywordRadio("OUTLINE", new string[] { "OUTLINE_OFF", "OUTLINES", "OUTLINE_BLENDING" }, new GUIContent[]
{
new GUIContent("Off", "No Outline"),
new GUIContent("Opaque", "Opaque Outline"),
new GUIContent("Blended", "Allows transparent Outline and other effects")
},
keywordsList, ref updateKeywords);
}
if (hasOutline)
{
EditorGUI.indentLevel++;
//Outline Type ---------------------------------------------------------------------------
ShowFilteredProperties("#OUTLINE#", props, false);
if (!isMobileShader && !HasFlags("FORCE_SM2"))
{
bool outlineTextured = TCP2_Utils.ShaderKeywordToggle("TCP2_OUTLINE_TEXTURED", "Outline Color from Texture", "If enabled, outline will take an averaged color from the main texture multiplied by Outline Color", keywordsList, ref updateKeywords);
if (outlineTextured)
{
ShowFilteredProperties("#OUTLINETEX#", props);
}
}
TCP2_Utils.ShaderKeywordToggle("TCP2_OUTLINE_CONST_SIZE", "Constant Size Outline", "If enabled, outline will have a constant size independently from camera distance", keywordsList, ref updateKeywords);
if (TCP2_Utils.ShaderKeywordToggle("TCP2_ZSMOOTH_ON", "Correct Z Artefacts", "Enable the outline z-correction to try to hide artefacts from complex models", keywordsList, ref updateKeywords))
{
ShowFilteredProperties("#OUTLINEZ#", props);
}
//Smoothed Normals -----------------------------------------------------------------------
EditorGUI.indentLevel--;
TCP2_GUI.Header("OUTLINE NORMALS", "Defines where to take the vertex normals from to draw the outline.\nChange this when using a smoothed mesh to fill the gaps shown in hard-edged meshes.");
EditorGUI.indentLevel++;
TCP2_Utils.ShaderKeywordRadio(null, new string[] { "TCP2_NONE", "TCP2_COLORS_AS_NORMALS", "TCP2_TANGENT_AS_NORMALS", "TCP2_UV2_AS_NORMALS" }, new GUIContent[]
{
new GUIContent("Regular", "Use regular vertex normals"),
new GUIContent("Vertex Colors", "Use vertex colors as normals (with smoothed mesh)"),
new GUIContent("Tangents", "Use tangents as normals (with smoothed mesh)"),
new GUIContent("UV2", "Use second texture coordinates as normals (with smoothed mesh)"),
},
keywordsList, ref updateKeywords);
EditorGUI.indentLevel--;
//Outline Blending -----------------------------------------------------------------------
if (hasOutlineBlending)
{
MaterialProperty[] blendProps = GetFilteredProperties("#BLEND#", props);
if (blendProps.Length != 2)
{
EditorGUILayout.HelpBox("Couldn't find Blending properties!", MessageType.Error);
}
else
{
TCP2_GUI.Header("OUTLINE BLENDING", "BLENDING EXAMPLES:\nAlpha Transparency: SrcAlpha / OneMinusSrcAlpha\nMultiply: DstColor / Zero\nAdd: One / One\nSoft Add: OneMinusDstColor / One");
UnityEngine.Rendering.BlendMode blendSrc = (UnityEngine.Rendering.BlendMode)blendProps[0].floatValue;
UnityEngine.Rendering.BlendMode blendDst = (UnityEngine.Rendering.BlendMode)blendProps[1].floatValue;
EditorGUI.BeginChangeCheck();
float f = EditorGUIUtility.fieldWidth;
float l = EditorGUIUtility.labelWidth;
EditorGUIUtility.fieldWidth = 110f;
EditorGUIUtility.labelWidth -= Mathf.Abs(f - EditorGUIUtility.fieldWidth);
blendSrc = (UnityEngine.Rendering.BlendMode)EditorGUILayout.EnumPopup("Source Factor", blendSrc);
blendDst = (UnityEngine.Rendering.BlendMode)EditorGUILayout.EnumPopup("Destination Factor", blendDst);
EditorGUIUtility.fieldWidth = f;
EditorGUIUtility.labelWidth = l;
if (EditorGUI.EndChangeCheck())
{
blendProps[0].floatValue = (float)blendSrc;
blendProps[1].floatValue = (float)blendDst;
}
}
}
}
TCP2_GUI.Separator();
}
//LIGHTMAP --------------------------------------------------------------------------------
#if UNITY_4_5
if (CategoryFilter("LIGHTMAP") && !isGeneratedShader)
{
TCP2_Utils.ShaderKeywordRadio("LIGHTMAP", new string[] { "TCP2_LIGHTMAP_OFF", "TCP2_LIGHTMAP" }, new GUIContent[] {
new GUIContent("Unity", "Use Unity's built-in lightmap decoding"),
new GUIContent("Toony Colors Pro 2", "Use TCP2's lightmap decoding (lightmaps will be affected by ramp and color settings)")
}, keywordsList, ref updateKeywords);
}
#endif
//TRANSPARENCY --------------------------------------------------------------------------------
if (CategoryFilter("ALPHA", "CUTOUT") && isGeneratedShader)
{
bool alpha = false;
bool cutout = false;
if (isGeneratedShader)
{
TCP2_GUI.Header("TRANSPARENCY");
alpha = HasFlags("ALPHA");
cutout = HasFlags("CUTOUT");
}
if (alpha)
{
MaterialProperty[] blendProps = GetFilteredProperties("#ALPHA#", props);
if (blendProps.Length != 2)
{
EditorGUILayout.HelpBox("Couldn't find Blending properties!", MessageType.Error);
}
else
{
TCP2_GUI.Header("BLENDING", "BLENDING EXAMPLES:\nAlpha Transparency: SrcAlpha / OneMinusSrcAlpha\nMultiply: DstColor / Zero\nAdd: One / One\nSoft Add: OneMinusDstColor / One");
UnityEngine.Rendering.BlendMode blendSrc = (UnityEngine.Rendering.BlendMode)blendProps[0].floatValue;
UnityEngine.Rendering.BlendMode blendDst = (UnityEngine.Rendering.BlendMode)blendProps[1].floatValue;
EditorGUI.BeginChangeCheck();
float f = EditorGUIUtility.fieldWidth;
float l = EditorGUIUtility.labelWidth;
EditorGUIUtility.fieldWidth = 110f;
EditorGUIUtility.labelWidth -= Mathf.Abs(f - EditorGUIUtility.fieldWidth);
blendSrc = (UnityEngine.Rendering.BlendMode)EditorGUILayout.EnumPopup("Source Factor", blendSrc);
blendDst = (UnityEngine.Rendering.BlendMode)EditorGUILayout.EnumPopup("Destination Factor", blendDst);
EditorGUIUtility.fieldWidth = f;
EditorGUIUtility.labelWidth = l;
if (EditorGUI.EndChangeCheck())
{
blendProps[0].floatValue = (float)blendSrc;
blendProps[1].floatValue = (float)blendDst;
}
}
}
if (cutout)
{
ShowFilteredProperties("#CUTOUT#", props);
}
}
#if DEBUG_INFO
//--------------------------------------------------------------------------------------
//DEBUG --------------------------------------------------------------------------------
TCP2_GUI.SeparatorBig();
TCP2_GUI.Header("DEBUG");
//Clear Keywords
if (GUILayout.Button("Clear Keywords", EditorStyles.miniButton))
{
keywordsList.Clear();
updateKeywords = true;
}
//Shader Flags
GUILayout.Label("Features", EditorStyles.boldLabel);
string features = "";
if (mShaderFeatures != null)
{
foreach (string flag in mShaderFeatures)
{
features += flag + ", ";
}
}
if (features.Length > 0)
{
features = features.Substring(0, features.Length - 2);
}
GUILayout.Label(features, EditorStyles.wordWrappedMiniLabel);
//Shader Keywords
GUILayout.Label("Keywords", EditorStyles.boldLabel);
string keywords = "";
foreach (string keyword in keywordsList)
{
keywords += keyword + ", ";
}
if (keywords.Length > 0)
{
keywords = keywords.Substring(0, keywords.Length - 2);
}
GUILayout.Label(keywords, EditorStyles.wordWrappedMiniLabel);
#endif
//--------------------------------------------------------------------------------------
if (EditorGUI.EndChangeCheck())
{
materialEditor.PropertiesChanged();
}
}
//Update Keywords
if (updateKeywords)
{
if (materialEditor.targets != null && materialEditor.targets.Length > 0)
{
foreach (Object t in materialEditor.targets)
{
(t as Material).shaderKeywords = keywordsList.ToArray();
EditorUtility.SetDirty(t);
}
}
else
{
targetMaterial.shaderKeywords = keywordsList.ToArray();
EditorUtility.SetDirty(targetMaterial);
}
}
//Update Variant
if (updateVariant && !isGeneratedShader)
{
string baseName = isMobileShader ? BASE_SHADER_NAME_MOB : BASE_SHADER_NAME;
string newShader = baseName;
for (int i = 0; i < ShaderVariants.Count; i++)
{
if (ShaderVariantsEnabled[i])
{
newShader += " " + ShaderVariants[i];
}
}
newShader = newShader.TrimEnd();
//If variant shader
string basePath = BASE_SHADER_PATH;
if (newShader != baseName)
{
basePath = VARIANT_SHADER_PATH;
}
Shader shader = Shader.Find(basePath + newShader);
if (shader != null)
{
materialEditor.SetShader(shader, false);
mJustChangedShader = true;
}
else
{
if (Event.current.type != EventType.Layout)
{
mVariantError = "Can't find shader variant:\n" + basePath + newShader;
}
materialEditor.Repaint();
}
}
else if (!string.IsNullOrEmpty(mVariantError) && Event.current.type != EventType.Layout)
{
mVariantError = null;
materialEditor.Repaint();
}
#endif
#if UNITY_5_5_OR_NEWER
materialEditor.RenderQueueField();
#endif
}
//Generate the source code for the shader as a string
private static string GenerateShaderSource(this TCP2_Config config, TCP2_ShaderGenerator.ShaderGeneratorTemplate template, Shader existingShader = null)
{
if (config == null)
{
var error = "[TCP2 Shader Generator] Config file is null";
Debug.LogError(error);
return(error);
}
if (template == null)
{
var error = "[TCP2 Shader Generator] Template is null";
Debug.LogError(error);
return(error);
}
if (template.textAsset == null || string.IsNullOrEmpty(template.textAsset.text))
{
var error = "[TCP2 Shader Generator] Template string is null or empty";
Debug.LogError(error);
return(error);
}
//------------------------------------------------
// SHADER PARAMETERS
//Masks
bool mask1 = false, mask2 = false, mask3 = false, vcolors_mask = false, mainTex_mask = false;
var mask1features = "";
var mask2features = "";
var mask3features = "";
//Enable Masks according to their dependencies (new system using Template)
foreach (var kvp in config.Keywords)
{
if (kvp.Value == "mask1")
{
var maskEnabled = template.GetMaskDependency(kvp.Key, config);
mask1 |= maskEnabled;
if (maskEnabled)
{
mask1features += template.GetMaskDisplayName(kvp.Key) + ",";
}
}
else if (kvp.Value == "mask2")
{
var maskEnabled = template.GetMaskDependency(kvp.Key, config);
mask2 |= maskEnabled;
if (maskEnabled)
{
mask2features += template.GetMaskDisplayName(kvp.Key) + ",";
}
}
else if (kvp.Value == "mask3")
{
var maskEnabled = template.GetMaskDependency(kvp.Key, config);
mask3 |= maskEnabled;
if (maskEnabled)
{
mask3features += template.GetMaskDisplayName(kvp.Key) + ",";
}
}
else if (kvp.Value == "IN.color" || kvp.Value == "vcolors")
{
vcolors_mask |= template.GetMaskDependency(kvp.Key, config);
}
else if (kvp.Value == "mainTex")
{
mainTex_mask |= template.GetMaskDependency(kvp.Key, config);
}
}
//Only enable Independent UVs if relevant Mask is actually enabled
foreach (var kvp in config.Keywords)
{
if (kvp.Key == "UV_mask1")
{
config.ToggleFeature("UVMASK1", (kvp.Value == "Independent UV" || kvp.Value == "Independent UV0") && mask1);
config.ToggleFeature("UVMASK1_UV2", kvp.Value == "Independent UV1" && mask1);
}
else if (kvp.Key == "UV_mask2")
{
config.ToggleFeature("UVMASK2", (kvp.Value == "Independent UV" || kvp.Value == "Independent UV0") && mask2);
config.ToggleFeature("UVMASK2_UV2", kvp.Value == "Independent UV1" && mask2);
}
else if (kvp.Key == "UV_mask3")
{
config.ToggleFeature("UVMASK3", (kvp.Value == "Independent UV" || kvp.Value == "Independent UV0") && mask3);
config.ToggleFeature("UVMASK3_UV2", kvp.Value == "Independent UV1" && mask3);
}
}
mask1features = mask1features.TrimEnd(',');
mask2features = mask2features.TrimEnd(',');
mask3features = mask3features.TrimEnd(',');
config.ToggleFeature("MASK1", mask1);
config.ToggleFeature("MASK2", mask2);
config.ToggleFeature("MASK3", mask3);
config.ToggleFeature("VCOLORS_MASK", vcolors_mask);
config.ToggleFeature("MASK_MAINTEX", mainTex_mask);
//---
var keywords = new Dictionary <string, string>(config.Keywords);
var flags = new List <string>(config.Flags);
var features = new List <string>(config.Features);
//Unity version
#if UNITY_5_4_OR_NEWER
TCP2_Utils.AddIfMissing(features, "UNITY_5_4");
#endif
#if UNITY_5_5_OR_NEWER
TCP2_Utils.AddIfMissing(features, "UNITY_5_5");
#endif
#if UNITY_2017_1_OR_NEWER
TCP2_Utils.AddIfMissing(features, "UNITY_2017_1");
#endif
#if UNITY_2018_1_OR_NEWER
TCP2_Utils.AddIfMissing(features, "UNITY_2018_1");
#endif
#if UNITY_2018_2_OR_NEWER
TCP2_Utils.AddIfMissing(features, "UNITY_2018_2");
#endif
//Masks
keywords.Add("MASK1", mask1features);
keywords.Add("MASK2", mask2features);
keywords.Add("MASK3", mask3features);
//Shader name
keywords.Add("SHADER_NAME", config.ShaderName);
//Include path
var include = GetIncludePrefix(config) + GetIncludeRelativePath(config, existingShader).TrimEnd('/');
keywords.Add("INCLUDE_PATH", include);
//Shader Model target (old templates)
if (!keywords.ContainsKey("SHADER_TARGET"))
{
var target = GetShaderTarget(config);
keywords.Add("SHADER_TARGET", target);
if (config.shaderTarget == 20)
{
TCP2_Utils.AddIfMissing(features, "FORCE_SM2");
}
}
//Generate Surface parameters
var strFlags = ArrayToString(flags.ToArray(), " ");
keywords.Add("SURF_PARAMS", strFlags);
//------------------------------------------------
// PARSING & GENERATION
var sb = new StringBuilder();
var templateLines = template.textAsset.text.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None);
var depth = -1;
var stack = new List <bool>();
var done = new List <bool>();
//Parse template file
string line = null;
for (var i = 0; i < templateLines.Length; i++)
{
line = templateLines[i];
//Comment
if (line.StartsWith("#"))
{
//Meta
if (line.StartsWith("#CONFIG="))
{
config.configType = line.Substring(8).TrimEnd().ToLower();
}
//Features UI
if (line.StartsWith("#FEATURES"))
{
while (i < templateLines.Length)
{
i++;
if (templateLines[i] == "#END")
{
break;
}
}
continue;
}
//Keywords
if (line.StartsWith("#KEYWORDS"))
{
while (i < templateLines.Length)
{
i++;
if (templateLines[i] == "#END")
{
break;
}
var error = ProcessKeywords(templateLines[i], config, ref features, ref flags, ref keywords, ref i, ref depth, ref stack, ref done);
if (!string.IsNullOrEmpty(error))
{
return(error);
}
}
//Update Surface parameters
strFlags = ArrayToString(flags.ToArray(), " ");
if (keywords.ContainsKey("SURF_PARAMS"))
{
keywords["SURF_PARAMS"] = strFlags;
}
else
{
keywords.Add("SURF_PARAMS", strFlags);
}
}
//Debugging
if (line.StartsWith("#break"))
{
Debug.Log("[TCP2] Parse Break @ " + i);
}
continue;
}
//Line break
if (string.IsNullOrEmpty(line) && ((depth >= 0 && stack[depth]) || depth < 0))
{
sb.AppendLine(line);
continue;
}
//Conditions
if (line.Contains("///"))
{
var error = ProcessCondition(line, ref features, ref i, ref depth, ref stack, ref done);
if (!string.IsNullOrEmpty(error))
{
return(error);
}
}
//Regular line
else
{
//Replace keywords
line = ReplaceKeywords(line, keywords);
//Append line if inside valid condition block
if ((depth >= 0 && stack[depth]) || depth < 0)
{
sb.AppendLine(line);
}
}
}
if (depth >= 0)
{
Debug.LogWarning("[TCP2 Shader Generator] Missing " + (depth + 1) + " ending '///' tags");
}
var sourceCode = sb.ToString();
//Normalize line endings
sourceCode = sourceCode.Replace("\r\n", "\n");
return(sourceCode);
}
//--------------------------------------------------------------------------------------------------
private Mesh CreateSmoothedMeshAsset(SelectedMesh originalMesh)
{
//Check if we are ok to overwrite
bool overwrite = true;
string rootPath = TCP2_Utils.FindReadmePath() + OUTPUT_FOLDER;
if (!System.IO.Directory.Exists(rootPath))
{
System.IO.Directory.CreateDirectory(rootPath);
}
#if UNITY_EDITOR_WIN
rootPath = rootPath.Replace(TCP2_Utils.UnityToSystemPath(Application.dataPath), "").Replace(@"\", "/");
#else
rootPath = rootPath.Replace(Application.dataPath, "");
#endif
string assetPath = "Assets" + rootPath;
string newAssetName = originalMesh.name + " " + MESH_SUFFIX + ".asset";
if (originalMesh.name.Contains(MESH_SUFFIX))
{
newAssetName = originalMesh.name + ".asset";
}
assetPath += newAssetName;
Mesh existingAsset = AssetDatabase.LoadAssetAtPath(assetPath, typeof(Mesh)) as Mesh;
bool assetExists = (existingAsset != null) && originalMesh.isAsset;
if (assetExists)
{
if (!mAlwaysOverwrite)
{
overwrite = EditorUtility.DisplayDialog("TCP2 : Smoothed Mesh", "The following smoothed mesh already exists:\n\n" + newAssetName + "\n\nOverwrite?", "Yes", "No");
}
if (!overwrite)
{
return(null);
}
else
{
originalMesh.mesh = existingAsset;
originalMesh.name = existingAsset.name;
}
}
Mesh newMesh = null;
if (originalMesh.isSkinned)
{
newMesh = TCP2_Utils.CreateSmoothedMesh(originalMesh.mesh, mFormat, false, true, false, !originalMesh.isAsset || (originalMesh.isAsset && assetExists));
}
else
{
newMesh = TCP2_Utils.CreateSmoothedMesh(originalMesh.mesh, mFormat, mVColors, mTangents, mUV2, !originalMesh.isAsset || (originalMesh.isAsset && assetExists));
}
if (newMesh == null)
{
ShowNotification(new GUIContent("Couldn't generate the mesh for:\n" + originalMesh.name));
}
else
{
if (originalMesh.associatedObjects != null)
{
Undo.RecordObjects(originalMesh.associatedObjects, "Assign TCP2 Smoothed Mesh to Selection");
foreach (Object o in originalMesh.associatedObjects)
{
if (o is SkinnedMeshRenderer)
{
(o as SkinnedMeshRenderer).sharedMesh = newMesh;
}
else if (o is MeshFilter)
{
(o as MeshFilter).sharedMesh = newMesh;
}
else
{
Debug.LogWarning("[TCP2 Smoothed Normals Utility] Unrecognized AssociatedObject: " + o + "\nType: " + o.GetType());
}
EditorUtility.SetDirty(o);
}
}
if (originalMesh.isAsset)
{
if (overwrite && !assetExists)
{
AssetDatabase.CreateAsset(newMesh, assetPath);
}
}
else
{
return(null);
}
}
return(newMesh);
}
public void ShaderPropertiesGUI(Material material)
{
// Use default labelWidth
EditorGUIUtility.labelWidth = 0f;
// Detect any changes to the material
EditorGUI.BeginChangeCheck();
{
BlendModePopup();
GUILayout.Space(8f);
expandStandardProperties = GUILayout.Toggle(expandStandardProperties, "STANDARD PROPERTIES", EditorStyles.toolbarButton);
if (expandStandardProperties)
{
//Background
Rect vertRect = EditorGUILayout.BeginVertical();
vertRect.xMax += 2;
vertRect.xMin--;
GUI.Box(vertRect, "", (GUIStyle)"RL Background");
GUILayout.Space(4f);
// Primary properties
GUILayout.Label(Styles.primaryMapsText, EditorStyles.boldLabel);
DoAlbedoArea(material);
DoSpecularMetallicArea();
m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, bumpMap,
bumpMap.textureValue != null ? bumpScale : null);
m_MaterialEditor.TexturePropertySingleLine(Styles.heightMapText, heightMap,
heightMap.textureValue != null ? heigtMapScale : null);
m_MaterialEditor.TexturePropertySingleLine(Styles.occlusionText, occlusionMap,
occlusionMap.textureValue != null ? occlusionStrength : null);
DoEmissionArea(material);
m_MaterialEditor.TexturePropertySingleLine(Styles.detailMaskText, detailMask);
EditorGUI.BeginChangeCheck();
m_MaterialEditor.TextureScaleOffsetProperty(albedoMap);
if (EditorGUI.EndChangeCheck())
{
emissionMap.textureScaleAndOffset = albedoMap.textureScaleAndOffset;
}
// Apply the main texture scale and offset to the emission texture as well, for Enlighten's sake
EditorGUILayout.Space();
// Secondary properties
GUILayout.Label(Styles.secondaryMapsText, EditorStyles.boldLabel);
m_MaterialEditor.TexturePropertySingleLine(Styles.detailAlbedoText, detailAlbedoMap);
m_MaterialEditor.TexturePropertySingleLine(Styles.detailNormalMapText, detailNormalMap, detailNormalMapScale);
m_MaterialEditor.TextureScaleOffsetProperty(detailAlbedoMap);
m_MaterialEditor.ShaderProperty(uvSetSecondary, Styles.uvSetLabel.text);
// Third properties
GUILayout.Label(Styles.forwardText, EditorStyles.boldLabel);
if (highlights != null)
{
m_MaterialEditor.ShaderProperty(highlights, Styles.highlightsText);
}
if (reflections != null)
{
m_MaterialEditor.ShaderProperty(reflections, Styles.reflectionsText);
}
GUILayout.Space(8f);
EditorGUILayout.EndVertical();
}
EditorGUILayout.Space();
//----------------------------------------------------------------
// TOONY COLORS PRO 2
bool useOutline = (m_MaterialEditor.target as Material).shaderKeywords.Contains("OUTLINES");
bool useOutlineBlended = (m_MaterialEditor.target as Material).shaderKeywords.Contains("OUTLINE_BLENDING");
bool hasOutlineShader = tcp2_outlineWidth != null;
bool hasOutlineBlendedShader = tcp2_srcBlendOutline != null;
bool useOutlineNew = useOutline;
bool useOutlineBlendedNew = useOutlineBlended;
expandTCP2Properties = GUILayout.Toggle(expandTCP2Properties, "TOONY COLORS PRO 2", EditorStyles.toolbarButton);
if (expandTCP2Properties)
{
//Background
Rect vertRect = EditorGUILayout.BeginVertical();
vertRect.xMax += 2;
vertRect.xMin--;
GUI.Box(vertRect, "", (GUIStyle)"RL Background");
GUILayout.Space(4f);
GUILayout.Label("Base Properties", EditorStyles.boldLabel);
m_MaterialEditor.ColorProperty(tcp2_highlightColor, Styles.tcp2_highlightColorText);
m_MaterialEditor.ColorProperty(tcp2_shadowColor, Styles.tcp2_shadowColorText);
// Wrapped Lighting
m_MaterialEditor.ShaderProperty(tcp2_TCP2_DISABLE_WRAPPED_LIGHT, "Disable Wrapped Lighting");
// Ramp Texture / Threshold
m_MaterialEditor.ShaderProperty(tcp2_TCP2_RAMPTEXT, "Use Ramp Texture");
if (tcp2_TCP2_RAMPTEXT.floatValue > 0)
{
EditorGUI.indentLevel++;
m_MaterialEditor.ShaderProperty(tcp2_ramp, Styles.tcp2_rampText);
//m_MaterialEditor.TexturePropertySingleLine(Styles.tcp2_rampText, tcp2_ramp);
EditorGUI.indentLevel--;
}
else
{
m_MaterialEditor.ShaderProperty(tcp2_rampThreshold, Styles.tcp2_rampThresholdText.text, 1);
m_MaterialEditor.ShaderProperty(tcp2_rampSmooth, Styles.tcp2_rampSmoothText.text, 1);
m_MaterialEditor.ShaderProperty(tcp2_rampSmoothAdd, Styles.tcp2_rampSmoothAddText.text, 1);
}
EditorGUILayout.Space();
GUILayout.Label("Stylization Options", EditorStyles.boldLabel);
// Stylized Specular
m_MaterialEditor.ShaderProperty(tcp2_SPEC_TOON, "Stylized Specular");
if (tcp2_SPEC_TOON.floatValue > 0)
{
m_MaterialEditor.ShaderProperty(tcp2_specSmooth, Styles.tcp2_specSmoothText.text, 1);
m_MaterialEditor.ShaderProperty(tcp2_SpecBlend, Styles.tcp2_SpecBlendText.text, 1);
EditorGUILayout.Space();
}
//Stylized Fresnel
m_MaterialEditor.ShaderProperty(tcp2_STYLIZED_FRESNEL, "Stylized Fresnel");
if (tcp2_STYLIZED_FRESNEL.floatValue > 0)
{
m_MaterialEditor.ShaderProperty(tcp2_rimStrength, Styles.tcp2_rimStrengthText.text, 1);
m_MaterialEditor.ShaderProperty(tcp2_rimMin, Styles.tcp2_rimMinText.text, 1);
m_MaterialEditor.ShaderProperty(tcp2_rimMax, Styles.tcp2_rimMaxText.text, 1);
EditorGUILayout.Space();
}
//Outline
useOutlineNew = EditorGUILayout.Toggle(new GUIContent("Outline", "Enable mesh-based outline"), useOutline);
if (useOutline && hasOutlineShader)
{
//Outline base props
m_MaterialEditor.ShaderProperty(tcp2_outlineColor, Styles.tcp2_outlineColorText.text, 1);
m_MaterialEditor.ShaderProperty(tcp2_outlineWidth, Styles.tcp2_outlineWidthText.text, 1);
m_MaterialEditor.ShaderProperty(tcp2_TCP2_OUTLINE_TEXTURED, "Textured Outline", 1);
if (tcp2_TCP2_OUTLINE_TEXTURED.floatValue > 0)
{
m_MaterialEditor.ShaderProperty(tcp2_TexLod, Styles.tcp2_TexLodText, 1);
}
m_MaterialEditor.ShaderProperty(tcp2_TCP2_OUTLINE_CONST_SIZE, "Constant Screen Size", 1);
m_MaterialEditor.ShaderProperty(tcp2_TCP2_ZSMOOTH_ON, "Z Smooth", 1);
if (tcp2_TCP2_ZSMOOTH_ON.floatValue > 0)
{
m_MaterialEditor.ShaderProperty(tcp2_ZSmooth, Styles.tcp2_ZSmoothText, 2);
m_MaterialEditor.ShaderProperty(tcp2_Offset1, Styles.tcp2_Offset1Text, 2);
m_MaterialEditor.ShaderProperty(tcp2_Offset2, Styles.tcp2_Offset2Text, 2);
}
//Blended Outline
EditorGUI.indentLevel++;
useOutlineBlendedNew = EditorGUILayout.Toggle(new GUIContent("Blended Outline", "Enable blended outline rather than opaque"), useOutlineBlended);
if (useOutlineBlended && hasOutlineBlendedShader)
{
EditorGUI.indentLevel++;
UnityEngine.Rendering.BlendMode blendSrc = (UnityEngine.Rendering.BlendMode)tcp2_srcBlendOutline.floatValue;
UnityEngine.Rendering.BlendMode blendDst = (UnityEngine.Rendering.BlendMode)tcp2_dstBlendOutline.floatValue;
EditorGUI.BeginChangeCheck();
blendSrc = (UnityEngine.Rendering.BlendMode)EditorGUILayout.EnumPopup(Styles.tcp2_srcBlendOutlineText, blendSrc);
blendDst = (UnityEngine.Rendering.BlendMode)EditorGUILayout.EnumPopup(Styles.tcp2_dstBlendOutlineText, blendDst);
if (EditorGUI.EndChangeCheck())
{
tcp2_srcBlendOutline.floatValue = (float)blendSrc;
tcp2_dstBlendOutline.floatValue = (float)blendDst;
}
EditorGUI.indentLevel--;
}
EditorGUI.indentLevel--;
//Outline Normals
int onIndex = GetOutlineNormalsIndex();
int newIndex = onIndex;
EditorGUI.indentLevel++;
if (TCP2_Utils.ScreenWidthRetina < 390f)
{
newIndex = TCP2_Utils.ShaderKeywordRadioGeneric("Outline Normals", newIndex, new GUIContent[]
{
new GUIContent("R", "Use regular vertex normals"),
new GUIContent("VC", "Use vertex colors as normals (with smoothed mesh)"),
new GUIContent("T", "Use tangents as normals (with smoothed mesh)"),
new GUIContent("UV2", "Use second texture coordinates as normals (with smoothed mesh)"),
});
}
else if (TCP2_Utils.ScreenWidthRetina < 560f)
{
newIndex = TCP2_Utils.ShaderKeywordRadioGeneric("Outline Normals", newIndex, new GUIContent[]
{
new GUIContent("Regular", "Use regular vertex normals"),
new GUIContent("VColors", "Use vertex colors as normals (with smoothed mesh)"),
new GUIContent("Tangents", "Use tangents as normals (with smoothed mesh)"),
new GUIContent("UV2", "Use second texture coordinates as normals (with smoothed mesh)"),
});
}
else
{
newIndex = TCP2_Utils.ShaderKeywordRadioGeneric("Outline Normals", newIndex, new GUIContent[]
{
new GUIContent("Regular", "Use regular vertex normals"),
new GUIContent("Vertex Colors", "Use vertex colors as normals (with smoothed mesh)"),
new GUIContent("Tangents", "Use tangents as normals (with smoothed mesh)"),
new GUIContent("UV2", "Use second texture coordinates as normals (with smoothed mesh)"),
});
}
EditorGUI.indentLevel--;
if (newIndex != onIndex)
{
UpdateOutlineNormalsKeyword(newIndex);
}
}
GUILayout.Space(8f);
GUILayout.EndVertical();
// TCP2 End
//----------------------------------------------------------------
}
GUILayout.Space(10f);
//TCP2: set correct shader based on outline properties
if (useOutline != useOutlineNew || useOutlineBlended != useOutlineBlendedNew)
{
SetTCP2Shader(useOutlineNew, useOutlineBlendedNew);
}
else if (useOutline != hasOutlineShader || useOutlineBlended != hasOutlineBlendedShader)
{
SetTCP2Shader(useOutline, useOutlineBlended);
}
}
if (EditorGUI.EndChangeCheck())
{
foreach (var obj in blendMode.targets)
{
MaterialChanged((Material)obj, m_WorkflowMode);
}
}
}
protected override void DrawGUI(Rect position, TCP2_Config config)
{
//GUIMask(config, this.label, this.tooltip, this.maskKeyword, this.channelKeyword, this.keyword, this.Enabled(config), this.increaseIndent, helpTopic: this.helpTopic, helpIndent: this.helpIndent);
var curMask = Array.IndexOf(masks, config.GetKeyword(maskKeyword));
if (curMask < 0)
{
curMask = 0;
}
var curChannel = TCP2_Utils.FromShader(config.GetKeyword(channelKeyword));
var uvKey = (curMask > 1 && curMask < 5) ? "UV_" + masks[curMask] : null;
var curUv = Array.IndexOf(uvs, config.GetKeyword(uvKey));
if (curUv < 0)
{
curUv = 0;
}
EditorGUI.BeginChangeCheck();
//Calculate rects
var helpButton = position;
helpButton.width = 16f;
helpButton.x += 2f;
position.width -= helpButton.width;
helpButton.x += position.width;
//Mask type (MainTex, 1, 2, 3)
var sideRect = position;
sideRect.width = position.width * 0.75f / 2f;
curMask = EditorGUI.Popup(sideRect, curMask, labels);
//Mask Channel (RGBA)
var middleRect = position;
middleRect.width = position.width * 0.25f;
middleRect.x += sideRect.width;
GUI.enabled &= curMask > 0;
curChannel = (TCP2_Utils.TextureChannel)EditorGUI.EnumPopup(middleRect, curChannel);
//Mask UVs
sideRect.x += sideRect.width + middleRect.width;
GUI.enabled &= curMask > 1 && curMask < 5;
curUv = EditorGUI.Popup(sideRect, curUv, uvs);
//Mask Help
TCP2_GUI.HelpButton(helpButton, "Masks");
if (EditorGUI.EndChangeCheck())
{
config.SetKeyword(maskKeyword, masks[curMask]);
if (curMask > 0)
{
config.SetKeyword(channelKeyword, curChannel.ToShader());
}
if (curMask > 1 && !string.IsNullOrEmpty(uvKey))
{
config.SetKeyword(uvKey, uvs[curUv]);
}
config.ToggleFeature("VCOLORS_MASK", (curMask == 5));
config.ToggleFeature(keyword, (curMask > 0));
}
}
private bool GUIMask(string label, string tooltip, string maskKeyword, string channelKeyword, string feature = null, bool enabled = true, bool increaseIndentLevel = false, bool visible = true, string helpTopic = null)
{
string[] labelsAndKeywords = new string[] {
"Off|",
"Main Texture|mainTex",
"Mask 1|mask1", "Mask 2|mask2", "Mask 3|mask3"
};
if (!enabled)
{
GUI.enabled = false;
}
if (increaseIndentLevel)
{
label = "▪ " + label;
}
string[] labels = new string[labelsAndKeywords.Length];
string[] masks = new string[labelsAndKeywords.Length];
string[] uvs = new string[] { "Main Tex UV", "Independent UV" };
for (int i = 0; i < labelsAndKeywords.Length; i++)
{
string[] data = labelsAndKeywords[i].Split('|');
labels[i] = data[0];
masks[i] = data[1];
}
int curMask = System.Array.IndexOf(masks, TCP2_ShaderGeneratorUtils.GetKeyword(mCurrentConfig, maskKeyword));
if (curMask < 0)
{
curMask = 0;
}
TCP2_Utils.TextureChannel curChannel = TCP2_Utils.FromShader(TCP2_ShaderGeneratorUtils.GetKeyword(mCurrentConfig, channelKeyword));
if (curMask <= 1)
{
curChannel = TCP2_Utils.TextureChannel.Alpha;
}
string uvKey = (curMask > 1) ? "UV_" + masks[curMask] : null;
int curUv = System.Array.IndexOf(uvs, TCP2_ShaderGeneratorUtils.GetKeyword(mCurrentConfig, uvKey));
if (curUv < 0)
{
curUv = 0;
}
if (mHideDisabled)
{
visible = enabled;
}
if (visible)
{
EditorGUILayout.BeginHorizontal();
float w = 166;
if (!string.IsNullOrEmpty(helpTopic))
{
w -= 20;
TCP2_GUI.HelpButton(label.TrimStart('▪', ' '), helpTopic);
}
TCP2_GUI.SubHeader(label, tooltip, (curMask > 0) && enabled, w);
curMask = EditorGUILayout.Popup(curMask, labels);
GUI.enabled = curMask > 1;
curChannel = (TCP2_Utils.TextureChannel)EditorGUILayout.EnumPopup(curChannel);
curUv = EditorGUILayout.Popup(curUv, uvs);
GUI.enabled = mGUIEnabled;
TCP2_GUI.HelpButton("Masks");
EditorGUILayout.EndHorizontal();
}
TCP2_ShaderGeneratorUtils.SetKeyword(mCurrentConfig.Keywords, maskKeyword, masks[curMask]);
if (curMask > 0)
{
TCP2_ShaderGeneratorUtils.SetKeyword(mCurrentConfig.Keywords, channelKeyword, curChannel.ToShader());
}
if (curMask > 1 && !string.IsNullOrEmpty(uvKey))
{
TCP2_ShaderGeneratorUtils.SetKeyword(mCurrentConfig.Keywords, uvKey, uvs[curUv]);
}
TCP2_ShaderGeneratorUtils.ToggleSingleFeature(mCurrentConfig.Features, feature, (curMask > 0));
if (!enabled)
{
GUI.enabled = mGUIEnabled;
}
return(curMask > 0);
}
void OnGUI()
{
sGUIEnabled = GUI.enabled;
EditorGUILayout.BeginHorizontal();
TCP2_GUI.HeaderBig("TOONY COLORS PRO 2 - SHADER GENERATOR");
TCP2_GUI.HelpButton("Shader Generator");
EditorGUILayout.EndHorizontal();
TCP2_GUI.Separator();
float lW = EditorGUIUtility.labelWidth;
EditorGUIUtility.labelWidth = 105f;
//Avoid refreshing Template meta at every Repaint
EditorGUILayout.BeginHorizontal();
TextAsset _tmpTemplate = EditorGUILayout.ObjectField("Template:", Template.textAsset, typeof(TextAsset), false) as TextAsset;
if (_tmpTemplate != Template.textAsset)
{
Template.SetTextAsset(_tmpTemplate);
}
//Load template
if (loadTemplateMenu != null)
{
if (GUILayout.Button("Load ▼", EditorStyles.miniButton, GUILayout.ExpandWidth(false)))
{
loadTemplateMenu.ShowAsContext();
}
}
EditorGUILayout.EndHorizontal();
//Template not found
if (Template == null || Template.textAsset == null)
{
EditorGUILayout.HelpBox("Couldn't find template file!\n\nVerify that the file 'TCP2_ShaderTemplate_Default.txt' is in your project.\nPlease reimport the pack if you can't find it!", MessageType.Error);
return;
}
//Infobox for custom templates
if (!string.IsNullOrEmpty(Template.templateInfo))
{
EditorGUILayout.HelpBox(Template.templateInfo, MessageType.Info);
}
if (!string.IsNullOrEmpty(Template.templateWarning))
{
EditorGUILayout.HelpBox(Template.templateWarning, MessageType.Warning);
}
TCP2_GUI.Separator();
EditorGUI.BeginChangeCheck();
EditorGUILayout.BeginHorizontal();
mCurrentShader = EditorGUILayout.ObjectField("Current Shader:", mCurrentShader, typeof(Shader), false) as Shader;
if (EditorGUI.EndChangeCheck())
{
if (mCurrentShader != null)
{
LoadCurrentConfigFromShader(mCurrentShader);
}
}
if (GUILayout.Button("Copy Shader", EditorStyles.miniButton, GUILayout.Width(78f)))
{
CopyShader();
}
if (GUILayout.Button("New Shader", EditorStyles.miniButton, GUILayout.Width(76f)))
{
NewShader();
}
EditorGUILayout.EndHorizontal();
if (mCurrentConfig.isModifiedExternally)
{
EditorGUILayout.HelpBox("It looks like this shader has been modified externally/manually. Updating it will overwrite the changes.", MessageType.Warning);
}
if (mUserShaders != null && mUserShaders.Length > 0)
{
EditorGUI.BeginChangeCheck();
int prevChoice = mConfigChoice;
Color gColor = GUI.color;
GUI.color = mDirtyConfig ? gColor * Color.yellow : GUI.color;
GUILayout.BeginHorizontal();
mConfigChoice = EditorGUILayout.Popup("Load Shader:", mConfigChoice, mUserShadersLabels.ToArray());
if (GUILayout.Button("◄", EditorStyles.miniButtonLeft, GUILayout.Width(22)))
{
mConfigChoice--;
if (mConfigChoice < 1)
{
mConfigChoice = mUserShaders.Length;
}
}
if (GUILayout.Button("►", EditorStyles.miniButtonRight, GUILayout.Width(22)))
{
mConfigChoice++;
if (mConfigChoice > mUserShaders.Length)
{
mConfigChoice = 1;
}
}
GUILayout.EndHorizontal();
GUI.color = gColor;
if (EditorGUI.EndChangeCheck() && prevChoice != mConfigChoice)
{
bool load = true;
if (mDirtyConfig)
{
if (mCurrentShader != null)
{
load = EditorUtility.DisplayDialog("TCP2 : Shader Generation", "You have unsaved changes for the following shader:\n\n" + mCurrentShader.name + "\n\nDiscard the changes and load a new shader?", "Yes", "No");
}
else
{
load = EditorUtility.DisplayDialog("TCP2 : Shader Generation", "You have unsaved changes.\n\nDiscard the changes and load a new shader?", "Yes", "No");
}
}
if (load)
{
//New Shader
if (mConfigChoice == 0)
{
NewShader();
}
else
{
//Load selected Shader
Shader selectedShader = mUserShaders[mConfigChoice - 1];
mCurrentShader = selectedShader;
LoadCurrentConfigFromShader(mCurrentShader);
}
}
else
{
//Revert choice
mConfigChoice = prevChoice;
}
}
}
EditorGUIUtility.labelWidth = lW;
if (mCurrentConfig == null)
{
NewShader();
}
//Name & Filename
TCP2_GUI.Separator();
GUI.enabled = (mCurrentShader == null);
EditorGUI.BeginChangeCheck();
mCurrentConfig.ShaderName = EditorGUILayout.TextField(new GUIContent("Shader Name", "Path will indicate how to find the Shader in Unity's drop-down list"), mCurrentConfig.ShaderName);
mCurrentConfig.ShaderName = Regex.Replace(mCurrentConfig.ShaderName, @"[^a-zA-Z0-9 _!/]", "");
if (EditorGUI.EndChangeCheck() && sAutoNames)
{
mCurrentConfig.AutoNames();
}
GUI.enabled &= !sAutoNames;
EditorGUILayout.BeginHorizontal();
mCurrentConfig.Filename = EditorGUILayout.TextField("File Name", mCurrentConfig.Filename);
mCurrentConfig.Filename = Regex.Replace(mCurrentConfig.Filename, @"[^a-zA-Z0-9 _!/]", "");
GUILayout.Label(".shader", GUILayout.Width(50f));
EditorGUILayout.EndHorizontal();
GUI.enabled = sGUIEnabled;
Space();
//########################################################################################################
// FEATURES
TCP2_GUI.Header("FEATURES");
//Scroll view
mScrollPosition = EditorGUILayout.BeginScrollView(mScrollPosition);
EditorGUI.BeginChangeCheck();
if (Template.newSystem)
{
//New UI embedded into Template
Template.FeaturesGUI(mCurrentConfig);
}
else
{
EditorGUILayout.HelpBox("Old template versions aren't supported anymore.", MessageType.Warning);
}
#if DEBUG_MODE
TCP2_GUI.SeparatorBig();
TCP2_GUI.SubHeaderGray("DEBUG MODE");
GUILayout.BeginHorizontal();
mDebugText = EditorGUILayout.TextField("Custom", mDebugText);
if (GUILayout.Button("Add Feature", EditorStyles.miniButtonLeft, GUILayout.Width(80f)))
{
mCurrentConfig.Features.Add(mDebugText);
}
if (GUILayout.Button("Add Flag", EditorStyles.miniButtonRight, GUILayout.Width(80f)))
{
mCurrentConfig.Flags.Add(mDebugText);
}
GUILayout.EndHorizontal();
GUILayout.Label("Features:");
GUILayout.BeginHorizontal();
int count = 0;
for (int i = 0; i < mCurrentConfig.Features.Count; i++)
{
if (count >= 3)
{
count = 0;
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
}
count++;
if (GUILayout.Button(mCurrentConfig.Features[i], EditorStyles.toolbarButton, GUILayout.ExpandWidth(false)))
{
mCurrentConfig.Features.RemoveAt(i);
break;
}
}
GUILayout.EndHorizontal();
GUILayout.Label("Flags:");
GUILayout.BeginHorizontal();
count = 0;
for (int i = 0; i < mCurrentConfig.Flags.Count; i++)
{
if (count >= 3)
{
count = 0;
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
}
count++;
if (GUILayout.Button(mCurrentConfig.Flags[i], EditorStyles.toolbarButton, GUILayout.ExpandWidth(false)))
{
mCurrentConfig.Flags.RemoveAt(i);
break;
}
}
GUILayout.EndHorizontal();
GUILayout.Label("Keywords:");
GUILayout.BeginHorizontal();
count = 0;
foreach (KeyValuePair <string, string> kvp in mCurrentConfig.Keywords)
{
if (count >= 3)
{
count = 0;
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
}
count++;
if (GUILayout.Button(kvp.Key + ":" + kvp.Value, EditorStyles.toolbarButton, GUILayout.ExpandWidth(false)))
{
mCurrentConfig.Keywords.Remove(kvp.Key);
break;
}
}
GUILayout.EndHorizontal();
//----------------------------------------------------------------
Space();
if (mCurrentShader != null)
{
if (mCurrentShaderImporter == null)
{
mCurrentShaderImporter = ShaderImporter.GetAtPath(AssetDatabase.GetAssetPath(mCurrentShader)) as ShaderImporter;
}
if (mCurrentShaderImporter != null && mCurrentShaderImporter.GetShader() == mCurrentShader)
{
mDebugExpandUserData = EditorGUILayout.Foldout(mDebugExpandUserData, "Shader UserData");
if (mDebugExpandUserData)
{
string[] userData = mCurrentShaderImporter.userData.Split(',');
foreach (var str in userData)
{
GUILayout.Label(str);
}
}
}
}
#endif
//Update config
if (EditorGUI.EndChangeCheck())
{
int newHash = mCurrentConfig.ToHash();
if (newHash != mCurrentHash)
{
mDirtyConfig = true;
}
else
{
mDirtyConfig = false;
}
}
//Scroll view
EditorGUILayout.EndScrollView();
Space();
//GENERATE
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button(mCurrentShader == null ? "Generate Shader" : "Update Shader", GUILayout.Width(120f), GUILayout.Height(30f)))
{
if (Template == null)
{
EditorUtility.DisplayDialog("TCP2 : Shader Generation", "Can't generate shader: no Template file defined!\n\nYou most likely want to link the TCP2_User.txt file to the Template field in the Shader Generator.", "Ok");
return;
}
//Set config type
if (Template.templateType != null)
{
mCurrentConfig.configType = Template.templateType;
}
//Set config file
mCurrentConfig.templateFile = Template.textAsset.name;
Shader generatedShader = TCP2_ShaderGeneratorUtils.Compile(mCurrentConfig, mCurrentShader, Template, true, !sOverwriteConfigs);
ReloadUserShaders();
if (generatedShader != null)
{
mDirtyConfig = false;
LoadCurrentConfigFromShader(generatedShader);
}
}
EditorGUILayout.EndHorizontal();
TCP2_GUI.Separator();
// OPTIONS
TCP2_GUI.Header("OPTIONS");
GUILayout.BeginHorizontal();
sSelectGeneratedShader = GUILayout.Toggle(sSelectGeneratedShader, new GUIContent("Select Generated Shader", "Will select the generated file in the Project view"), GUILayout.Width(180f));
sAutoNames = GUILayout.Toggle(sAutoNames, new GUIContent("Automatic Name", "Will automatically generate the shader filename based on its UI name"), GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
sOverwriteConfigs = GUILayout.Toggle(sOverwriteConfigs, new GUIContent("Always overwrite shaders", "Overwrite shaders when generating/updating (no prompt)"), GUILayout.Width(180f));
sHideDisabled = GUILayout.Toggle(sHideDisabled, new GUIContent("Hide disabled fields", "Hide properties settings when they cannot be accessed"), GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUI.BeginChangeCheck();
TCP2_ShaderGeneratorUtils.CustomOutputDir = GUILayout.Toggle(TCP2_ShaderGeneratorUtils.CustomOutputDir, new GUIContent("Custom Output Directory:", "Will save the generated shaders in a custom directory within the Project"), GUILayout.Width(165f));
GUI.enabled &= TCP2_ShaderGeneratorUtils.CustomOutputDir;
if (TCP2_ShaderGeneratorUtils.CustomOutputDir)
{
TCP2_ShaderGeneratorUtils.OutputPath = EditorGUILayout.TextField("", TCP2_ShaderGeneratorUtils.OutputPath);
if (GUILayout.Button("Select...", EditorStyles.miniButton, GUILayout.ExpandWidth(false)))
{
string path = EditorUtility.OpenFolderPanel("Choose custom output directory for TCP2 generated shaders", Application.dataPath, "");
if (!string.IsNullOrEmpty(path))
{
bool validPath = TCP2_Utils.SystemToUnityPath(ref path);
if (validPath)
{
if (path == "Assets")
{
TCP2_ShaderGeneratorUtils.OutputPath = "/";
}
else
{
TCP2_ShaderGeneratorUtils.OutputPath = path.Substring("Assets/".Length);
}
}
else
{
EditorApplication.Beep();
EditorUtility.DisplayDialog("Invalid Path", "The selected path is invalid.\n\nPlease select a folder inside the \"Assets\" folder of your project!", "Ok");
}
}
}
}
else
{
EditorGUILayout.TextField("", TCP2_ShaderGeneratorUtils.OUTPUT_PATH);
}
if (EditorGUI.EndChangeCheck())
{
ReloadUserShaders();
}
GUI.enabled = sGUIEnabled;
EditorGUILayout.EndHorizontal();
EditorGUI.BeginChangeCheck();
sLoadAllShaders = GUILayout.Toggle(sLoadAllShaders, new GUIContent("Reload Shaders from all Project", "Load shaders from all your Project folders instead of just Toony Colors Pro 2.\nEnable it if you move your generated shader files outside of the default TCP2 Generated folder."), GUILayout.ExpandWidth(false));
if (EditorGUI.EndChangeCheck())
{
ReloadUserShaders();
}
TCP2_ShaderGeneratorUtils.SelectGeneratedShader = sSelectGeneratedShader;
}
void OnGUI()
{
sGUIEnabled = GUI.enabled;
EditorGUILayout.BeginHorizontal();
TCP2_GUI.HeaderBig("TOONY COLORS PRO 2 - SHADER GENERATOR");
TCP2_GUI.HelpButton("Shader Generator");
EditorGUILayout.EndHorizontal();
TCP2_GUI.Separator();
var lW = EditorGUIUtility.labelWidth;
EditorGUIUtility.labelWidth = 105f;
//Avoid refreshing Template meta at every Repaint
EditorGUILayout.BeginHorizontal();
var _tmpTemplate = EditorGUILayout.ObjectField("Template:", Template.textAsset, typeof(TextAsset), false) as TextAsset;
if (_tmpTemplate != Template.textAsset)
{
Template.SetTextAsset(_tmpTemplate);
}
//Load template
if (loadTemplateMenu != null)
{
if (GUILayout.Button("Load ▼", EditorStyles.miniButton, GUILayout.ExpandWidth(false)))
{
loadTemplateMenu.ShowAsContext();
}
}
/*
* if(GUILayout.Button("Reload", EditorStyles.miniButton, GUILayout.ExpandWidth(false)))
* {
* Template.Reload();
* }
*/
EditorGUILayout.EndHorizontal();
//Template not found
if (Template == null || Template.textAsset == null)
{
EditorGUILayout.HelpBox("Couldn't find template file!\n\nVerify that the file 'TCP2_ShaderTemplate_Default.txt' is in your project.\nPlease reimport the pack if you can't find it!", MessageType.Error);
return;
}
//Infobox for custom templates
if (!string.IsNullOrEmpty(Template.templateInfo))
{
TCP2_GUI.HelpBoxLayout(Template.templateInfo, MessageType.Info);
}
if (!string.IsNullOrEmpty(Template.templateWarning))
{
TCP2_GUI.HelpBoxLayout(Template.templateWarning, MessageType.Warning);
}
TCP2_GUI.Separator();
//If current shader is unsaved, show yellow color
var gColor = GUI.color;
GUI.color = mDirtyConfig ? gColor * unsavedChangesColor : GUI.color;
EditorGUI.BeginChangeCheck();
mCurrentShader = EditorGUILayout.ObjectField("Current Shader:", mCurrentShader, typeof(Shader), false) as Shader;
if (EditorGUI.EndChangeCheck())
{
if (mCurrentShader != null)
{
LoadCurrentConfigFromShader(mCurrentShader);
}
}
EditorGUILayout.BeginHorizontal();
GUILayout.Space(EditorGUIUtility.labelWidth + 4);
if (mDirtyConfig)
{
var guiContent = new GUIContent("Unsaved changes");
var rect = GUILayoutUtility.GetRect(guiContent, EditorStyles.helpBox, GUILayout.Height(16));
rect.y -= 2;
GUI.Label(rect, guiContent, EditorStyles.helpBox);
}
GUILayout.FlexibleSpace();
using (new EditorGUI.DisabledScope(mCurrentShader == null))
{
if (GUILayout.Button("Copy", EditorStyles.miniButtonLeft, GUILayout.Width(60f), GUILayout.Height(16)))
{
CopyShader();
}
}
if (GUILayout.Button("Load ▼", EditorStyles.miniButtonMid, GUILayout.Width(60f), GUILayout.Height(16)))
{
loadShadersMenu.ShowAsContext();
}
if (GUILayout.Button("New", EditorStyles.miniButtonRight, GUILayout.Width(60f), GUILayout.Height(16)))
{
NewShader();
}
GUILayout.Space(18); //leave space to align with the Object Field box
EditorGUILayout.EndHorizontal();
GUI.color = gColor;
if (mCurrentConfig == null)
{
NewShader();
}
if (mCurrentConfig.isModifiedExternally)
{
EditorGUILayout.HelpBox("It looks like this shader has been modified externally/manually. Updating it will overwrite the changes.", MessageType.Warning);
}
EditorGUIUtility.labelWidth = lW;
//Name & Filename
TCP2_GUI.Separator();
GUI.enabled = (mCurrentShader == null);
EditorGUI.BeginChangeCheck();
mCurrentConfig.ShaderName = EditorGUILayout.TextField(new GUIContent("Shader Name", "Path will indicate how to find the Shader in Unity's drop-down list"), mCurrentConfig.ShaderName);
mCurrentConfig.ShaderName = Regex.Replace(mCurrentConfig.ShaderName, @"[^a-zA-Z0-9 _!/]", "");
if (EditorGUI.EndChangeCheck() && sAutoNames)
{
mCurrentConfig.AutoNames();
}
GUI.enabled &= !sAutoNames;
EditorGUILayout.BeginHorizontal();
mCurrentConfig.Filename = EditorGUILayout.TextField("File Name", mCurrentConfig.Filename);
mCurrentConfig.Filename = Regex.Replace(mCurrentConfig.Filename, @"[^a-zA-Z0-9 _!/]", "");
GUILayout.Label(".shader", GUILayout.Width(50f));
EditorGUILayout.EndHorizontal();
GUI.enabled = sGUIEnabled;
TCP2_GUI.Separator();
//########################################################################################################
// FEATURES
TCP2_GUI.Header("FEATURES");
//Scroll view
mScrollPosition = EditorGUILayout.BeginScrollView(mScrollPosition);
EditorGUI.BeginChangeCheck();
if (Template.newSystem)
{
//New UI embedded into Template
Template.FeaturesGUI(mCurrentConfig);
if (mFirstHashPass)
{
mCurrentHash = mCurrentConfig.ToHash();
mFirstHashPass = false;
}
}
else
{
EditorGUILayout.HelpBox("Old template versions aren't supported anymore.", MessageType.Warning);
}
#if DEBUG_MODE
TCP2_GUI.SeparatorBig();
TCP2_GUI.SubHeaderGray("DEBUG MODE");
GUILayout.BeginHorizontal();
mDebugText = EditorGUILayout.TextField("Custom", mDebugText);
if (GUILayout.Button("Add Feature", EditorStyles.miniButtonLeft, GUILayout.Width(80f)))
{
mCurrentConfig.Features.Add(mDebugText);
}
if (GUILayout.Button("Add Flag", EditorStyles.miniButtonRight, GUILayout.Width(80f)))
{
mCurrentConfig.Flags.Add(mDebugText);
}
GUILayout.EndHorizontal();
GUILayout.Label("Features:");
GUILayout.BeginHorizontal();
int count = 0;
for (int i = 0; i < mCurrentConfig.Features.Count; i++)
{
if (count >= 3)
{
count = 0;
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
}
count++;
if (GUILayout.Button(mCurrentConfig.Features[i], EditorStyles.toolbarButton, GUILayout.ExpandWidth(false)))
{
mCurrentConfig.Features.RemoveAt(i);
break;
}
}
GUILayout.EndHorizontal();
GUILayout.Label("Flags:");
GUILayout.BeginHorizontal();
count = 0;
for (int i = 0; i < mCurrentConfig.Flags.Count; i++)
{
if (count >= 3)
{
count = 0;
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
}
count++;
if (GUILayout.Button(mCurrentConfig.Flags[i], EditorStyles.toolbarButton, GUILayout.ExpandWidth(false)))
{
mCurrentConfig.Flags.RemoveAt(i);
break;
}
}
GUILayout.EndHorizontal();
GUILayout.Label("Keywords:");
GUILayout.BeginHorizontal();
count = 0;
foreach (KeyValuePair <string, string> kvp in mCurrentConfig.Keywords)
{
if (count >= 3)
{
count = 0;
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
}
count++;
if (GUILayout.Button(kvp.Key + ":" + kvp.Value, EditorStyles.toolbarButton, GUILayout.ExpandWidth(false)))
{
mCurrentConfig.Keywords.Remove(kvp.Key);
break;
}
}
GUILayout.EndHorizontal();
//----------------------------------------------------------------
Space();
if (mCurrentShader != null)
{
if (mCurrentShaderImporter == null)
{
mCurrentShaderImporter = ShaderImporter.GetAtPath(AssetDatabase.GetAssetPath(mCurrentShader)) as ShaderImporter;
}
if (mCurrentShaderImporter != null && mCurrentShaderImporter.GetShader() == mCurrentShader)
{
mDebugExpandUserData = EditorGUILayout.Foldout(mDebugExpandUserData, "Shader UserData");
if (mDebugExpandUserData)
{
string[] userData = mCurrentShaderImporter.userData.Split(',');
foreach (var str in userData)
{
GUILayout.Label(str);
}
}
}
}
#endif
//Update config
if (EditorGUI.EndChangeCheck())
{
var newHash = mCurrentConfig.ToHash();
if (newHash != mCurrentHash)
{
mDirtyConfig = true;
}
else
{
mDirtyConfig = false;
}
}
//Scroll view
EditorGUILayout.EndScrollView();
Space();
//GENERATE
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUI.color = mDirtyConfig ? gColor * unsavedChangesColor : GUI.color;
if (GUILayout.Button(mCurrentShader == null ? "Generate Shader" : "Update Shader", GUILayout.Width(120f), GUILayout.Height(30f)))
{
if (Template == null)
{
EditorUtility.DisplayDialog("TCP2 : Shader Generation", "Can't generate shader: no Template file defined!\n\nYou most likely want to link the TCP2_User.txt file to the Template field in the Shader Generator.", "Ok");
return;
}
//Set config type
if (Template.templateType != null)
{
mCurrentConfig.configType = Template.templateType;
}
//Set config file
mCurrentConfig.templateFile = Template.textAsset.name;
var generatedShader = TCP2_ShaderGeneratorUtils.Compile(mCurrentConfig, mCurrentShader, Template, true, !sOverwriteConfigs);
ReloadUserShaders();
if (generatedShader != null)
{
mDirtyConfig = false;
LoadCurrentConfigFromShader(generatedShader);
}
//Workaround to force the inspector to refresh, so that state is reset.
//Needed in case of switching between specular/metallic and related
//options, while the inspector is opened, so that it shows/hides the
//relevant properties according to the changes.
TCP2_MaterialInspector_SurfacePBS_SG.InspectorNeedsUpdate = true;
}
GUI.color = gColor;
EditorGUILayout.EndHorizontal();
TCP2_GUI.Separator();
// OPTIONS
TCP2_GUI.Header("OPTIONS");
GUILayout.BeginHorizontal();
sSelectGeneratedShader = GUILayout.Toggle(sSelectGeneratedShader, new GUIContent("Select Generated Shader", "Will select the generated file in the Project view"), GUILayout.Width(180f));
sAutoNames = GUILayout.Toggle(sAutoNames, new GUIContent("Automatic Name", "Will automatically generate the shader filename based on its UI name"), GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
sOverwriteConfigs = GUILayout.Toggle(sOverwriteConfigs, new GUIContent("Always overwrite shaders", "Overwrite shaders when generating/updating (no prompt)"), GUILayout.Width(180f));
sHideDisabled = GUILayout.Toggle(sHideDisabled, new GUIContent("Hide disabled fields", "Hide properties settings when they cannot be accessed"), GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
EditorGUI.BeginChangeCheck();
TCP2_ShaderGeneratorUtils.CustomOutputDir = GUILayout.Toggle(TCP2_ShaderGeneratorUtils.CustomOutputDir, new GUIContent("Custom Output Directory:", "Will save the generated shaders in a custom directory within the Project"), GUILayout.Width(165f));
GUI.enabled &= TCP2_ShaderGeneratorUtils.CustomOutputDir;
if (TCP2_ShaderGeneratorUtils.CustomOutputDir)
{
TCP2_ShaderGeneratorUtils.OutputPath = EditorGUILayout.TextField("", TCP2_ShaderGeneratorUtils.OutputPath);
if (GUILayout.Button("Select...", EditorStyles.miniButton, GUILayout.ExpandWidth(false)))
{
var outputPath = TCP2_Utils.OpenFolderPanel_ProjectPath("Choose custom output directory for TCP2 generated shaders");
if (!string.IsNullOrEmpty(outputPath))
{
TCP2_ShaderGeneratorUtils.OutputPath = outputPath;
}
}
}
else
{
EditorGUILayout.TextField("", TCP2_ShaderGeneratorUtils.OUTPUT_PATH);
}
if (EditorGUI.EndChangeCheck())
{
ReloadUserShaders();
}
GUI.enabled = sGUIEnabled;
EditorGUILayout.EndHorizontal();
EditorGUI.BeginChangeCheck();
sLoadAllShaders = GUILayout.Toggle(sLoadAllShaders, new GUIContent("Reload Shaders from all Project", "Load shaders from all your Project folders instead of just Toony Colors Pro 2.\nEnable it if you move your generated shader files outside of the default TCP2 Generated folder."), GUILayout.ExpandWidth(false));
if (EditorGUI.EndChangeCheck())
{
ReloadUserShaders();
}
TCP2_ShaderGeneratorUtils.SelectGeneratedShader = sSelectGeneratedShader;
}
//Generate the source code for the shader as a string
static private string GenerateShaderSource(this TCP2_Config config, string template, Shader existingShader = null)
{
if (config == null)
{
string error = "[TCP2 Shader Generator] Config file is null";
Debug.LogError(error);
return(error);
}
if (string.IsNullOrEmpty(template))
{
string error = "[TCP2 Shader Generator] Template string is null or empty";
Debug.LogError(error);
return(error);
}
//------------------------------------------------
// SHADER PARAMETERS
//Custom Lighting
bool customLighting = NeedCustomLighting(config) || HasFeatures(config, "CUSTOM_LIGHTING_FORCE");
if (customLighting && !config.Features.Contains("CUSTOM_LIGHTING"))
{
config.Features.Add("CUSTOM_LIGHTING");
}
else if (!customLighting && config.Features.Contains("CUSTOM_LIGHTING"))
{
config.Features.Remove("CUSTOM_LIGHTING");
}
//Custom Ambient
bool customAmbient = NeedCustomAmbient(config) || HasFeatures(config, "CUSTOM_AMBIENT_FORCE");
if (customAmbient && !config.Features.Contains("CUSTOM_AMBIENT"))
{
config.Features.Add("CUSTOM_AMBIENT");
}
else if (!customAmbient && config.Features.Contains("CUSTOM_AMBIENT"))
{
config.Features.Remove("CUSTOM_AMBIENT");
}
//Specific dependencies
if (HasFeatures(config, "MATCAP_ADD", "MATCAP_MULT"))
{
if (!config.Features.Contains("MATCAP"))
{
config.Features.Add("MATCAP");
}
}
else
{
if (config.Features.Contains("MATCAP"))
{
config.Features.Remove("MATCAP");
}
}
//Masks
bool mask1 = false, mask2 = false, mask3 = false;
string mask1features = "";
string mask2features = "";
string mask3features = "";
foreach (KeyValuePair <string, string> kvp in config.Keywords)
{
if (kvp.Key == "UV_mask1")
{
ToggleFlag(config.Features, "UVMASK1", kvp.Value == "Independent UV");
}
else if (kvp.Key == "UV_mask2")
{
ToggleFlag(config.Features, "UVMASK2", kvp.Value == "Independent UV");
}
else if (kvp.Key == "UV_mask3")
{
ToggleFlag(config.Features, "UVMASK3", kvp.Value == "Independent UV");
}
else if (kvp.Value == "mask1")
{
mask1 |= GetMaskDependency(config, kvp.Key); if (mask1)
{
mask1features += GetDisplayNameForMask(kvp.Key) + ",";
}
}
else if (kvp.Value == "mask2")
{
mask2 |= GetMaskDependency(config, kvp.Key); if (mask2)
{
mask2features += GetDisplayNameForMask(kvp.Key) + ",";
}
}
else if (kvp.Value == "mask3")
{
mask3 |= GetMaskDependency(config, kvp.Key); if (mask3)
{
mask3features += GetDisplayNameForMask(kvp.Key) + ",";
}
}
}
mask1features = mask1features.TrimEnd(',');
mask2features = mask2features.TrimEnd(',');
mask3features = mask3features.TrimEnd(',');
ToggleFlag(config.Features, "MASK1", mask1);
ToggleFlag(config.Features, "MASK2", mask2);
ToggleFlag(config.Features, "MASK3", mask3);
//---
Dictionary <string, string> keywords = new Dictionary <string, string>(config.Keywords);
List <string> flags = new List <string>(config.Flags);
List <string> features = new List <string>(config.Features);
//Unity version
#if UNITY_5_4_OR_NEWER
TCP2_Utils.AddIfMissing(features, "UNITY_5_4");
#endif
//Masks
keywords.Add("MASK1", mask1features);
keywords.Add("MASK2", mask2features);
keywords.Add("MASK3", mask3features);
//Shader name
keywords.Add("SHADER_NAME", config.ShaderName);
//Include path
string include = GetIncludePrefix(config) + GetIncludeRelativePath(config, existingShader) + GetIncludeFile(config);
keywords.Add("INCLUDE_PATH", include);
//Lighting Model
string lightingModel = GetLightingFunction(config);
keywords.Add("LIGHTING_MODEL", lightingModel);
//SurfaceOutput struct
string surfOut = GetSurfaceOutput(config);
keywords.Add("SURFACE_OUTPUT", surfOut);
//Shader Model target
string target = GetShaderTarget(config);
keywords.Add("SHADER_TARGET", target);
if (config.shaderTarget == 20)
{
TCP2_Utils.AddIfMissing(features, "FORCE_SM2");
}
//Vertex Function
bool vertexFunction = NeedVertexFunction(config);
if (vertexFunction)
{
TCP2_Utils.AddIfMissing(flags, "vertex:vert");
features.Add("VERTEX_FUNC");
}
//Final Colors Function
bool finalColorFunction = NeedFinalColorFunction(config);
if (finalColorFunction)
{
TCP2_Utils.AddIfMissing(flags, "finalcolor:fcolor");
features.Add("FINAL_COLOR");
}
//Alpha Testing (Cutout)
if (HasFeatures(config, "CUTOUT"))
{
TCP2_Utils.AddIfMissing(flags, "alphatest:_Cutoff");
}
#if UNITY_5
//Alpha
if (HasFeatures(config, "ALPHA"))
{
TCP2_Utils.AddIfMissing(flags, "keepalpha");
}
#endif
//Shadows
if (HasFeatures(config, "CUTOUT"))
{
TCP2_Utils.AddIfMissing(flags, "addshadow");
}
//No/Custom Ambient
if (HasFeatures(config, "CUSTOM_AMBIENT"))
{
TCP2_Utils.AddIfMissing(flags, "noambient");
}
//Generate Surface parameters
string strFlags = ArrayToString(flags.ToArray(), " ");
keywords.Add("SURF_PARAMS", strFlags);
//------------------------------------------------
// PARSING & GENERATION
System.Text.StringBuilder sb = new System.Text.StringBuilder();
string[] templateLines = template.Split(new string[] { "\r\n", "\n" }, System.StringSplitOptions.None);
int depth = -1;
List <bool> stack = new List <bool>();
List <bool> done = new List <bool>();
//Parse template file
string line = null;
for (int i = 0; i < templateLines.Length; i++)
{
line = templateLines[i];
//Comment
if (line.StartsWith("#"))
{
//Meta
if (line.StartsWith("#CONFIG="))
{
config.configType = line.Substring(8).TrimEnd().ToLower();
}
//Debugging
if (line.StartsWith("#break"))
{
Debug.Log("[TCP2] Parse Break @ " + i);
}
continue;
}
//Line break
if (string.IsNullOrEmpty(line) && ((depth >= 0 && stack[depth]) || depth < 0))
{
sb.AppendLine(line);
continue;
}
//Conditions
if (line.Contains("///"))
{
//Remove leading white spaces
line = line.TrimStart();
string[] parts = line.Split(new string[] { " " }, System.StringSplitOptions.RemoveEmptyEntries);
if (parts.Length == 1) //END TAG
{
if (depth < 0)
{
string error = "[TCP2 Shader Generator] Found end tag /// without any beginning! Aborting shader generation.\n@ line: " + i;
Debug.LogError(error);
return(error);
}
stack.RemoveAt(depth);
done.RemoveAt(depth);
depth--;
}
else if (parts.Length >= 2)
{
if (parts[1] == "IF")
{
bool cond = EvaluateExpression(i, features, parts);
depth++;
stack.Add(cond && ((depth <= 0) ? true : stack[depth - 1]));
done.Add(cond);
}
else if (parts[1] == "ELIF")
{
if (done[depth])
{
stack[depth] = false;
continue;
}
bool cond = EvaluateExpression(i, features, parts);
stack[depth] = cond && ((depth <= 0) ? true : stack[depth - 1]);
done[depth] = cond;
}
else if (parts[1] == "ELSE")
{
if (done[depth])
{
stack[depth] = false;
continue;
}
else
{
stack[depth] = ((depth <= 0) ? true : stack[depth - 1]);
done[depth] = true;
}
}
}
}
//Regular line
else
{
//Replace keywords
line = ReplaceKeywords(line, keywords);
if ((depth >= 0 && stack[depth]) || depth < 0)
{
sb.AppendLine(line);
}
}
}
if (depth >= 0)
{
Debug.LogWarning("[TCP2 Shader Generator] Missing " + (depth + 1) + " ending '///' tags");
}
string sourceCode = sb.ToString();
return(sourceCode);
}
//Extract an archive into an array of PackedFile
static public PackedFile[] ExtractArchive(string archivePath, string filter = null)
{
string archive = File.ReadAllText(archivePath);
string[] archiveLines = File.ReadAllLines(archivePath);
if (archiveLines[0] != "# TCP2 PACKED SHADERS")
{
EditorApplication.Beep();
Debug.LogError("[TCP2 ExtractArchive] Invalid TCP2 archive:\n" + archivePath);
return(null);
}
//Find offset
int offset = archive.IndexOf("###") + 4;
if (offset < 20)
{
Debug.LogError("[TCP2 ExtractArchive] Invalid TCP2 archive:\n" + archivePath);
return(null);
}
string tcpRoot = TCP2_Utils.FindReadmePath();
List <PackedFile> packedFilesList = new List <PackedFile>();
for (int line = 1; line < archiveLines.Length; line++)
{
//Index end, start content parsing
if (archiveLines[line].StartsWith("#"))
{
break;
}
string[] shaderIndex = archiveLines[line].Split(new string[] { ";" }, System.StringSplitOptions.RemoveEmptyEntries);
if (shaderIndex.Length != 3)
{
EditorApplication.Beep();
Debug.LogError("[TCP2 ExtractArchive] Invalid format in TCP2 archive, at line " + line + ":\n" + archivePath);
return(null);
}
//Get data
string relativePath = shaderIndex[0];
int start = int.Parse(shaderIndex[1]);
int length = int.Parse(shaderIndex[2]);
//Get content
string content = archive.Substring(offset + start, length);
//Skip if file already extracted
if (File.Exists(tcpRoot + relativePath))
{
continue;
}
//Filter?
if (!string.IsNullOrEmpty(filter))
{
string[] filters = filter.Split(new string[] { " " }, System.StringSplitOptions.RemoveEmptyEntries);
bool skip = false;
foreach (string f in filters)
{
if (!relativePath.ToLower().Contains(f.ToLower()))
{
skip = true;
break;
}
}
if (skip)
{
continue;
}
}
//Add File
packedFilesList.Add(new PackedFile(relativePath, content));
}
return(packedFilesList.ToArray());
}
void OnGUI()
{
EditorGUILayout.BeginHorizontal();
TCP2_GUI.HeaderBig("TCP 2 - SMOOTHED NORMALS UTILITY");
TCP2_GUI.HelpButton("Smoothed Normals Utility");
EditorGUILayout.EndHorizontal();
TCP2_GUI.Separator();
/*
* mFormat = EditorGUILayout.TextField(new GUIContent("Axis format", "Normals axis may need to be swapped before being packed into vertex colors/tangent/uv2 data. See documentation for more information."), mFormat);
* mFormat = Regex.Replace(mFormat, @"[^xyzXYZ-]", "");
* EditorGUILayout.BeginHorizontal();
* GUILayout.Label("Known formats:");
* if(GUILayout.Button("XYZ", EditorStyles.miniButtonLeft)) { mFormat = "XYZ"; GUI.FocusControl(null); }
* if(GUILayout.Button("-YZ-X", EditorStyles.miniButtonMid)) { mFormat = "-YZ-X"; GUI.FocusControl(null); }
* if(GUILayout.Button("-Z-Y-X", EditorStyles.miniButtonRight)) { mFormat = "-Z-Y-X"; GUI.FocusControl(null); }
* EditorGUILayout.EndHorizontal();
*/
if (mMeshes != null && mMeshes.Count > 0)
{
GUILayout.Space(4);
TCP2_GUI.Header("Meshes ready to be processed:", null, true);
mScroll = EditorGUILayout.BeginScrollView(mScroll);
TCP2_GUI.GUILine(Color.gray, 1);
foreach (var sm in mMeshes.Values)
{
GUILayout.Space(2);
GUILayout.BeginHorizontal();
var label = sm.name;
if (label.Contains(MESH_SUFFIX))
{
label = label.Replace(MESH_SUFFIX, "\n" + MESH_SUFFIX);
}
GUILayout.Label(label, EditorStyles.wordWrappedMiniLabel, GUILayout.Width(270));
sm.isSkinned = GUILayout.Toggle(sm.isSkinned, new GUIContent("Skinned", "Should be checked if the mesh will be used on a SkinnedMeshRenderer"), EditorStyles.toolbarButton);
GUILayout.Space(6);
GUILayout.EndHorizontal();
GUILayout.Space(2);
TCP2_GUI.GUILine(Color.gray, 1);
}
EditorGUILayout.EndScrollView();
GUILayout.FlexibleSpace();
if (GUILayout.Button(mMeshes.Count == 1 ? "Generate Smoothed Mesh" : "Generate Smoothed Meshes", GUILayout.Height(30)))
{
try
{
var selection = new List <Object>();
float progress = 1;
float total = mMeshes.Count;
foreach (var sm in mMeshes.Values)
{
if (sm == null)
{
continue;
}
EditorUtility.DisplayProgressBar("Hold On", (mMeshes.Count > 1 ? "Generating Smoothed Meshes:\n" : "Generating Smoothed Mesh:\n") + sm.name, progress / total);
progress++;
Object o = CreateSmoothedMeshAsset(sm);
if (o != null)
{
selection.Add(o);
}
}
Selection.objects = selection.ToArray();
}
finally
{
EditorUtility.ClearProgressBar();
}
}
}
else
{
EditorGUILayout.HelpBox("Select one or multiple meshes to create a smoothed normals version.\n\nYou can also select models directly in the Scene, the new mesh will automatically be assigned.", MessageType.Info);
GUILayout.FlexibleSpace();
using (new EditorGUI.DisabledScope(true))
GUILayout.Button("Generate Smoothed Mesh", GUILayout.Height(30));
}
TCP2_GUI.Separator();
TCP2_GUI.Header("Store smoothed normals in:", "You will have to select the correct option in the Material Inspector when using outlines", true);
var choice = 0;
if (mTangents)
{
choice = 1;
}
if (mUV2)
{
choice = 2;
}
choice = TCP2_GUI.RadioChoice(choice, true, "Vertex Colors", "Tangents", "UV2");
EditorGUILayout.HelpBox("Smoothed Normals for Skinned meshes will be stored in Tangents only. See Help to know why.", MessageType.Warning);
mVColors = (choice == 0);
mTangents = (choice == 1);
mUV2 = (choice == 2);
TCP2_GUI.Separator();
TCP2_GUI.Header("Options", null, true);
mAlwaysOverwrite = EditorGUILayout.Toggle(new GUIContent("Always Overwrite", "Will always overwrite existing [TCP2 Smoothed] meshes"), mAlwaysOverwrite);
mCustomDirectory = EditorGUILayout.Toggle(new GUIContent("Custom Output Directory", "Save the generated smoothed meshes in a custom directory"), mCustomDirectory);
using (new EditorGUI.DisabledScope(!mCustomDirectory))
{
EditorGUILayout.BeginHorizontal();
mCustomDirectoryPath = EditorGUILayout.TextField(GUIContent.none, mCustomDirectoryPath);
if (GUILayout.Button("Select...", EditorStyles.miniButton, GUILayout.ExpandWidth(false)))
{
var outputPath = TCP2_Utils.OpenFolderPanel_ProjectPath("Choose custom output directory for generated smoothed meshes");
if (!string.IsNullOrEmpty(outputPath))
{
mCustomDirectoryPath = outputPath;
}
}
EditorGUILayout.EndHorizontal();
};
GUILayout.Space(10);
}
public override void OnInspectorGUI()
{
if (!this.isVisible)
{
return;
}
#if SHOW_DEFAULT_INSPECTOR
base.OnInspectorGUI();
return;
#else
//Detect if Shader has changed
if (targetMaterial.shader != mCurrentShader)
{
mCurrentShader = targetMaterial.shader;
}
UpdateFeaturesFromShader();
//Get material keywords
List <string> keywordsList = new List <string>(targetMaterial.shaderKeywords);
bool updateKeywords = false;
//Header
TCP2_GUI.HeaderBig("TOONY COLORS PRO 2 - Outlines Only");
TCP2_GUI.Separator();
//Iterate Shader properties
serializedObject.Update();
SerializedProperty mShader = serializedObject.FindProperty("m_Shader");
if (isVisible && !mShader.hasMultipleDifferentValues && mShader.objectReferenceValue != null)
{
EditorGUIUtility.labelWidth = TCP2_Utils.ScreenWidthRetina - 120f;
EditorGUIUtility.fieldWidth = 64f;
EditorGUI.BeginChangeCheck();
MaterialProperty[] props = GetMaterialProperties(this.targets);
//UNFILTERED PARAMETERS ==============================================================
if (ShowFilteredProperties(null, props, false))
{
TCP2_GUI.Separator();
}
//FILTERED PARAMETERS ================================================================
//Outline Type ---------------------------------------------------------------------------
ShowFilteredProperties("#OUTLINE#", props, false);
if (!mShaderModel2)
{
bool texturedOutline = TCP2_Utils.ShaderKeywordToggle("TCP2_OUTLINE_TEXTURED", "Outline Color from Texture", "If enabled, outline will take an averaged color from the main texture multiplied by Outline Color", keywordsList, ref updateKeywords);
if (texturedOutline)
{
ShowFilteredProperties("#OUTLINETEX#", props);
}
}
TCP2_Utils.ShaderKeywordToggle("TCP2_OUTLINE_CONST_SIZE", "Constant Size Outline", "If enabled, outline will have a constant size independently from camera distance", keywordsList, ref updateKeywords);
if (TCP2_Utils.ShaderKeywordToggle("TCP2_ZSMOOTH_ON", "Correct Z Artefacts", "Enable the outline z-correction to try to hide artefacts from complex models", keywordsList, ref updateKeywords))
{
ShowFilteredProperties("#OUTLINEZ#", props);
}
//Smoothed Normals -----------------------------------------------------------------------
TCP2_GUI.Header("OUTLINE NORMALS", "Defines where to take the vertex normals from to draw the outline.\nChange this when using a smoothed mesh to fill the gaps shown in hard-edged meshes.");
TCP2_Utils.ShaderKeywordRadio(null, new string[] { "TCP2_NONE", "TCP2_COLORS_AS_NORMALS", "TCP2_TANGENT_AS_NORMALS", "TCP2_UV2_AS_NORMALS" }, new GUIContent[]
{
new GUIContent("Regular", "Use regular vertex normals"),
new GUIContent("Vertex Colors", "Use vertex colors as normals (with smoothed mesh)"),
new GUIContent("Tangents", "Use tangents as normals (with smoothed mesh)"),
new GUIContent("UV2", "Use second texture coordinates as normals (with smoothed mesh)"),
},
keywordsList, ref updateKeywords);
//Outline Blending -----------------------------------------------------------------------
if (mIsOutlineBlending)
{
MaterialProperty[] blendProps = GetFilteredProperties("#BLEND#", props);
if (blendProps.Length != 2)
{
EditorGUILayout.HelpBox("Couldn't find Blending properties!", MessageType.Error);
}
else
{
TCP2_GUI.Header("OUTLINE BLENDING", "BLENDING EXAMPLES:\nAlpha Transparency: SrcAlpha / OneMinusSrcAlpha\nMultiply: DstColor / Zero\nAdd: One / One\nSoft Add: OneMinusDstColor / One");
UnityEngine.Rendering.BlendMode blendSrc = (UnityEngine.Rendering.BlendMode)blendProps[0].floatValue;
UnityEngine.Rendering.BlendMode blendDst = (UnityEngine.Rendering.BlendMode)blendProps[1].floatValue;
EditorGUI.BeginChangeCheck();
float f = EditorGUIUtility.fieldWidth;
float l = EditorGUIUtility.labelWidth;
EditorGUIUtility.fieldWidth = 110f;
EditorGUIUtility.labelWidth -= Mathf.Abs(f - EditorGUIUtility.fieldWidth);
blendSrc = (UnityEngine.Rendering.BlendMode)EditorGUILayout.EnumPopup("Source Factor", blendSrc);
blendDst = (UnityEngine.Rendering.BlendMode)EditorGUILayout.EnumPopup("Destination Factor", blendDst);
EditorGUIUtility.fieldWidth = f;
EditorGUIUtility.labelWidth = l;
if (EditorGUI.EndChangeCheck())
{
blendProps[0].floatValue = (float)blendSrc;
blendProps[1].floatValue = (float)blendDst;
}
}
}
TCP2_GUI.Separator();
//--------------------------------------------------------------------------------------
if (EditorGUI.EndChangeCheck())
{
PropertiesChanged();
}
}
//Update Keywords
if (updateKeywords)
{
if (targets != null && targets.Length > 0)
{
foreach (Object t in targets)
{
(t as Material).shaderKeywords = keywordsList.ToArray();
EditorUtility.SetDirty(t);
}
}
else
{
targetMaterial.shaderKeywords = keywordsList.ToArray();
EditorUtility.SetDirty(targetMaterial);
}
}
#endif
}
//Generate the source code for the shader as a string
static private string GenerateShaderSource(this TCP2_Config config, TCP2_ShaderGenerator.ShaderGeneratorTemplate template, Shader existingShader = null)
{
if (config == null)
{
string error = "[TCP2 Shader Generator] Config file is null";
Debug.LogError(error);
return(error);
}
if (template == null)
{
string error = "[TCP2 Shader Generator] Template is null";
Debug.LogError(error);
return(error);
}
if (template.textAsset == null || string.IsNullOrEmpty(template.textAsset.text))
{
string error = "[TCP2 Shader Generator] Template string is null or empty";
Debug.LogError(error);
return(error);
}
//------------------------------------------------
// SHADER PARAMETERS
//Old hard-coded dependencies
if (!template.newSystem)
{
//Custom Lighting
bool customLighting = NeedCustomLighting(config) || HasFeatures(config, "CUSTOM_LIGHTING_FORCE");
if (customLighting && !config.Features.Contains("CUSTOM_LIGHTING"))
{
config.Features.Add("CUSTOM_LIGHTING");
}
else if (!customLighting && config.Features.Contains("CUSTOM_LIGHTING"))
{
config.Features.Remove("CUSTOM_LIGHTING");
}
//Custom Ambient
bool customAmbient = NeedCustomAmbient(config) || HasFeatures(config, "CUSTOM_AMBIENT_FORCE");
if (customAmbient && !config.Features.Contains("CUSTOM_AMBIENT"))
{
config.Features.Add("CUSTOM_AMBIENT");
}
else if (!customAmbient && config.Features.Contains("CUSTOM_AMBIENT"))
{
config.Features.Remove("CUSTOM_AMBIENT");
}
//Specific dependencies
if (HasFeatures(config, "MATCAP_ADD", "MATCAP_MULT"))
{
if (!config.Features.Contains("MATCAP"))
{
config.Features.Add("MATCAP");
}
}
else
{
if (config.Features.Contains("MATCAP"))
{
config.Features.Remove("MATCAP");
}
}
}
//Masks
bool mask1 = false, mask2 = false, mask3 = false, vcolors_mask = false;
string mask1features = "";
string mask2features = "";
string mask3features = "";
//Enable Masks according to their dependencies
foreach (KeyValuePair <string, string> kvp in config.Keywords)
{
if (kvp.Value == "mask1")
{
mask1 |= GetMaskDependency(config, kvp.Key); if (mask1)
{
mask1features += GetDisplayNameForMask(kvp.Key) + ",";
}
}
else if (kvp.Value == "mask2")
{
mask2 |= GetMaskDependency(config, kvp.Key); if (mask2)
{
mask2features += GetDisplayNameForMask(kvp.Key) + ",";
}
}
else if (kvp.Value == "mask3")
{
mask3 |= GetMaskDependency(config, kvp.Key); if (mask3)
{
mask3features += GetDisplayNameForMask(kvp.Key) + ",";
}
}
else if (kvp.Value == "IN.color")
{
vcolors_mask |= GetMaskDependency(config, kvp.Key);
}
}
//Only enable Independent UVs if relevant Mask is actually enabled
foreach (KeyValuePair <string, string> kvp in config.Keywords)
{
if (kvp.Key == "UV_mask1")
{
ToggleSingleFeature(config.Features, "UVMASK1", kvp.Value == "Independent UV" && mask1);
}
else if (kvp.Key == "UV_mask2")
{
ToggleSingleFeature(config.Features, "UVMASK2", kvp.Value == "Independent UV" && mask2);
}
else if (kvp.Key == "UV_mask3")
{
ToggleSingleFeature(config.Features, "UVMASK3", kvp.Value == "Independent UV" && mask3);
}
}
mask1features = mask1features.TrimEnd(',');
mask2features = mask2features.TrimEnd(',');
mask3features = mask3features.TrimEnd(',');
ToggleSingleFeature(config.Features, "MASK1", mask1);
ToggleSingleFeature(config.Features, "MASK2", mask2);
ToggleSingleFeature(config.Features, "MASK3", mask3);
ToggleSingleFeature(config.Features, "VCOLORS_MASK", vcolors_mask);
//---
Dictionary <string, string> keywords = new Dictionary <string, string>(config.Keywords);
List <string> flags = new List <string>(config.Flags);
List <string> features = new List <string>(config.Features);
//Unity version
#if UNITY_5_4_OR_NEWER
TCP2_Utils.AddIfMissing(features, "UNITY_5_4");
#endif
//Masks
keywords.Add("MASK1", mask1features);
keywords.Add("MASK2", mask2features);
keywords.Add("MASK3", mask3features);
//Shader name
keywords.Add("SHADER_NAME", config.ShaderName);
//Include path
string include = GetIncludePrefix(config) + GetIncludeRelativePath(config, existingShader) + GetIncludeFile(config);
keywords.Add("INCLUDE_PATH", include);
//Lighting Model
if (!template.newSystem)
{
string lightingModel = GetLightingFunction(config);
keywords.Add("LIGHTING_MODEL", lightingModel);
}
//SurfaceOutput struct
string surfOut = GetSurfaceOutput(config);
keywords.Add("SURFACE_OUTPUT", surfOut);
//Shader Model target
string target = GetShaderTarget(config);
keywords.Add("SHADER_TARGET", target);
if (config.shaderTarget == 20)
{
TCP2_Utils.AddIfMissing(features, "FORCE_SM2");
}
if (!template.newSystem)
{
//Vertex Function
bool vertexFunction = NeedVertexFunction(config);
if (vertexFunction)
{
TCP2_Utils.AddIfMissing(flags, "vertex:vert");
features.Add("VERTEX_FUNC");
}
//Final Colors Function
bool finalColorFunction = NeedFinalColorFunction(config);
if (finalColorFunction)
{
TCP2_Utils.AddIfMissing(flags, "finalcolor:fcolor");
features.Add("FINAL_COLOR");
}
//Alpha Testing (Cutout)
if (HasFeatures(config, "CUTOUT"))
{
TCP2_Utils.AddIfMissing(flags, "alphatest:_Cutoff");
}
}
#if UNITY_5
//Alpha
if (HasFeatures(config, "ALPHA"))
{
TCP2_Utils.AddIfMissing(flags, "keepalpha");
}
#endif
//Shadows
if (HasFeatures(config, "CUTOUT"))
{
TCP2_Utils.AddIfMissing(flags, "addshadow");
}
//No/Custom Ambient
if (HasFeatures(config, "CUSTOM_AMBIENT"))
{
TCP2_Utils.AddIfMissing(flags, "noambient");
}
//Generate Surface parameters
string strFlags = ArrayToString(flags.ToArray(), " ");
keywords.Add("SURF_PARAMS", strFlags);
//------------------------------------------------
// PARSING & GENERATION
System.Text.StringBuilder sb = new System.Text.StringBuilder();
string[] templateLines = template.textAsset.text.Split(new string[] { "\r\n", "\n" }, System.StringSplitOptions.None);
int depth = -1;
List <bool> stack = new List <bool>();
List <bool> done = new List <bool>();
//Parse template file
string line = null;
for (int i = 0; i < templateLines.Length; i++)
{
line = templateLines[i];
//Comment
if (line.StartsWith("#"))
{
//Meta
if (line.StartsWith("#CONFIG="))
{
config.configType = line.Substring(8).TrimEnd().ToLower();
}
//Features UI
if (line.StartsWith("#FEATURES"))
{
while (i < templateLines.Length)
{
i++;
if (templateLines[i] == "#END")
{
break;
}
}
continue;
}
//Keywords
if (line.StartsWith("#KEYWORDS"))
{
while (i < templateLines.Length)
{
i++;
if (templateLines[i] == "#END")
{
break;
}
string error = ProcessKeywords(templateLines[i], ref features, ref flags, ref keywords, ref i, ref depth, ref stack, ref done, template.newSystem);
if (!string.IsNullOrEmpty(error))
{
return(error);
}
}
//Update Surface parameters
strFlags = ArrayToString(flags.ToArray(), " ");
if (keywords.ContainsKey("SURF_PARAMS"))
{
keywords["SURF_PARAMS"] = strFlags;
}
else
{
keywords.Add("SURF_PARAMS", strFlags);
}
}
//Debugging
if (line.StartsWith("#break"))
{
Debug.Log("[TCP2] Parse Break @ " + i);
}
continue;
}
//Line break
if (string.IsNullOrEmpty(line) && ((depth >= 0 && stack[depth]) || depth < 0))
{
sb.AppendLine(line);
continue;
}
//Conditions
if (line.Contains("///"))
{
string error = ProcessCondition(line, ref features, ref i, ref depth, ref stack, ref done, template.newSystem);
if (!string.IsNullOrEmpty(error))
{
return(error);
}
}
//Regular line
else
{
//Replace keywords
line = ReplaceKeywords(line, keywords);
//Append line if inside valid condition block
if ((depth >= 0 && stack[depth]) || depth < 0)
{
sb.AppendLine(line);
}
}
}
if (depth >= 0)
{
Debug.LogWarning("[TCP2 Shader Generator] Missing " + (depth + 1) + " ending '///' tags");
}
string sourceCode = sb.ToString();
//Normalize line endings
sourceCode = sourceCode.Replace("\r\n", "\n");
return(sourceCode);
}
