protected virtual void SetMaterialAutoPropertiesAndKeywords(Material mat)
{
ShaderGUIUtils.SetKeyword(mat, "_USEMAINTEX_ON", mat.GetTexture("_MainTex"));
ShaderGUIUtils.SetKeyword(mat, "_USEOCCLUSIONMAP_ON", mat.GetTexture("_OcclusionMap"));
bool usesBumpMap = mat.GetTexture("_BumpMap");
bool usesSpecMap = mat.GetTexture("_SpecularMap");
bool usesGlossMap = mat.GetTexture("_GlossMap");
bool usesEmissionMap = mat.GetTexture("_EmissionMap");
ShaderGUIUtils.SetKeyword(mat, "_USEBUMPMAP_ON", usesBumpMap);
ShaderGUIUtils.SetKeyword(mat, "_USESPECULARMAP_ON", usesSpecMap);
ShaderGUIUtils.SetKeyword(mat, "_USEGLOSSMAP_ON", usesGlossMap);
ShaderGUIUtils.SetKeyword(mat, "_USEEMISSIONMAP_ON", usesEmissionMap);
if (usesBumpMap || usesSpecMap || usesGlossMap || usesEmissionMap)
{
mat.SetFloat("_ForcePerPixel", 1.0f);
}
var texScaleOffset = mat.GetVector("_TextureScaleOffset");
bool usesScale = texScaleOffset.x != 1.0f || texScaleOffset.y != 1.0f;
bool usesOffset = texScaleOffset.z != 0.0f || texScaleOffset.w != 0.0f;
ShaderGUIUtils.SetKeyword(mat, "_MainTex_SCALE_ON", usesScale);
ShaderGUIUtils.SetKeyword(mat, "_MainTex_OFFSET_ON", usesOffset);
}
public override void AssignNewShaderToMaterial(Material mat, Shader oldShader, Shader newShader)
{
// _Emission property is lost after assigning, transfer it before assigning the new shader
if (mat.HasProperty("_Emission"))
{
mat.SetColor("_EmissionColor", mat.GetColor("_Emission"));
}
base.AssignNewShaderToMaterial(mat, oldShader, newShader);
if (oldShader == null)
{
return;
}
BlendMode blendMode = BlendMode.Opaque;
bool standard = oldShader.name.Contains("Standard");
bool legacy = oldShader.name.Contains("Legacy Shaders/");
bool mobile = oldShader.name.Contains("Mobile/");
bool transparent = oldShader.name.Contains("Transparent/");
bool cutout = oldShader.name.Contains("Transparent/Cutout/");
bool unlit = oldShader.name.Contains("Unlit");
bool directionalLightOnly = oldShader.name.Contains("DirectionalLight");
bool vertexLit = oldShader.name.Contains("VertexLit");
bool spec = !oldShader.name.Contains("Diffuse");
if (standard)
{
SetMaterialLighting(mat, true, true, ShaderGUIUtils.TryGetToggle(mat, "_SpecularHighlights", true), true, true);
}
else if (mobile || legacy)
{
if (cutout)
{
blendMode = BlendMode.Cutout;
}
else if (transparent)
{
blendMode = BlendMode.Transparent;
}
if (unlit)
{
SetMaterialLighting(mat, false, false, false, false, false);
}
else
{
//TODO: need to handle way more cases
SetMaterialLighting(mat, true, true, spec, !directionalLightOnly, vertexLit);
}
SetMaterialBlendMode(mat, blendMode);
}
}
protected override void ShowOutputConfigurationGUI(MaterialEditor matEditor)
{
ShaderGUIUtils.BeginHeader("Output Configuration");
{
matEditor.ShaderProperty(zTest, Styles.zTest);
matEditor.ShaderProperty(zWrite, Styles.zWrite);
matEditor.ShaderProperty(colorWriteMask, Styles.colorWriteMask);
matEditor.RenderQueueField();
}
ShaderGUIUtils.EndHeader();
}
protected virtual void ShowOutputConfigurationGUI(MaterialEditor matEditor)
{
var mode = (BlendMode)blendMode.floatValue;
if (mode == BlendMode.Advanced)
{
ShaderGUIUtils.BeginHeader("Output Configuration");
{
matEditor.ShaderProperty(cullMode, Styles.cullMode);
matEditor.ShaderProperty(zTest, Styles.zTest);
matEditor.ShaderProperty(zWrite, Styles.zWrite);
matEditor.ShaderProperty(colorWriteMask, Styles.colorWriteMask);
}
ShaderGUIUtils.EndHeader();
}
}
public static void SetScaleOffsetKeywords
(
MaterialEditor matEditor,
MaterialProperty textureProp,
MaterialProperty scaleOffsetProp
)
{
var texScaleOffset = scaleOffsetProp.vectorValue;
bool usesScale = texScaleOffset.x != 1.0f || texScaleOffset.y != 1.0f;
bool usesOffset = texScaleOffset.z != 0.0f || texScaleOffset.w != 0.0f;
var mat = matEditor.target as Material;
var scaleKeyword = textureProp.name + "_SCALE_ON";
var offsetKeyword = textureProp.name + "_OFFSET_ON";
ShaderGUIUtils.SetKeyword(mat, scaleKeyword, usesScale);
ShaderGUIUtils.SetKeyword(mat, offsetKeyword, usesOffset);
}
protected virtual void SetMaterialBlendMode(Material mat, BlendMode blendMode)
{
switch (blendMode)
{
case BlendMode.Opaque:
mat.SetOverrideTag("RenderType", "");
mat.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
mat.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
mat.SetInt("_ZWrite", 1);
ShaderGUIUtils.SetKeyword(mat, "_ALPHATEST_ON", false);
mat.renderQueue = -1;
break;
case BlendMode.Cutout:
mat.SetOverrideTag("RenderType", "TransparentCutout");
mat.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
mat.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
mat.SetInt("_ZWrite", 1);
ShaderGUIUtils.SetKeyword(mat, "_ALPHATEST_ON", true);
mat.renderQueue = (int)UnityEngine.Rendering.RenderQueue.AlphaTest;
break;
case BlendMode.Transparent:
mat.SetOverrideTag("RenderType", "Transparent");
//non pre-multiplied alpha
mat.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
mat.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
mat.SetInt("_ZWrite", 1);
ShaderGUIUtils.SetKeyword(mat, "_ALPHATEST_ON", false);
mat.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
break;
case BlendMode.Advanced:
//user configured
break;
}
}
protected virtual void ShowMainGUI(MaterialEditor matEditor)
{
ShowBlendModeGUI(matEditor);
var mode = (BlendMode)blendMode.floatValue;
var mat = matEditor.target as Material;
ShaderGUIUtils.BeginHeader("Base Texture and Color");
{
matEditor.ShaderProperty(vertexColorEnabled, Styles.vertexColorEnabled);
CustomMaterialEditor.TextureWithToggleableColorAutoScaleOffsetSingleLine(matEditor,
Styles.main,
mainTexture,
mainColorEnabled, mainColor,
textureScaleAndOffset);
matEditor.TexturePropertySingleLine(Styles.occlusionMap, occlusionMap);
if (mode == BlendMode.Cutout)
{
matEditor.ShaderProperty(alphaCutoff, Styles.alphaCutoffText.text);
}
}
ShaderGUIUtils.EndHeader();
ShaderGUIUtils.HeaderSeparator();
ShaderGUIUtils.BeginHeader("Lighting");
{
matEditor.ShaderProperty(ambientLightingEnabled, Styles.ambientLightingEnabled);
matEditor.ShaderProperty(diffuseLightingEnabled, Styles.diffuseLightingEnabled);
matEditor.ShaderProperty(useAdditionalLightingData, Styles.useAdditionalLighingData);
EditorGUI.BeginDisabledGroup(MaterialNeedsPerPixel(mat));
matEditor.ShaderProperty(perPixelLighting, Styles.perPixelLighting);
EditorGUI.EndDisabledGroup();
ShaderGUIUtils.BeginHeaderProperty(matEditor, Styles.specularLightingEnabled.text, specularLightingEnabled);
{
if (specularLightingEnabled.floatValue != 0.0f)
{
matEditor.ShaderProperty(specularColor, Styles.specularColor);
//consider a special slider + tex control
matEditor.TexturePropertySingleLine(Styles.specular, specularMap, specular);
matEditor.TexturePropertySingleLine(Styles.gloss, glossMap, gloss);
}
}
ShaderGUIUtils.EndHeader();
matEditor.TexturePropertySingleLine(Styles.normalMap, normalMap);
ShaderGUIUtils.BeginHeaderProperty(matEditor, Styles.rimLightingEnabled.text, rimLightingEnabled);
{
if (rimLightingEnabled.floatValue != 0.0f)
{
matEditor.ShaderProperty(rimPower, Styles.rimPower);
matEditor.ShaderProperty(rimColor, Styles.rimColor);
}
}
ShaderGUIUtils.EndHeader();
ShaderGUIUtils.BeginHeaderProperty(matEditor, Styles.reflectionsEnabled.text, reflectionsEnabled);
{
if (reflectionsEnabled.floatValue != 0.0f)
{
matEditor.TexturePropertySingleLine(Styles.cubeMap, cubeMap);
matEditor.ShaderProperty(reflectionScale, Styles.reflectionScale);
matEditor.ShaderProperty(calibrationSpaceReflections, Styles.calibrationSpaceReflections);
}
}
ShaderGUIUtils.EndHeader();
CustomMaterialEditor.TextureWithToggleableColorSingleLine(matEditor, Styles.emission, emissionMap, emissionColorEnabled, emissionColor);
}
ShaderGUIUtils.EndHeader();
ShaderGUIUtils.HeaderSeparator();
ShaderGUIUtils.BeginHeader("Global");
{
CustomMaterialEditor.TextureScaleOffsetVector4Property(matEditor, textureScaleAndOffset);
}
ShaderGUIUtils.EndHeader();
ShaderGUIUtils.HeaderSeparator();
if (mode == BlendMode.Advanced)
{
ShaderGUIUtils.BeginHeader("Alpha Blending");
{
matEditor.ShaderProperty(srcBlend, Styles.srcBlend);
matEditor.ShaderProperty(dstBlend, Styles.dstBlend);
matEditor.ShaderProperty(blendOp, Styles.blendOp);
}
ShaderGUIUtils.EndHeader();
ShaderGUIUtils.HeaderSeparator();
}
}