public void Foldout(int xOffset, string name, PoiToon gui)
{
var style = new GUIStyle("ShurikenModuleTitle");
style.font = new GUIStyle(EditorStyles.label).font;
style.border = new RectOffset(15, 7, 4, 4);
style.fixedHeight = 22;
style.contentOffset = new Vector2(20f, -2f);
style.margin.left = 30 * xOffset;
var rect = GUILayoutUtility.GetRect(16f + 20f, 22f, style);
GUI.Box(rect, name, style);
var e = Event.current;
var toggleRect = new Rect(rect.x + 4f, rect.y + 2f, 13f, 13f);
if (e.type == EventType.Repaint)
{
EditorStyles.foldout.Draw(toggleRect, false, false, getState(), false);
}
if (e.type == EventType.MouseDown && rect.Contains(e.mousePosition))
{
this.Toggle();
e.Use();
gui.sendActiveShader = true;
}
}
//test if the path to the presets has changed
public void testPresetsChanged(MaterialProperty[] props)
{
MaterialProperty presetsProperty = PoiToon.FindProperty(props, "shader_presets");
if (!(presetsProperty == null))
{
testPresetsChanged(presetsProperty);
}
else
{
hasPresets = false;
}
}
public static void restorePoiMaterials()
{
StreamReader reader = new StreamReader(POI_MATERIALS_FILE_PATH);
string l;
while ((l = reader.ReadLine()) != null)
{
string[] materialData = l.Split(new string[] { ":" }, System.StringSplitOptions.None);
Material material = AssetDatabase.LoadAssetAtPath <Material>(AssetDatabase.GUIDToAssetPath(materialData[0]));
Shader shader = Shader.Find(materialData[1]);
material.shader = shader;
material.renderQueue = int.Parse(materialData[2]);
PoiToon.UpdateRenderQueue(material, shader);
}
RepaintAllMaterialEditors();
reader.Close();
}
public static void updateQueueShadersIfNessecary()
{
string[] guids = AssetDatabase.FindAssets("poiUpdatedShaders");
if (guids.Length == 0)
{
return;
}
string file_path = AssetDatabase.GUIDToAssetPath(guids[0]);
if (!file_path.Contains("/poiUpdatedShaders"))
{
return;
}
StreamReader reader = new StreamReader(file_path);
string shader_file_name;
List <Material> materialsToUpdate = new List <Material>();
List <int> renderQueues = new List <int>();
while ((shader_file_name = reader.ReadLine()) != null)
{
//for each updated shader
string[] shaderGuids = AssetDatabase.FindAssets(shader_file_name);
string defaultShaderGuid = null;
foreach (string g in shaderGuids)
{
if (AssetDatabase.GUIDToAssetPath(g).EndsWith(shader_file_name + ".shader"))
{
defaultShaderGuid = g;
}
}
if (defaultShaderGuid == null)
{
continue;
}
Shader defaultShader = AssetDatabase.LoadAssetAtPath <Shader>(AssetDatabase.GUIDToAssetPath(defaultShaderGuid));
string[] matGuids = AssetDatabase.FindAssets("t:material");
materialsToUpdate.Clear();
renderQueues.Clear();
foreach (string mG in matGuids)
{
Material material = AssetDatabase.LoadAssetAtPath <Material>(AssetDatabase.GUIDToAssetPath(mG));
if (material.shader.name.Contains(defaultShader.name) && material.shader.name.Length > defaultShader.name.Length)
{
materialsToUpdate.Add(material);
renderQueues.Add(material.renderQueue);
material.shader = defaultShader;
}
}
for (int i = 0; i < shaderGuids.Length; i++)
{
if (shaderGuids[i] != defaultShaderGuid)
{
AssetDatabase.DeleteAsset(AssetDatabase.GUIDToAssetPath(shaderGuids[i]));
}
}
for (int i = 0; i < materialsToUpdate.Count; i++)
{
materialsToUpdate[i].renderQueue = renderQueues[i];
PoiToon.UpdateRenderQueue(materialsToUpdate[i], defaultShader);
}
}
reader.Close();
File.Delete(file_path);
AssetDatabase.DeleteAsset(file_path);
}
public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
{
Material material = materialEditor.target as Material;
HeaderInit(materialEditor);
// map shader properties to script variables
FindProperties(props);
// set up style for the base look
SetupStyle();
// load default toggle values
LoadDefaults(material);
DrawMasterLabel();
// main section
m_mainOptions = PoiToonUI.Foldout("Main", m_mainOptions);
if (m_mainOptions.getState())
{
EditorGUILayout.Space();
materialEditor.ShaderProperty(m_color, Styles.Color);
materialEditor.ShaderProperty(m_desaturation, Styles.Desaturation);
materialEditor.ShaderProperty(m_mainTex, Styles.MainTex);
materialEditor.ShaderProperty(m_normalMap, Styles.NormalMap);
materialEditor.ShaderProperty(m_normalIntensity, Styles.NormalIntensity);
materialEditor.ShaderProperty(m_clip, Styles.Clip);
EditorGUILayout.Space();
}
m_metallicOptions = PoiToonUI.Foldout("Metallic", m_metallicOptions);
if (m_metallicOptions.getState())
{
EditorGUILayout.Space();
materialEditor.ShaderProperty(m_cubeMap, Styles.CubeMap);
materialEditor.ShaderProperty(m_sampleWorld, Styles.SampleWorld);
materialEditor.ShaderProperty(m_metallicMap, Styles.MetallicMap);
materialEditor.ShaderProperty(m_metallic, Styles.Metallic);
materialEditor.ShaderProperty(m_roughnessMap, Styles.RoughnessMap);
materialEditor.ShaderProperty(m_roughness, Styles.Roughness);
EditorGUILayout.Space();
}
// outline section
m_outlineOptions = PoiToonUI.Foldout("Outline", m_outlineOptions);
if (m_outlineOptions.getState())
{
EditorGUILayout.Space();
materialEditor.ShaderProperty(m_lineWidth, Styles.LineWidth);
materialEditor.ShaderProperty(m_outlineColor, Styles.OutlineColor);
materialEditor.ShaderProperty(m_outlineEmission, Styles.OutlineEmission);
materialEditor.ShaderProperty(m_outlineTexture, Styles.OutlineTexture);
materialEditor.ShaderProperty(m_speed, Styles.Speed);
EditorGUILayout.Space();
}
// emissive section
m_emissionOptions = PoiToonUI.Foldout("Emission", m_emissionOptions);
if (m_emissionOptions.getState())
{
EditorGUILayout.Space();
materialEditor.ShaderProperty(m_emissionColor, Styles.EmissionColor);
materialEditor.ShaderProperty(m_emissionMap, Styles.EmissionMap);
materialEditor.ShaderProperty(m_emissionScrollSpeed, Styles.EmissionScrollSpeed);
materialEditor.ShaderProperty(m_emissionStrength, Styles.EmissionStrength);
EditorGUILayout.Space();
materialEditor.ShaderProperty(m_emissiveBlinkMin, Styles.EmissiveBlinkMin);
materialEditor.ShaderProperty(m_emissiveBlinkMax, Styles.EmissiveBlinkMax);
materialEditor.ShaderProperty(m_emissiveBlinkVelocity, Styles.EmissiveBlinkVelocity);
EditorGUILayout.Space();
materialEditor.ShaderProperty(m_emissiveScrollEnabled, Styles.EmissiveScrollEnabled);
materialEditor.ShaderProperty(m_emissiveScrollDirection, Styles.EmissiveScrollDirection);
materialEditor.ShaderProperty(m_emissiveScrollWidth, Styles.EmissiveScrollWidth);
materialEditor.ShaderProperty(m_emissiveScrollVelocity, Styles.EmissiveScrollVelocity);
materialEditor.ShaderProperty(m_emissiveScrollInterval, Styles.EmissiveScrollInterval);
EditorGUILayout.Space();
}
// fake lighting
m_fakeLightingOptions = PoiToonUI.Foldout("Fake Lighting", m_fakeLightingOptions);
if (m_fakeLightingOptions.getState())
{
EditorGUILayout.Space();
materialEditor.ShaderProperty(m_lightingGradient, Styles.LightingGradient);
materialEditor.ShaderProperty(m_lightingShadowStrength, Styles.LightingShadowStrength);
materialEditor.ShaderProperty(m_lightingShadowOffset, Styles.LightingShadowOffsett);
materialEditor.ShaderProperty(m_forceLightDirection, Styles.ForceLightDirection);
materialEditor.ShaderProperty(m_lightingDirection, Styles.LightingDirection);
materialEditor.ShaderProperty(m_minBrightness, Styles.MinBrightness);
materialEditor.ShaderProperty(m_maxDirectionalIntensity, Styles.MaxDirectionalIntensity);
materialEditor.ShaderProperty(m_additiveRamp, Styles.AdditiveRamp);
EditorGUILayout.Space();
}
// Specular Highlights
m_specularHighlightsOptions = PoiToonUI.Foldout("Specular Highlight", m_specularHighlightsOptions);
if (m_specularHighlightsOptions.getState())
{
EditorGUILayout.Space();
materialEditor.ShaderProperty(m_specularMap, Styles.SpecularMap);
materialEditor.ShaderProperty(m_gloss, Styles.Gloss);
materialEditor.ShaderProperty(m_specularColor, Styles.SpecularColor);
materialEditor.ShaderProperty(m_specularStrength, Styles.SpecularStrength);
materialEditor.ShaderProperty(m_specularBias, Styles.SpecularBias);
materialEditor.ShaderProperty(m_hardSpecular, Styles.HardSpecular);
materialEditor.ShaderProperty(m_specularSize, Styles.SpecularSize);
EditorGUILayout.Space();
}
// Rim Lighting
m_rimLightOptions = PoiToonUI.Foldout("Rim Lighting", m_rimLightOptions);
if (m_rimLightOptions.getState())
{
EditorGUILayout.Space();
materialEditor.ShaderProperty(m_rimColor, Styles.RimColor);
materialEditor.ShaderProperty(m_rimStrength, Styles.RimGlowStrength);
materialEditor.ShaderProperty(m_rimSharpness, Styles.RimSharpness);
materialEditor.ShaderProperty(m_rimWidth, Styles.RimWidth);
materialEditor.ShaderProperty(m__rimLightColorBias, Styles.RimColorBias);
materialEditor.ShaderProperty(m_rimTex, Styles.RimTexture);
materialEditor.ShaderProperty(m_rimTexPanSpeed, Styles.RimTexturePanSpeed);
EditorGUILayout.Space();
}
m_stencilOptions = PoiToonUI.Foldout("Stencil", m_stencilOptions);
if (m_stencilOptions.getState())
{
EditorGUILayout.Space();
materialEditor.ShaderProperty(m_stencilRef, Styles.StencilRef);
materialEditor.ShaderProperty(m_stencilCompareFunction, Styles.StencilCompareFunction);
materialEditor.ShaderProperty(m_stencilOp, Styles.StencilOp);
EditorGUILayout.Space();
}
m_miscOptions = PoiToonUI.Foldout("Misc", m_miscOptions);
if (m_miscOptions.getState())
{
EditorGUILayout.Space();
materialEditor.ShaderProperty(m_cullMode, Styles.CullMode);
materialEditor.ShaderProperty(m_srcBlend, Styles.SrcBlend);
materialEditor.ShaderProperty(m_dstBlend, Styles.DstBlend);
materialEditor.ShaderProperty(m_zTest, Styles.ZTest);
EditorGUILayout.Space();
}
ToggleDefines(material);
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
PoiToon.linkButton(70, 20, "Github", "https://github.com/poiyomi/PoiyomiToonShader");
GUILayout.Space(2);
PoiToon.linkButton(70, 20, "Discord", "https://discord.gg/Ays52PY");
GUILayout.Space(2);
PoiToon.linkButton(70, 20, "Donate", "https://www.paypal.me/poiyomi");
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
}
public void applyPreset(string presetName, MaterialProperty[] props, Material[] materials)
{
List <string[]> sets;
if (presets.TryGetValue(presetName, out sets))
{
foreach (string[] set in sets)
{
MaterialProperty p = PoiToon.FindProperty(props, set[0]);
if (p != null)
{
if (p.type == MaterialProperty.PropType.Texture)
{
string[] guids = AssetDatabase.FindAssets(set[1] + " t:Texture", null);
if (guids.Length == 0)
{
Debug.LogError("Couldn't find texture: " + set[1]);
}
else
{
string path = AssetDatabase.GUIDToAssetPath(guids[0]);
Texture tex = (Texture)EditorGUIUtility.Load(path);
foreach (Material m in materials)
{
m.SetTexture(Shader.PropertyToID(set[0]), tex);
}
}
}
else if (p.type == MaterialProperty.PropType.Float || p.type == MaterialProperty.PropType.Range)
{
float value;
if (float.TryParse(set[1], out value))
{
foreach (Material m in materials)
{
m.SetFloat(Shader.PropertyToID(set[0]), value);
}
}
}
else if (p.type == MaterialProperty.PropType.Vector)
{
string[] xyzw = set[1].Split(",".ToCharArray());
Vector4 vector = new Vector4(float.Parse(xyzw[0]), float.Parse(xyzw[1]), float.Parse(xyzw[2]), float.Parse(xyzw[3]));
foreach (Material m in materials)
{
m.SetVector(Shader.PropertyToID(set[0]), vector);
}
}
else if (p.type == MaterialProperty.PropType.Color)
{
float[] rgb = new float[3];
string[] rgbString = set[1].Split(',');
float.TryParse(rgbString[0], out rgb[0]);
float.TryParse(rgbString[1], out rgb[1]);
float.TryParse(rgbString[2], out rgb[2]);
foreach (Material m in materials)
{
m.SetColor(Shader.PropertyToID(set[0]), new Color(rgb[0], rgb[1], rgb[2]));
}
}
}
else if (set[0] == "render_queue")
{
int q = 0;
Debug.Log(set[0] + "," + set[1]);
if (int.TryParse(set[1], out q))
{
foreach (Material m in materials)
{
m.renderQueue = q;
}
}
}
}
}
}
