Custom shader

GameDevRick · Nov 6, 2017

I would like to add an alpha channel or opacity slider to the Detail Albedo secondary map, but I don't
know which property it would be associated with when calling FindProperty(). I am adding a line after
this one in the standard shader:

Code (CSharp):

detailAlbedoMap = FindProperty("_DetailAlbedoMap", props);

That new line should find the opacity or alpha channel property so I can set it to a slider with ranges.
Something like this?:

Code (CSharp):

detailAlbedoMap = FindProperty("_DetailAlbedoMapAlpha", props);

Baste · Nov 6, 2017

Where are you calling FindProperty from? There's some context missing here.

If you're making a custom drawer for a material, there's a special API to do that.

GameDevRick · Nov 6, 2017

In the Custom editor GUI code.
At about the middle of the following image, the call is commented with // CUSTOM

https://gyazo.com/9a933514b2333e669954ed54d8b69819

How should I be going about this?

Baste · Nov 6, 2017

Right, so that's a copy of some built-in material editor?

First of all, you'll need to also draw the detailMaskAlpha. Do it in the same place/way as the detailAlbedoMap is drawn.
Then, make sure your copy of the editor script is in an Editor folder.
Then, have your custom shader reference your editor script. In the bottom of the shader file, there's a line that references which editor to use. Replace that with your own editor.

That should work.

GameDevRick · Nov 6, 2017

Ya.. that's where I am with this I think.Yes, it is a copy of the standard shader.
I think I need to know what the name of the property is for the alpha on this line:

https://gyazo.com/9466ea5c57542cc62de457aa76378f4c

I will post the entire shader so you can see why it isn't working.
Note that the custom editor code is in the editor folder and it works with the shader fine.
Also note that any additions or changes I made to the shader are commented with // CUSTOM for ease of searching.

Code (CSharp):

// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)

using System;

using UnityEngine;

namespace UnityEditor

{

internal class CustomStandardShaderGUI : ShaderGUI

{

private enum WorkflowMode

{

Specular,

Metallic,

Dielectric

}

public enum BlendMode

{

Opaque,

Cutout,

Fade, // Old school alpha-blending mode, fresnel does not affect amount of transparency

Transparent // Physically plausible transparency mode, implemented as alpha pre-multiply

}

public enum SmoothnessMapChannel

{

SpecularMetallicAlpha,

AlbedoAlpha,

}

private static class Styles

{

public static GUIContent uvSetLabel = new GUIContent("UV Set");

public static GUIContent albedoText = new GUIContent("Albedo", "Albedo (RGB) and Transparency (A)");

public static GUIContent alphaCutoffText = new GUIContent("Alpha Cutoff", "Threshold for alpha cutoff");

public static GUIContent specularMapText = new GUIContent("Specular", "Specular (RGB) and Smoothness (A)");

public static GUIContent metallicMapText = new GUIContent("Metallic", "Metallic (R) and Smoothness (A)");

public static GUIContent smoothnessText = new GUIContent("Smoothness", "Smoothness value");

public static GUIContent smoothnessScaleText = new GUIContent("Smoothness", "Smoothness scale factor");

public static GUIContent smoothnessMapChannelText = new GUIContent("Source", "Smoothness texture and channel");

public static GUIContent highlightsText = new GUIContent("Specular Highlights", "Specular Highlights");

public static GUIContent reflectionsText = new GUIContent("Reflections", "Glossy Reflections");

public static GUIContent normalMapText = new GUIContent("Normal Map", "Normal Map");

public static GUIContent heightMapText = new GUIContent("Height Map", "Height Map (G)");

public static GUIContent occlusionText = new GUIContent("Occlusion", "Occlusion (G)");

public static GUIContent emissionText = new GUIContent("Color", "Emission (RGB)");

public static GUIContent detailMaskText = new GUIContent("Detail Mask", "Mask for Secondary Maps (A)");

public static GUIContent detailAlbedoText = new GUIContent("Detail Albedo x2", "Albedo (RGB) multiplied by 2");

// CUSTOM

public static GUIContent detailAlphaText = new GUIContent("Detail Alpha", "Alpha channel for setting opacity");

public static GUIContent detailNormalMapText = new GUIContent("Normal Map", "Normal Map");

public static string primaryMapsText = "Main Maps";

public static string secondaryMapsText = "Secondary Maps";

public static string forwardText = "Forward Rendering Options";

public static string renderingMode = "Rendering Mode";

public static string advancedText = "Advanced Options";

public static GUIContent emissiveWarning = new GUIContent("Emissive value is animated but the material has not been configured to support emissive. Please make sure the material itself has some amount of emissive.");

public static readonly string[] blendNames = Enum.GetNames(typeof(BlendMode));

}

MaterialProperty blendMode = null;

MaterialProperty albedoMap = null;

MaterialProperty albedoColor = null;

MaterialProperty alphaCutoff = null;

MaterialProperty specularMap = null;

MaterialProperty specularColor = null;

MaterialProperty metallicMap = null;

MaterialProperty metallic = null;

MaterialProperty smoothness = null;

MaterialProperty smoothnessScale = null;

MaterialProperty smoothnessMapChannel = null;

MaterialProperty highlights = null;

MaterialProperty reflections = null;

MaterialProperty bumpScale = null;

MaterialProperty bumpMap = null;

MaterialProperty occlusionStrength = null;

MaterialProperty occlusionMap = null;

MaterialProperty heigtMapScale = null;

MaterialProperty heightMap = null;

MaterialProperty emissionColorForRendering = null;

MaterialProperty emissionMap = null;

MaterialProperty detailMask = null;

// CUSTOM

MaterialProperty detailMaskAlpha = null;

MaterialProperty detailAlbedoMap = null;

MaterialProperty detailNormalMapScale = null;

MaterialProperty detailNormalMap = null;

MaterialProperty uvSetSecondary = null;

MaterialEditor m_MaterialEditor;

WorkflowMode m_WorkflowMode = WorkflowMode.Specular;

private const float kMaxfp16 = 65536f; // Clamp to a value that fits into fp16.

ColorPickerHDRConfig m_ColorPickerHDRConfig = new ColorPickerHDRConfig(0f, kMaxfp16, 1 / kMaxfp16, 3f);

bool m_FirstTimeApply = true;

public void FindProperties(MaterialProperty[] props)

{

blendMode = FindProperty("_Mode", props);

albedoMap = FindProperty("_MainTex", props);

albedoColor = FindProperty("_Color", props);

alphaCutoff = FindProperty("_Cutoff", props);

specularMap = FindProperty("_SpecGlossMap", props, false);

specularColor = FindProperty("_SpecColor", props, false);

metallicMap = FindProperty("_MetallicGlossMap", props, false);

metallic = FindProperty("_Metallic", props, false);

if (specularMap != null && specularColor != null)

m_WorkflowMode = WorkflowMode.Specular;

else if (metallicMap != null && metallic != null)

m_WorkflowMode = WorkflowMode.Metallic;

else

m_WorkflowMode = WorkflowMode.Dielectric;

smoothness = FindProperty("_Glossiness", props);

smoothnessScale = FindProperty("_GlossMapScale", props, false);

smoothnessMapChannel = FindProperty("_SmoothnessTextureChannel", props, false);

highlights = FindProperty("_SpecularHighlights", props, false);

reflections = FindProperty("_GlossyReflections", props, false);

bumpScale = FindProperty("_BumpScale", props);

bumpMap = FindProperty("_BumpMap", props);

heigtMapScale = FindProperty("_Parallax", props);

heightMap = FindProperty("_ParallaxMap", props);

occlusionStrength = FindProperty("_OcclusionStrength", props);

occlusionMap = FindProperty("_OcclusionMap", props);

emissionColorForRendering = FindProperty("_EmissionColor", props);

emissionMap = FindProperty("_EmissionMap", props);

detailMask = FindProperty("_DetailMask", props);

detailAlbedoMap = FindProperty("_DetailAlbedoMap", props);

// CUSTOM - This is the property that I want to make into a range to control the opacity

detailMaskAlpha = FindProperty("_DetailMaskAlpha", props);

detailNormalMapScale = FindProperty("_DetailNormalMapScale", props);

detailNormalMap = FindProperty("_DetailNormalMap", props);

uvSetSecondary = FindProperty("_UVSec", props);

}

public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)

{

FindProperties(props); // MaterialProperties can be animated so we do not cache them but fetch them every event to ensure animated values are updated correctly

m_MaterialEditor = materialEditor;

Material material = materialEditor.target as Material;

// Make sure that needed setup (ie keywords/renderqueue) are set up if we're switching some existing

// material to a standard shader.

// Do this before any GUI code has been issued to prevent layout issues in subsequent GUILayout statements (case 780071)

if (m_FirstTimeApply)

{

MaterialChanged(material, m_WorkflowMode);

m_FirstTimeApply = false;

}

ShaderPropertiesGUI(material);

}

// SHADER PROPERTIES GUI

public void ShaderPropertiesGUI(Material material)

{

// Use default labelWidth

EditorGUIUtility.labelWidth = 0f;

// Detect any changes to the material

EditorGUI.BeginChangeCheck();

{

BlendModePopup();

// Primary properties

GUILayout.Label(Styles.primaryMapsText, EditorStyles.boldLabel);

DoAlbedoArea(material);

DoSpecularMetallicArea();

m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, bumpMap, bumpMap.textureValue != null ? bumpScale : null);

m_MaterialEditor.TexturePropertySingleLine(Styles.heightMapText, heightMap, heightMap.textureValue != null ? heigtMapScale : null);

m_MaterialEditor.TexturePropertySingleLine(Styles.occlusionText, occlusionMap, occlusionMap.textureValue != null ? occlusionStrength : null);

m_MaterialEditor.TexturePropertySingleLine(Styles.detailMaskText, detailMask);

DoEmissionArea(material);

EditorGUI.BeginChangeCheck();

m_MaterialEditor.TextureScaleOffsetProperty(albedoMap);

if (EditorGUI.EndChangeCheck())

emissionMap.textureScaleAndOffset = albedoMap.textureScaleAndOffset; // Apply the main texture scale and offset to the emission texture as well, for Enlighten's sake

EditorGUILayout.Space();

// Secondary properties

GUILayout.Label(Styles.secondaryMapsText, EditorStyles.boldLabel);

m_MaterialEditor.TexturePropertySingleLine(Styles.detailAlbedoText, detailAlbedoMap);

// CUSTOM

m_MaterialEditor.TexturePropertySingleLine(Styles.detailAlphaText, detailMaskAlpha);

m_MaterialEditor.TexturePropertySingleLine(Styles.detailNormalMapText, detailNormalMap, detailNormalMapScale);

m_MaterialEditor.TextureScaleOffsetProperty(detailAlbedoMap);

m_MaterialEditor.ShaderProperty(uvSetSecondary, Styles.uvSetLabel.text);

// Third properties

GUILayout.Label(Styles.forwardText, EditorStyles.boldLabel);

if (highlights != null)

m_MaterialEditor.ShaderProperty(highlights, Styles.highlightsText);

if (reflections != null)

m_MaterialEditor.ShaderProperty(reflections, Styles.reflectionsText);

}

if (EditorGUI.EndChangeCheck())

{

foreach (var obj in blendMode.targets)

MaterialChanged((Material)obj, m_WorkflowMode);

}

EditorGUILayout.Space();

// NB renderqueue editor is not shown on purpose: we want to override it based on blend mode

GUILayout.Label(Styles.advancedText, EditorStyles.boldLabel);

m_MaterialEditor.EnableInstancingField();

m_MaterialEditor.DoubleSidedGIField();

}

internal void DetermineWorkflow(MaterialProperty[] props)

{

if (FindProperty("_SpecGlossMap", props, false) != null && FindProperty("_SpecColor", props, false) != null)

m_WorkflowMode = WorkflowMode.Specular;

else if (FindProperty("_MetallicGlossMap", props, false) != null && FindProperty("_Metallic", props, false) != null)

m_WorkflowMode = WorkflowMode.Metallic;

else

m_WorkflowMode = WorkflowMode.Dielectric;

}

public override void AssignNewShaderToMaterial(Material material, Shader oldShader, Shader newShader)

{

// _Emission property is lost after assigning Standard shader to the material

// thus transfer it before assigning the new shader

if (material.HasProperty("_Emission"))

{

material.SetColor("_EmissionColor", material.GetColor("_Emission"));

}

base.AssignNewShaderToMaterial(material, oldShader, newShader);

if (oldShader == null || !oldShader.name.Contains("Legacy Shaders/"))

{

SetupMaterialWithBlendMode(material, (BlendMode)material.GetFloat("_Mode"));

return;

}

BlendMode blendMode = BlendMode.Opaque;

if (oldShader.name.Contains("/Transparent/Cutout/"))

{

blendMode = BlendMode.Cutout;

}

else if (oldShader.name.Contains("/Transparent/"))

{

// NOTE: legacy shaders did not provide physically based transparency

// therefore Fade mode

blendMode = BlendMode.Fade;

}

material.SetFloat("_Mode", (float)blendMode);

DetermineWorkflow(MaterialEditor.GetMaterialProperties(new Material[] { material }));

MaterialChanged(material, m_WorkflowMode);

}

void BlendModePopup()

{

EditorGUI.showMixedValue = blendMode.hasMixedValue;

var mode = (BlendMode)blendMode.floatValue;

EditorGUI.BeginChangeCheck();

mode = (BlendMode)EditorGUILayout.Popup(Styles.renderingMode, (int)mode, Styles.blendNames);

if (EditorGUI.EndChangeCheck())

{

m_MaterialEditor.RegisterPropertyChangeUndo("Rendering Mode");

blendMode.floatValue = (float)mode;

}

EditorGUI.showMixedValue = false;

}

void DoAlbedoArea(Material material)

{

m_MaterialEditor.TexturePropertySingleLine(Styles.albedoText, albedoMap, albedoColor);

if (((BlendMode)material.GetFloat("_Mode") == BlendMode.Cutout))

{

m_MaterialEditor.ShaderProperty(alphaCutoff, Styles.alphaCutoffText.text, MaterialEditor.kMiniTextureFieldLabelIndentLevel + 1);

}

}

void DoEmissionArea(Material material)

{

// Emission for GI?

if (m_MaterialEditor.EmissionEnabledProperty())

{

bool hadEmissionTexture = emissionMap.textureValue != null;

// Texture and HDR color controls

m_MaterialEditor.TexturePropertyWithHDRColor(Styles.emissionText, emissionMap, emissionColorForRendering, m_ColorPickerHDRConfig, false);

// If texture was assigned and color was black set color to white

float brightness = emissionColorForRendering.colorValue.maxColorComponent;

if (emissionMap.textureValue != null && !hadEmissionTexture && brightness <= 0f)

emissionColorForRendering.colorValue = Color.white;

// change the GI flag and fix it up with emissive as black if necessary

m_MaterialEditor.LightmapEmissionFlagsProperty(MaterialEditor.kMiniTextureFieldLabelIndentLevel, true);

}

}

void DoSpecularMetallicArea()

{

bool hasGlossMap = false;

if (m_WorkflowMode == WorkflowMode.Specular)

{

hasGlossMap = specularMap.textureValue != null;

m_MaterialEditor.TexturePropertySingleLine(Styles.specularMapText, specularMap, hasGlossMap ? null : specularColor);

}

else if (m_WorkflowMode == WorkflowMode.Metallic)

{

hasGlossMap = metallicMap.textureValue != null;

m_MaterialEditor.TexturePropertySingleLine(Styles.metallicMapText, metallicMap, hasGlossMap ? null : metallic);

}

bool showSmoothnessScale = hasGlossMap;

if (smoothnessMapChannel != null)

{

int smoothnessChannel = (int)smoothnessMapChannel.floatValue;

if (smoothnessChannel == (int)SmoothnessMapChannel.AlbedoAlpha)

showSmoothnessScale = true;

}

int indentation = 2; // align with labels of texture properties

m_MaterialEditor.ShaderProperty(showSmoothnessScale ? smoothnessScale : smoothness, showSmoothnessScale ? Styles.smoothnessScaleText : Styles.smoothnessText, indentation);

++indentation;

if (smoothnessMapChannel != null)

m_MaterialEditor.ShaderProperty(smoothnessMapChannel, Styles.smoothnessMapChannelText, indentation);

}

public static void SetupMaterialWithBlendMode(Material material, BlendMode blendMode)

{

switch (blendMode)

{

case BlendMode.Opaque:

material.SetOverrideTag("RenderType", "");

material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);

material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);

material.SetInt("_ZWrite", 1);

material.DisableKeyword("_ALPHATEST_ON");

material.DisableKeyword("_ALPHABLEND_ON");

material.DisableKeyword("_ALPHAPREMULTIPLY_ON");

material.renderQueue = -1;

break;

case BlendMode.Cutout:

material.SetOverrideTag("RenderType", "TransparentCutout");

material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);

material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);

material.SetInt("_ZWrite", 1);

material.EnableKeyword("_ALPHATEST_ON");

material.DisableKeyword("_ALPHABLEND_ON");

material.DisableKeyword("_ALPHAPREMULTIPLY_ON");

material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.AlphaTest;

break;

case BlendMode.Fade:

material.SetOverrideTag("RenderType", "Transparent");

material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);

material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);

material.SetInt("_ZWrite", 0);

material.DisableKeyword("_ALPHATEST_ON");

material.EnableKeyword("_ALPHABLEND_ON");

material.DisableKeyword("_ALPHAPREMULTIPLY_ON");

material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;

break;

case BlendMode.Transparent:

material.SetOverrideTag("RenderType", "Transparent");

material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);

material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);

material.SetInt("_ZWrite", 0);

material.DisableKeyword("_ALPHATEST_ON");

material.DisableKeyword("_ALPHABLEND_ON");

material.EnableKeyword("_ALPHAPREMULTIPLY_ON");

material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;

break;

}

}

static SmoothnessMapChannel GetSmoothnessMapChannel(Material material)

{

int ch = (int)material.GetFloat("_SmoothnessTextureChannel");

if (ch == (int)SmoothnessMapChannel.AlbedoAlpha)

return SmoothnessMapChannel.AlbedoAlpha;

else

return SmoothnessMapChannel.SpecularMetallicAlpha;

}

static void SetMaterialKeywords(Material material, WorkflowMode workflowMode)

{

// Note: keywords must be based on Material value not on MaterialProperty due to multi-edit & material animation

// (MaterialProperty value might come from renderer material property block)

SetKeyword(material, "_NORMALMAP", material.GetTexture("_BumpMap") || material.GetTexture("_DetailNormalMap"));

if (workflowMode == WorkflowMode.Specular)

SetKeyword(material, "_SPECGLOSSMAP", material.GetTexture("_SpecGlossMap"));

else if (workflowMode == WorkflowMode.Metallic)

SetKeyword(material, "_METALLICGLOSSMAP", material.GetTexture("_MetallicGlossMap"));

SetKeyword(material, "_PARALLAXMAP", material.GetTexture("_ParallaxMap"));

SetKeyword(material, "_DETAIL_MULX2", material.GetTexture("_DetailAlbedoMap") || material.GetTexture("_DetailNormalMap"));

// A material's GI flag internally keeps track of whether emission is enabled at all, it's enabled but has no effect

// or is enabled and may be modified at runtime. This state depends on the values of the current flag and emissive color.

// The fixup routine makes sure that the material is in the correct state if/when changes are made to the mode or color.

MaterialEditor.FixupEmissiveFlag(material);

bool shouldEmissionBeEnabled = (material.globalIlluminationFlags & MaterialGlobalIlluminationFlags.EmissiveIsBlack) == 0;

SetKeyword(material, "_EMISSION", shouldEmissionBeEnabled);

if (material.HasProperty("_SmoothnessTextureChannel"))

{

SetKeyword(material, "_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A", GetSmoothnessMapChannel(material) == SmoothnessMapChannel.AlbedoAlpha);

}

}

static void MaterialChanged(Material material, WorkflowMode workflowMode)

{

SetupMaterialWithBlendMode(material, (BlendMode)material.GetFloat("_Mode"));

SetMaterialKeywords(material, workflowMode);

}

static void SetKeyword(Material m, string keyword, bool state)

{

if (state)

m.EnableKeyword(keyword);

else

m.DisableKeyword(keyword);

}

}

} // namespace UnityEditor

Baste · Nov 6, 2017

That's not a shader. That's an editor for a shader. Have you written an edited version of the standard shader? Just writing an editor isn't going to get you very far.

Or are you trying to add a drawer for a property that already exists in the standard shader, but isn't exposed?

GameDevRick · Nov 6, 2017

Ah ya.. I'm sorry.. I modified the shader too:

"are you trying to add a drawer for a property that already exists in the standard shader, but isn't exposed?"
I can't answer that question because I don't fully get what's going on in there. I don't quite understand
how the shader and editor code are working together and how to access the alpha property yet.

Here is the shader:

Code (CSharp):

// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)

Shader "CustomStandardShader"

{

Properties

{

_Color("Color", Color) = (1,1,1,1)

_MainTex("Albedo", 2D) = "white" {}

_Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5

_Glossiness("Smoothness", Range(0.0, 1.0)) = 0.5

_GlossMapScale("Smoothness Scale", Range(0.0, 1.0)) = 1.0

[Enum(Metallic Alpha,0,Albedo Alpha,1)] _SmoothnessTextureChannel ("Smoothness texture channel", Float) = 0

[Gamma] _Metallic("Metallic", Range(0.0, 1.0)) = 0.0

_MetallicGlossMap("Metallic", 2D) = "white" {}

[ToggleOff] _SpecularHighlights("Specular Highlights", Float) = 1.0

[ToggleOff] _GlossyReflections("Glossy Reflections", Float) = 1.0

_BumpScale("Scale", Float) = 1.0

_BumpMap("Normal Map", 2D) = "bump" {}

_Parallax ("Height Scale", Range (0.005, 0.08)) = 0.02

_ParallaxMap ("Height Map", 2D) = "black" {}

_OcclusionStrength("Strength", Range(0.0, 1.0)) = 1.0

_OcclusionMap("Occlusion", 2D) = "white" {}

_EmissionColor("Color", Color) = (0,0,0)

_EmissionMap("Emission", 2D) = "white" {}

_DetailMask("Detail Mask", 2D) = "white" {}

_DetailAlbedoMap("Detail Albedo x2", 2D) = "grey" {}

// CUSTOM This was an attempt at the slider, but I think it is drawing the texture property

// and I don't know how to make it only the alpha value. I don't really understand how this

// is working with the custom editor. This is my first attempt at shader modding.

// _DetailAlbedoMapAlpha("Alpha", Range(0.0, 1.0)) = 1.0

_DetailNormalMapScale("Scale", Float) = 1.0

_DetailNormalMap("Normal Map", 2D) = "bump" {}

[Enum(UV0,0,UV1,1)] _UVSec ("UV Set for secondary textures", Float) = 0

// Blending state

[HideInInspector] _Mode ("__mode", Float) = 0.0

[HideInInspector] _SrcBlend ("__src", Float) = 1.0

[HideInInspector] _DstBlend ("__dst", Float) = 0.0

[HideInInspector] _ZWrite ("__zw", Float) = 1.0

}

CGINCLUDE

#define UNITY_SETUP_BRDF_INPUT MetallicSetup

ENDCG

SubShader

{

Tags { "RenderType"="Opaque" "PerformanceChecks"="False" }

LOD 300

// ------------------------------------------------------------------

// Base forward pass (directional light, emission, lightmaps, ...)

Pass

{

Name "FORWARD"

Tags { "LightMode" = "ForwardBase" }

Blend [_SrcBlend] [_DstBlend]

ZWrite [_ZWrite]

CGPROGRAM

#pragma target 3.0

// -------------------------------------

#pragma shader_feature _NORMALMAP

#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON

#pragma shader_feature _EMISSION

#pragma shader_feature _METALLICGLOSSMAP

#pragma shader_feature ___ _DETAIL_MULX2

#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A

#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF

#pragma shader_feature _ _GLOSSYREFLECTIONS_OFF

#pragma shader_feature _PARALLAXMAP

#pragma multi_compile_fwdbase

#pragma multi_compile_fog

#pragma multi_compile_instancing

// Uncomment the following line to enable dithering LOD crossfade. Note: there are more in the file to uncomment for other passes.

//#pragma multi_compile _ LOD_FADE_CROSSFADE

#pragma vertex vertBase

#pragma fragment fragBase

#include "UnityStandardCoreForward.cginc"

ENDCG

}

// ------------------------------------------------------------------

// Additive forward pass (one light per pass)

Pass

{

Name "FORWARD_DELTA"

Tags { "LightMode" = "ForwardAdd" }

Blend [_SrcBlend] One

Fog { Color (0,0,0,0) } // in additive pass fog should be black

ZWrite Off

ZTest LEqual

CGPROGRAM

#pragma target 3.0

// -------------------------------------

#pragma shader_feature _NORMALMAP

#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON

#pragma shader_feature _METALLICGLOSSMAP

#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A

#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF

#pragma shader_feature ___ _DETAIL_MULX2

#pragma shader_feature _PARALLAXMAP

#pragma multi_compile_fwdadd_fullshadows

#pragma multi_compile_fog

// Uncomment the following line to enable dithering LOD crossfade. Note: there are more in the file to uncomment for other passes.

//#pragma multi_compile _ LOD_FADE_CROSSFADE

#pragma vertex vertAdd

#pragma fragment fragAdd

#include "UnityStandardCoreForward.cginc"

ENDCG

}

// ------------------------------------------------------------------

// Shadow rendering pass

Pass {

Name "ShadowCaster"

Tags { "LightMode" = "ShadowCaster" }

ZWrite On ZTest LEqual

CGPROGRAM

#pragma target 3.0

// -------------------------------------

#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON

#pragma shader_feature _METALLICGLOSSMAP

#pragma shader_feature _PARALLAXMAP

#pragma multi_compile_shadowcaster

#pragma multi_compile_instancing

// Uncomment the following line to enable dithering LOD crossfade. Note: there are more in the file to uncomment for other passes.

//#pragma multi_compile _ LOD_FADE_CROSSFADE

#pragma vertex vertShadowCaster

#pragma fragment fragShadowCaster

#include "UnityStandardShadow.cginc"

ENDCG

}

// ------------------------------------------------------------------

// Deferred pass

Pass

{

Name "DEFERRED"

Tags { "LightMode" = "Deferred" }

CGPROGRAM

#pragma target 3.0

#pragma exclude_renderers nomrt

// -------------------------------------

#pragma shader_feature _NORMALMAP

#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON

#pragma shader_feature _EMISSION

#pragma shader_feature _METALLICGLOSSMAP

#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A

#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF

#pragma shader_feature ___ _DETAIL_MULX2

#pragma shader_feature _PARALLAXMAP

#pragma multi_compile_prepassfinal

#pragma multi_compile_instancing

// Uncomment the following line to enable dithering LOD crossfade. Note: there are more in the file to uncomment for other passes.

//#pragma multi_compile _ LOD_FADE_CROSSFADE

#pragma vertex vertDeferred

#pragma fragment fragDeferred

#include "UnityStandardCore.cginc"

ENDCG

}

// ------------------------------------------------------------------

// Extracts information for lightmapping, GI (emission, albedo, ...)

// This pass it not used during regular rendering.

Pass

{

Name "META"

Tags { "LightMode"="Meta" }

Cull Off

CGPROGRAM

#pragma vertex vert_meta

#pragma fragment frag_meta

#pragma shader_feature _EMISSION

#pragma shader_feature _METALLICGLOSSMAP

#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A

#pragma shader_feature ___ _DETAIL_MULX2

#pragma shader_feature EDITOR_VISUALIZATION

#include "UnityStandardMeta.cginc"

ENDCG

}

}

SubShader

{

Tags { "RenderType"="Opaque" "PerformanceChecks"="False" }

LOD 150

// ------------------------------------------------------------------

// Base forward pass (directional light, emission, lightmaps, ...)

Pass

{

Name "FORWARD"

Tags { "LightMode" = "ForwardBase" }

Blend [_SrcBlend] [_DstBlend]

ZWrite [_ZWrite]

CGPROGRAM

#pragma target 2.0

#pragma shader_feature _NORMALMAP

#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON

#pragma shader_feature _EMISSION

#pragma shader_feature _METALLICGLOSSMAP

#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A

#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF

#pragma shader_feature _ _GLOSSYREFLECTIONS_OFF

// SM2.0: NOT SUPPORTED shader_feature ___ _DETAIL_MULX2

// SM2.0: NOT SUPPORTED shader_feature _PARALLAXMAP

#pragma skip_variants SHADOWS_SOFT DIRLIGHTMAP_COMBINED

#pragma multi_compile_fwdbase

#pragma multi_compile_fog

#pragma vertex vertBase

#pragma fragment fragBase

#include "UnityStandardCoreForward.cginc"

ENDCG

}

// ------------------------------------------------------------------

// Additive forward pass (one light per pass)

Pass

{

Name "FORWARD_DELTA"

Tags { "LightMode" = "ForwardAdd" }

Blend [_SrcBlend] One

Fog { Color (0,0,0,0) } // in additive pass fog should be black

ZWrite Off

ZTest LEqual

CGPROGRAM

#pragma target 2.0

#pragma shader_feature _NORMALMAP

#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON

#pragma shader_feature _METALLICGLOSSMAP

#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A

#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF

#pragma shader_feature ___ _DETAIL_MULX2

// SM2.0: NOT SUPPORTED shader_feature _PARALLAXMAP

#pragma skip_variants SHADOWS_SOFT

#pragma multi_compile_fwdadd_fullshadows

#pragma multi_compile_fog

#pragma vertex vertAdd

#pragma fragment fragAdd

#include "UnityStandardCoreForward.cginc"

ENDCG

}

// ------------------------------------------------------------------

// Shadow rendering pass

Pass {

Name "ShadowCaster"

Tags { "LightMode" = "ShadowCaster" }

ZWrite On ZTest LEqual

CGPROGRAM

#pragma target 2.0

#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON

#pragma shader_feature _METALLICGLOSSMAP

#pragma skip_variants SHADOWS_SOFT

#pragma multi_compile_shadowcaster

#pragma vertex vertShadowCaster

#pragma fragment fragShadowCaster

#include "UnityStandardShadow.cginc"

ENDCG

}

// ------------------------------------------------------------------

// Extracts information for lightmapping, GI (emission, albedo, ...)

// This pass it not used during regular rendering.

Pass

{

Name "META"

Tags { "LightMode"="Meta" }

Cull Off

CGPROGRAM

#pragma vertex vert_meta

#pragma fragment frag_meta

#pragma shader_feature _EMISSION

#pragma shader_feature _METALLICGLOSSMAP

#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A

#pragma shader_feature ___ _DETAIL_MULX2

#pragma shader_feature EDITOR_VISUALIZATION

#include "UnityStandardMeta.cginc"

ENDCG

}

}

FallBack "VertexLit"

CustomEditor "CustomStandardShaderGUI"

}

Baste · Nov 6, 2017

Right.

So first of all, the names have to match. So in your shader, you have:

Code (csharp):

_DetailAlbedoMapAlpha("Alpha", Range(0.0, 1.0)) = 1.0

So when you get that property in your editor, you have to use the same name:

Code (csharp):

// CUSTOM - This is the property that I want to make into a range to control the opacity

detailMaskAlpha = FindProperty("_DetailAlbedoMapAlpha", props);

Then, when drawing it, you can't use TexturePropertySingleLine. That method is for Textures (as the name implies), but you're drawing a float. Checking the other sliders (like the Metallic and Smoothness sliders), they use ShaderProperty, which is a generic property drawer, so you can use that:

Code (csharp):

m_MaterialEditor.ShaderProperty(detailMaskAlpha, Styles.detailAlphaText);

All that put together draws the thing correctly.

Now, you actually have to change the shader to use you custom masking. This is a bit more involved, as the detail albedo map isn't used directly in the standard shader, but instead in a .cginc file.

So on line 99 in your shader, you have:

Code (csharp):

#include "UnityStandardCoreForward.cginc"

That means "copy-paste everything in the file UnityStandardCoreForward.cginc in here". So your line 99 is repalced by an entire file.

Similarly, in UnityStandardCoreForward.cginc, the file UnityStandardCore.cginc is included. And from that file, UnityStandardInput.cginc is included. In that file, _DetailAlbedoMap is actually sampled and applied to the material:

So in order to apply your alpha slider, you'll have to replace all of those files with your custom ones, and have those reference each other. After that, you'll need to figure out how to actually apply your alpha value.

Final detail: Shaders are already pretty complex, and the Standard shader is probably the most complex shader that exists in Unity. After all of the #includes have resolved, it's probably thousands of lines long. So don't be too discouraged if this is a bit over your head.

@Eric5h5 or @hippocoder, maybe move this thread into the shader subforum?

GameDevRick · Nov 8, 2017

Thank you very much Baste!
The custom property drawer is drawing correctly, but your hint at the complexity of the shader is spot on.
It may be proving to be too cumbersome to locate and modify the alpha property within the cginc files.
I am looking into using Shader Forge as a way to set up custom property drawers, but I am not familiar
with it yet and I don't know if that is possible.

Search Unity

Unity ID

Useful Searches

Custom shader