Created StackLit material.

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Material.hlsl

 #include "Lit/Lit.hlsl"
 #elif defined(UNITY_MATERIAL_UNLIT)
 #include "Unlit/Unlit.hlsl"
+#elif defined(UNITY_MATERIAL_STACKLIT)
+#include "StackLit/StackLit.hlsl"
 #endif
 
 //-----------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/StackLit.meta

+fileFormatVersion: 2
+guid: fd74f5e99c8fb6d4086471ff874e0ba2
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit.meta

+fileFormatVersion: 2
+guid: 86c95bf966685564ba869d965bb5efe0
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderPass/ShaderPassForwardStackLit.hlsl

+#if SHADERPASS != SHADERPASS_FORWARD_STACKLIT
+#error SHADERPASS_is_not_correctly_define
+#endif
+
+#include "VertMesh.hlsl"
+
+PackedVaryingsType Vert(AttributesMesh inputMesh)
+{
+    VaryingsType varyingsType;
+    varyingsType.vmesh = VertMesh(inputMesh);
+    return PackVaryingsType(varyingsType);
+}
+
+#ifdef TESSELLATION_ON
+
+PackedVaryingsToPS VertTesselation(VaryingsToDS input)
+{
+    VaryingsToPS output;
+    output.vmesh = VertMeshTesselation(input.vmesh);
+    return PackVaryingsToPS(output);
+}
+
+#include "TessellationShare.hlsl"
+
+#endif // TESSELLATION_ON
+
+float4 Frag(PackedVaryingsToPS packedInput) : SV_Target
+{
+    FragInputs input = UnpackVaryingsMeshToFragInputs(packedInput.vmesh);
+
+    // input.positionSS is SV_Position
+    PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionWS);
+
+#ifdef VARYINGS_NEED_POSITION_WS
+    float3 V = GetWorldSpaceNormalizeViewDir(input.positionWS);
+#else
+    float3 V = 0; // Avoid the division by 0
+#endif
+
+    SurfaceData surfaceData;
+    BuiltinData builtinData;
+    GetSurfaceAndBuiltinData(input, V, posInput, surfaceData, builtinData);
+
+    // Not lit here (but emissive is allowed)
+    BSDFData bsdfData = ConvertSurfaceDataToBSDFData(surfaceData);
+
+    // TODO: we must not access bsdfData here, it break the genericity of the code!
+    float4 outColor = ApplyBlendMode(bsdfData.color + builtinData.emissiveColor, builtinData.opacity);
+    outColor = EvaluateAtmosphericScattering(posInput, outColor);
+
+#ifdef DEBUG_DISPLAY
+    // Same code in ShaderPassForward.shader
+    if (_DebugViewMaterial != 0)
+    {
+        float3 result = float3(1.0, 0.0, 1.0);
+        bool needLinearToSRGB = false;
+
+        GetPropertiesDataDebug(_DebugViewMaterial, result, needLinearToSRGB);
+        GetVaryingsDataDebug(_DebugViewMaterial, input, result, needLinearToSRGB);
+        GetBuiltinDataDebug(_DebugViewMaterial, builtinData, result, needLinearToSRGB);
+        GetSurfaceDataDebug(_DebugViewMaterial, surfaceData, result, needLinearToSRGB);
+        GetBSDFDataDebug(_DebugViewMaterial, bsdfData, result, needLinearToSRGB);
+
+        // TEMP!
+        // For now, the final blit in the backbuffer performs an sRGB write
+        // So in the meantime we apply the inverse transform to linear data to compensate.
+        if (!needLinearToSRGB)
+            result = SRGBToLinear(max(0, result));
+
+        outColor = float4(result, 1.0);
+    }
+#endif
+
+    return outColor;
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderPass/ShaderPassForwardStackLit.hlsl.meta

+fileFormatVersion: 2
+guid: 9ac43d36e5407514781096fa0cc40d58
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/StackLit/BaseUnlitUI.cs

+using System;
+using UnityEngine;
+using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
+
+namespace UnityEditor.Experimental.Rendering.HDPipeline
+{
+    // A Material can be authored from the shader graph or by hand. When written by hand we need to provide an inspector.
+    // Such a Material will share some properties between it various variant (shader graph variant or hand authored variant).
+    // This is the purpose of BaseLitGUI. It contain all properties that are common to all Material based on Lit template.
+    // For the default hand written Lit material see LitUI.cs that contain specific properties for our default implementation.
+    public abstract class BaseStackLitGUI : ShaderGUI
+    {
+        protected static class StylesBaseStackLit
+        {
+            public static string TransparencyInputsText = "Transparency Inputs";
+            public static string optionText = "Surface options";
+            public static string surfaceTypeText = "Surface Type";
+            public static string blendModeText = "Blend Mode";
+
+            public static readonly string[] surfaceTypeNames = Enum.GetNames(typeof(SurfaceType));
+            public static readonly string[] blendModeNames = Enum.GetNames(typeof(BlendMode));
+            public static readonly int[] blendModeValues = Enum.GetValues(typeof(BlendMode)) as int[];
+
+            public static GUIContent alphaCutoffEnableText = new GUIContent("Alpha Cutoff Enable", "Threshold for alpha cutoff");
+            public static GUIContent alphaCutoffText = new GUIContent("Alpha Cutoff", "Threshold for alpha cutoff");
+            public static GUIContent alphaCutoffShadowText = new GUIContent("Alpha Cutoff Shadow", "Threshold for alpha cutoff in case of shadow pass");
+            public static GUIContent alphaCutoffPrepassText = new GUIContent("Alpha Cutoff Prepass", "Threshold for alpha cutoff in case of depth prepass");
+            public static GUIContent alphaCutoffPostpassText = new GUIContent("Alpha Cutoff Postpass", "Threshold for alpha cutoff in case of depth postpass");
+            public static GUIContent transparentDepthPrepassEnableText = new GUIContent("Enable transparent depth prepass", "It allow to to fill depth buffer to improve sorting");
+            public static GUIContent transparentDepthPostpassEnableText = new GUIContent("Enable transparent depth postpass", "It allow to fill depth buffer for postprocess effect like DOF");
+            public static GUIContent transparentBackfaceEnableText = new GUIContent("Enable back then front rendering", "It allow to better sort transparent mesh by first rendering back faces then front faces in two separate drawcall");
+
+            public static GUIContent transparentSortPriorityText = new GUIContent("Transparent Sort Priority", "Allow to define priority (from -100 to +100) to solve sorting issue with transparent");
+            public static GUIContent enableTransparentFogText = new GUIContent("Enable fog", "Enable fog on transparent material");
+            public static GUIContent enableBlendModePreserveSpecularLightingText = new GUIContent("Blend preserve specular lighting", "Blend mode will only affect diffuse lighting, allowing correct specular lighting (reflection) on transparent object");
+
+            public static GUIContent doubleSidedEnableText = new GUIContent("Double Sided", "This will render the two face of the objects (disable backface culling) and flip/mirror normal");
+            public static GUIContent distortionEnableText = new GUIContent("Distortion", "Enable distortion on this shader");
+            public static GUIContent distortionOnlyText = new GUIContent("Distortion Only", "This shader will only be use to render distortion");
+            public static GUIContent distortionDepthTestText = new GUIContent("Distortion Depth Test", "Enable the depth test for distortion");
+            public static GUIContent distortionVectorMapText = new GUIContent("Distortion Vector Map - Dist(RG) Blur(B)", "Vector Map for the distorsion - Dist(RG) Blur(B)");
+            public static GUIContent distortionBlendModeText = new GUIContent("Distortion Blend Mode", "Distortion Blend Mode");
+            public static GUIContent distortionScaleText = new GUIContent("Distortion Scale", "Distortion Scale");
+            public static GUIContent distortionBlurScaleText = new GUIContent("Distortion Blur Scale", "Distortion Blur Scale");
+            public static GUIContent distortionBlurRemappingText = new GUIContent("Distortion Blur Remapping", "Distortion Blur Remapping");
+
+            public static GUIContent transparentPrepassText = new GUIContent("Pre Refraction Pass", "Render objects before the refraction pass");
+
+            public static GUIContent enableMotionVectorForVertexAnimationText = new GUIContent("Enable MotionVector For Vertex Animation", "This will enable an object motion vector pass for this material. Useful if wind animation is enabled or if displacement map is animated");
+
+            public static string advancedText = "Advanced Options";
+        }
+
+        public enum SurfaceType
+        {
+            Opaque,
+            Transparent
+        }
+
+        // Enum values are hardcoded for retro-compatibility. Don't change them.
+        public enum BlendMode
+        {
+            Alpha = 0,
+            Additive = 1,
+            PremultipliedAlpha = 4
+        }
+
+        protected MaterialEditor m_MaterialEditor;
+
+        // Properties
+        protected MaterialProperty surfaceType = null;
+        protected const string kSurfaceType = "_SurfaceType";
+        protected MaterialProperty alphaCutoffEnable = null;
+        protected const string kAlphaCutoffEnabled = "_AlphaCutoffEnable";
+        protected MaterialProperty alphaCutoff = null;
+        protected const string kAlphaCutoff = "_AlphaCutoff";
+        protected MaterialProperty alphaCutoffShadow = null;
+        protected const string kAlphaCutoffShadow = "_AlphaCutoffShadow";
+        protected MaterialProperty alphaCutoffPrepass = null;
+        protected const string kAlphaCutoffPrepass = "_AlphaCutoffPrepass";
+        protected MaterialProperty alphaCutoffPostpass = null;
+        protected const string kAlphaCutoffPostpass = "_AlphaCutoffPostpass";
+        protected MaterialProperty transparentDepthPrepassEnable = null;
+        protected const string kTransparentDepthPrepassEnable = "_TransparentDepthPrepassEnable";
+        protected MaterialProperty transparentDepthPostpassEnable = null;
+        protected const string kTransparentDepthPostpassEnable = "_TransparentDepthPostpassEnable";
+        protected MaterialProperty transparentBackfaceEnable = null;
+        protected const string kTransparentBackfaceEnable = "_TransparentBackfaceEnable";
+        protected MaterialProperty transparentSortPriority = null;
+        protected const string kTransparentSortPriority = "_TransparentSortPriority";
+        protected MaterialProperty doubleSidedEnable = null;
+        protected const string kDoubleSidedEnable = "_DoubleSidedEnable";
+        protected MaterialProperty blendMode = null;
+        protected const string kBlendMode = "_BlendMode";
+        protected MaterialProperty distortionEnable = null;
+        protected const string kDistortionEnable = "_DistortionEnable";
+        protected MaterialProperty distortionOnly = null;
+        protected const string kDistortionOnly = "_DistortionOnly";
+        protected MaterialProperty distortionDepthTest = null;
+        protected const string kDistortionDepthTest = "_DistortionDepthTest";
+        protected MaterialProperty distortionVectorMap = null;
+        protected const string kDistortionVectorMap = "_DistortionVectorMap";
+        protected MaterialProperty distortionBlendMode = null;
+        protected const string kDistortionBlendMode = "_DistortionBlendMode";
+        protected MaterialProperty distortionScale = null;
+        protected const string kDistortionScale = "_DistortionScale";
+        protected MaterialProperty distortionVectorScale = null;
+        protected const string kDistortionVectorScale = "_DistortionVectorScale";
+        protected MaterialProperty distortionVectorBias = null;
+        protected const string kDistortionVectorBias = "_DistortionVectorBias";
+        protected MaterialProperty distortionBlurScale = null;
+        protected const string kDistortionBlurScale = "_DistortionBlurScale";
+        protected MaterialProperty distortionBlurRemapMin = null;
+        protected const string kDistortionBlurRemapMin = "_DistortionBlurRemapMin";
+        protected MaterialProperty distortionBlurRemapMax = null;
+        protected const string kDistortionBlurRemapMax = "_DistortionBlurRemapMax";
+        protected MaterialProperty preRefractionPass = null;
+        protected const string kPreRefractionPass = "_PreRefractionPass";
+        protected MaterialProperty enableFogOnTransparent = null;
+        protected const string kEnableFogOnTransparent = "_EnableFogOnTransparent";
+        protected MaterialProperty enableBlendModePreserveSpecularLighting = null;
+        protected const string kEnableBlendModePreserveSpecularLighting = "_EnableBlendModePreserveSpecularLighting";
+
+        protected MaterialProperty enableMotionVectorForVertexAnimation = null;
+        protected const string kEnableMotionVectorForVertexAnimation = "_EnableMotionVectorForVertexAnimation";
+
+        protected const string kZTestDepthEqualForOpaque = "_ZTestDepthEqualForOpaque";
+        protected const string kZTestGBuffer = "_ZTestGBuffer";
+        protected const string kZTestModeDistortion = "_ZTestModeDistortion";
+
+        // See comment in LitProperties.hlsl
+        const string kEmissionColor = "_EmissionColor";
+
+        bool m_ShowBlendModePopup = true;
+        protected virtual bool showBlendModePopup { get { return m_ShowBlendModePopup; } }
+
+        // The following set of functions are call by the ShaderGraph
+        // It will allow to display our common parameters + setup keyword correctly for them
+        protected abstract void FindMaterialProperties(MaterialProperty[] props);
+        protected abstract void SetupMaterialKeywordsAndPassInternal(Material material);
+        protected abstract void MaterialPropertiesGUI(Material material);
+        protected abstract void MaterialPropertiesAdvanceGUI(Material material);
+        protected abstract void VertexAnimationPropertiesGUI();
+        // This function will say if emissive is used or not regarding enlighten/PVR
+        protected abstract bool ShouldEmissionBeEnabled(Material material);
+
+        protected virtual void FindBaseMaterialProperties(MaterialProperty[] props)
+        {
+            // Everything is optional (except surface type) so users that derive from this class can decide what they expose or not
+            surfaceType = FindProperty(kSurfaceType, props);
+            alphaCutoffEnable = FindProperty(kAlphaCutoffEnabled, props, false);
+            alphaCutoff = FindProperty(kAlphaCutoff, props, false);
+
+            alphaCutoffShadow = FindProperty(kAlphaCutoffShadow, props, false);
+            alphaCutoffPrepass = FindProperty(kAlphaCutoffPrepass, props, false);
+            alphaCutoffPostpass = FindProperty(kAlphaCutoffPostpass, props, false);
+            transparentDepthPrepassEnable = FindProperty(kTransparentDepthPrepassEnable, props, false);
+            transparentDepthPostpassEnable = FindProperty(kTransparentDepthPostpassEnable, props, false);
+            transparentBackfaceEnable = FindProperty(kTransparentBackfaceEnable, props, false);
+
+            transparentSortPriority = FindProperty(kTransparentSortPriority, props, false);
+
+            doubleSidedEnable = FindProperty(kDoubleSidedEnable, props, false);
+            blendMode = FindProperty(kBlendMode, props, false);
+
+            // Distortion is optional
+            distortionEnable = FindProperty(kDistortionEnable, props, false);
+            distortionOnly = FindProperty(kDistortionOnly, props, false);
+            distortionDepthTest = FindProperty(kDistortionDepthTest, props, false);
+            distortionVectorMap = FindProperty(kDistortionVectorMap, props, false);
+            distortionBlendMode = FindProperty(kDistortionBlendMode, props, false);
+            distortionScale = FindProperty(kDistortionScale, props, false);
+            distortionVectorScale = FindProperty(kDistortionVectorScale, props, false);
+            distortionVectorBias = FindProperty(kDistortionVectorBias, props, false);
+            distortionBlurScale = FindProperty(kDistortionBlurScale, props, false);
+            distortionBlurRemapMin = FindProperty(kDistortionBlurRemapMin, props, false);
+            distortionBlurRemapMax = FindProperty(kDistortionBlurRemapMax, props, false);
+            preRefractionPass = FindProperty(kPreRefractionPass, props, false);
+
+            enableFogOnTransparent = FindProperty(kEnableFogOnTransparent, props, false);
+            enableBlendModePreserveSpecularLighting = FindProperty(kEnableBlendModePreserveSpecularLighting, props, false);
+
+            enableMotionVectorForVertexAnimation = FindProperty(kEnableMotionVectorForVertexAnimation, props, false);
+        }
+
+        void SurfaceTypePopup()
+        {
+            EditorGUI.showMixedValue = surfaceType.hasMixedValue;
+            var mode = (SurfaceType)surfaceType.floatValue;
+
+            EditorGUI.BeginChangeCheck();
+            mode = (SurfaceType)EditorGUILayout.Popup(StylesBaseStackLit.surfaceTypeText, (int)mode, StylesBaseStackLit.surfaceTypeNames);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_MaterialEditor.RegisterPropertyChangeUndo("Surface Type");
+                surfaceType.floatValue = (float)mode;
+            }
+
+            EditorGUI.showMixedValue = false;
+        }
+
+        private void BlendModePopup()
+        {
+            EditorGUI.showMixedValue = blendMode.hasMixedValue;
+            var mode = (BlendMode)blendMode.floatValue;
+
+            EditorGUI.BeginChangeCheck();
+            mode = (BlendMode)EditorGUILayout.IntPopup(StylesBaseStackLit.blendModeText, (int)mode, StylesBaseStackLit.blendModeNames, StylesBaseStackLit.blendModeValues);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_MaterialEditor.RegisterPropertyChangeUndo("Blend Mode");
+                blendMode.floatValue = (float)mode;
+            }
+
+            EditorGUI.showMixedValue = false;
+        }
+
+        protected virtual void BaseMaterialPropertiesGUI()
+        {
+            EditorGUILayout.LabelField(StylesBaseStackLit.optionText, EditorStyles.boldLabel);
+
+            EditorGUI.indentLevel++;
+
+            SurfaceTypePopup();
+            if ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent)
+            {
+                if (blendMode != null && showBlendModePopup)
+                    BlendModePopup();
+
+                EditorGUI.indentLevel++;
+                if (enableBlendModePreserveSpecularLighting != null && blendMode != null && showBlendModePopup)
+                    m_MaterialEditor.ShaderProperty(enableBlendModePreserveSpecularLighting, StylesBaseStackLit.enableBlendModePreserveSpecularLightingText);
+                if (enableFogOnTransparent != null)
+                    m_MaterialEditor.ShaderProperty(enableFogOnTransparent, StylesBaseStackLit.enableTransparentFogText);
+                if (preRefractionPass != null)
+                    m_MaterialEditor.ShaderProperty(preRefractionPass, StylesBaseStackLit.transparentPrepassText);
+                EditorGUI.indentLevel--;
+            }
+
+            if (alphaCutoffEnable != null)
+                m_MaterialEditor.ShaderProperty(alphaCutoffEnable, StylesBaseStackLit.alphaCutoffEnableText);
+
+            if (alphaCutoffEnable != null && alphaCutoffEnable.floatValue == 1.0f)
+            {
+                EditorGUI.indentLevel++;
+                m_MaterialEditor.ShaderProperty(alphaCutoff, StylesBaseStackLit.alphaCutoffText);
+
+                // With transparent object and few specific materials like Hair, we need more control on the cutoff to apply
+                // This allow to get a better sorting (with prepass), better shadow (better silhouettes fidelity) etc...
+                if ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent)
+                {
+                    if (alphaCutoffShadow != null)
+                    {
+                        m_MaterialEditor.ShaderProperty(alphaCutoffShadow, StylesBaseStackLit.alphaCutoffShadowText);
+                    }
+
+                    if (transparentDepthPrepassEnable != null)
+                    {
+                        m_MaterialEditor.ShaderProperty(transparentDepthPrepassEnable, StylesBaseStackLit.transparentDepthPrepassEnableText);
+                        if (transparentDepthPrepassEnable.floatValue == 1.0f)
+                        {
+                            EditorGUI.indentLevel++;
+                            m_MaterialEditor.ShaderProperty(alphaCutoffPrepass, StylesBaseStackLit.alphaCutoffPrepassText);
+                            EditorGUI.indentLevel--;
+                        }
+                    }
+
+                    if (transparentDepthPostpassEnable != null)
+                    {
+                        m_MaterialEditor.ShaderProperty(transparentDepthPostpassEnable, StylesBaseStackLit.transparentDepthPostpassEnableText);
+                        if (transparentDepthPostpassEnable.floatValue == 1.0f)
+                        {
+                            EditorGUI.indentLevel++;
+                            m_MaterialEditor.ShaderProperty(alphaCutoffPostpass, StylesBaseStackLit.alphaCutoffPostpassText);
+                            EditorGUI.indentLevel--;
+                        }
+                    }
+                }
+                EditorGUI.indentLevel--;
+            }
+
+            if (transparentBackfaceEnable != null && ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent))
+                m_MaterialEditor.ShaderProperty(transparentBackfaceEnable, StylesBaseStackLit.transparentBackfaceEnableText);
+
+            if (transparentSortPriority != null && ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent))
+            {
+                EditorGUI.BeginChangeCheck();
+                m_MaterialEditor.ShaderProperty(transparentSortPriority, StylesBaseStackLit.transparentSortPriorityText);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    transparentSortPriority.floatValue = Mathf.Clamp((int)transparentSortPriority.floatValue, -(int)HDRenderQueue.k_TransparentPriorityQueueRange, (int)HDRenderQueue.k_TransparentPriorityQueueRange);
+                }
+            }
+
+            // This function must finish with double sided option (see LitUI.cs)
+            if (doubleSidedEnable != null)
+            {
+                m_MaterialEditor.ShaderProperty(doubleSidedEnable, StylesBaseStackLit.doubleSidedEnableText);
+            }
+
+            EditorGUI.indentLevel--;
+        }
+
+        protected void DoDistortionInputsGUI()
+        {
+            if (distortionEnable != null)
+            {
+                m_MaterialEditor.ShaderProperty(distortionEnable, StylesBaseStackLit.distortionEnableText);
+
+                if (distortionEnable.floatValue == 1.0f)
+                {
+                    EditorGUI.indentLevel++;
+                    m_MaterialEditor.ShaderProperty(distortionBlendMode, StylesBaseStackLit.distortionBlendModeText);
+                    if (distortionOnly != null)
+                        m_MaterialEditor.ShaderProperty(distortionOnly, StylesBaseStackLit.distortionOnlyText);
+                    m_MaterialEditor.ShaderProperty(distortionDepthTest, StylesBaseStackLit.distortionDepthTestText);
+
+                    EditorGUI.indentLevel++;
+                    m_MaterialEditor.TexturePropertySingleLine(StylesBaseStackLit.distortionVectorMapText, distortionVectorMap, distortionVectorScale, distortionVectorBias);
+                    EditorGUI.indentLevel++;
+                    m_MaterialEditor.ShaderProperty(distortionScale, StylesBaseStackLit.distortionScaleText);
+                    m_MaterialEditor.ShaderProperty(distortionBlurScale, StylesBaseStackLit.distortionBlurScaleText);
+                    float remapMin = distortionBlurRemapMin.floatValue;
+                    float remapMax = distortionBlurRemapMax.floatValue;
+                    EditorGUI.BeginChangeCheck();
+                    EditorGUILayout.MinMaxSlider(StylesBaseStackLit.distortionBlurRemappingText, ref remapMin, ref remapMax, 0.0f, 1.0f);
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        distortionBlurRemapMin.floatValue = remapMin;
+                        distortionBlurRemapMax.floatValue = remapMax;
+                    }
+                    EditorGUI.indentLevel--;
+
+                    EditorGUI.indentLevel--;
+
+                    EditorGUI.indentLevel--;
+                }
+            }
+        }
+
+        // All Setup Keyword functions must be static. It allow to create script to automatically update the shaders with a script if ocde change
+        static public void SetupBaseStackLitKeywords(Material material)
+        {
+            bool alphaTestEnable = material.HasProperty(kAlphaCutoffEnabled) && material.GetFloat(kAlphaCutoffEnabled) > 0.0f;
+            CoreUtils.SetKeyword(material, "_ALPHATEST_ON", alphaTestEnable);
+
+            SurfaceType surfaceType = (SurfaceType)material.GetFloat(kSurfaceType);
+            CoreUtils.SetKeyword(material, "_SURFACE_TYPE_TRANSPARENT", surfaceType == SurfaceType.Transparent);
+
+            bool enableBlendModePreserveSpecularLighting = (surfaceType == SurfaceType.Transparent) && material.HasProperty(kEnableBlendModePreserveSpecularLighting) && material.GetFloat(kEnableBlendModePreserveSpecularLighting) > 0.0f;
+            CoreUtils.SetKeyword(material, "_BLENDMODE_PRESERVE_SPECULAR_LIGHTING", enableBlendModePreserveSpecularLighting);
+
+            // These need to always been set either with opaque or transparent! So a users can switch to opaque and remove the keyword correctly
+            CoreUtils.SetKeyword(material, "_BLENDMODE_ALPHA", false);
+            CoreUtils.SetKeyword(material, "_BLENDMODE_ADD", false);
+            CoreUtils.SetKeyword(material, "_BLENDMODE_PRE_MULTIPLY", false);
+
+            // Alpha tested materials always have a prepass where we perform the clip.
+            // Then during Gbuffer pass we don't perform the clip test, so we need to use depth equal in this case.
+            if (alphaTestEnable)
+            {
+                material.SetInt(kZTestGBuffer, (int)UnityEngine.Rendering.CompareFunction.Equal);
+            }
+            else
+            {
+                material.SetInt(kZTestGBuffer, (int)UnityEngine.Rendering.CompareFunction.LessEqual);
+            }
+
+            // If the material use the kZTestDepthEqualForOpaque it mean it require depth equal test for opaque but transparent are not affected
+            if (material.HasProperty(kZTestDepthEqualForOpaque))
+            {
+                if (surfaceType == SurfaceType.Opaque)
+                    material.SetInt(kZTestDepthEqualForOpaque, (int)UnityEngine.Rendering.CompareFunction.Equal);
+                else
+                    material.SetInt(kZTestDepthEqualForOpaque, (int)UnityEngine.Rendering.CompareFunction.LessEqual);
+            }
+
+            if (surfaceType == SurfaceType.Opaque)
+            {
+                material.SetOverrideTag("RenderType", alphaTestEnable ? "TransparentCutout" : "");
+                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+                material.SetInt("_ZWrite", 1);
+                material.renderQueue = alphaTestEnable ? (int)HDRenderQueue.Priority.OpaqueAlphaTest : (int)HDRenderQueue.Priority.Opaque;
+            }
+            else
+            {
+                material.SetOverrideTag("RenderType", "Transparent");
+                material.SetInt("_ZWrite", 0);
+                var isPrepass = material.HasProperty(kPreRefractionPass) && material.GetFloat(kPreRefractionPass) > 0.0f;
+                material.renderQueue = (int)(isPrepass ? HDRenderQueue.Priority.PreRefraction : HDRenderQueue.Priority.Transparent) + (int)material.GetFloat(kTransparentSortPriority);
+
+                if (material.HasProperty(kBlendMode))
+                {
+                    BlendMode blendMode = (BlendMode)material.GetFloat(kBlendMode);
+
+                    CoreUtils.SetKeyword(material, "_BLENDMODE_ALPHA", BlendMode.Alpha == blendMode);
+                    CoreUtils.SetKeyword(material, "_BLENDMODE_ADD", BlendMode.Additive == blendMode);
+                    CoreUtils.SetKeyword(material, "_BLENDMODE_PRE_MULTIPLY", BlendMode.PremultipliedAlpha == blendMode);
+
+                    switch (blendMode)
+                    {
+                        // Alpha
+                        // color: src * src_a + dst * (1 - src_a)
+                        // src * src_a is done in the shader as it allow to reduce precision issue when using _BLENDMODE_PRESERVE_SPECULAR_LIGHTING (See Material.hlsl)
+                        case BlendMode.Alpha:
+                            material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                            material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
+                            break;
+
+                        // Additive
+                        // color: src * src_a + dst
+                        // src * src_a is done in the shader
+                        case BlendMode.Additive:
+                            material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                            material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                            break;
+
+                        // PremultipliedAlpha
+                        // color: src * src_a + dst * (1 - src_a)
+                        // src is supposed to have been multiplied by alpha in the texture on artists side.
+                        case BlendMode.PremultipliedAlpha:
+                            material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                            material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
+                            break;
+                    }
+                }
+            }
+
+            bool fogEnabled = material.HasProperty(kEnableFogOnTransparent) && material.GetFloat(kEnableFogOnTransparent) > 0.0f && surfaceType == SurfaceType.Transparent;
+            CoreUtils.SetKeyword(material, "_ENABLE_FOG_ON_TRANSPARENT", fogEnabled);
+
+            if (material.HasProperty(kDistortionEnable))
+            {
+                bool distortionDepthTest = material.GetFloat(kDistortionDepthTest) > 0.0f;
+                if (material.HasProperty(kZTestModeDistortion))
+                {
+                    if (distortionDepthTest)
+                    {
+                        material.SetInt(kZTestModeDistortion, (int)UnityEngine.Rendering.CompareFunction.LessEqual);
+                    }
+                    else
+                    {
+                        material.SetInt(kZTestModeDistortion, (int)UnityEngine.Rendering.CompareFunction.Always);
+                    }
+                }
+
+                var distortionBlendMode = material.GetInt(kDistortionBlendMode);
+                switch (distortionBlendMode)
+                {
+                    default:
+                    case 0: // Add
+                        material.SetInt("_DistortionSrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                        material.SetInt("_DistortionDstBlend", (int)UnityEngine.Rendering.BlendMode.One);
+
+                        material.SetInt("_DistortionBlurSrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                        material.SetInt("_DistortionBlurDstBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                        material.SetInt("_DistortionBlurBlendOp", (int)UnityEngine.Rendering.BlendOp.Max);
+                            break;
+
+                    case 1: // Multiply
+                        material.SetInt("_DistortionSrcBlend", (int)UnityEngine.Rendering.BlendMode.DstColor);
+                        material.SetInt("_DistortionDstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+
+                        material.SetInt("_DistortionBlurSrcBlend", (int)UnityEngine.Rendering.BlendMode.DstAlpha);
+                        material.SetInt("_DistortionBlurDstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+                        material.SetInt("_DistortionBlurBlendOp", (int)UnityEngine.Rendering.BlendOp.Add);
+                        break;
+                }
+            }
+
+            bool isBackFaceEnable = material.HasProperty(kTransparentBackfaceEnable) && material.GetFloat(kTransparentBackfaceEnable) > 0.0f && surfaceType == SurfaceType.Transparent;
+            bool doubleSidedEnable = material.HasProperty(kDoubleSidedEnable) && material.GetFloat(kDoubleSidedEnable) > 0.0f;
+
+            // Disable culling if double sided
+            material.SetInt("_CullMode", doubleSidedEnable ? (int)UnityEngine.Rendering.CullMode.Off : (int)UnityEngine.Rendering.CullMode.Back);
+
+            // We have a separate cullmode (_CullModeForward) for Forward in case we use backface then frontface rendering, need to configure it
+            if (isBackFaceEnable)
+            {
+                material.SetInt("_CullModeForward", (int)UnityEngine.Rendering.CullMode.Back);
+            }
+            else
+            {
+                material.SetInt("_CullModeForward", doubleSidedEnable ? (int)UnityEngine.Rendering.CullMode.Off : (int)UnityEngine.Rendering.CullMode.Back);
+            }
+
+            CoreUtils.SetKeyword(material, "_DOUBLESIDED_ON", doubleSidedEnable);
+
+            // 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);
+
+            // Commented out for now because unfortunately we used the hard coded property names used by the GI system for our own parameters
+            // So we need a way to work around that before we activate this.
+            SetupMainTexForAlphaTestGI("_EmissiveColorMap", "_EmissiveColor", material);
+
+            // DoubleSidedGI has to be synced with our double sided toggle
+            var serializedObject = new SerializedObject(material);
+            var doubleSidedGIppt = serializedObject.FindProperty("m_DoubleSidedGI");
+            doubleSidedGIppt.boolValue = doubleSidedEnable;
+            serializedObject.ApplyModifiedProperties();
+        }
+
+        // This is a hack for GI. PVR looks in the shader for a texture named "_MainTex" to extract the opacity of the material for baking. In the same manner, "_Cutoff" and "_Color" are also necessary.
+        // Since we don't have those parameters in our shaders we need to provide a "fake" useless version of them with the right values for the GI to work.
+        protected static void SetupMainTexForAlphaTestGI(string colorMapPropertyName, string colorPropertyName, Material material)
+        {
+            if (material.HasProperty(colorMapPropertyName))
+            {
+                var mainTex = material.GetTexture(colorMapPropertyName);
+                material.SetTexture("_MainTex", mainTex);
+            }
+
+            if (material.HasProperty(colorPropertyName))
+            {
+                var color = material.GetColor(colorPropertyName);
+                material.SetColor("_Color", color);
+            }
+
+            if (material.HasProperty("_AlphaCutoff")) // Same for all our materials
+            {
+                var cutoff = material.GetFloat("_AlphaCutoff");
+                material.SetFloat("_Cutoff", cutoff);
+            }
+        }
+
+        static public void SetupBaseStackLitMaterialPass(Material material)
+        {
+            if (material.HasProperty(kDistortionEnable))
+            {
+                bool distortionEnable = material.GetFloat(kDistortionEnable) > 0.0f && ((SurfaceType)material.GetFloat(kSurfaceType) == SurfaceType.Transparent);
+
+                bool distortionOnly = false;
+                if (material.HasProperty(kDistortionOnly))
+                {
+                    distortionOnly = material.GetFloat(kDistortionOnly) > 0.0f;
+                }
+
+                // If distortion only is enabled, disable all passes (except distortion and debug)
+                bool enablePass = !(distortionEnable && distortionOnly);
+
+                // Disable all passes except distortion
+                // Distortion is setup in code above
+                material.SetShaderPassEnabled(HDShaderPassNames.s_ForwardStr, enablePass);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_DepthOnlyStr, enablePass);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_DepthForwardOnlyStr, enablePass);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_ForwardOnlyStr, enablePass);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_GBufferStr, enablePass);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_GBufferWithPrepassStr, enablePass);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_MotionVectorsStr, enablePass);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_DistortionVectorsStr, distortionEnable); // note: use distortionEnable
+                material.SetShaderPassEnabled(HDShaderPassNames.s_TransparentDepthPrepassStr, enablePass);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_TransparentBackfaceStr, enablePass);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_TransparentDepthPostpassStr, enablePass);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_MetaStr, enablePass);
+                material.SetShaderPassEnabled(HDShaderPassNames.s_ShadowCasterStr, enablePass);
+            }
+
+            if (material.HasProperty(kTransparentDepthPrepassEnable))
+            {
+                bool depthWriteEnable = (material.GetFloat(kTransparentDepthPrepassEnable) > 0.0f) && ((SurfaceType)material.GetFloat(kSurfaceType) == SurfaceType.Transparent);
+                if (depthWriteEnable)
+                {
+                    material.SetShaderPassEnabled(HDShaderPassNames.s_TransparentDepthPrepassStr, true);
+                }
+                else
+                {
+                    material.SetShaderPassEnabled(HDShaderPassNames.s_TransparentDepthPrepassStr, false);
+                }
+            }
+
+            if (material.HasProperty(kTransparentDepthPostpassEnable))
+            {
+                bool depthWriteEnable = (material.GetFloat(kTransparentDepthPostpassEnable) > 0.0f) && ((SurfaceType)material.GetFloat(kSurfaceType) == SurfaceType.Transparent);
+                if (depthWriteEnable)
+                {
+                    material.SetShaderPassEnabled(HDShaderPassNames.s_TransparentDepthPostpassStr, true);
+                }
+                else
+                {
+                    material.SetShaderPassEnabled(HDShaderPassNames.s_TransparentDepthPostpassStr, false);
+                }
+            }
+
+            if (material.HasProperty(kTransparentBackfaceEnable))
+            {
+                bool backFaceEnable = (material.GetFloat(kTransparentBackfaceEnable) > 0.0f) && ((SurfaceType)material.GetFloat(kSurfaceType) == SurfaceType.Transparent);
+                if (backFaceEnable)
+                {
+                    material.SetShaderPassEnabled(HDShaderPassNames.s_TransparentBackfaceStr, true);
+                }
+                else
+                {
+                    material.SetShaderPassEnabled(HDShaderPassNames.s_TransparentBackfaceStr, false);
+                }
+            }
+
+            if (material.HasProperty(kEnableMotionVectorForVertexAnimation))
+            {
+                material.SetShaderPassEnabled(HDShaderPassNames.s_MotionVectorsStr, material.GetFloat(kEnableMotionVectorForVertexAnimation) > 0.0f);
+            }
+        }
+
+        // Dedicated to emissive - for emissive Enlighten/PVR
+        protected void DoEmissionArea(Material material)
+        {
+            // Emission for GI?
+            if (ShouldEmissionBeEnabled(material))
+            {
+                if (m_MaterialEditor.EmissionEnabledProperty())
+                {
+                    // change the GI flag and fix it up with emissive as black if necessary
+                    m_MaterialEditor.LightmapEmissionFlagsProperty(MaterialEditor.kMiniTextureFieldLabelIndentLevel, true);
+                }
+            }
+        }
+
+        public void ShaderPropertiesGUI(Material material)
+        {
+            // Use default labelWidth
+            EditorGUIUtility.labelWidth = 0f;
+
+            // Detect any changes to the material
+            EditorGUI.BeginChangeCheck();
+            {
+                //EditorGUI.indentLevel++;
+                BaseMaterialPropertiesGUI();
+                EditorGUILayout.Space();
+
+                VertexAnimationPropertiesGUI();
+
+                EditorGUILayout.Space();
+                MaterialPropertiesGUI(material);
+
+                DoEmissionArea(material);
+
+                EditorGUILayout.Space();
+                EditorGUILayout.LabelField(StylesBaseStackLit.advancedText, EditorStyles.boldLabel);
+                // NB RenderQueue editor is not shown on purpose: we want to override it based on blend mode
+                EditorGUI.indentLevel++;
+                m_MaterialEditor.EnableInstancingField();
+                MaterialPropertiesAdvanceGUI(material);
+                EditorGUI.indentLevel--;
+            }
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                foreach (var obj in m_MaterialEditor.targets)
+                    SetupMaterialKeywordsAndPassInternal((Material)obj);
+            }
+        }
+
+        public override void AssignNewShaderToMaterial(Material material, Shader oldShader, Shader newShader)
+        {
+            base.AssignNewShaderToMaterial(material, oldShader, newShader);
+
+            SetupMaterialKeywordsAndPassInternal(material);
+        }
+
+        // This is call by the inspector
+        public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
+        {
+            m_MaterialEditor = materialEditor;
+            // We should always do this call at the beginning
+            m_MaterialEditor.serializedObject.Update();
+
+            // MaterialProperties can be animated so we do not cache them but fetch them every event to ensure animated values are updated correctly
+            FindBaseMaterialProperties(props);
+            FindMaterialProperties(props);
+
+            Material material = materialEditor.target as Material;
+            ShaderPropertiesGUI(material);
+
+            // We should always do this call at the end
+            m_MaterialEditor.serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/StackLit/BaseUnlitUI.cs.meta

+fileFormatVersion: 2
+guid: 5737e27afd16fa444a3f5ef2c7568a56
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/StackLit/UnlitUI.cs

+using System;
+using UnityEngine;
+using UnityEngine.Experimental.Rendering;
+
+namespace UnityEditor.Experimental.Rendering.HDPipeline
+{
+    class StackLitGUI : BaseStackLitGUI
+    {
+        protected static class Styles
+        {
+            public static string InputsText = "Inputs";
+
+            public static GUIContent colorText = new GUIContent("Color", "Color");
+
+            public static GUIContent emissiveText = new GUIContent("Emissive Color", "Emissive");
+            public static GUIContent emissiveIntensityText = new GUIContent("Emissive Intensity", "Emissive");
+        }
+
+        protected MaterialProperty color = null;
+        protected const string kColor = "_UnlitColor";
+        protected MaterialProperty colorMap = null;
+        protected const string kColorMap = "_UnlitColorMap";
+        protected MaterialProperty emissiveColor = null;
+        protected const string kEmissiveColor = "_EmissiveColor";
+        protected MaterialProperty emissiveColorMap = null;
+        protected const string kEmissiveColorMap = "_EmissiveColorMap";
+        protected MaterialProperty emissiveIntensity = null;
+        protected const string kEmissiveIntensity = "_EmissiveIntensity";
+
+        override protected void FindMaterialProperties(MaterialProperty[] props)
+        {
+            color = FindProperty(kColor, props);
+            colorMap = FindProperty(kColorMap, props);
+
+            emissiveColor = FindProperty(kEmissiveColor, props);
+            emissiveColorMap = FindProperty(kEmissiveColorMap, props);
+            emissiveIntensity = FindProperty(kEmissiveIntensity, props);
+        }
+
+        protected override void MaterialPropertiesGUI(Material material)
+        {
+            EditorGUILayout.LabelField(Styles.InputsText, EditorStyles.boldLabel);
+
+            m_MaterialEditor.TexturePropertySingleLine(Styles.colorText, colorMap, color);
+            m_MaterialEditor.TextureScaleOffsetProperty(colorMap);
+
+            m_MaterialEditor.TexturePropertySingleLine(Styles.emissiveText, emissiveColorMap, emissiveColor);
+            m_MaterialEditor.TextureScaleOffsetProperty(emissiveColorMap);
+            m_MaterialEditor.ShaderProperty(emissiveIntensity, Styles.emissiveIntensityText);
+
+            var surfaceTypeValue = (SurfaceType)surfaceType.floatValue;
+            if (surfaceTypeValue == SurfaceType.Transparent)
+            {
+                EditorGUILayout.Space();
+                EditorGUILayout.LabelField(StylesBaseStackLit.TransparencyInputsText, EditorStyles.boldLabel);
+                ++EditorGUI.indentLevel;
+
+                DoDistortionInputsGUI();
+
+                --EditorGUI.indentLevel;
+            }
+        }
+
+        protected override void MaterialPropertiesAdvanceGUI(Material material)
+        {
+        }
+
+        protected override void VertexAnimationPropertiesGUI()
+        {
+
+        }
+
+        protected override bool ShouldEmissionBeEnabled(Material mat)
+        {
+            return mat.GetFloat(kEmissiveIntensity) > 0.0f;
+        }
+
+        protected override void SetupMaterialKeywordsAndPassInternal(Material material)
+        {
+            SetupMaterialKeywordsAndPass(material);
+        }
+
+        // All Setup Keyword functions must be static. It allow to create script to automatically update the shaders with a script if code change
+        static public void SetupMaterialKeywordsAndPass(Material material)
+        {
+            SetupBaseStackLitKeywords(material);
+            SetupBaseStackLitMaterialPass(material);
+
+            CoreUtils.SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(kEmissiveColorMap));
+        }
+    }
+} // namespace UnityEditor

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/StackLit/UnlitUI.cs.meta

+fileFormatVersion: 2
+guid: 5cae14264af711542ad1a58d690262e0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/StackLit/UnlitsToHDUnlitUpgrader.cs

+using UnityEngine;
+using System.Collections.Generic;
+
+namespace UnityEditor.Experimental.Rendering.HDPipeline
+{
+	public class UnlitsToHDStackLitUpgrader : MaterialUpgrader
+	{
+		string Unlit_Color = "Unlit/Color";
+		//string Unlit_Texture = "Unlit/Texture";
+		string Unlit_Transparent = "Unlit/Transparent";
+		string Unlit_Cutout = "Unlit/Transparent Cutout";
+
+		public UnlitsToHDStackLitUpgrader(string sourceShaderName, string destShaderName, MaterialFinalizer finalizer = null)
+        {
+            RenameShader(sourceShaderName, destShaderName, finalizer);
+
+			if (sourceShaderName == Unlit_Color)
+            	RenameColor("_Color", "_UnlitColor");
+			else // all other unlit have a texture
+            	RenameTexture("_MainTex", "_UnlitColorMap");
+
+			if (sourceShaderName == Unlit_Cutout)
+			{
+            	RenameFloat("_Cutoff", "_AlphaCutoff");
+				SetFloat("_AlphaCutoffEnable", 1f);
+			}
+			else
+				SetFloat("_AlphaCutoffEnable", 0f);
+
+
+			SetFloat("_SurfaceType", (sourceShaderName == Unlit_Transparent)? 1f : 0f );
+
+		}
+
+		public override void Convert(Material srcMaterial, Material dstMaterial)
+        {
+            //dstMaterial.hideFlags = HideFlags.DontUnloadUnusedAsset;
+
+            base.Convert(srcMaterial, dstMaterial);
+
+            HDEditorUtils.ResetMaterialKeywords(dstMaterial);
+		}
+	}
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/StackLit/UnlitsToHDUnlitUpgrader.cs.meta

+fileFormatVersion: 2
+guid: 267783f9e84ba0e4d9998841fb5fcc6a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/ShaderPass.meta

+fileFormatVersion: 2
+guid: 9fd26622ba7766c4f9285e0cd3f8199c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/ShaderPass/StackLitDepthPass.hlsl

+#ifndef SHADERPASS
+#error Undefine_SHADERPASS
+#endif
+
+#ifdef _ALPHATEST_ON
+#define ATTRIBUTES_NEED_TEXCOORD0
+
+#define VARYINGS_NEED_TEXCOORD0
+#endif
+
+// This include will define the various Attributes/Varyings structure
+#include "../../ShaderPass/VaryingMesh.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/ShaderPass/StackLitDepthPass.hlsl.meta

+fileFormatVersion: 2
+guid: 60c153442d48a7f45a551c0808637155
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/ShaderPass/StackLitDistortionPass.hlsl

+#ifndef SHADERPASS
+#error Undefine_SHADERPASS
+#endif
+
+#define ATTRIBUTES_NEED_TEXCOORD0
+
+#define VARYINGS_NEED_TEXCOORD0
+
+// This include will define the various Attributes/Varyings structure
+#include "../../ShaderPass/VaryingMesh.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/ShaderPass/StackLitDistortionPass.hlsl.meta

+fileFormatVersion: 2
+guid: e9ce97cf6b6d6304fac625fa22747b2f
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/ShaderPass/StackLitSharePass.hlsl

+#ifndef SHADERPASS
+#error Undefine_SHADERPASS
+#endif
+
+#define ATTRIBUTES_NEED_TEXCOORD0
+
+#if defined(DEBUG_DISPLAY) || (SHADERPASS == SHADERPASS_LIGHT_TRANSPORT)
+// For the meta pass with emissive we require UV1 and/or UV2
+#define ATTRIBUTES_NEED_TEXCOORD1
+#define ATTRIBUTES_NEED_TEXCOORD2
+#endif
+
+#if defined(_ENABLE_FOG_ON_TRANSPARENT) || (SHADERPASS == SHADERPASS_VELOCITY)
+#define VARYINGS_NEED_POSITION_WS
+#endif
+
+#define VARYINGS_NEED_TEXCOORD0
+
+// This include will define the various Attributes/Varyings structure
+#include "../../ShaderPass/VaryingMesh.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/ShaderPass/StackLitSharePass.hlsl.meta

+fileFormatVersion: 2
+guid: 8950ba3f99538d5489ffd15903311678
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.cs

+using UnityEngine;
+using System;
+
+//-----------------------------------------------------------------------------
+// structure definition
+//-----------------------------------------------------------------------------
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    public class StackLit : RenderPipelineMaterial
+    {
+        //-----------------------------------------------------------------------------
+        // SurfaceData
+        //-----------------------------------------------------------------------------
+
+        // Main structure that store the user data (i.e user input of master node in material graph)
+        [GenerateHLSL(PackingRules.Exact, false, true, 1200)]
+        public struct SurfaceData
+        {
+            [SurfaceDataAttributes("Color", false, true)]
+            public Vector3 color;
+        };
+
+        //-----------------------------------------------------------------------------
+        // BSDFData
+        //-----------------------------------------------------------------------------
+
+        [GenerateHLSL(PackingRules.Exact, false, true, 1230)]
+        public struct BSDFData
+        {
+            [SurfaceDataAttributes("", false, true)]
+            public Vector3 color;
+        };
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.cs.hlsl

+//
+// This file was automatically generated. Please don't edit by hand.
+// HAND EDITED FOR NOW... NEED TO REGENERATE FOR STACKLIT
+//
+
+#ifndef STACKLIT_CS_HLSL
+#define STACKLIT_CS_HLSL
+//
+// UnityEngine.Experimental.Rendering.HDPipeline.StackLit+SurfaceData:  static fields
+//
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COLOR (1100)
+
+//
+// UnityEngine.Experimental.Rendering.HDPipeline.StackLit+BSDFData:  static fields
+//
+#define DEBUGVIEW_STACKLIT_BSDFDATA_COLOR (1130)
+
+// Generated from UnityEngine.Experimental.Rendering.HDPipeline.StackLit+SurfaceData
+// PackingRules = Exact
+struct SurfaceData
+{
+    float3 color;
+};
+
+// Generated from UnityEngine.Experimental.Rendering.HDPipeline.StackLit+BSDFData
+// PackingRules = Exact
+struct BSDFData
+{
+    float3 color;
+};
+
+//
+// Debug functions
+//
+void GetGeneratedSurfaceDataDebug(uint paramId, SurfaceData surfacedata, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+        case DEBUGVIEW_STACKLIT_SURFACEDATA_COLOR:
+            result = surfacedata.color;
+            needLinearToSRGB = true;
+            break;
+    }
+}
+
+//
+// Debug functions
+//
+void GetGeneratedBSDFDataDebug(uint paramId, BSDFData bsdfdata, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+        case DEBUGVIEW_STACKLIT_BSDFDATA_COLOR:
+            result = bsdfdata.color;
+            needLinearToSRGB = true;
+            break;
+    }
+}
+
+
+#endif

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.cs.hlsl.meta

+fileFormatVersion: 2
+guid: e9689279fece92a43a07134408146db1
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.cs.meta

+fileFormatVersion: 2
+guid: c791362c2eaa3a94c807d88c81a53119
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.hlsl

+//-----------------------------------------------------------------------------
+// SurfaceData and BSDFData
+//-----------------------------------------------------------------------------
+
+// SurfaceData is define in StackLit.cs which generate StackLit.cs.hlsl
+#include "StackLit.cs.hlsl"
+
+//-----------------------------------------------------------------------------
+// conversion function for forward
+//-----------------------------------------------------------------------------
+
+BSDFData ConvertSurfaceDataToBSDFData(SurfaceData data)
+{
+    BSDFData output;
+    output.color = data.color;
+
+    return output;
+}
+
+//-----------------------------------------------------------------------------
+// Debug method (use to display values)
+//-----------------------------------------------------------------------------
+
+void GetSurfaceDataDebug(uint paramId, SurfaceData surfaceData, inout float3 result, inout bool needLinearToSRGB)
+{
+    GetGeneratedSurfaceDataDebug(paramId, surfaceData, result, needLinearToSRGB);
+}
+
+void GetBSDFDataDebug(uint paramId, BSDFData bsdfData, inout float3 result, inout bool needLinearToSRGB)
+{
+    GetGeneratedBSDFDataDebug(paramId, bsdfData, result, needLinearToSRGB);
+}
+
+//-----------------------------------------------------------------------------
+// No light evaluation, this is StackLit
+//-----------------------------------------------------------------------------
+
+LightTransportData GetLightTransportData(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData)
+{
+    LightTransportData lightTransportData;
+
+    lightTransportData.diffuseColor = float3(0.0, 0.0, 0.0);
+    lightTransportData.emissiveColor = builtinData.emissiveColor;
+
+    return lightTransportData;
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.hlsl.meta

+fileFormatVersion: 2
+guid: 03326c2e6dae9c549bcbb37408fb9cd2
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.shader

+Shader "HDRenderPipeline/StackLit"
+{
+    Properties
+    {
+        // Be careful, do not change the name here to _Color. It will conflict with the "fake" parameters (see end of properties) required for GI.
+        _UnlitColor("Color", Color) = (1,1,1,1)
+        _UnlitColorMap("ColorMap", 2D) = "white" {}
+
+        _EmissiveColor("EmissiveColor", Color) = (1, 1, 1)
+        _EmissiveColorMap("EmissiveColorMap", 2D) = "white" {}
+        _EmissiveIntensity("EmissiveIntensity", Float) = 0
+
+        _DistortionVectorMap("DistortionVectorMap", 2D) = "black" {}
+        [ToggleUI] _DistortionEnable("Enable Distortion", Float) = 0.0
+        [ToggleUI] _DistortionOnly("Distortion Only", Float) = 0.0
+        [ToggleUI] _DistortionDepthTest("Distortion Depth Test Enable", Float) = 1.0
+        [Enum(Add, 0, Multiply, 1)] _DistortionBlendMode("Distortion Blend Mode", Int) = 0
+        [HideInInspector] _DistortionSrcBlend("Distortion Blend Src", Int) = 0
+        [HideInInspector] _DistortionDstBlend("Distortion Blend Dst", Int) = 0
+        [HideInInspector] _DistortionBlurSrcBlend("Distortion Blur Blend Src", Int) = 0
+        [HideInInspector] _DistortionBlurDstBlend("Distortion Blur Blend Dst", Int) = 0
+        [HideInInspector] _DistortionBlurBlendMode("Distortion Blur Blend Mode", Int) = 0
+        _DistortionScale("Distortion Scale", Float) = 1
+        _DistortionVectorScale("Distortion Vector Scale", Float) = 2
+        _DistortionVectorBias("Distortion Vector Bias", Float) = -1
+        _DistortionBlurScale("Distortion Blur Scale", Float) = 1
+        _DistortionBlurRemapMin("DistortionBlurRemapMin", Float) = 0.0
+        _DistortionBlurRemapMax("DistortionBlurRemapMax", Float) = 1.0
+
+        // Transparency
+        [ToggleUI] _PreRefractionPass("PreRefractionPass", Float) = 0.0
+
+        [ToggleUI]  _AlphaCutoffEnable("Alpha Cutoff Enable", Float) = 0.0
+        _AlphaCutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
+        _TransparentSortPriority("_TransparentSortPriority", Float) = 0
+
+        // Blending state
+        [HideInInspector] _SurfaceType("__surfacetype", Float) = 0.0
+        [HideInInspector] _BlendMode("__blendmode", Float) = 0.0
+        [HideInInspector] _SrcBlend("__src", Float) = 1.0
+        [HideInInspector] _DstBlend("__dst", Float) = 0.0
+        [HideInInspector] _ZWrite("__zw", Float) = 1.0
+        [HideInInspector] _CullMode("__cullmode", Float) = 2.0
+        [HideInInspector] _ZTestModeDistortion("_ZTestModeDistortion", Int) = 8
+
+        [ToggleUI] _EnableFogOnTransparent("Enable Fog", Float) = 0.0
+        [ToggleUI] _DoubleSidedEnable("Double sided enable", Float) = 0.0
+
+        // Stencil state
+        [HideInInspector] _StencilRef("_StencilRef", Int) = 2 // StencilLightingUsage.RegularLighting  (fixed at compile time)
+        [HideInInspector] _StencilWriteMask("_StencilWriteMask", Int) = 7 // StencilMask.Lighting  (fixed at compile time)
+        [HideInInspector] _StencilRefMV("_StencilRefMV", Int) = 128 // StencilLightingUsage.RegularLighting  (fixed at compile time)
+        [HideInInspector] _StencilWriteMaskMV("_StencilWriteMaskMV", Int) = 128 // StencilMask.ObjectsVelocity  (fixed at compile time)
+
+        // Caution: C# code in BaseLitUI.cs call LightmapEmissionFlagsProperty() which assume that there is an existing "_EmissionColor"
+        // value that exist to identify if the GI emission need to be enabled.
+        // In our case we don't use such a mechanism but need to keep the code quiet. We declare the value and always enable it.
+        // TODO: Fix the code in legacy unity so we can customize the beahvior for GI
+        _EmissionColor("Color", Color) = (1, 1, 1)
+
+        // HACK: GI Baking system relies on some properties existing in the shader ("_MainTex", "_Cutoff" and "_Color") for opacity handling, so we need to store our version of those parameters in the hard-coded name the GI baking system recognizes.
+        _MainTex("Albedo", 2D) = "white" {}
+        _Color("Color", Color) = (1,1,1,1)
+        _Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
+    }
+
+    HLSLINCLUDE
+
+    #pragma target 4.5
+    #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
+    //-------------------------------------------------------------------------------------
+    // Variant
+    //-------------------------------------------------------------------------------------
+
+    #pragma shader_feature _ALPHATEST_ON
+    // #pragma shader_feature _DOUBLESIDED_ON - We have no lighting, so no need to have this combination for shader, the option will just disable backface culling
+
+    #pragma shader_feature _EMISSIVE_COLOR_MAP
+
+    // Keyword for transparent
+    #pragma shader_feature _SURFACE_TYPE_TRANSPARENT
+    #pragma shader_feature _ _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_PRE_MULTIPLY
+    #pragma shader_feature _ENABLE_FOG_ON_TRANSPARENT
+
+    //enable GPU instancing support
+    #pragma multi_compile_instancing
+
+    //-------------------------------------------------------------------------------------
+    // Define
+    //-------------------------------------------------------------------------------------
+
+    #define UNITY_MATERIAL_STACKLIT // Need to be define before including Material.hlsl
+
+    //-------------------------------------------------------------------------------------
+    // Include
+    //-------------------------------------------------------------------------------------
+
+    #include "CoreRP/ShaderLibrary/common.hlsl"
+    #include "../../ShaderVariables.hlsl"
+    #include "../../ShaderPass/FragInputs.hlsl"
+    #include "../../ShaderPass/ShaderPass.cs.hlsl"
+
+    //-------------------------------------------------------------------------------------
+    // variable declaration
+    //-------------------------------------------------------------------------------------
+
+    #include "../../Material/StackLit/StackLitProperties.hlsl"
+
+    // All our shaders use same name for entry point
+    #pragma vertex Vert
+    #pragma fragment Frag
+
+    ENDHLSL
+
+    SubShader
+    {
+        // This tags allow to use the shader replacement features
+        Tags{ "RenderPipeline" = "HDRenderPipeline" "RenderType" = "HDStackLitShader" }
+
+        // Caution: The outline selection in the editor use the vertex shader/hull/domain shader of the first pass declare. So it should not be the meta pass.
+
+        Pass
+        {
+            Name "Depth prepass"
+            Tags{ "LightMode" = "DepthForwardOnly" }
+
+            Cull[_CullMode]
+
+            ZWrite On
+
+            HLSLPROGRAM
+
+            #define SHADERPASS SHADERPASS_DEPTH_ONLY
+            #include "../../Material/Material.hlsl"
+            #include "ShaderPass/StackLitDepthPass.hlsl"
+            #include "StackLitData.hlsl"
+            #include "../../ShaderPass/ShaderPassDepthOnly.hlsl"
+
+            ENDHLSL
+        }
+
+        // StackLit shader always render in forward
+        Pass
+        {
+            Name "Forward StackLit"
+            Tags { "LightMode" = "ForwardOnly" }
+
+            Blend [_SrcBlend] [_DstBlend]
+            ZWrite [_ZWrite]
+            Cull [_CullMode]
+
+            HLSLPROGRAM
+
+            #pragma multi_compile _ DEBUG_DISPLAY
+
+            #ifdef DEBUG_DISPLAY
+            #include "../../Debug/DebugDisplay.hlsl"
+            #endif
+
+            #define SHADERPASS SHADERPASS_FORWARD_STACKLIT
+            #include "../../Material/Material.hlsl"
+            #include "ShaderPass/StackLitSharePass.hlsl"
+            #include "StackLitData.hlsl"
+            #include "../../ShaderPass/ShaderPassForwardStackLit.hlsl"
+
+            ENDHLSL
+        }
+
+        // Extracts information for lightmapping, GI (emission, albedo, ...)
+        // This pass it not used during regular rendering.
+        Pass
+        {
+            Name "META"
+            Tags{ "LightMode" = "Meta" }
+
+            Cull Off
+
+            HLSLPROGRAM
+
+            // Lightmap memo
+            // DYNAMICLIGHTMAP_ON is used when we have an "enlighten lightmap" ie a lightmap updated at runtime by enlighten.This lightmap contain indirect lighting from realtime lights and realtime emissive material.Offline baked lighting(from baked material / light,
+            // both direct and indirect lighting) will hand up in the "regular" lightmap->LIGHTMAP_ON.
+
+            #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
+            #include "../../Material/Material.hlsl"
+            #include "ShaderPass/StackLitSharePass.hlsl"
+            #include "StackLitData.hlsl"
+            #include "../../ShaderPass/ShaderPassLightTransport.hlsl"
+
+            ENDHLSL
+        }
+
+        Pass
+        {
+            Name "Distortion" // Name is not used
+            Tags { "LightMode" = "DistortionVectors" } // This will be only for transparent object based on the RenderQueue index
+
+            Blend [_DistortionSrcBlend] [_DistortionDstBlend], [_DistortionBlurSrcBlend] [_DistortionBlurDstBlend]
+            BlendOp Add, [_DistortionBlurBlendOp]
+            ZTest [_ZTestModeDistortion]
+            ZWrite off
+            Cull [_CullMode]
+
+            HLSLPROGRAM
+
+            #define SHADERPASS SHADERPASS_DISTORTION
+            #include "../../Material/Material.hlsl"
+            #include "ShaderPass/StackLitDistortionPass.hlsl"
+            #include "StackLitData.hlsl"
+            #include "../../ShaderPass/ShaderPassDistortion.hlsl"
+
+            ENDHLSL
+        }
+    }
+
+    CustomEditor "Experimental.Rendering.HDPipeline.StackLitGUI"
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLit.shader.meta

+fileFormatVersion: 2
+guid: 3a796817b9614b347895c0e8db89b63a
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLitData.hlsl

+//-------------------------------------------------------------------------------------
+// Fill SurfaceData/Builtin data function
+//-------------------------------------------------------------------------------------
+#include "../MaterialUtilities.hlsl"
+
+void GetSurfaceAndBuiltinData(FragInputs input, float3 V, inout PositionInputs posInput, out SurfaceData surfaceData, out BuiltinData builtinData)
+{
+    float2 unlitColorMapUv = TRANSFORM_TEX(input.texCoord0, _UnlitColorMap);
+    surfaceData.color = SAMPLE_TEXTURE2D(_UnlitColorMap, sampler_UnlitColorMap, unlitColorMapUv).rgb * _UnlitColor.rgb;
+    float alpha = SAMPLE_TEXTURE2D(_UnlitColorMap, sampler_UnlitColorMap, unlitColorMapUv).a * _UnlitColor.a;
+
+#ifdef _ALPHATEST_ON
+    DoAlphaTest(alpha, _AlphaCutoff);
+#endif
+
+    // Builtin Data
+    builtinData.opacity = alpha;
+
+    builtinData.bakeDiffuseLighting = float3(0.0, 0.0, 0.0);
+
+    // Emissive Intensity is only use here, but is part of BuiltinData to enforce UI parameters as we want the users to fill one color and one intensity
+    builtinData.emissiveIntensity = _EmissiveIntensity;
+
+#ifdef _EMISSIVE_COLOR_MAP
+    builtinData.emissiveColor = SAMPLE_TEXTURE2D(_EmissiveColorMap, sampler_EmissiveColorMap, TRANSFORM_TEX(input.texCoord0, _EmissiveColorMap)).rgb * _EmissiveColor * builtinData.emissiveIntensity;
+#else
+    builtinData.emissiveColor = _EmissiveColor * builtinData.emissiveIntensity;
+#endif
+
+    builtinData.velocity = float2(0.0, 0.0);
+
+    builtinData.shadowMask0 = 0.0;
+    builtinData.shadowMask1 = 0.0;
+    builtinData.shadowMask2 = 0.0;
+    builtinData.shadowMask3 = 0.0;
+
+#if (SHADERPASS == SHADERPASS_DISTORTION) || defined(DEBUG_DISPLAY)
+    float3 distortion = SAMPLE_TEXTURE2D(_DistortionVectorMap, sampler_DistortionVectorMap, input.texCoord0).rgb;
+    distortion.rg = distortion.rg * _DistortionVectorScale.xx + _DistortionVectorBias.xx;
+    builtinData.distortion = distortion.rg * _DistortionScale;
+    builtinData.distortionBlur = clamp(distortion.b * _DistortionBlurScale, 0.0, 1.0) * (_DistortionBlurRemapMax - _DistortionBlurRemapMin) + _DistortionBlurRemapMin;
+#else
+    builtinData.distortion = float2(0.0, 0.0);
+    builtinData.distortionBlur = 0.0;
+#endif
+
+    builtinData.depthOffset = 0.0;
+
+#if defined(DEBUG_DISPLAY)
+    if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)
+    {
+        surfaceData.color = GetTextureDataDebug(_DebugMipMapMode, unlitColorMapUv, _UnlitColorMap, _UnlitColorMap_TexelSize, _UnlitColorMap_MipInfo, surfaceData.color);
+    }
+#endif
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLitData.hlsl.meta

+fileFormatVersion: 2
+guid: 3a7c3981c91d6d448ae2b9830a62386f
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLitProperties.hlsl

+TEXTURE2D(_DistortionVectorMap);
+SAMPLER(sampler_DistortionVectorMap);
+
+TEXTURE2D(_UnlitColorMap);
+SAMPLER(sampler_UnlitColorMap);
+
+TEXTURE2D(_EmissiveColorMap);
+SAMPLER(sampler_EmissiveColorMap);
+
+CBUFFER_START(UnityPerMaterial)
+
+float4  _UnlitColor;
+float4 _UnlitColorMap_ST;
+float4 _UnlitColorMap_TexelSize;
+float4 _UnlitColorMap_MipInfo;
+
+float3 _EmissiveColor;
+float4 _EmissiveColorMap_ST;
+
+float _EmissiveIntensity;
+
+float _AlphaCutoff;
+float _DistortionScale;
+float _DistortionVectorScale;
+float _DistortionVectorBias;
+float _DistortionBlurScale;
+float _DistortionBlurRemapMin;
+float _DistortionBlurRemapMax;
+
+// Caution: C# code in BaseLitUI.cs call LightmapEmissionFlagsProperty() which assume that there is an existing "_EmissionColor"
+// value that exist to identify if the GI emission need to be enabled.
+// In our case we don't use such a mechanism but need to keep the code quiet. We declare the value and always enable it.
+// TODO: Fix the code in legacy unity so we can customize the behavior for GI
+float3 _EmissionColor;
+
+CBUFFER_END

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/StackLit/StackLitProperties.hlsl.meta

+fileFormatVersion: 2
+guid: 11f90969f030f4a4186577bf302f41d3
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: