private void DrawShadowSettings(MaterialEditor materialEditor, Material material)
{
showShadows = XSStyles.ShurikenFoldout("Shadows", showShadows);
if (showShadows)
{
materialEditor.TexturePropertySingleLine(new GUIContent("Ramp Selection Mask", "A black to white mask that determins how far up on the multi ramp to sample. 0 for bottom, 1 for top, 0.5 for middle, 0.25, and 0.75 for mid bottom and mid top respectively."), _RampSelectionMask);
XSStyles.SeparatorThin();
if (_RampSelectionMask.textureValue != null)
{
string rampMaskPath = AssetDatabase.GetAssetPath(_RampSelectionMask.textureValue);
TextureImporter ti = (TextureImporter)TextureImporter.GetAtPath(rampMaskPath);
if (ti.sRGBTexture)
{
if (XSStyles.HelpBoxWithButton(new GUIContent("This texture is not marked as Linear.", "This is recommended for the mask"), new GUIContent("Fix Now")))
{
ti.sRGBTexture = false;
AssetDatabase.ImportAsset(rampMaskPath, ImportAssetOptions.ForceUpdate);
AssetDatabase.Refresh();
}
}
}
materialEditor.TexturePropertySingleLine(new GUIContent("Shadow Ramp", "Shadow Ramp, Dark to Light should be Left to Right"), _Ramp);
materialEditor.ShaderProperty(_ShadowSharpness, new GUIContent("Shadow Sharpness", "Controls the sharpness of recieved shadows, as well as the sharpness of 'shadows' from Vertex Lighting."));
XSStyles.SeparatorThin();
materialEditor.TexturePropertySingleLine(new GUIContent("Occlusion Map", "Occlusion Map, used to darken areas on the model artifically."), _OcclusionMap);
XSStyles.constrainedShaderProperty(materialEditor, _OcclusionColor, new GUIContent("Occlusion Tint", "Occlusion shadow tint."), 2);
materialEditor.ShaderProperty(_UVSetOcclusion, new GUIContent("UV Set", "The UV set to use for the Occlusion Texture"), 2);
materialEditor.TextureScaleOffsetProperty(_OcclusionMap);
XSStyles.SeparatorThin();
XSStyles.constrainedShaderProperty(materialEditor, _ShadowRim, new GUIContent("Shadow Rim", "Shadow Rim Color. Set to white to disable."), 0);
materialEditor.ShaderProperty(_ShadowRimAlbedoTint, new GUIContent("Shadow Rim Albedo Tint", "How much the Albedo texture should effect the Shadow Rim color."));
materialEditor.ShaderProperty(_ShadowRimRange, new GUIContent("Range", "Range of the Shadow Rim"), 2);
materialEditor.ShaderProperty(_ShadowRimThreshold, new GUIContent("Threshold", "Threshold of the Shadow Rim"), 2);
materialEditor.ShaderProperty(_ShadowRimSharpness, new GUIContent("Sharpness", "Sharpness of the Shadow Rim"), 2);
XSStyles.callGradientEditor(material);
}
}
public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
{
Material material = materialEditor.target as Material;
Shader shader = material.shader;
isCutout = shader.name.Contains("Cutout") && !shader.name.Contains("A2C");
isOutlined = shader.name.Contains("Outline");
//Find all material properties listed in the script using reflection, and set them using a loop only if they're of type MaterialProperty.
//This makes things a lot nicer to maintain and cleaner to look at.
foreach (var property in GetType().GetFields(bindingFlags))
{
if (property.FieldType == typeof(MaterialProperty))
{
property.SetValue(this, FindProperty(property.Name, props));
}
}
EditorGUI.BeginChangeCheck();
{
if (!isCutout) // Do this to make sure that if you're using AlphaToCoverage that you fallback to cutout with 0.5 Cutoff if your shaders are blocked.
{
material.SetFloat("_Cutoff", 0.5f);
}
XSStyles.ShurikenHeaderCentered("XSToon v" + XSStyles.ver);
showMainSettings = XSStyles.ShurikenFoldout("Main Settings", showMainSettings);
if (showMainSettings)
{
materialEditor.TexturePropertySingleLine(new GUIContent("Main Texture", "The Main Texture."), _MainTex, _Color);
if (isCutout)
{
materialEditor.ShaderProperty(_Cutoff, new GUIContent("Cutoff", "The Cutoff Amount"), 2);
}
materialEditor.ShaderProperty(_UVSetAlbedo, new GUIContent("UV Set", "The UV set to use for the Albedo Texture"), 2);
materialEditor.TextureScaleOffsetProperty(_MainTex);
materialEditor.ShaderProperty(_Saturation, new GUIContent("Saturation", "Controls saturation of the final output from the shader."));
materialEditor.ShaderProperty(_Culling, _Culling.displayName);
materialEditor.ShaderProperty(_AdvMode, "Shader Mode");
}
showShadows = XSStyles.ShurikenFoldout("Shadows", showShadows);
if (showShadows)
{
materialEditor.TexturePropertySingleLine(new GUIContent("Shadow Ramp", "Shadow Ramp, Dark to Light should be Left to Right, or Down to Up"), _Ramp);
materialEditor.ShaderProperty(_ShadowSharpness, new GUIContent("Shadow Sharpness", "Only affects recieved shadows and self shadows. Does not affect shadow ramp. You need a realtime directional light with shadows to see changes from this!"));
GUILayout.Space(5);
materialEditor.TexturePropertySingleLine(new GUIContent("Occlusion Map", "Occlusion Map, used to darken areas on the model artifically."), _OcclusionMap);
XSStyles.constrainedShaderProperty(materialEditor, _OcclusionColor, new GUIContent("Occlusion Tint", "Occlusion shadow tint."), 2);
materialEditor.ShaderProperty(_UVSetOcclusion, new GUIContent("UV Set", "The UV set to use for the Occlusion Texture"), 2);
GUILayout.Space(5);
XSStyles.constrainedShaderProperty(materialEditor, _ShadowRim, new GUIContent("Shadow Rim", "Shadow Rim Color. Set to white to disable."), 0);
materialEditor.ShaderProperty(_ShadowRimRange, new GUIContent("Range", "Range of the Shadow Rim"), 2);
materialEditor.ShaderProperty(_ShadowRimThreshold, new GUIContent("Threshold", "Threshold of the Shadow Rim"), 2);
materialEditor.ShaderProperty(_ShadowRimSharpness, new GUIContent("Sharpness", "Sharpness of the Shadow Rim"), 2);
XSStyles.callGradientEditor(material);
}
if (isOutlined)
{
showOutlines = XSStyles.ShurikenFoldout("Outlines", showOutlines);
if (showOutlines)
{
materialEditor.TexturePropertySingleLine(new GUIContent("Outline Mask", "Outline width mask, black will make the outline minimum width."), _OutlineMask);
materialEditor.ShaderProperty(_OutlineWidth, new GUIContent("Outline Width", "Width of the Outlines"));
XSStyles.constrainedShaderProperty(materialEditor, _OutlineColor, new GUIContent("Outline Color", "Color of the outlines"), 0);
}
}
showNormalMapSettings = XSStyles.ShurikenFoldout("Normal Maps", showNormalMapSettings);
if (showNormalMapSettings)
{
materialEditor.TexturePropertySingleLine(new GUIContent("Normal Map", "Normal Map"), _BumpMap);
materialEditor.ShaderProperty(_BumpScale, new GUIContent("Normal Strength", "Strength of the main Normal Map"), 2);
materialEditor.ShaderProperty(_UVSetNormal, new GUIContent("UV Set", "The UV set to use for the Normal Map"), 2);
materialEditor.TextureScaleOffsetProperty(_BumpMap);
GUILayout.Space(5);
materialEditor.TexturePropertySingleLine(new GUIContent("Detail Normal Map", "Detail Normal Map"), _DetailNormalMap);
materialEditor.ShaderProperty(_DetailNormalMapScale, new GUIContent("Detail Normal Strength", "Strength of the detail Normal Map"), 2);
materialEditor.ShaderProperty(_UVSetDetNormal, new GUIContent("UV Set", "The UV set to use for the Detail Normal Map"), 2);
materialEditor.TextureScaleOffsetProperty(_DetailNormalMap);
GUILayout.Space(5);
materialEditor.TexturePropertySingleLine(new GUIContent("Detail Mask", "Mask for Detail Normal Map"), _DetailMask);
materialEditor.ShaderProperty(_UVSetDetMask, new GUIContent("UV Set", "The UV set to use for the Detail Mask"), 2);
materialEditor.TextureScaleOffsetProperty(_DetailMask);
}
showSpecular = XSStyles.ShurikenFoldout("Specular", showSpecular);
if (showSpecular)
{
materialEditor.ShaderProperty(_SpecMode, new GUIContent("Specular Mode", "Specular Mode."));
materialEditor.ShaderProperty(_SpecularStyle, new GUIContent("Specular Style", "Specular Style."));
materialEditor.TexturePropertySingleLine(new GUIContent("Specular Map(R,G,B)", "Specular Map. Red channel controls Intensity, Green controls how much specular is tinted by Albedo, and Blue controls Smoothness (Only for Blinn-Phong, and GGX)."), _SpecularMap);
materialEditor.TextureScaleOffsetProperty(_SpecularMap);
materialEditor.ShaderProperty(_UVSetSpecular, new GUIContent("UV Set", "The UV set to use for the Specular Map"), 2);
materialEditor.ShaderProperty(_SpecularIntensity, new GUIContent("Specular Intensity", "Specular Intensity."), 2);
materialEditor.ShaderProperty(_SpecularAlbedoTint, new GUIContent("Specular Albedo Tint", "How much the specular highlight should derive color from the albedo of the object."), 2);
if (_SpecMode.floatValue == 0 || _SpecMode.floatValue == 2)
{
materialEditor.ShaderProperty(_SpecularArea, new GUIContent("Specular Area", "Specular Area."), 2);
}
else
{
materialEditor.ShaderProperty(_AnisotropicAX, new GUIContent("Anisotropic Width", "Anisotropic Width"), 2);
materialEditor.ShaderProperty(_AnisotropicAY, new GUIContent("Anisotropic Height", "Anisotropic Height"), 2);
}
}
showReflection = XSStyles.ShurikenFoldout("Reflections", showReflection);
if (showReflection)
{
materialEditor.ShaderProperty(_ReflectionMode, new GUIContent("Reflection Mode", "Reflection Mode."));
if (_ReflectionMode.floatValue == 0) // PBR
{
materialEditor.ShaderProperty(_ReflectionBlendMode, new GUIContent("Reflection Blend Mode", "Blend mode for reflection. Additive is Color + reflection, Multiply is Color * reflection, and subtractive is Color - reflection"));
materialEditor.TexturePropertySingleLine(new GUIContent("Fallback Cubemap", " Used as fallback in 'Unity' reflection mode if reflection probe is black."), _BakedCubemap);
materialEditor.TexturePropertySingleLine(new GUIContent("Metallic Map", "Metallic Map, Metallic on Red Channel, Smoothness on Alpha Channel"), _MetallicGlossMap);
materialEditor.TextureScaleOffsetProperty(_MetallicGlossMap);
materialEditor.ShaderProperty(_UVSetMetallic, new GUIContent("UV Set", "The UV set to use for the MetallicSmoothness Map"), 2);
materialEditor.ShaderProperty(_Metallic, new GUIContent("Metallic", "Metallic, set to 1 if using metallic map"), 2);
materialEditor.ShaderProperty(_Glossiness, new GUIContent("Smoothness", "Smoothness, set to 1 if using metallic map"), 2);
}
else if (_ReflectionMode.floatValue == 1) //Baked cube
{
materialEditor.ShaderProperty(_ReflectionBlendMode, new GUIContent("Reflection Blend Mode", "Blend mode for reflection. Additive is Color + reflection, Multiply is Color * reflection, and subtractive is Color - reflection"));
materialEditor.TexturePropertySingleLine(new GUIContent("Baked Cubemap", "Baked cubemap."), _BakedCubemap);
materialEditor.TexturePropertySingleLine(new GUIContent("Metallic Map", "Metallic Map, Metallic on Red Channel, Smoothness on Alpha Channel"), _MetallicGlossMap);
materialEditor.TextureScaleOffsetProperty(_MetallicGlossMap);
materialEditor.ShaderProperty(_UVSetMetallic, new GUIContent("UV Set", "The UV set to use for the MetallicSmoothness Map"), 2);
materialEditor.ShaderProperty(_Metallic, new GUIContent("Metallic", "Metallic, set to 1 if using metallic map"), 2);
materialEditor.ShaderProperty(_Glossiness, new GUIContent("Smoothness", "Smoothness, set to 1 if using metallic map"), 2);
}
else if (_ReflectionMode.floatValue == 2) //Matcap
{
materialEditor.ShaderProperty(_ReflectionBlendMode, new GUIContent("Reflection Blend Mode", "Blend mode for reflection. Additive is Color + reflection, Multiply is Color * reflection, and subtractive is Color - reflection"));
materialEditor.TexturePropertySingleLine(new GUIContent("Matcap", "Matcap Texture"), _Matcap);
materialEditor.ShaderProperty(_Glossiness, new GUIContent("Matcap Blur", "Matcap blur, blurs the Matcap, set to 1 for full clarity"), 2);
material.SetFloat("_Metallic", 0);
material.SetTexture("_MetallicGlossMap", null);
}
if (_ReflectionMode.floatValue != 3)
{
materialEditor.TexturePropertySingleLine(new GUIContent("Reflectivity Mask", "Mask for reflections."), _ReflectivityMask);
materialEditor.TextureScaleOffsetProperty(_ReflectivityMask);
materialEditor.ShaderProperty(_UVSetReflectivity, new GUIContent("UV Set", "The UV set to use for the Reflectivity Mask"), 2);
materialEditor.ShaderProperty(_Reflectivity, new GUIContent("Reflectivity", "The strength of the reflections."), 2);
}
if (_ReflectionMode.floatValue == 3)
{
material.SetFloat("_Metallic", 0);
material.SetFloat("_ReflectionBlendMode", 0);
}
}
showEmission = XSStyles.ShurikenFoldout("Emission", showEmission);
if (showEmission)
{
materialEditor.TexturePropertySingleLine(new GUIContent("Emission Map", "Emissive map. White to black, unless you want multiple colors."), _EmissionMap, _EmissionColor);
materialEditor.ShaderProperty(_UVSetEmission, new GUIContent("UV Set", "The UV set to use for the Emission Map"), 2);
materialEditor.TextureScaleOffsetProperty(_EmissionMap);
}
showRimlight = XSStyles.ShurikenFoldout("Rimlight", showRimlight);
if (showRimlight)
{
materialEditor.ShaderProperty(_RimIntensity, new GUIContent("Rimlight Intensity", "Strnegth of the Rimlight."));
materialEditor.ShaderProperty(_RimRange, new GUIContent("Range", "Range of the Rim"), 2);
materialEditor.ShaderProperty(_RimThreshold, new GUIContent("Threshold", "Threshold of the Rim"), 2);
materialEditor.ShaderProperty(_RimSharpness, new GUIContent("Sharpness", "Sharpness of the Rim"), 2);
}
showSubsurface = XSStyles.ShurikenFoldout("Subsurface Scattering", showSubsurface);
if (showSubsurface)
{
materialEditor.TexturePropertySingleLine(new GUIContent("Thickness Map", "Thickness Map, used to mask areas where subsurface can happen"), _ThicknessMap);
materialEditor.TextureScaleOffsetProperty(_ThicknessMap);
materialEditor.ShaderProperty(_UVSetThickness, new GUIContent("UV Set", "The UV set to use for the Thickness Map"), 2);
XSStyles.constrainedShaderProperty(materialEditor, _SSColor, new GUIContent("Subsurface Color", "Subsurface Scattering Color"), 2);
materialEditor.ShaderProperty(_SSDistortion, new GUIContent("Subsurface Distortion", "How much the subsurface follows the normals of the mesh, Normal map."), 2);
materialEditor.ShaderProperty(_SSPower, new GUIContent("Subsurface Power", "Subsurface Power"), 2);
materialEditor.ShaderProperty(_SSScale, new GUIContent("Subsurface Scale", "Subsurface Scale"), 2);
materialEditor.ShaderProperty(_SSSRange, new GUIContent("Subsurface Range", "Subsurface Range"), 2);
materialEditor.ShaderProperty(_SSSSharpness, new GUIContent("Subsurface Sharpness", "Subsurface Sharpness"), 2);
}
if (_AdvMode.floatValue == 1)
{
showAdvanced = XSStyles.ShurikenFoldout("Advanced Settings", showAdvanced);
if (showAdvanced)
{
materialEditor.ShaderProperty(_Stencil, _Stencil.displayName);
materialEditor.ShaderProperty(_StencilComp, _StencilComp.displayName);
materialEditor.ShaderProperty(_StencilOp, _StencilOp.displayName);
}
}
XSStyles.DoFooter();
}
}
//static bool disableOutlinePass = false;
public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
{
XSStyles.setupIcons();
Material material = materialEditor.target as Material;
{
//Find all the properties within the shader
shadowRamp = ShaderGUI.FindProperty("_ShadowRamp", props);
specMap = ShaderGUI.FindProperty("_SpecularMap", props);
specPattern = ShaderGUI.FindProperty("_SpecularPattern", props);
tint = ShaderGUI.FindProperty("_Color", props);
mainTex = ShaderGUI.FindProperty("_MainTex", props);
normal = ShaderGUI.FindProperty("_Normal", props);
specIntensity = ShaderGUI.FindProperty("_SpecularIntensity", props);
specArea = ShaderGUI.FindProperty("_SpecularArea", props);
rimWidth = ShaderGUI.FindProperty("_RimWidth", props);
rimIntensity = ShaderGUI.FindProperty("_RimIntensity", props);
emissiveToggle = ShaderGUI.FindProperty("_Emissive", props);
emissiveTex = ShaderGUI.FindProperty("_EmissiveTex", props);
emissiveColor = ShaderGUI.FindProperty("_EmissiveColor", props);
alphaCutoff = ShaderGUI.FindProperty("_Cutoff", props);
culling = ShaderGUI.FindProperty("_Culling", props);
rimStyle = ShaderGUI.FindProperty("_RimlightType", props);
advMode = ShaderGUI.FindProperty("_advMode", props);
reflSmooth = ShaderGUI.FindProperty("_ReflSmoothness", props);
metal = ShaderGUI.FindProperty("_Metallic", props);
metalMap = ShaderGUI.FindProperty("_MetallicMap", props);
roughMap = ShaderGUI.FindProperty("_RoughMap", props);
bakedCube = ShaderGUI.FindProperty("_BakedCube", props);
shadowType = ShaderGUI.FindProperty("_ShadowType", props);
reflType = ShaderGUI.FindProperty("_ReflType", props);
saturation = ShaderGUI.FindProperty("_Saturation", props);
useRefl = ShaderGUI.FindProperty("_UseReflections", props);
matcapStyle = ShaderGUI.FindProperty("_MatcapStyle", props);
stylizedType = ShaderGUI.FindProperty("_StylizedReflStyle", props);
rampColor = ShaderGUI.FindProperty("_RampColor", props);
rimColor = ShaderGUI.FindProperty("_RimColor", props);
aX = ShaderGUI.FindProperty("_anistropicAX", props);
aY = ShaderGUI.FindProperty("_anistropicAY", props);
specStyle = ShaderGUI.FindProperty("_SpecularStyle", props);
detailNormal = ShaderGUI.FindProperty("_DetailNormal", props);
detailMask = ShaderGUI.FindProperty("_DetailMask", props);
normalStrength = ShaderGUI.FindProperty("_NormalStrength", props);
detailNormalStrength = ShaderGUI.FindProperty("_DetailNormalStrength", props);
occlusionMap = ShaderGUI.FindProperty("_OcclusionMap", props);
occlusionStrength = ShaderGUI.FindProperty("_OcclusionStrength", props);
ThicknessMap = ShaderGUI.FindProperty("_ThicknessMap", props);
SSSDist = ShaderGUI.FindProperty("_SSSDist", props);
SSSPow = ShaderGUI.FindProperty("_SSSPow", props);
SSSIntensity = ShaderGUI.FindProperty("_SSSIntensity", props);
SSSCol = ShaderGUI.FindProperty("_SSSCol", props);
invertThickness = ShaderGUI.FindProperty("_invertThickness", props);
ThicknessMapPower = ShaderGUI.FindProperty("_ThicknessMapPower", props);
UseSSS = ShaderGUI.FindProperty("_UseSSS", props);
UseSpecular = ShaderGUI.FindProperty("_UseSpecular", props);
UseUV2Emiss = ShaderGUI.FindProperty("_EmissUv2", props);
EmissScaleWithLight = ShaderGUI.FindProperty("_ScaleWithLight", props);
EmissTintToColor = ShaderGUI.FindProperty("_EmissTintToColor", props);
EmissionPower = ShaderGUI.FindProperty("_EmissionPower", props);
if (material.shader.name.Contains("Outlined")) //Shader.Find("Xiexe/Toon/XSToonCutoutOutlined") || material.shader == Shader.Find("Xiexe/Toon/XSToonOutlined") || material.shader == Shader.Find("Xiexe/Toon/XSToonTransparentDitheredOUTLINED"))
{
OutlineColor = ShaderGUI.FindProperty("_OutlineColor", props);
OutlineThickness = ShaderGUI.FindProperty("_OutlineThickness", props);
OutlineTextureMap = ShaderGUI.FindProperty("_OutlineTextureMap", props);
_LitOutline = ShaderGUI.FindProperty("_LitOutlines", props);
outlined = true;
}
else
{
outlined = false;
outlines = false;
}
_AORAMPMODE_ON = ShaderGUI.FindProperty("_AORAMPMODE_ON", props);
_OcclusionColor = ShaderGUI.FindProperty("_OcclusionColor", props);
_DetailNormalUv2 = ShaderGUI.FindProperty("_DetailNormalUv2", props);
_NormalUv2 = ShaderGUI.FindProperty("_NormalUv2", props);
_MetallicUv2 = ShaderGUI.FindProperty("_MetallicUv2", props);
_SpecularUv2 = ShaderGUI.FindProperty("_SpecularUv2", props);
_SpecularPatternUv2 = ShaderGUI.FindProperty("_SpecularPatternUv2", props);
_AOUV2 = ShaderGUI.FindProperty("_AOUV2", props);
//advanced options
colorMask = ShaderGUI.FindProperty("_colormask", props);
stencil = ShaderGUI.FindProperty("_Stencil", props);
stencilComp = ShaderGUI.FindProperty("_StencilComp", props);
stencilOp = ShaderGUI.FindProperty("_StencilOp", props);
stencilFail = ShaderGUI.FindProperty("_StencilFail", props);
stencilZFail = ShaderGUI.FindProperty("_StencilZFail", props);
zwrite = ShaderGUI.FindProperty("_ZWrite", props);
ztest = ShaderGUI.FindProperty("_ZTest", props);
RampBaseAnchor = ShaderGUI.FindProperty("_RampBaseAnchor", props);
//
//Show Properties in Inspector
//materialEditor.ShaderProperty(, .displayName);
EditorGUI.BeginChangeCheck();
{
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = advMode.hasMixedValue;
var aMode = (DisplayType)advMode.floatValue;
EditorGUI.BeginChangeCheck();
aMode = (DisplayType)EditorGUILayout.Popup("Shader Mode", (int)aMode, Enum.GetNames(typeof(DisplayType)));
if (EditorGUI.EndChangeCheck())
{
materialEditor.RegisterPropertyChangeUndo("Shader Mode");
advMode.floatValue = (float)aMode;
EditorGUI.showMixedValue = false;
}
materialEditor.ShaderProperty(culling, culling.displayName);
//main
//Rect rect = (0,0);
XSStyles.Separator();
EditorGUILayout.BeginHorizontal();
materialEditor.TexturePropertySingleLine(Styles.MainTexText, mainTex, tint);
XSStyles.helpPopup(XSStyles.mainURL);
EditorGUILayout.EndHorizontal();
GUI.skin = null;
materialEditor.ShaderProperty(saturation, Styles.Saturation, 3);
materialEditor.TextureScaleOffsetProperty(mainTex);
//cutoff
if (material.shader.name.Contains("Cutout") && !material.shader.name.Contains("AlphaToMask"))
{
materialEditor.ShaderProperty(alphaCutoff, Styles.cutoutText);
}
if (material.shader.name.Contains("AlphaToMask"))
{
//So that a fallback to standard works as intended.
material.SetFloat("_Cutoff", 0.5f);
}
//-----
//outlines
if (outlined == true)
{
XSStyles.Separator();
EditorGUILayout.BeginHorizontal();
outlines = EditorGUILayout.Foldout(outlines, "OUTLINES", true);
XSStyles.helpPopup(XSStyles.outlineURL);
EditorGUILayout.EndHorizontal();
GUI.skin = null;
if (outlines)
{
XSStyles.SeparatorThin();
materialEditor.ShaderProperty(_LitOutline, "Outline Light Mode");
materialEditor.TexturePropertySingleLine(Styles.outlineTex, OutlineTextureMap);
materialEditor.ShaderProperty(OutlineColor, "Outline Color");
materialEditor.ShaderProperty(OutlineThickness, "Outline Scale");
}
}
//-----
//normal map
XSStyles.Separator();
EditorGUILayout.BeginHorizontal();
normals = EditorGUILayout.Foldout(normals, "NORMAL MAPS", true);
XSStyles.helpPopup(XSStyles.normalsURL);
EditorGUILayout.EndHorizontal();
GUI.skin = null;
if (normals)
{
XSStyles.SeparatorThin();
materialEditor.TexturePropertySingleLine(Styles.normalText, normal, normalStrength);
materialEditor.TextureScaleOffsetProperty(normal);
materialEditor.TexturePropertySingleLine(Styles.detailNormal, detailNormal, detailNormalStrength);
materialEditor.TextureScaleOffsetProperty(detailNormal);
materialEditor.TexturePropertySingleLine(Styles.detailMask, detailMask);
materialEditor.ShaderProperty(_NormalUv2, "Normal UV");
materialEditor.ShaderProperty(_DetailNormalUv2, "Detail UV");
}
//-----
//shadows
XSStyles.Separator();
EditorGUILayout.BeginHorizontal();
shadows = EditorGUILayout.Foldout(shadows, "SHADOWS", true);
XSStyles.helpPopup(XSStyles.shadowsURL);
EditorGUILayout.EndHorizontal();
GUI.skin = null;
if (shadows)
{
XSStyles.SeparatorThin();
materialEditor.TexturePropertySingleLine(Styles.rampText, shadowRamp);
materialEditor.ShaderProperty(rampColor, "Ramp Mode", 2);
materialEditor.ShaderProperty(shadowType, Styles.shadowTypeText, 2);
materialEditor.TexturePropertySingleLine(Styles.occlusionMap, occlusionMap);
materialEditor.ShaderProperty(_AORAMPMODE_ON, "AO Style", 2);
if (material.GetTexture("_OcclusionMap") && _AORAMPMODE_ON.floatValue == 1)
{
materialEditor.ShaderProperty(occlusionStrength, "Strength", 3);
}
else
{
material.SetFloat("_OcclusionStrength", 1);
}
if (_AORAMPMODE_ON.floatValue == 0)
{
materialEditor.ShaderProperty(_OcclusionColor, "AO Color", 2);
}
materialEditor.ShaderProperty(_AOUV2, "Occlusion UV");
XSStyles.callGradientEditor();
}
//ambient
//ramp
//mixed
if (rampColor.floatValue == 0)
{
material.SetFloat("_WORLDSHADOWCOLOR_ON", 1);
material.SetFloat("_MIXEDSHADOWCOLOR_ON", 0);
}
if (rampColor.floatValue == 1)
{
material.SetFloat("_WORLDSHADOWCOLOR_ON", 0);
material.SetFloat("_MIXEDSHADOWCOLOR_ON", 0);
}
if (rampColor.floatValue == 2)
{
material.SetFloat("_WORLDSHADOWCOLOR_ON", 0);
material.SetFloat("_MIXEDSHADOWCOLOR_ON", 1);
}
//-----
//Rimlighting
XSStyles.Separator();
EditorGUILayout.BeginHorizontal();
rimlighting = EditorGUILayout.Foldout(rimlighting, "RIMLIGHT", true);
XSStyles.helpPopup(XSStyles.rimlightURL);
EditorGUILayout.EndHorizontal();
GUI.skin = null;
if (rimlighting)
{
XSStyles.SeparatorThin();
materialEditor.ShaderProperty(rimStyle, Styles.rimLightTypeText);
if (rimStyle.floatValue == 0)
{
materialEditor.ShaderProperty(rimWidth, Styles.rimWidthText, 2);
materialEditor.ShaderProperty(rimIntensity, Styles.rimIntText, 2);
materialEditor.ShaderProperty(rimColor, "Rimlight Tint", 2);
}
if (rimStyle.floatValue == 1)
{
materialEditor.ShaderProperty(rimWidth, Styles.rimWidthText, 2);
materialEditor.ShaderProperty(rimIntensity, Styles.rimIntText, 2);
materialEditor.ShaderProperty(rimColor, "Rimlight Tint", 2);
}
if (rimStyle.floatValue == 2)
{
material.SetFloat("_RimIntensity", 0);
}
}
//----
//emission
XSStyles.Separator();
EditorGUILayout.BeginHorizontal();
emission = EditorGUILayout.Foldout(emission, "EMISSION", true);
XSStyles.helpPopup(XSStyles.emissionsURL);
EditorGUILayout.EndHorizontal();
GUI.skin = null;
if (emission)
{
XSStyles.SeparatorThin();
materialEditor.ShaderProperty(emissiveToggle, "Emission");
if (emissiveToggle.floatValue == 0)
{
materialEditor.TexturePropertySingleLine(Styles.emissText, emissiveTex, emissiveColor);
materialEditor.ShaderProperty(EmissTintToColor, "Tint To Diffuse");
materialEditor.ShaderProperty(EmissScaleWithLight, "Scale With Light");
if (EmissScaleWithLight.floatValue == 0)
{
materialEditor.ShaderProperty(EmissionPower, "Threshold", 2);
}
materialEditor.ShaderProperty(UseUV2Emiss, "Emission UV");
}
else
{
material.SetColor("_EmissiveColor", Color.black);
}
}
//-----
//specular
XSStyles.Separator();
EditorGUILayout.BeginHorizontal();
specular = EditorGUILayout.Foldout(specular, "SPECULAR", true);
XSStyles.helpPopup(XSStyles.specularURL);
EditorGUILayout.EndHorizontal();
EditorGUI.BeginChangeCheck();
if (specular)
{
XSStyles.SeparatorThin();
materialEditor.ShaderProperty(UseSpecular, "Specular");
if (UseSpecular.floatValue == 0)
{
materialEditor.TexturePropertySingleLine(Styles.specMapText, specMap);
GUI.skin = null;
materialEditor.TextureScaleOffsetProperty(specMap);
materialEditor.TexturePropertySingleLine(Styles.specPatternText, specPattern);
materialEditor.TextureScaleOffsetProperty(specPattern);
materialEditor.ShaderProperty(stylizedType, "Specular Type");
materialEditor.ShaderProperty(specStyle, "Specular Style");
if (stylizedType.floatValue == 1)
{
material.SetFloat("_ANISTROPIC_ON", 1);
materialEditor.ShaderProperty(aX, "Length", 3);
materialEditor.ShaderProperty(aY, "Width", 3);
}
else
{
material.SetFloat("_ANISTROPIC_ON", 0);
materialEditor.ShaderProperty(specArea, Styles.SmoothnessText, 3);
}
materialEditor.ShaderProperty(specIntensity, Styles.sintensityText, 3);
materialEditor.ShaderProperty(_SpecularUv2, "Specular UV");
materialEditor.ShaderProperty(_SpecularPatternUv2, "Pattern UV");
}
else
{
material.SetFloat("_SpecularIntensity", 0);
}
}
//-----
//metallic
XSStyles.Separator();
EditorGUILayout.BeginHorizontal();
reflections = EditorGUILayout.Foldout(reflections, "REFLECTIONS", true);
XSStyles.helpPopup(XSStyles.reflURL);
EditorGUILayout.EndHorizontal();
GUI.skin = null;
if (reflections)
{
XSStyles.SeparatorThin();
materialEditor.ShaderProperty(useRefl, "Reflections");
if (useRefl.floatValue == 0)
{
materialEditor.ShaderProperty(reflType, "Reflection Style");
material.EnableKeyword("_REFLECTIONS_ON");
//pbr
if (reflType.floatValue == 0)
{
materialEditor.TexturePropertySingleLine(Styles.bakedCube, bakedCube);
material.SetFloat("_PBRREFL_ON", 1);
material.SetFloat("_MATCAP_ON", 0);
material.SetFloat("_MATCAP_CUBEMAP_ON", 0);
materialEditor.TexturePropertySingleLine(Styles.MetalMap, metalMap);
if (!material.GetTexture("_MetallicMap"))
{
materialEditor.ShaderProperty(metal, "Metallic", 2);
}
else
{
material.SetFloat("_Metallic", 1);
}
materialEditor.ShaderProperty(reflSmooth, "Smoothness", 2);
materialEditor.ShaderProperty(_MetallicUv2, "Metal/Rough UV");
}
//matcap
if (reflType.floatValue == 1)
{
material.SetFloat("_MATCAP_ON", 1);
material.SetFloat("_MATCAP_CUBEMAP_ON", 0);
material.SetFloat("_PBRREFL_ON", 0);
materialEditor.ShaderProperty(matcapStyle, "Blend Mode");
materialEditor.TexturePropertySingleLine(Styles.Matcap, metalMap);
materialEditor.TexturePropertySingleLine(Styles.MatcapMask, roughMap);
materialEditor.ShaderProperty(metal, "Intensity", 2);
materialEditor.ShaderProperty(reflSmooth, "Blur", 2);
}
//bakedcubemap
if (reflType.floatValue == 2)
{
material.SetFloat("_MATCAP_CUBEMAP_ON", 1);
material.SetFloat("_MATCAP_ON", 0);
material.SetFloat("_PBRREFL_ON", 0);
materialEditor.TexturePropertySingleLine(Styles.bakedCube, bakedCube);
materialEditor.TexturePropertySingleLine(Styles.MetalMap, metalMap);
if (!material.GetTexture("_MetallicMap"))
{
materialEditor.ShaderProperty(metal, "Metallic", 2);
}
else
{
material.SetFloat("_Metallic", 1);
}
materialEditor.ShaderProperty(reflSmooth, "Smoothness", 2);
materialEditor.ShaderProperty(_MetallicUv2, "UVSet");
}
}
else
{
material.DisableKeyword("_REFLECTIONS_ON");
material.SetFloat("_PBRREFL_ON", 0);
material.SetFloat("_MATCAP_ON", 0);
material.SetFloat("_MATCAP_CUBEMAP_ON", 0);
}
}
//-----
//Subsurface Scattering
XSStyles.Separator();
EditorGUILayout.BeginHorizontal();
subsurface = EditorGUILayout.Foldout(subsurface, "SUBSURFACE SCATTERING", true);
XSStyles.helpPopup(XSStyles.sssURL);
GUI.skin = null;
EditorGUILayout.EndHorizontal();
if (subsurface)
{
XSStyles.SeparatorThin();
materialEditor.ShaderProperty(UseSSS, "Subsurface Scattering");
if (UseSSS.floatValue == 0)
{
materialEditor.TexturePropertySingleLine(Styles.thicknessMap, ThicknessMap);
materialEditor.ShaderProperty(invertThickness, "Invert", 3);
materialEditor.ShaderProperty(ThicknessMapPower, "Power", 3);
materialEditor.ShaderProperty(SSSCol, "Subsurface Color", 2);
materialEditor.ShaderProperty(SSSDist, "Displacement", 2);
materialEditor.ShaderProperty(SSSPow, "Sharpness", 2);
materialEditor.ShaderProperty(SSSIntensity, "Intensity", 2);
}
else
{
material.SetFloat("_SSSIntensity", 0);
}
}
else
{
if (UseSSS.floatValue == 1)
{
material.SetFloat("_SSSIntensity", 0);
}
}
//-----
GUI.skin = null;
if (advMode.floatValue == 1)
{
XSStyles.Separator();
advancedSettings = EditorGUILayout.Foldout(advancedSettings, "ADVANCED SETTINGS", true);
if (advancedSettings)
{
XSStyles.SeparatorThin();
// GUILayout.Label(Styles.advancedOptions, EditorStyles.boldLabel);
//Stencil
GUILayout.Label("Stencil Buffer", EditorStyles.boldLabel);
materialEditor.ShaderProperty(colorMask, colorMask.displayName, 2);
materialEditor.ShaderProperty(stencil, stencil.displayName, 2);
materialEditor.ShaderProperty(stencilComp, stencilComp.displayName, 2);
materialEditor.ShaderProperty(stencilOp, stencilOp.displayName, 2);
materialEditor.ShaderProperty(stencilFail, stencilFail.displayName, 2);
materialEditor.ShaderProperty(stencilZFail, stencilZFail.displayName, 2);
materialEditor.ShaderProperty(ztest, ztest.displayName, 2);
materialEditor.ShaderProperty(zwrite, zwrite.displayName, 2);
materialEditor.ShaderProperty(RampBaseAnchor, "Ramp Anchor", 2);
// Reset ZWrite/ZTest
XSStyles.ResetAdv(material);
XSStyles.ResetAdvAll(material);
// disable pass toggle
// disableOutlinePass = EditorGUILayout.Toggle("Disable Outline Pass", disableOutlinePass);
// if(disableOutlinePass == true)
// material.SetShaderPassEnabled("Always", false);
// else
// material.SetShaderPassEnabled("Always", true);
}
}
if (advMode.floatValue == 0)
{
XSStyles.CallResetAdv(material);
}
}
}
DoFooter();
}
public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
{
Material material = materialEditor.target as Material;
Shader shader = material.shader;
isCutout = shader.name.Contains("Cutout") && !shader.name.Contains("A2C");
isOutlined = shader.name.Contains("Outline");
//Find all material properties listed in the script using reflection, and set them using a loop only if they're of type MaterialProperty.
//This makes things a lot nicer to maintain and cleaner to look at.
foreach (var property in GetType().GetFields(bindingFlags))
{
if (property.FieldType == typeof(MaterialProperty))
{
property.SetValue(this, FindProperty(property.Name, props));
}
}
EditorGUI.BeginChangeCheck();
{
if (!isCutout)// Do this to make sure that if you're using AlphaToCoverage that you fallback to cutout with 0.5 Cutoff if your shaders are blocked.
{
material.SetFloat("_Cutoff", 0.5f);
}
XSStyles.ShurikenHeaderCentered("XSToon v" + XSStyles.ver);
materialEditor.ShaderProperty(_AdvMode, new GUIContent("Shader Mode", "Setting this to 'Advanced' will give you access to things such as stenciling, and other expiremental/advanced features."));
materialEditor.ShaderProperty(_Culling, new GUIContent("Culling Mode", "Changes the culling mode. 'Off' will result in a two sided material, while 'Front' and 'Back' will cull those sides respectively"));
materialEditor.ShaderProperty(_TilingMode, new GUIContent("Tiling Mode", "Setting this to Merged will tile and offset all textures based on the Main texture's Tiling/Offset."));
showMainSettings = XSStyles.ShurikenFoldout("Main Settings", showMainSettings);
if (showMainSettings)
{
materialEditor.TexturePropertySingleLine(new GUIContent("Main Texture", "The Main Texture."), _MainTex, _Color);
if (isCutout)
{
materialEditor.ShaderProperty(_Cutoff, new GUIContent("Cutoff", "The Cutoff Amount"), 2);
}
materialEditor.ShaderProperty(_UVSetAlbedo, new GUIContent("UV Set", "The UV set to use for the Albedo Texture"), 2);
materialEditor.TextureScaleOffsetProperty(_MainTex);
materialEditor.ShaderProperty(_Saturation, new GUIContent("Saturation", "Controls saturation of the final output from the shader."));
}
showShadows = XSStyles.ShurikenFoldout("Shadows", showShadows);
if (showShadows)
{
materialEditor.TexturePropertySingleLine(new GUIContent("Ramp Selection Mask", "A black to white mask that determins how far up on the multi ramp to sample. 0 for bottom, 1 for top, 0.5 for middle, 0.25, and 0.75 for mid bottom and mid top respectively."), _RampSelectionMask);
if (_RampSelectionMask.textureValue != null)
{
string rampMaskPath = AssetDatabase.GetAssetPath(_RampSelectionMask.textureValue);
TextureImporter ti = (TextureImporter)TextureImporter.GetAtPath(rampMaskPath);
if (ti.sRGBTexture)
{
if (XSStyles.HelpBoxWithButton(new GUIContent("This texture is not marked as Linear.", "This is recommended for the mask"), new GUIContent("Fix Now")))
{
ti.sRGBTexture = false;
AssetDatabase.ImportAsset(rampMaskPath, ImportAssetOptions.ForceUpdate);
AssetDatabase.Refresh();
}
}
}
materialEditor.TexturePropertySingleLine(new GUIContent("Shadow Ramp", "Shadow Ramp, Dark to Light should be Left to Right, or Down to Up"), _Ramp);
materialEditor.ShaderProperty(_ShadowSharpness, new GUIContent("Shadow Sharpness", "Controls the sharpness of recieved shadows, as well as the sharpness of 'shadows' from Vertex Lighting."));
GUILayout.Space(5);
materialEditor.TexturePropertySingleLine(new GUIContent("Occlusion Map", "Occlusion Map, used to darken areas on the model artifically."), _OcclusionMap);
XSStyles.constrainedShaderProperty(materialEditor, _OcclusionColor, new GUIContent("Occlusion Tint", "Occlusion shadow tint."), 2);
materialEditor.ShaderProperty(_UVSetOcclusion, new GUIContent("UV Set", "The UV set to use for the Occlusion Texture"), 2);
materialEditor.TextureScaleOffsetProperty(_OcclusionMap);
GUILayout.Space(5);
XSStyles.constrainedShaderProperty(materialEditor, _ShadowRim, new GUIContent("Shadow Rim", "Shadow Rim Color. Set to white to disable."), 0);
materialEditor.ShaderProperty(_ShadowRimRange, new GUIContent("Range", "Range of the Shadow Rim"), 2);
materialEditor.ShaderProperty(_ShadowRimThreshold, new GUIContent("Threshold", "Threshold of the Shadow Rim"), 2);
materialEditor.ShaderProperty(_ShadowRimSharpness, new GUIContent("Sharpness", "Sharpness of the Shadow Rim"), 2);
XSStyles.callGradientEditor(material);
}
if (isOutlined)
{
showOutlines = XSStyles.ShurikenFoldout("Outlines", showOutlines);
if (showOutlines)
{
materialEditor.TexturePropertySingleLine(new GUIContent("Outline Mask", "Outline width mask, black will make the outline minimum width."), _OutlineMask);
materialEditor.ShaderProperty(_OutlineWidth, new GUIContent("Outline Width", "Width of the Outlines"));
XSStyles.constrainedShaderProperty(materialEditor, _OutlineColor, new GUIContent("Outline Color", "Color of the outlines"), 0);
}
}
showNormalMapSettings = XSStyles.ShurikenFoldout("Normal Maps", showNormalMapSettings);
if (showNormalMapSettings)
{
materialEditor.TexturePropertySingleLine(new GUIContent("Normal Map", "Normal Map"), _BumpMap);
materialEditor.ShaderProperty(_BumpScale, new GUIContent("Normal Strength", "Strength of the main Normal Map"), 2);
materialEditor.ShaderProperty(_UVSetNormal, new GUIContent("UV Set", "The UV set to use for the Normal Map"), 2);
materialEditor.TextureScaleOffsetProperty(_BumpMap);
GUILayout.Space(5);
materialEditor.TexturePropertySingleLine(new GUIContent("Detail Normal Map", "Detail Normal Map"), _DetailNormalMap);
materialEditor.ShaderProperty(_DetailNormalMapScale, new GUIContent("Detail Normal Strength", "Strength of the detail Normal Map"), 2);
materialEditor.ShaderProperty(_UVSetDetNormal, new GUIContent("UV Set", "The UV set to use for the Detail Normal Map"), 2);
materialEditor.TextureScaleOffsetProperty(_DetailNormalMap);
GUILayout.Space(5);
materialEditor.TexturePropertySingleLine(new GUIContent("Detail Mask", "Mask for Detail Normal Map"), _DetailMask);
materialEditor.ShaderProperty(_UVSetDetMask, new GUIContent("UV Set", "The UV set to use for the Detail Mask"), 2);
materialEditor.TextureScaleOffsetProperty(_DetailMask);
}
showSpecular = XSStyles.ShurikenFoldout("Specular", showSpecular);
if (showSpecular)
{
materialEditor.ShaderProperty(_SpecMode, new GUIContent("Specular Mode", "Specular Mode."));
materialEditor.ShaderProperty(_SpecularStyle, new GUIContent("Specular Style", "Specular Style."));
materialEditor.TexturePropertySingleLine(new GUIContent("Specular Map(R,G,B)", "Specular Map. Red channel controls Intensity, Green controls how much specular is tinted by Albedo, and Blue controls Smoothness (Only for Blinn-Phong, and GGX)."), _SpecularMap);
materialEditor.TextureScaleOffsetProperty(_SpecularMap);
materialEditor.ShaderProperty(_UVSetSpecular, new GUIContent("UV Set", "The UV set to use for the Specular Map"), 2);
materialEditor.ShaderProperty(_SpecularIntensity, new GUIContent("Specular Intensity", "Specular Intensity."), 2);
materialEditor.ShaderProperty(_SpecularAlbedoTint, new GUIContent("Specular Albedo Tint", "How much the specular highlight should derive color from the albedo of the object."), 2);
if (_SpecMode.floatValue == 0 || _SpecMode.floatValue == 2)
{
materialEditor.ShaderProperty(_SpecularArea, new GUIContent("Specular Area", "Specular Area."), 2);
}
else
{
materialEditor.ShaderProperty(_AnisotropicAX, new GUIContent("Anisotropic Width", "Anisotropic Width, makes anistropic relfections more horizontal"), 2);
materialEditor.ShaderProperty(_AnisotropicAY, new GUIContent("Anisotropic Height", "Anisotropic Height, makes anistropic relfections more vertical"), 2);
}
}
showReflection = XSStyles.ShurikenFoldout("Reflections", showReflection);
if (showReflection)
{
materialEditor.ShaderProperty(_ReflectionMode, new GUIContent("Reflection Mode", "Reflection Mode."));
if (_ReflectionMode.floatValue == 0) // PBR
{
materialEditor.ShaderProperty(_ReflectionBlendMode, new GUIContent("Reflection Blend Mode", "Blend mode for reflection. Additive is Color + reflection, Multiply is Color * reflection, and subtractive is Color - reflection"));
materialEditor.ShaderProperty(_ClearCoat, new GUIContent("Clearcoat", "Clearcoat"));
materialEditor.TexturePropertySingleLine(new GUIContent("Fallback Cubemap", " Used as fallback in 'Unity' reflection mode if reflection probe is black."), _BakedCubemap);
materialEditor.TexturePropertySingleLine(new GUIContent("Metallic Map", "Metallic Map, Metallic on Red Channel, Smoothness on Alpha Channel. \nIf Clearcoat is enabled, Clearcoat Smoothness on Green Channel, Clearcoat Reflectivity on Blue Channel."), _MetallicGlossMap);
materialEditor.TextureScaleOffsetProperty(_MetallicGlossMap);
materialEditor.ShaderProperty(_UVSetMetallic, new GUIContent("UV Set", "The UV set to use for the Metallic Smoothness Map"), 2);
materialEditor.ShaderProperty(_Metallic, new GUIContent("Metallic", "Metallic, set to 1 if using metallic map"), 2);
materialEditor.ShaderProperty(_Glossiness, new GUIContent("Smoothness", "Smoothness, set to 1 if using metallic map"), 2);
materialEditor.ShaderProperty(_ClearcoatSmoothness, new GUIContent("Clearcoat Smoothness", "Smoothness of the clearcoat."), 2);
materialEditor.ShaderProperty(_ClearcoatStrength, new GUIContent("Clearcoat Reflectivity", "The strength of the clearcoat reflection."), 2);
}
else if (_ReflectionMode.floatValue == 1) //Baked cube
{
materialEditor.ShaderProperty(_ReflectionBlendMode, new GUIContent("Reflection Blend Mode", "Blend mode for reflection. Additive is Color + reflection, Multiply is Color * reflection, and subtractive is Color - reflection"));
materialEditor.ShaderProperty(_ClearCoat, new GUIContent("Clearcoat", "Clearcoat"));
materialEditor.TexturePropertySingleLine(new GUIContent("Baked Cubemap", "Baked cubemap."), _BakedCubemap);
materialEditor.TexturePropertySingleLine(new GUIContent("Metallic Map", "Metallic Map, Metallic on Red Channel, Smoothness on Alpha Channel. \nIf Clearcoat is enabled, Clearcoat Smoothness on Green Channel, Clearcoat Reflectivity on Blue Channel."), _MetallicGlossMap);
materialEditor.TextureScaleOffsetProperty(_MetallicGlossMap);
materialEditor.ShaderProperty(_UVSetMetallic, new GUIContent("UV Set", "The UV set to use for the MetallicSmoothness Map"), 2);
materialEditor.ShaderProperty(_Metallic, new GUIContent("Metallic", "Metallic, set to 1 if using metallic map"), 2);
materialEditor.ShaderProperty(_Glossiness, new GUIContent("Smoothness", "Smoothness, set to 1 if using metallic map"), 2);
materialEditor.ShaderProperty(_ClearcoatSmoothness, new GUIContent("Clearcoat Smoothness", "Smoothness of the clearcoat."), 2);
materialEditor.ShaderProperty(_ClearcoatStrength, new GUIContent("Clearcoat Reflectivity", "The strength of the clearcoat reflection."), 2);
}
else if (_ReflectionMode.floatValue == 2) //Matcap
{
materialEditor.ShaderProperty(_ReflectionBlendMode, new GUIContent("Reflection Blend Mode", "Blend mode for reflection. Additive is Color + reflection, Multiply is Color * reflection, and subtractive is Color - reflection"));
materialEditor.TexturePropertySingleLine(new GUIContent("Matcap", "Matcap Texture"), _Matcap, _MatcapTint);
materialEditor.ShaderProperty(_Glossiness, new GUIContent("Matcap Blur", "Matcap blur, blurs the Matcap, set to 1 for full clarity"), 2);
material.SetFloat("_Metallic", 0);
material.SetFloat("_ClearCoat", 0);
material.SetTexture("_MetallicGlossMap", null);
}
if (_ReflectionMode.floatValue != 3)
{
materialEditor.TexturePropertySingleLine(new GUIContent("Reflectivity Mask", "Mask for reflections."), _ReflectivityMask);
materialEditor.TextureScaleOffsetProperty(_ReflectivityMask);
materialEditor.ShaderProperty(_UVSetReflectivity, new GUIContent("UV Set", "The UV set to use for the Reflectivity Mask"), 2);
materialEditor.ShaderProperty(_Reflectivity, new GUIContent("Reflectivity", "The strength of the reflections."), 2);
}
if (_ReflectionMode.floatValue == 3)
{
material.SetFloat("_Metallic", 0);
material.SetFloat("_ReflectionBlendMode", 0);
material.SetFloat("_ClearCoat", 0);
}
}
showEmission = XSStyles.ShurikenFoldout("Emission", showEmission);
if (showEmission)
{
materialEditor.TexturePropertySingleLine(new GUIContent("Emission Map", "Emissive map. White to black, unless you want multiple colors."), _EmissionMap, _EmissionColor);
materialEditor.TextureScaleOffsetProperty(_EmissionMap);
materialEditor.ShaderProperty(_UVSetEmission, new GUIContent("UV Set", "The UV set to use for the Emission Map"), 2);
materialEditor.ShaderProperty(_EmissionToDiffuse, new GUIContent("Tint To Diffuse", "Tints the emission to the Diffuse Color"), 2);
GUILayout.Space(5);
materialEditor.ShaderProperty(_ScaleWithLight, new GUIContent("Scale w/ Light", "Scales the emission intensity based on how dark or bright the environment is."));
if (_ScaleWithLight.floatValue == 0)
{
materialEditor.ShaderProperty(_ScaleWithLightSensitivity, new GUIContent("Scaling Sensitivity", "How agressively the emission should scale with the light."));
}
}
showRimlight = XSStyles.ShurikenFoldout("Rimlight", showRimlight);
if (showRimlight)
{
materialEditor.ShaderProperty(_RimColor, new GUIContent("Rimlight Tint", "The Tint of the Rimlight."));
materialEditor.ShaderProperty(_RimIntensity, new GUIContent("Rimlight Intensity", "Strength of the Rimlight."));
materialEditor.ShaderProperty(_RimRange, new GUIContent("Range", "Range of the Rim"), 2);
materialEditor.ShaderProperty(_RimThreshold, new GUIContent("Threshold", "Threshold of the Rim"), 2);
materialEditor.ShaderProperty(_RimSharpness, new GUIContent("Sharpness", "Sharpness of the Rim"), 2);
}
showSubsurface = XSStyles.ShurikenFoldout("Subsurface Scattering", showSubsurface);
if (showSubsurface)
{
materialEditor.TexturePropertySingleLine(new GUIContent("Thickness Map", "Thickness Map, used to mask areas where subsurface can happen"), _ThicknessMap);
materialEditor.TextureScaleOffsetProperty(_ThicknessMap);
materialEditor.ShaderProperty(_UVSetThickness, new GUIContent("UV Set", "The UV set to use for the Thickness Map"), 2);
XSStyles.constrainedShaderProperty(materialEditor, _SSColor, new GUIContent("Subsurface Color", "Subsurface Scattering Color"), 2);
materialEditor.ShaderProperty(_SSDistortion, new GUIContent("Subsurface Distortion", "How much the subsurface follows the normals of the mesh, Normal map."), 2);
materialEditor.ShaderProperty(_SSPower, new GUIContent("Subsurface Power", "Subsurface Power"), 2);
materialEditor.ShaderProperty(_SSScale, new GUIContent("Subsurface Scale", "Subsurface Scale"), 2);
materialEditor.ShaderProperty(_SSSRange, new GUIContent("Subsurface Range", "Subsurface Range"), 2);
materialEditor.ShaderProperty(_SSSSharpness, new GUIContent("Subsurface Sharpness", "Subsurface Sharpness"), 2);
}
if (_AdvMode.floatValue == 1)
{
showAdvanced = XSStyles.ShurikenFoldout("Advanced Settings", showAdvanced);
if (showAdvanced)
{
materialEditor.ShaderProperty(_Stencil, _Stencil.displayName);
materialEditor.ShaderProperty(_StencilComp, _StencilComp.displayName);
materialEditor.ShaderProperty(_StencilOp, _StencilOp.displayName);
}
}
XSStyles.DoFooter();
}
}