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();
}
}
//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 void OnGUI()
{
if (gradient == null)
{
gradient = new Gradient();
}
EditorGUI.BeginChangeCheck();
SerializedObject serializedGradient = new SerializedObject(this);
SerializedProperty colorGradient = serializedGradient.FindProperty("gradient");
EditorGUILayout.PropertyField(colorGradient, true, null);
serializedGradient.ApplyModifiedProperties();
int width = 128;
int height = 8;
res = (resolutions)EditorGUILayout.EnumPopup("Resolution: ", res);
switch (res)
{
case resolutions.Large512x8:
width = 512;
break;
case resolutions.Medium256x8:
width = 256;
break;
case resolutions.Small128x8:
width = 128;
break;
case resolutions.Tiny64x8:
width = 64;
break;
}
if (gradient != null)
{
Texture2D tex = new Texture2D(width, height, TextureFormat.RGBA32, false);
for (int y = 0; y < tex.height; y++)
{
for (int x = 0; x < tex.width; x++)
{
tex.SetPixel(x, y, gradient.Evaluate((float)x / (float)width));
}
}
XSStyles.Separator();
if (GUILayout.Button("Save Ramp"))
{
XSStyles.findAssetPath(finalFilePath);
string path = EditorUtility.SaveFilePanel("Save Ramp as PNG", finalFilePath + "/Textures/Shadow Ramps/Generated", "gradient.png", "png");
if (path.Length != 0)
{
GenTexture(tex, path);
}
}
}
XSStyles.HelpBox("You can use this to create a custom shadow ramp. \nYou must save the asset with the save button to apply changes. \n\n - Click the Gradient box. \n - Choose resolution. \n - Save. \n - Drag texture into slot.", MessageType.Info);
}
public void OnGUI()
{
if (gradient == null)
{
gradient = new Gradient();
}
if (oldGradient == null)
{
oldGradient = new Gradient();
}
if (focusedMat != null && gradient != null)
{
XSStyles.ShurikenHeader("Current Material: " + focusedMat.name);
}
else
{
XSStyles.ShurikenHeader("Current Material: None");
}
SerializedObject serializedGradient = new SerializedObject(this);
SerializedProperty colorGradient = serializedGradient.FindProperty("gradient");
EditorGUILayout.PropertyField(colorGradient, true, null);
serializedGradient.ApplyModifiedProperties();
bool changed = !CompareGradients(oldGradient, gradient);
if (oldFocusedMat != focusedMat)
{
changed = true;
if (this.oldTexture != null)
{
if (this.oldTexture == EditorGUIUtility.whiteTexture)
{
this.oldTexture = null;
}
oldFocusedMat.SetTexture("_Ramp", this.oldTexture);
this.oldTexture = null;
}
oldFocusedMat = focusedMat;
}
if (changed)
{
oldGradient.SetKeys(gradient.colorKeys, gradient.alphaKeys);
oldGradient.mode = gradient.mode;
}
Resolutions oldRes = res;
res = (Resolutions)EditorGUILayout.EnumPopup("Resolution: ", res);
if (oldRes != res)
{
changed = true;
}
int width = (int)res;
int height = 8;
isLinear = GUILayout.Toggle(isLinear, "Make Linear Texture");
if (gradient != null)
{
Texture2D tex = new Texture2D(width, height, TextureFormat.RGBA32, false);
for (int y = 0; y < tex.height; y++)
{
for (int x = 0; x < tex.width; x++)
{
tex.SetPixel(x, y, gradient.Evaluate((float)x / (float)width));
}
}
if (focusedMat != null)
{
if (changed)
{
if (focusedMat.HasProperty("_Ramp"))
{
if (this.oldTexture == null)
{
if (focusedMat.GetTexture("_Ramp") == null)
{
this.oldTexture = EditorGUIUtility.whiteTexture;
}
else
{
this.oldTexture = focusedMat.GetTexture("_Ramp");
}
}
tex.wrapMode = TextureWrapMode.Clamp;
tex.Apply(false);
focusedMat.SetTexture("_Ramp", tex);
}
}
}
XSStyles.Separator();
if (GUILayout.Button("Save Ramp"))
{
finalFilePath = XSStyles.findAssetPath(finalFilePath);
string path = EditorUtility.SaveFilePanel("Save Ramp as PNG", finalFilePath + "/Textures/Shadow Ramps/Generated", "gradient.png", "png");
if (path.Length != 0)
{
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("_Ramp", ramp);
this.oldTexture = null;
}
}
}
}
}
}
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);
}
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();
}