private void DrawAdvancedSettings(MaterialEditor materialEditor)
{
if (_AdvMode.floatValue == 1)
{
showAdvanced = XSStyles.ShurikenFoldout("Advanced Settings", showAdvanced);
if (showAdvanced)
{
materialEditor.ShaderProperty(_VertexColorAlbedo, new GUIContent("Vertex Color Albedo", "Multiplies the vertex color of the mesh by the Albedo texture to derive the final Albedo color."));
if (isDithered || isCutout)
{
materialEditor.ShaderProperty(_UseClipsForDissolve, new GUIContent("Control Dissolve With Clip"));
materialEditor.TexturePropertySingleLine(new GUIContent("Clip Map (RGBA)", "Used to control clipping in an advanced manner, read tooltip for Clip Mask Vectors below."), _ClipMap);
materialEditor.TextureScaleOffsetProperty(_ClipMap);
materialEditor.ShaderProperty(_UVSetClipMap, new GUIContent("UV Set", "The UV set to use for the Clip Map"), 2);
materialEditor.ShaderProperty(_ClipAgainstVertexColorGreaterZeroFive, new GUIContent("Clip Mask > 0.5 Opacity", "Uses the Clip Map RGBA channels as a multiplier for clipping."));
_ClipAgainstVertexColorGreaterZeroFive.vectorValue = ClampVec4(_ClipAgainstVertexColorGreaterZeroFive.vectorValue);
materialEditor.ShaderProperty(_ClipAgainstVertexColorLessZeroFive, new GUIContent("Clip Mask Color < 0.5 Opacity", "Uses the Clip Map RGBA channels as a multiplier for clipping."));
_ClipAgainstVertexColorLessZeroFive.vectorValue = ClampVec4(_ClipAgainstVertexColorLessZeroFive.vectorValue);
}
materialEditor.ShaderProperty(_WireColor, new GUIContent("Wire Color On UV2", "This will only work with a specific second uv channel setup."));
materialEditor.ShaderProperty(_WireWidth, new GUIContent("Wire Width", "Controls the above wire width."));
materialEditor.ShaderProperty(_Stencil, _Stencil.displayName);
materialEditor.ShaderProperty(_StencilComp, _StencilComp.displayName);
materialEditor.ShaderProperty(_StencilOp, _StencilOp.displayName);
materialEditor.RenderQueueField();
}
}
}
private void DrawSpecularSettings(MaterialEditor materialEditor)
{
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."));
XSStyles.SeparatorThin();
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);
}
}
}
private void DrawMainSettings(MaterialEditor materialEditor)
{
showMainSettings = XSStyles.ShurikenFoldout("Main Settings", showMainSettings);
if (showMainSettings)
{
materialEditor.TexturePropertySingleLine(new GUIContent("Main Texture", "The main Albedo texture."), _MainTex, _Color);
if (isCutout)
{
materialEditor.ShaderProperty(_Cutoff, new GUIContent("Cutoff", "The Cutoff Amount"), 2);
}
if (isCutoutMasked)
{
materialEditor.TexturePropertySingleLine(new GUIContent("Dissolve Mask", "Black and white cutout mask"), _CutoutMask);
materialEditor.ShaderProperty(_Cutoff, new GUIContent("Dissolve Progress", "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."));
if (isDithered)
{
//Dither Fading
materialEditor.TexturePropertySingleLine(new GUIContent("Dissolve Mask", "Black and white mask to control dithering."), _CutoutMask);
materialEditor.ShaderProperty(_FadeDither, new GUIContent("Use Distance Fading", "Make the shader dither out based on the distance to the camera."), 2);
materialEditor.ShaderProperty(_FadeDitherDistance, new GUIContent("Fade Distance", "The distance at which the fading starts happening."), 2);
}
}
}
private void DrawPatreonSettings(MaterialEditor materialEditor)
{
//Plugins for Patreon releases
if (isPatreonShader)
{
if (isEyeTracking)
{
showEyeTracking = XSStyles.ShurikenFoldout("Eye Tracking Settings", showEyeTracking);
if (showEyeTracking)
{
materialEditor.ShaderProperty(_LeftRightPan, new GUIContent("Left Right Adj.", "Adjusts the eyes manually left or right."));
materialEditor.ShaderProperty(_UpDownPan, new GUIContent("Up Down Adj.", "Adjusts the eyes manually up or down."));
XSStyles.SeparatorThin();
materialEditor.ShaderProperty(_AttentionSpan, new GUIContent("Attention Span", "How often should the eyes look at the target; 0 = never, 1 = always, 0.5 = half of the time."));
materialEditor.ShaderProperty(_FollowPower, new GUIContent("Follow Power", "The influence the target has on the eye"));
materialEditor.ShaderProperty(_LookSpeed, new GUIContent("Look Speed", "How fast the eye transitions to looking at the target"));
materialEditor.ShaderProperty(_Twitchyness, new GUIContent("Refocus Frequency", "How much should the eyes look around near the target?"));
XSStyles.SeparatorThin();
materialEditor.ShaderProperty(_IrisSize, new GUIContent("Iris Size", "Size of the iris"));
materialEditor.ShaderProperty(_FollowLimit, new GUIContent("Follow Limit", "Limits the angle from the front of the face on how far the eyes can track/rotate."));
materialEditor.ShaderProperty(_EyeOffsetLimit, new GUIContent("Offset Limit", "Limit for how far the eyes can turn"));
}
}
}
//
}
static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
{
if (xsFilePath == null)
{
xsFilePath = XSStyles.findAssetPath("");
}
foreach (string str in importedAssets)
{
if (str.StartsWith(xsFilePath + "/Main/CGIncludes"))
{
Debug.Log("XS CGInclude updated: " + str.Replace(xsFilePath + "/Main/CGIncludes/", ""));
string[] files = Directory.GetFiles(xsFilePath + "/Main/Shaders", "*.shader");
foreach (string file in files)
{
AssetDatabase.ImportAsset(file, ImportAssetOptions.ForceUpdate);
}
}
if (str.StartsWith(xsFilePath + "/Main/Patreon/CGIncludes"))
{
Debug.Log("XS CGInclude updated: " + str.Replace(xsFilePath + "/Main/Patreon/CGIncludes/", ""));
string[] files = Directory.GetFiles(xsFilePath + "/Main/Patreon/Shaders", "*.shader");
foreach (string file in files)
{
AssetDatabase.ImportAsset(file, ImportAssetOptions.ForceUpdate);
}
}
}
}
private void DrawMainSettings(MaterialEditor materialEditor)
{
showMainSettings = XSStyles.ShurikenFoldout("Main Settings", showMainSettings);
if (showMainSettings)
{
materialEditor.TexturePropertySingleLine(new GUIContent("Main Texture", "The main Albedo 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.TexturePropertySingleLine(new GUIContent("HSV Mask", "RGB Mask: R = Hue, G = Saturation, B = Brightness"), _HSVMask);
materialEditor.ShaderProperty(_Hue, new GUIContent("Hue", "Controls Hue of the final output from the shader."));
materialEditor.ShaderProperty(_Saturation, new GUIContent("Saturation", "Controls saturation of the final output from the shader."));
materialEditor.ShaderProperty(_Value, new GUIContent("Brightness", "Controls value of the final output from the shader."));
if (isDithered)
{
XSStyles.SeparatorThin();
materialEditor.ShaderProperty(_FadeDither, new GUIContent("Distance Fading", "Make the shader dither out based on the distance to the camera."));
materialEditor.ShaderProperty(_FadeDitherDistance, new GUIContent("Fade Threshold", "The distance at which the fading starts happening."));
}
}
}
private void DrawNormalSettings(MaterialEditor materialEditor)
{
showNormalMapSettings = XSStyles.ShurikenFoldout("Normal Maps", showNormalMapSettings);
if (showNormalMapSettings)
{
materialEditor.ShaderProperty(_NormalMapMode, new GUIContent("Normal Map Source", "How to alter the normals of the mesh, using which source?"));
if (_NormalMapMode.floatValue == 0)
{
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);
XSStyles.SeparatorThin();
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);
XSStyles.SeparatorThin();
materialEditor.TexturePropertySingleLine(new GUIContent("Detail Mask", "Mask for Detail Maps"), _DetailMask);
materialEditor.ShaderProperty(_UVSetDetMask, new GUIContent("UV Set", "The UV set to use for the Detail Mask"), 2);
materialEditor.TextureScaleOffsetProperty(_DetailMask);
}
}
}
public static void DoFooter()
{
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
XSStyles.discordButton(70, 30);
XSStyles.patreonButton(70, 30);
XSStyles.githubButton(70, 30);
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
XSStyles.openInfoPanel(200, 20);
}
void drawHelpText()
{
XSStyles.Separator();
dHelpText = XSStyles.ShurikenFoldout("Information", dHelpText);
if (dHelpText)
{
scrollPos = EditorGUILayout.BeginScrollView(scrollPos);
XSStyles.HelpBox("You can use this to create a custom shadow ramp in realtime. \nIf you do not save, the ramp will be reverted back to what it was previously. \n\n - Click the Gradient box. \n - Choose resolution of the texture. \n - Save.", MessageType.Info);
XSStyles.HelpBox("Ramp textures support up to 5 ramps in one texture. That means you can have up to 5 ramps on a single material. You will need to author a ramp mask to choose which ramp to sample from. \n\nA texture that is fully black would sample from the bottom ramp, a texture that is fully white would sample from the top ramp, and a texture that is half gray would sample from the middle ramp. \n\n A quick tip would be that you can sample from each of the 5 ramps with 0, 0.25, 0.5, 0.75, and 1 on the texture. \n\nThe order of the gradients on the UI is the order that they will be on the texture.", MessageType.Info);
EditorGUILayout.EndScrollView();
}
}
private void DrawRefractionSettings(MaterialEditor materialEditor)
{
if (isRefractive)
{
showRefractionSettings = XSStyles.ShurikenFoldout("Refraction", showRefractionSettings);
if (showRefractionSettings)
{
materialEditor.ShaderProperty(_RefractionModel, new GUIContent("Refraction Model", "Refraction technique"));
materialEditor.ShaderProperty(_IOR, new GUIContent("Index of Refraction", "The index of refraction of the material. Glass: 1.5, Crystal: 2.0, Ice: 1.309, Water: 1.325"));
}
}
}
void drawMGInputOutput()
{
GUILayout.BeginHorizontal();
XSMultiGradient old_xsmg = xsmg;
xsmg = (XSMultiGradient)EditorGUILayout.ObjectField("MultiGradient Preset", xsmg, typeof(XSMultiGradient), false, null);
if (xsmg != old_xsmg)
{
if (xsmg != null)
{
this.gradients = xsmg.gradients;
this.gradients_index = xsmg.order;
makeReorderedList();
}
else
{
List <Gradient> new_Grads = new List <Gradient>();
for (int i = 0; i < this.gradients.Count; i++)
{
new_Grads.Add(reflessGradient(this.gradients[i]));
}
this.gradients = new_Grads;
this.gradients_index = reflessIndexes(this.gradients_index);
makeReorderedList();
}
changed = true;
}
if (GUILayout.Button("Save New", EditorStyles.miniButton, GUILayout.ExpandWidth(false)))
{
finalFilePath = XSStyles.findAssetPath(finalFilePath);
string path = EditorUtility.SaveFilePanel("Save MultiGradient", (finalFilePath + "/Textures/Shadow Ramps/MGPresets"), "MultiGradient", "asset");
if (path.Length != 0)
{
path = path.Substring(Application.dataPath.Length - "Assets".Length);
XSMultiGradient _xsmg = ScriptableObject.CreateInstance <XSMultiGradient>();
_xsmg.uniqueName = Path.GetFileNameWithoutExtension(path);
foreach (Gradient grad in gradients)
{
_xsmg.gradients.Add(reflessGradient(grad));
}
_xsmg.order.AddRange(gradients_index.ToArray());
xsmg = _xsmg;
AssetDatabase.CreateAsset(_xsmg, path);
this.gradients = xsmg.gradients;
this.gradients_index = xsmg.order;
makeReorderedList();
AssetDatabase.SaveAssets();
}
}
GUILayout.EndHorizontal();
}
public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
{
Material material = materialEditor.target as Material;
Shader shader = material.shader;
isCutout = material.GetInt("_BlendMode") == 1;
isDithered = material.GetInt("_BlendMode") == 2;
isRefractive = material.GetInt("_UseRefraction") == 1;
isOutlined = shader.name.Contains("Outline");
isPatreonShader = shader.name.Contains("Patreon");
isEyeTracking = shader.name.Contains("EyeTracking");
//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))
{
try { property.SetValue(this, FindProperty(property.Name, props)); } catch { /*Is it really a problem if it doesn't exist?*/ }
}
}
EditorGUI.BeginChangeCheck();
{
XSStyles.ShurikenHeaderCentered("XSToon v" + XSStyles.ver);
material.SetShaderPassEnabled("Always", isRefractive);
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."));
materialEditor.ShaderProperty(_BlendMode, new GUIContent("Blend Mode", "Blend mode of the material. (Opaque, transparent, cutout, etc.)"));
materialEditor.ShaderProperty(_UseRefraction, new GUIContent("Refraction", "Should this material be refractive? (Warning, this can be expensive!)"));
DoBlendModeSettings(material);
DrawMainSettings(materialEditor);
DrawDissolveSettings(materialEditor);
DrawShadowSettings(materialEditor, material);
DrawOutlineSettings(materialEditor);
DrawNormalSettings(materialEditor);
DrawSpecularSettings(materialEditor);
DrawReflectionsSettings(materialEditor, material);
DrawRefractionSettings(materialEditor);
DrawEmissionSettings(materialEditor);
DrawRimlightSettings(materialEditor);
DrawHalfToneSettings(materialEditor);
DrawTransmissionSettings(materialEditor);
DrawAdvancedSettings(materialEditor);
DrawPatreonSettings(materialEditor);
XSStyles.DoFooter();
}
}
private void DrawTransmissionSettings(MaterialEditor materialEditor)
{
showSubsurface = XSStyles.ShurikenFoldout("Transmission", showSubsurface);
if (showSubsurface)
{
materialEditor.TexturePropertySingleLine(new GUIContent("Thickness Map", "Thickness Map, used to mask areas where transmission 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("Transmission Color", "Transmission Color"), 2);
materialEditor.ShaderProperty(_SSDistortion, new GUIContent("Transmission Distortion", "How much the Transmission should follow the normals of the mesh and/or normal map."), 2);
materialEditor.ShaderProperty(_SSPower, new GUIContent("Transmission Power", "Subsurface Power"), 2);
materialEditor.ShaderProperty(_SSScale, new GUIContent("Transmission Scale", "Subsurface Scale"), 2);
}
}
public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
{
Material material = materialEditor.target as Material;
Shader shader = material.shader;
isDithered = shader.name.Contains("Dithered");
isCutout = shader.name.Contains("Cutout") && !shader.name.Contains("A2C");
isCutoutMasked = shader.name.Contains("A2C") && shader.name.Contains("Masked");
isOutlined = shader.name.Contains("Outline");
isPatreonShader = shader.name.Contains("Patreon");
isEyeTracking = shader.name.Contains("EyeTracking");
//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))
{
try{ property.SetValue(this, FindProperty(property.Name, props)); } catch { /*Is it really a problem if it doesn't exist?*/ }
}
}
EditorGUI.BeginChangeCheck();
{
if (!isCutout && !isCutoutMasked) // 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."));
DrawMainSettings(materialEditor);
DrawShadowSettings(materialEditor, material);
DrawOutlineSettings(materialEditor);
DrawNormalSettings(materialEditor);
DrawSpecularSettings(materialEditor);
DrawReflectionsSettings(materialEditor, material);
DrawEmissionSettings(materialEditor);
DrawRimlightSettings(materialEditor);
DrawHalfToneSettings(materialEditor);
DrawTransmissionSettings(materialEditor);
DrawAdvancedSettings(materialEditor);
DrawPatreonSettings(materialEditor);
XSStyles.DoFooter();
}
}
private void DrawRimlightSettings(MaterialEditor materialEditor)
{
showRimlight = XSStyles.ShurikenFoldout("Rimlight", showRimlight);
if (showRimlight)
{
materialEditor.ShaderProperty(_RimColor, new GUIContent("Rimlight Tint", "The Tint of the Rimlight."));
materialEditor.ShaderProperty(_RimAlbedoTint, new GUIContent("Rim Albedo Tint", "How much the Albedo texture should effect the rimlight color."));
materialEditor.ShaderProperty(_RimCubemapTint, new GUIContent("Rim Environment Tint", "How much the Environment cubemap should effect the rimlight color."));
materialEditor.ShaderProperty(_RimAttenEffect, new GUIContent("Rim Attenuation Effect", "How much should realtime shadows mask out 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);
}
}
private void DrawOutlineSettings(MaterialEditor materialEditor)
{
if (isOutlined)
{
showOutlines = XSStyles.ShurikenFoldout("Outlines", showOutlines);
if (showOutlines)
{
materialEditor.ShaderProperty(_OutlineLighting, new GUIContent("Outline Lighting", "Makes outlines respect the lighting, or be emissive."));
materialEditor.ShaderProperty(_OutlineAlbedoTint, new GUIContent("Outline Albedo Tint", "Includes the color of the Albedo Texture in the calculation for the color of the outline."));
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);
}
}
}
private void DrawAdvancedSettings(MaterialEditor materialEditor)
{
if (_AdvMode.floatValue == 1)
{
showAdvanced = XSStyles.ShurikenFoldout("Advanced Settings", showAdvanced);
if (showAdvanced)
{
materialEditor.ShaderProperty(_VertexColorAlbedo, new GUIContent("Vertex Color Albedo", "Multiplies the vertex color of the mesh by the Albedo texture to derive the final Albedo color."));
materialEditor.ShaderProperty(_Stencil, _Stencil.displayName);
materialEditor.ShaderProperty(_StencilComp, _StencilComp.displayName);
materialEditor.ShaderProperty(_StencilOp, _StencilOp.displayName);
materialEditor.RenderQueueField();
}
}
}
private void DrawDissolveSettings(MaterialEditor materialEditor)
{
if (isCutout || isDithered)
{
showDissolveSettings = XSStyles.ShurikenFoldout("Dissolve", showDissolveSettings);
if (showDissolveSettings)
{
materialEditor.ShaderProperty(_DissolveCoordinates, new GUIContent("Dissolve Coordinates", "Should Dissolve happen in world space, texture space, or vertically?"));
materialEditor.TexturePropertySingleLine(new GUIContent("Dissolve Texture", "Noise texture used to control up dissolve pattern"), _DissolveTexture, _DissolveColor);
materialEditor.TextureScaleOffsetProperty(_DissolveTexture);
materialEditor.ShaderProperty(_UVSetDissolve, new GUIContent("UV Set", "The UV set to use for the Dissolve Texture."), 2);
materialEditor.ShaderProperty(_DissolveStrength, new GUIContent("Dissolve Sharpness", "Sharpness of the dissolve texture."));
materialEditor.ShaderProperty(_DissolveProgress, new GUIContent("Dissolve Progress", "Progress of the dissolve effect."));
}
}
}
private void DrawSpecularSettings(MaterialEditor materialEditor)
{
showSpecular = XSStyles.ShurikenFoldout("Specular", showSpecular);
if (showSpecular)
{
XSStyles.SeparatorThin();
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("Intensity", "Specular Intensity."), 2);
materialEditor.ShaderProperty(_SpecularArea, new GUIContent("Roughness", "Roughness"), 2);
materialEditor.ShaderProperty(_SpecularAlbedoTint, new GUIContent("Albedo Tint", "How much the specular highlight should derive color from the albedo of the object."), 2);
materialEditor.ShaderProperty(_SpecularSharpness, new GUIContent("Sharpness", "How hard of and edge transitions should the specular have?"), 2);
materialEditor.ShaderProperty(_AnisotropicSpecular, new GUIContent("Anisotropy", "The amount of anisotropy the surface has - this will stretch the reflection along an axis (think bottom of a frying pan)"), 2);
}
}
private void DrawEmissionSettings(MaterialEditor materialEditor)
{
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);
XSStyles.SeparatorThin();
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."));
}
}
}
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.ShaderProperty(_OcclusionMode, new GUIContent("Occlusion Mode", "How to calculate the occlusion map contribution"));
materialEditor.TexturePropertySingleLine(new GUIContent("Occlusion Map", "Occlusion Map, used to darken areas on the model artifically."), _OcclusionMap);
materialEditor.ShaderProperty(_OcclusionIntensity, new GUIContent("Intensity", "Occlusion intensity"), 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);
}
}
private void DrawHalfToneSettings(MaterialEditor materialEditor)
{
showHalftones = XSStyles.ShurikenFoldout("Halftones", showHalftones);
if (showHalftones)
{
materialEditor.ShaderProperty(_HalftoneType, new GUIContent("Halftone Style", "Controls where halftone and stippling effects are drawn."));
if (_HalftoneType.floatValue == 1 || _HalftoneType.floatValue == 2)
{
materialEditor.ShaderProperty(_HalftoneDotSize, new GUIContent("Stippling Scale", "How large should the stippling pattern be?"));
materialEditor.ShaderProperty(_HalftoneDotAmount, new GUIContent("Stippling Density", "How dense is the stippling effect?"));
}
if (_HalftoneType.floatValue == 0 || _HalftoneType.floatValue == 2)
{
materialEditor.ShaderProperty(_HalftoneLineAmount, new GUIContent("Halftone Line Count", "How many lines should the halftone shadows have?"));
materialEditor.ShaderProperty(_HalftoneLineIntensity, new GUIContent("Halftone Line Intensity", "How dark should the halftone lines be?"));
}
}
}
private void DrawOutlineSettings(MaterialEditor materialEditor)
{
if (isOutlined)
{
showOutlines = XSStyles.ShurikenFoldout("Outlines", showOutlines);
if (showOutlines)
{
materialEditor.ShaderProperty(_OutlineNormalMode, new GUIContent("Outline Normal Mode", "How to calcuate the outline expand direction. Using mesh normals may result in split edges."));
if (_OutlineNormalMode.floatValue == 2)
{
materialEditor.ShaderProperty(_OutlineUVSelect, new GUIContent("Normals UV", "UV Channel to pull the modified normals from for outlines."));
}
materialEditor.ShaderProperty(_OutlineLighting, new GUIContent("Outline Lighting", "Makes outlines respect the lighting, or be emissive."));
materialEditor.ShaderProperty(_OutlineAlbedoTint, new GUIContent("Outline Albedo Tint", "Includes the color of the Albedo Texture in the calculation for the color of the outline."));
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);
}
}
}
public void OnGUI()
{
scrollPos = EditorGUILayout.BeginScrollView(scrollPos);
GUILayout.BeginHorizontal();
GUILayout.Space(105);
XSStyles.doLabel("1");
GUILayout.Space(105);
XSStyles.doLabel("2");
GUILayout.Space(105);
XSStyles.doLabel("3");
GUILayout.Space(105);
XSStyles.doLabel("4");
GUILayout.EndHorizontal();
XSStyles.SeparatorThin();
GUILayout.BeginHorizontal();
for (int i = 0; i < 4; i++)
{
EditorGUIUtility.labelWidth = 0.01f;
textures[i] = (Texture2D)EditorGUILayout.ObjectField(new GUIContent("", ""), textures[i], typeof(Texture2D), true);
}
GUILayout.EndHorizontal();
float oldLabelWidth = EditorGUIUtility.labelWidth;
EditorGUIUtility.labelWidth = 40;
GUIStyle headerStyle = EditorStyles.boldLabel;
headerStyle.alignment = TextAnchor.UpperLeft;
headerStyle.fontStyle = FontStyle.Bold;
headerStyle.stretchWidth = true;
XSStyles.SeparatorThin();
EditorGUILayout.BeginHorizontal();
GUILayout.Label("Output Channel:", headerStyle);
GUILayout.Label("R", headerStyle);
GUILayout.Label("G", headerStyle);
GUILayout.Label("B", headerStyle);
GUILayout.Label("A", headerStyle);
EditorGUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("Src Texture:");
GUILayout.Space(20);
for (int i = 0; i < 4; i++)
{
pickTexture[i] = (ETextures)EditorGUILayout.EnumPopup("", pickTexture[i]);
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("Src Channel:");
GUILayout.Space(17);
for (int i = 0; i < 4; i++)
{
texChannels[i] = (EChannels)EditorGUILayout.EnumPopup("", texChannels[i]);
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("Invert Channel:");
for (int i = 0; i < 4; i++)
{
invertChannel[i] = EditorGUILayout.Toggle("", invertChannel[i]);
}
GUILayout.EndHorizontal();
GUILayout.Space(20);
EditorGUILayout.EndScrollView();
//Button and Resolution
GUILayout.BeginVertical();
XSStyles.doLabel("Resolution");
GUILayout.BeginHorizontal();
GUILayout.Space(175);
res = (resolutions)EditorGUILayout.EnumPopup("", res);
GUILayout.Space(175);
GUILayout.EndHorizontal();
if (GUILayout.Button("Merge Channels"))
{
if (progress < 2)
{
EditorUtility.DisplayProgressBar("XSToon Texture Merger", "Merging and compressing new texture...", (float)(progress / 2));
}
//Set target textures to be ReadWriteable
for (int i = 0; i < textures.Length; i++)
{
if (textures[i] == null)
{
break;
}
string texturePath = AssetDatabase.GetAssetPath(textures[i]);
TextureImporter texture = (TextureImporter)TextureImporter.GetAtPath(texturePath);
if (texture != null)
{
texture.isReadable = true;
texture.SaveAndReimport();
}
}
switch (res)
{
case resolutions.Tiny_256x256:
resolution = 256;
break;
case resolutions.Small_512x512:
resolution = 512;
break;
case resolutions.Medium_1024x1024:
resolution = 1024;
break;
case resolutions.Large_2048x2048:
resolution = 2048;
break;
case resolutions.VeryLarge_4096x4096:
resolution = 4096;
break;
case resolutions.Why_8192x8192:
resolution = 8192;
break;
}
XSStyles.findAssetPath(finalFilePath);
finalFilePath = EditorUtility.SaveFilePanel("Save Merged Texture", finalFilePath + "/Textures/", "mergedTex.png", "png");
Texture2D newTexture = new Texture2D(resolution, resolution, TextureFormat.RGBA32, false);
//Get Colors textures and write them to the proper channel
for (int y = 0; y < resolution; y++)
{
for (int x = 0; x < resolution; x++)
{
float u = x / (float)resolution;
float v = y / (float)resolution;
// Grab out the texture values into an array for later lookup. Could probably just be done at the moment the texture color is needed.
for (int i = 0; i < textures.Length; i++)
{
if (textures[i] != null)
{
texColors[i] = textures[i].GetPixelBilinear(u, v);
}
else
{
texColors[i] = new Color(0, 0, 0, 1);
}
}
Color outputColor = new Color(0, 0, 0, 1);
// Iterate the output RGBA channels
for (int i = 0; i < 4; i++)
{
// Convert the enums to indices we can use. 'None' will turn into -1 which will be discarded as invalid.
int srcTexIdx = ((int)pickTexture[i]) - 1;
int srcChannelIdx = ((int)texChannels[i]) - 1;
// Go through each channel in the output color and assign it
if (srcTexIdx >= 0 && srcChannelIdx >= 0)
{
outputColor[i] = texColors[srcTexIdx][srcChannelIdx];
//Allow you to invert specific channels.
if (invertChannel[i])
{
outputColor[i] = 1f - outputColor[i];
}
}
}
newTexture.SetPixel(x, y, outputColor);
}
}
progress += 1;
newTexture.Apply();
ExportTexture(newTexture);
}
GUILayout.Space(10);
GUILayout.EndVertical();
EditorGUIUtility.labelWidth = oldLabelWidth;
}
public void OnGUI()
{
tab = GUILayout.Toolbar(tab, new string[] { "Documentation", "Updater", "Social" });
XSStyles.SeparatorThin();
switch (tab)
{
case 0:
//show Docs from git
XSStyles.doLabel("You can find Documentation here.");
if (GUILayout.Button("Open Documentation"))
{
Application.OpenURL(docsURL);
}
break;
case 1:
EditorGUI.BeginChangeCheck();
XSStyles.HelpBox("The currently installed version is: v" + XSStyles.ver + "\n\nTo check for updates, use the update button. If you choose to download an update, you will need to manually overwrite the old install by extracting the .zip into the project using the windows explorer. \n\nDo not drag the update directly into Unity - it won't ask to overwrite - it'll just create a duplicate and break.", MessageType.Info);
XSStyles.SeparatorThin();
if (GUILayout.Button("Check for Updates"))
{
req(updateUrl);
EditorApplication.update += changelogEditorUpdate;
showInfo = true;
}
if (showInfo)
{
scrollPos = EditorGUILayout.BeginScrollView(scrollPos);
Repaint();
XSStyles.doLabelLeft("Newest version: ");
XSStyles.doLabelSmall(curVer);
XSStyles.SeparatorThin();
XSStyles.doLabelLeft("Release Date: ");
XSStyles.doLabelSmall(publishdate);
XSStyles.SeparatorThin();
XSStyles.doLabelLeft("Changelog: ");
XSStyles.doLabelSmall(changelog);
EditorGUILayout.EndScrollView();
XSStyles.SeparatorThin();
if (GUILayout.Button("Download"))
{
Application.OpenURL(downloadLink);
}
}
else
{
XSStyles.doLabel("Hit 'Check for Updates' to begin");
}
EditorGUI.EndChangeCheck();
break;
case 2:
//show Patrons
XSStyles.doLabel("Thank you to my patreon supporters, and the people who have helped me along the way, you guys are great!\n Note: You must be in the Discord server to show on this list.");
XSStyles.SeparatorThin();
XSStyles.doLabel("Current Patrons");
XSStyles.SeparatorThin();
scrollPos = EditorGUILayout.BeginScrollView(scrollPos);
if (!hasCalledPatronlist)
{
hasCalledPatronlist = true;
req(patronsURL);
EditorApplication.update += EditorUpdate;
}
for (int i = 0; i < patrons.Length; i++)
{
XSStyles.doLabel(" - " + patrons[i]);
}
EditorGUILayout.EndScrollView();
XSStyles.SeparatorThin();
//show social links
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
XSStyles.discordButton(70, 30);
XSStyles.patreonButton(70, 30);
XSStyles.githubButton(70, 30);
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
break;
}
}
public void OnGUI()
{
changed = false;
if (focusedMat != null)
{
XSStyles.ShurikenHeader("Current Material: " + focusedMat.name);
}
else
{
XSStyles.ShurikenHeader("Current Material: None");
}
if (preButton == null)
{
iconToolbarPlus = EditorGUIUtility.IconContent("Toolbar Plus", "Add Gradient");
iconToolbarMinus = EditorGUIUtility.IconContent("Toolbar Minus", "Remove Gradient");
preButton = new GUIStyle("RL FooterButton");
buttonBackground = new GUIStyle("RL Header");
}
if (gradients.Count == 0)
{
gradients.Add(new Gradient());
gradients.Add(new Gradient());
gradients.Add(new Gradient());
gradients.Add(new Gradient());
gradients.Add(new Gradient());
}
if (grad_index_reorderable == null)
{
makeReorderedList();
}
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
Rect r = EditorGUILayout.GetControlRect();
float rightEdge = r.xMax;
float leftEdge = rightEdge - 48f;
r = new Rect(leftEdge, r.y, rightEdge - leftEdge, r.height);
if (Event.current.type == EventType.Repaint)
{
buttonBackground.Draw(r, false, false, false, false);
}
leftEdge += 18f;
EditorGUI.BeginDisabledGroup(gradients_index.Count == 5);
bool addE = GUI.Button(new Rect(leftEdge + 4, r.y, 25, 13), iconToolbarPlus, preButton);
EditorGUI.EndDisabledGroup();
EditorGUI.BeginDisabledGroup(gradients_index.Count == 1);
bool removeE = GUI.Button(new Rect(leftEdge - 19, r.y, 25, 13), iconToolbarMinus, preButton);
EditorGUI.EndDisabledGroup();
if (addE)
{
grad_index_reorderable.index++;
int wat = 0;
for (int i = 0; i < 5; i++)
{
if (!gradients_index.Contains(i))
{
wat = i;
break;
}
}
gradients_index.Add(wat);
changed = true;
}
if (removeE)
{
gradients_index.Remove(gradients_index[gradients_index.Count - 1]);
grad_index_reorderable.index--;
changed = true;
}
GUIStyle button = new GUIStyle(EditorStyles.miniButton);
button.normal = !reorder ? EditorStyles.miniButton.normal : EditorStyles.miniButton.onNormal;
if (GUILayout.Button(new GUIContent("Reorder", "Don't use Reorder if you want to undo a gradient change"), button, GUILayout.ExpandWidth(false)))
{
reorder = !reorder;
}
GUILayout.EndHorizontal();
SerializedObject serializedObject = new SerializedObject(this);
if (reorder)
{
grad_index_reorderable.DoLayoutList();
}
else
{
SerializedProperty colorGradients = serializedObject.FindProperty("gradients");
if (colorGradients.arraySize == 5)
{
for (int i = 0; i < gradients_index.Count; i++)
{
Rect _r = EditorGUILayout.GetControlRect();
_r.x += 16f;
_r.width -= 2f + 16f;
_r.height += 5f;
_r.y += 2f + (3f * i);
EditorGUI.PropertyField(_r, colorGradients.GetArrayElementAtIndex(gradients_index[i]), new GUIContent(""));
}
GUILayout.Space(Mathf.Lerp(9f, 24f, gradients_index.Count / 5f));
}
}
if (serializedObject.ApplyModifiedProperties())
{
changed = true;
}
if (oldFocusedMat != focusedMat)
{
changed = true;
if (this.oldTexture != null)
{
if (this.oldTexture == EditorGUIUtility.whiteTexture)
{
this.oldTexture = null;
}
oldFocusedMat.SetTexture(rampProperty, this.oldTexture);
this.oldTexture = null;
}
oldFocusedMat = focusedMat;
}
Resolutions oldRes = res;
res = (Resolutions)EditorGUILayout.EnumPopup("Resolution: ", res);
if (oldRes != res)
{
changed = true;
}
int width = (int)res;
int height = 30;
if (gradients_index.Count == 1)
{
height = 8;
}
else
{
height = 150;
}
if (tex == null)
{
tex = new Texture2D(width, height, TextureFormat.RGBA32, false);
}
bool old_isLinear = isLinear;
drawAdvancedOptions();
if (old_isLinear != isLinear)
{
changed = true;
}
if (manualMaterial)
{
focusedMat = (Material)EditorGUILayout.ObjectField(new GUIContent("", ""), focusedMat, typeof(Material), true);
}
if (focusedMat != null)
{
if (focusedMat.HasProperty("_Ramp"))
{
rampProperty = "_Ramp";
}
else
{
rampProperty = EditorGUILayout.TextField("Ramp Property Name", rampProperty);
if (!focusedMat.HasProperty(rampProperty))
{
GUILayout.Label("Property not found!");
}
}
}
if (changed)
{
updateTexture(width, height);
if (focusedMat != null)
{
if (focusedMat.HasProperty(rampProperty))
{
if (this.oldTexture == null)
{
if (focusedMat.GetTexture(rampProperty) == null)
{
this.oldTexture = EditorGUIUtility.whiteTexture;
}
else
{
this.oldTexture = focusedMat.GetTexture(rampProperty);
}
}
tex.wrapMode = TextureWrapMode.Clamp;
tex.Apply(false, false);
focusedMat.SetTexture(rampProperty, tex);
}
}
}
XSStyles.Separator();
drawMGInputOutput();
if (GUILayout.Button("Save Ramp"))
{
finalFilePath = XSStyles.findAssetPath(finalFilePath);
string path = EditorUtility.SaveFilePanel("Save Ramp as PNG", finalFilePath + "/Textures/Shadow Ramps/Generated", "gradient", "png");
if (path.Length != 0)
{
updateTexture(width, height);
bool success = GenTexture(tex, path);
if (success)
{
if (focusedMat != null)
{
string s = path.Substring(path.IndexOf("Assets"));
Texture ramp = AssetDatabase.LoadAssetAtPath <Texture>(s);
if (ramp != null)
{
focusedMat.SetTexture(rampProperty, ramp);
this.oldTexture = null;
}
}
}
}
}
drawHelpText();
}
private void DrawReflectionsSettings(MaterialEditor materialEditor, Material material)
{
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"));
XSStyles.SeparatorThin();
materialEditor.TexturePropertySingleLine(new GUIContent("Fallback Cubemap", " Used as fallback in 'Unity' reflection mode if reflection probe is black."), _BakedCubemap);
XSStyles.SeparatorThin();
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(_AnisotropicReflection, new GUIContent("Anisotropy", "The amount of anisotropy the surface has - this will stretch the reflection along an axis (think bottom of a frying pan)"), 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"));
XSStyles.SeparatorThin();
materialEditor.TexturePropertySingleLine(new GUIContent("Baked Cubemap", "Baked cubemap."), _BakedCubemap);
XSStyles.SeparatorThin();
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(_AnisotropicReflection, new GUIContent("Anisotropic", "Anisotropic, stretches reflection in an axis."), 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"));
XSStyles.SeparatorThin();
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);
materialEditor.ShaderProperty(_MatcapTintToDiffuse, new GUIContent("Tint To Diffuse", "Tints matcap to diffuse color."), 2);
material.SetFloat("_Metallic", 0);
material.SetFloat("_ClearCoat", 0);
material.SetTexture("_MetallicGlossMap", null);
}
if (_ReflectionMode.floatValue != 3)
{
XSStyles.SeparatorThin();
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);
}
}
}
