Merge remote-tracking branch 'refs/remotes/origin/master' into FixFix_TestFrameworkTools

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Common.hlsl

 // The reason is that for compute shader we need to guarantee that the layout of CBs is consistent across kernels. Something that we can't control with the global namespace (uniforms get optimized out if not used, modifying the global CBuffer layout per kernel)
 
 // Structure definition that are share between C# and hlsl.
-// These structures need to be align on float4 to respect various packing rules from shader language. This mean that these structure need to be padded.
-// Rules: When doing an array for constant buffer variables, we always use float4 to avoid any packing issue, particularly between compute shader and pixel shaders
-// i.e don't use SetGlobalFloatArray or SetComputeFloatParams
-// The array can be alias in hlsl. Exemple:
-// uniform float4 packedArray[3];
+// These structures need to be align on float4 to respect various packing rules from shader language. This mean that these structure need to be padded.
+// Rules: When doing an array for constant buffer variables, we always use float4 to avoid any packing issue, particularly between compute shader and pixel shaders
+// i.e don't use SetGlobalFloatArray or SetComputeFloatParams
+// The array can be alias in hlsl. Exemple:
+// uniform float4 packedArray[3];
 // static float unpackedArray[12] = (float[12])packedArray;
 
 // The function of the shader library are stateless, no uniform decalare in it.
     return ComputeTextureLOD(uv);
 }
 
-uint GetMipCount(Texture2D tex)
+uint GetMipCount(Texture2D tex)
 {
 #if defined(SHADER_API_D3D11) || defined(SHADER_API_D3D12) || defined(SHADER_API_D3D11_9X) || defined(SHADER_API_XBOXONE) || defined(SHADER_API_PSSL)
     #define MIP_COUNT_SUPPORTED 1
     // Metal doesn't support high enough OpenGL version
 
 #if defined(MIP_COUNT_SUPPORTED)
-    uint width, height, depth, mipCount;
-    width = height = depth = mipCount = 0;
-    tex.GetDimensions(width, height, depth, mipCount);
+    uint width, height, depth, mipCount;
+    width = height = depth = mipCount = 0;
+    tex.GetDimensions(width, height, depth, mipCount);
-#endif
+#endif
 }
 
 // ----------------------------------------------------------------------------

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Debug.hlsl

     }
 }
 
-float4 GetStreamingMipColor(uint mipCount, float4 mipInfo)
+float4 GetStreamingMipColor(uint mipCount, float4 mipInfo)
-
+
-    uint originalTextureMipCount = uint(mipInfo.y);
+    uint originalTextureMipCount = uint(mipInfo.y);
-    uint desiredMipLevel = uint(mipInfo.z);
+    uint desiredMipLevel = uint(mipInfo.z);
     uint mipCountDesired = uint(originalTextureMipCount)-uint(desiredMipLevel);
     if (mipCount == 0)
     {
         float ratioToOriginal = float(mipCount) / float(originalTextureMipCount);
         return float4(0.0, 1.0, 0.0, 1.0 - ratioToOriginal);
     }
-}
-
-float4 GetSimpleMipCountColor(uint mipCount)
+}
+
+float4 GetSimpleMipCountColor(uint mipCount)
 {
     // Grey scale for mip counts where mip count of 12 = white
     float mipCountColor = float(mipCount) / 12.0;
     // Magenta is no valid mip count
     // Original colour if greater than 12
     return mipCount==0 ? float4(1.0, 0.0, 1.0, 1.0) : (mipCount > 12 ? float4(1.0, 1.0, 1.0, 0.0) : color );
-}
-
-float4 GetMipLevelColor(float2 uv, float4 texelSize)
-{
+}
+
+float4 GetMipLevelColor(float2 uv, float4 texelSize)
+{
-
+
-    mipLevel = clamp(mipLevel, 0.0, 5.0 - 0.0001);
-
+    mipLevel = clamp(mipLevel, 0.0, 5.0 - 0.0001);
+
-        float4(0.0, 0.0, 1.0, 0.8), // 0 BLUE = too little texture detail
-        float4(0.0, 0.5, 1.0, 0.4), // 1 
-        float4(1.0, 1.0, 1.0, 0.0), // 2 = optimal level
-        float4(1.0, 0.7, 0.0, 0.2), // 3 (YELLOW tint)
-        float4(1.0, 0.3, 0.0, 0.6), // 4 (clamped mipLevel 4.9999)
-        float4(1.0, 0.0, 0.0, 0.8)  // 5 RED = too much texture detail (max blended value)
-    };
-
-    int mipLevelInt = floor(mipLevel);
-    float t = frac(mipLevel);
-    float4 a = colors[mipLevelInt];
-    float4 b = colors[mipLevelInt + 1];
-    float4 color = lerp(a, b, t);
-
-    return color;
+        float4(0.0, 0.0, 1.0, 0.8), // 0 BLUE = too little texture detail
+        float4(0.0, 0.5, 1.0, 0.4), // 1 
+        float4(1.0, 1.0, 1.0, 0.0), // 2 = optimal level
+        float4(1.0, 0.7, 0.0, 0.2), // 3 (YELLOW tint)
+        float4(1.0, 0.3, 0.0, 0.6), // 4 (clamped mipLevel 4.9999)
+        float4(1.0, 0.0, 0.0, 0.8)  // 5 RED = too much texture detail (max blended value)
+    };
+
+    int mipLevelInt = floor(mipLevel);
+    float t = frac(mipLevel);
+    float4 a = colors[mipLevelInt];
+    float4 b = colors[mipLevelInt + 1];
+    float4 color = lerp(a, b, t);
+
+    return color;
-{
-    // https://aras-p.info/blog/2011/05/03/a-way-to-visualize-mip-levels/
-    float4 mipColor= GetMipLevelColor(uv, texelSize);
+{
+    // https://aras-p.info/blog/2011/05/03/a-way-to-visualize-mip-levels/
+    float4 mipColor= GetMipLevelColor(uv, texelSize);
-{
+{
-    float4 mipColor = GetSimpleMipCountColor(mipCount);
+    float4 mipColor = GetSimpleMipCountColor(mipCount);
-{
+{
-    return GetStreamingMipColor(mipCount, mipInfo).xyz;
+    return GetStreamingMipColor(mipCount, mipInfo).xyz;
-{
+{
-    float4 mipColor = GetStreamingMipColor(mipCount, mipInfo);
+    float4 mipColor = GetStreamingMipColor(mipCount, mipInfo);
-{
+{
     uint originalTextureMipCount = uint(mipInfo.y);
     if (originalTextureMipCount != 0)
     {
 }
 
 float3 GetDebugMipReductionColor(Texture2D tex, float4 mipInfo)
-{
+{
     uint originalTextureMipCount = uint(mipInfo.y);
     if (originalTextureMipCount != 0)
     {
 }
 
 #ifdef DEBUG_DISPLAY
-float3 GetTextureDataDebug(uint paramId, float2 uv, Texture2D tex, float4 texelSize, float4 mipInfo, float3 originalColor)
-{
-    switch (paramId)
-    {
+float3 GetTextureDataDebug(uint paramId, float2 uv, Texture2D tex, float4 texelSize, float4 mipInfo, float3 originalColor)
+{
+    switch (paramId)
+    {
     case DEBUGMIPMAPMODE_MIP_RATIO:
         return GetDebugMipColorIncludingMipReduction(originalColor, tex, texelSize, uv, mipInfo);
     case DEBUGMIPMAPMODE_MIP_COUNT:
         return GetDebugStreamingMipColorBlended(originalColor, tex, mipInfo);
     }
 
-    return originalColor;
+    return originalColor;
-#endif // DEBUG_DISPLAY
+#endif // DEBUG_DISPLAY
 
 #endif // UNITY_DEBUG_INCLUDED

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/MaterialDebug.cs

         public static GUIContent[] debugViewMaterialPropertiesStrings = null;
         public static int[] debugViewMaterialPropertiesValues = null;
         public static GUIContent[] debugViewMaterialTextureStrings = null;
-        public static int[] debugViewMaterialTextureValues = null;
+        public static int[] debugViewMaterialTextureValues = null;
         public static GUIContent[] debugViewMaterialGBufferStrings = null;
         public static int[] debugViewMaterialGBufferValues = null;
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/LayeredLit/LayeredLitUI.cs

 
             CoreUtils.SetKeyword(material, "_INFLUENCEMASK_MAP", material.GetTexture(kLayerInfluenceMaskMap) && material.GetFloat(kkUseMainLayerInfluence) != 0.0f);
 
+            CoreUtils.SetKeyword(material, "_EMISSIVE_MAPPING_PLANAR", ((UVBaseMapping)material.GetFloat(kUVEmissive)) == UVBaseMapping.Planar && material.GetTexture(kEmissiveColorMap));
+            CoreUtils.SetKeyword(material, "_EMISSIVE_MAPPING_TRIPLANAR", ((UVBaseMapping)material.GetFloat(kUVEmissive)) == UVBaseMapping.Triplanar && material.GetTexture(kEmissiveColorMap));
             CoreUtils.SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(kEmissiveColorMap));
             CoreUtils.SetKeyword(material, "_ENABLESPECULAROCCLUSION", material.GetFloat(kEnableSpecularOcclusion) > 0.0f);
 
 
             CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_SUBSURFACE_SCATTERING", materialId == BaseLitGUI.MaterialId.LitSSS);
             CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_TRANSMISSION", materialId == BaseLitGUI.MaterialId.LitSSS);
-        }
-        private void DoEmissiveGUI(Material material)
-        {
-            EditorGUILayout.Space();
-            EditorGUILayout.LabelField(Styles.lightingText, EditorStyles.boldLabel);
-            m_MaterialEditor.ShaderProperty(enableSpecularOcclusion, Styles.enableSpecularOcclusionText);
-            // TODO: display warning if we don't have bent normal (either OS or TS) and ambient occlusion
-            //if (enableSpecularOcclusion.floatValue > 0.0f)
-            {
-                // EditorGUILayout.HelpBox(Styles.specularOcclusionWarning.text, MessageType.Error);
-            }
-            EditorGUI.indentLevel++;
-            m_MaterialEditor.TexturePropertySingleLine(Styles.emissiveText, emissiveColorMap, emissiveColor);
-            m_MaterialEditor.ShaderProperty(emissiveIntensity, Styles.emissiveIntensityText);
-            m_MaterialEditor.ShaderProperty(albedoAffectEmissive, Styles.albedoAffectEmissiveText);
-            EditorGUI.indentLevel--;
         }
 
         public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
 
 
             bool layerChanged = DoLayersGUI(materialImporter);
-            DoEmissiveGUI(material);
+            EditorGUI.BeginChangeCheck();
+            {
+                DoEmissiveGUI(material);
+            }
+            if (EditorGUI.EndChangeCheck())
+            {
+                optionsChanged = true;
+            }
             DoEmissionArea(material);
             EditorGUI.indentLevel--;
             m_MaterialEditor.EnableInstancingField();

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Lit/LitUI.cs

         protected const string kEmissiveIntensity = "_EmissiveIntensity";
         protected MaterialProperty albedoAffectEmissive = null;
         protected const string kAlbedoAffectEmissive = "_AlbedoAffectEmissive";
+        protected MaterialProperty UVEmissive = null;
+        protected const string kUVEmissive = "_UVEmissive";
+        protected MaterialProperty TexWorldScaleEmissive = null;
+        protected const string kTexWorldScaleEmissive = "_TexWorldScaleEmissive";
+        protected MaterialProperty UVMappingMaskEmissive = null;
+        protected const string kUVMappingMaskEmissive = "_UVMappingMaskEmissive";
+
         protected MaterialProperty enableSpecularOcclusion = null;
         protected const string kEnableSpecularOcclusion = "_EnableSpecularOcclusion";
 
             emissiveColorMap = FindProperty(kEmissiveColorMap, props);
             emissiveIntensity = FindProperty(kEmissiveIntensity, props);
             albedoAffectEmissive = FindProperty(kAlbedoAffectEmissive, props);
+
+            UVEmissive = FindProperty(kUVEmissive, props);
+            TexWorldScaleEmissive = FindProperty(kTexWorldScaleEmissive, props);
+            UVMappingMaskEmissive = FindProperty(kUVMappingMaskEmissive, props);
+
             enableSpecularOcclusion = FindProperty(kEnableSpecularOcclusion, props);
         }
 
                 if (EditorGUI.EndChangeCheck())
                 {
                     UpdateDisplacement(layerIndex);
-                }                
+                }
             }
 
             switch ((BaseLitGUI.MaterialId)materialID.floatValue)
             }
         }
 
-        private void DoEmissiveGUI(Material material)
+        protected void DoEmissiveGUI(Material material)
         {
             EditorGUILayout.Space();
             EditorGUILayout.LabelField(Styles.lightingText, EditorStyles.boldLabel);
             }
             EditorGUI.indentLevel++;
             m_MaterialEditor.TexturePropertySingleLine(Styles.emissiveText, emissiveColorMap, emissiveColor);
+
+            m_MaterialEditor.ShaderProperty(UVEmissive, Styles.UVBaseMappingText);
+            UVBaseMapping uvEmissiveMapping = (UVBaseMapping)UVEmissive.floatValue;
+
+            float X, Y, Z, W;
+            X = (uvEmissiveMapping == UVBaseMapping.UV0) ? 1.0f : 0.0f;
+            Y = (uvEmissiveMapping == UVBaseMapping.UV1) ? 1.0f : 0.0f;
+            Z = (uvEmissiveMapping == UVBaseMapping.UV2) ? 1.0f : 0.0f;
+            W = (uvEmissiveMapping == UVBaseMapping.UV3) ? 1.0f : 0.0f;
+
+            UVMappingMaskEmissive.colorValue = new Color(X, Y, Z, W);
+
+            if ((uvEmissiveMapping == UVBaseMapping.Planar) || (uvEmissiveMapping == UVBaseMapping.Triplanar))
+            {
+                m_MaterialEditor.ShaderProperty(TexWorldScaleEmissive, Styles.texWorldScaleText);
+            }
+
+
             m_MaterialEditor.ShaderProperty(emissiveIntensity, Styles.emissiveIntensityText);
             m_MaterialEditor.ShaderProperty(albedoAffectEmissive, Styles.albedoAffectEmissiveText);
             EditorGUI.indentLevel--;
             // (MaterialProperty value might come from renderer material property block)
             CoreUtils.SetKeyword(material, "_MAPPING_PLANAR", ((UVBaseMapping)material.GetFloat(kUVBase)) == UVBaseMapping.Planar);
             CoreUtils.SetKeyword(material, "_MAPPING_TRIPLANAR", ((UVBaseMapping)material.GetFloat(kUVBase)) == UVBaseMapping.Triplanar);
+
             CoreUtils.SetKeyword(material, "_NORMALMAP_TANGENT_SPACE", (normalMapSpace == NormalMapSpace.TangentSpace));
 
             if (normalMapSpace == NormalMapSpace.TangentSpace)
                 CoreUtils.SetKeyword(material, "_BENTNORMALMAP", material.GetTexture(kBentNormalMapOS));
             }
             CoreUtils.SetKeyword(material, "_MASKMAP", material.GetTexture(kMaskMap));
+
+            CoreUtils.SetKeyword(material, "_EMISSIVE_MAPPING_PLANAR", ((UVBaseMapping)material.GetFloat(kUVEmissive)) == UVBaseMapping.Planar && material.GetTexture(kEmissiveColorMap));
+            CoreUtils.SetKeyword(material, "_EMISSIVE_MAPPING_TRIPLANAR", ((UVBaseMapping)material.GetFloat(kUVEmissive)) == UVBaseMapping.Triplanar && material.GetTexture(kEmissiveColorMap));
+
             CoreUtils.SetKeyword(material, "_ENABLESPECULAROCCLUSION", material.GetFloat(kEnableSpecularOcclusion) > 0.0f);
             CoreUtils.SetKeyword(material, "_HEIGHTMAP", material.GetTexture(kHeightMap));
             CoreUtils.SetKeyword(material, "_ANISOTROPYMAP", material.GetTexture(kAnisotropyMap));

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Volumetrics/Resources/VolumetricLighting.compute

 #pragma kernel VolumetricLightingClustered       VolumetricLighting=VolumetricLightingClustered       ENABLE_REPROJECTION=0 LIGHTLOOP_TILE_PASS   USE_CLUSTERED_LIGHTLIST
 #pragma kernel VolumetricLightingClusteredReproj VolumetricLighting=VolumetricLightingClusteredReproj ENABLE_REPROJECTION=1 LIGHTLOOP_TILE_PASS   USE_CLUSTERED_LIGHTLIST
 
-#pragma enable_d3d11_debug_symbols
+// #pragma debug
 
 #define DEBUG_REPROJECTION 0
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/LayeredLit/LayeredLit.shader

         [HideInInspector] _InvPrimScale("Inverse primitive scale for non-planar POM", Vector) = (1, 1, 0, 0)
 
         [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1
+        [Enum(UV0, 0, Planar, 4, TriPlanar, 5)] _UVEmissive("UV Set for emissive", Float) = 0
+        _TexWorldScaleEmissive("Scale to apply on world coordinate", Float) = 1.0
+        [HideInInspector] _UVMappingMaskEmissive("_UVMappingMaskEmissive", Color) = (1, 0, 0, 0)
 
         // Wind
         [ToggleOff]  _EnableWind("Enable Wind", Float) = 0.0
     #pragma shader_feature _PIXEL_DISPLACEMENT_LOCK_OBJECT_SCALE
     #pragma shader_feature _VERTEX_WIND
 
+    #pragma shader_feature _ _EMISSIVE_MAPPING_PLANAR _EMISSIVE_MAPPING_TRIPLANAR
     #pragma shader_feature _LAYER_TILING_COUPLED_WITH_UNIFORM_OBJECT_SCALE
     #pragma shader_feature _ _LAYER_MAPPING_PLANAR_BLENDMASK _LAYER_MAPPING_TRIPLANAR_BLENDMASK
     #pragma shader_feature _ _LAYER_MAPPING_PLANAR0 _LAYER_MAPPING_TRIPLANAR0
 
     // enable dithering LOD crossfade
     #pragma multi_compile _ LOD_FADE_CROSSFADE
+
+    //enable GPU instancing support
+    #pragma multi_compile_instancing
 
     //-------------------------------------------------------------------------------------
     // Define

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/LayeredLit/LayeredLitData.hlsl

 }
 
 #include "LayeredLitDataDisplacement.hlsl"
+#include "../Lit/LitBuiltinData.hlsl"
 
 void GetSurfaceAndBuiltinData(FragInputs input, float3 V, inout PositionInputs posInput, out SurfaceData surfaceData, out BuiltinData builtinData)
 {
 #if defined(DEBUG_DISPLAY)
     if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)
     {
-        surfaceData.baseColor = GetTextureDataDebug(_DebugMipMapMode, layerTexCoord.base0.uv, _BaseColorMap0, _BaseColorMap0_TexelSize, _BaseColorMap0_MipInfo, surfaceData.baseColor);
+        surfaceData.baseColor = GetTextureDataDebug(_DebugMipMapMode, layerTexCoord.base0.uv, _BaseColorMap0, _BaseColorMap0_TexelSize, _BaseColorMap0_MipInfo, surfaceData.baseColor);
         surfaceData.metallic = 0;
     }
 #endif

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/LayeredLit/LayeredLitTessellation.shader

         [HideInInspector] _InvPrimScale("Inverse primitive scale for non-planar POM", Vector) = (1, 1, 0, 0)
 
         [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1
+        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3, Planar, 4, Triplanar, 5)] _UVEmissive("UV Set for emissive", Float) = 0
+        _TexWorldScaleEmissive("Scale to apply on world coordinate", Float) = 1.0
+        [HideInInspector] _UVMappingMaskEmissive("_UVMappingMaskEmissive", Color) = (1, 0, 0, 0)
 
         // Wind
         [ToggleOff]  _EnableWind("Enable Wind", Float) = 0.0
     #pragma shader_feature _VERTEX_WIND
     #pragma shader_feature _TESSELLATION_PHONG
 
+    #pragma shader_feature _ _EMISSIVE_MAPPING_PLANAR _EMISSIVE_MAPPING_TRIPLANAR
     #pragma shader_feature _LAYER_TILING_COUPLED_WITH_UNIFORM_OBJECT_SCALE
     #pragma shader_feature _ _LAYER_MAPPING_PLANAR_BLENDMASK _LAYER_MAPPING_TRIPLANAR_BLENDMASK
     #pragma shader_feature _ _LAYER_MAPPING_PLANAR0 _LAYER_MAPPING_TRIPLANAR0
 
     // enable dithering LOD crossfade
     #pragma multi_compile _ LOD_FADE_CROSSFADE
+
+    // enable GPU instancing
+    #pragma multi_compile_instancing
 
     //-------------------------------------------------------------------------------------
     // Define

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.shader

         [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVDetail("UV Set for detail", Float) = 0
         [HideInInspector] _UVDetailsMappingMask("_UVDetailsMappingMask", Color) = (1, 0, 0, 0)
         [ToggleOff] _LinkDetailsWithBase("LinkDetailsWithBase", Float) = 1.0
+
+        [Enum(UV0, 0, Planar, 4, TriPlanar, 5)] _UVEmissive("UV Set for emissive", Float) = 0
+        _TexWorldScaleEmissive("Scale to apply on world coordinate", Float) = 1.0
+        [HideInInspector] _UVMappingMaskEmissive("_UVMappingMaskEmissive", Color) = (1, 0, 0, 0)
 
         // Wind
         [ToggleOff]  _EnableWind("Enable Wind", Float) = 0.0
     #pragma shader_feature _VERTEX_WIND
     #pragma shader_feature _ _REFRACTION_PLANE _REFRACTION_SPHERE
 
+    #pragma shader_feature _ _EMISSIVE_MAPPING_PLANAR _EMISSIVE_MAPPING_TRIPLANAR
     #pragma shader_feature _ _MAPPING_PLANAR _MAPPING_TRIPLANAR
     #pragma shader_feature _NORMALMAP_TANGENT_SPACE
     #pragma shader_feature _ _REQUIRE_UV2 _REQUIRE_UV3
 
     // enable dithering LOD crossfade
     #pragma multi_compile _ LOD_FADE_CROSSFADE
+
+    //enable GPU instancing support
+    #pragma multi_compile_instancing
 
     //-------------------------------------------------------------------------------------
     // Define

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/LitData.hlsl

-//-------------------------------------------------------------------------------------
-// Fill SurfaceData/Builtin data function
-//-------------------------------------------------------------------------------------
-#include "CoreRP/ShaderLibrary/Sampling/SampleUVMapping.hlsl"
-#include "../MaterialUtilities.hlsl"
-#include "../Decal/DecalUtilities.hlsl"
-
-// TODO: move this function to commonLighting.hlsl once validated it work correctly
-float GetSpecularOcclusionFromBentAO(float3 V, float3 bentNormalWS, SurfaceData surfaceData)
-{
-    // Retrieve cone angle
-    // Ambient occlusion is cosine weighted, thus use following equation. See slide 129
-    float cosAv = sqrt(1.0 - surfaceData.ambientOcclusion);
-    float roughness = max(PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness), 0.01); // Clamp to 0.01 to avoid edge cases
-    float cosAs = exp2((-log(10.0)/log(2.0)) * Sq(roughness));
-    float cosB = dot(bentNormalWS, reflect(-V, surfaceData.normalWS));
-
-    return SphericalCapIntersectionSolidArea(cosAv, cosAs, cosB) / (TWO_PI * (1.0 - cosAs));
-}
-
-void GetBuiltinData(FragInputs input, SurfaceData surfaceData, float alpha, float3 bentNormalWS, float depthOffset, out BuiltinData builtinData)
-{
-    // Builtin Data
-    builtinData.opacity = alpha;
-
-    // TODO: Sample lightmap/lightprobe/volume proxy
-    // This should also handle projective lightmap
-    builtinData.bakeDiffuseLighting = SampleBakedGI(input.positionWS, bentNormalWS, input.texCoord1, input.texCoord2);
-
-    // It is safe to call this function here as surfaceData have been filled
-    // We want to know if we must enable transmission on GI for SSS material, if the material have no SSS, this code will be remove by the compiler.
-    BSDFData bsdfData = ConvertSurfaceDataToBSDFData(surfaceData);
-    if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
-    {
-        // For now simply recall the function with inverted normal, the compiler should be able to optimize the lightmap case to not resample the directional lightmap
-        // however it will not optimize the lightprobe case due to the proxy volume relying on dynamic if (we rely must get right of this dynamic if), not a problem for SH9, but a problem for proxy volume.
-        // TODO: optimize more this code.
-        // Add GI transmission contribution by resampling the GI for inverted vertex normal
-        builtinData.bakeDiffuseLighting += SampleBakedGI(input.positionWS, -input.worldToTangent[2], input.texCoord1, input.texCoord2) * bsdfData.transmittance;
-    }
-
-#ifdef SHADOWS_SHADOWMASK
-    float4 shadowMask = SampleShadowMask(input.positionWS, input.texCoord1);
-    builtinData.shadowMask0 = shadowMask.x;
-    builtinData.shadowMask1 = shadowMask.y;
-    builtinData.shadowMask2 = shadowMask.z;
-    builtinData.shadowMask3 = shadowMask.w;
-#else
-    builtinData.shadowMask0 = 0.0;
-    builtinData.shadowMask1 = 0.0;
-    builtinData.shadowMask2 = 0.0;
-    builtinData.shadowMask3 = 0.0;
-#endif
-
-    // 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; // We still store intensity here so we can reuse it with debug code
-
-    builtinData.emissiveColor = _EmissiveColor * builtinData.emissiveIntensity * lerp(float3(1.0, 1.0, 1.0), surfaceData.baseColor.rgb, _AlbedoAffectEmissive);
-#ifdef _EMISSIVE_COLOR_MAP
-    builtinData.emissiveColor *= SAMPLE_TEXTURE2D(_EmissiveColorMap, sampler_EmissiveColorMap, TRANSFORM_TEX(input.texCoord0, _EmissiveColorMap)).rgb;
-#endif
-
-    builtinData.velocity = float2(0.0, 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 = depthOffset;
-}
-
-// Struct that gather UVMapping info of all layers + common calculation
-// This is use to abstract the mapping that can differ on layers
-struct LayerTexCoord
-{
-#ifndef LAYERED_LIT_SHADER
-    UVMapping base;
-    UVMapping details;
-#else
-    // Regular texcoord
-    UVMapping base0;
-    UVMapping base1;
-    UVMapping base2;
-    UVMapping base3;
-
-    UVMapping details0;
-    UVMapping details1;
-    UVMapping details2;
-    UVMapping details3;
-
-    // Dedicated for blend mask
-    UVMapping blendMask;
-#endif
-
-    // Store information that will be share by all UVMapping
-    float3 vertexNormalWS; // TODO: store also object normal map for object triplanar
-    float3 triplanarWeights;
-
-#ifdef SURFACE_GRADIENT
-    // tangent basis for each UVSet - up to 4 for now
-    float3 vertexTangentWS0, vertexBitangentWS0;
-    float3 vertexTangentWS1, vertexBitangentWS1;
-    float3 vertexTangentWS2, vertexBitangentWS2;
-    float3 vertexTangentWS3, vertexBitangentWS3;
-#endif
-};
-
-#ifdef SURFACE_GRADIENT
-void GenerateLayerTexCoordBasisTB(FragInputs input, inout LayerTexCoord layerTexCoord)
-{
-    float3 vertexNormalWS = input.worldToTangent[2];
-
-    layerTexCoord.vertexTangentWS0 = input.worldToTangent[0];
-    layerTexCoord.vertexBitangentWS0 = input.worldToTangent[1];
-
-    // TODO: We should use relative camera position here - This will be automatic when we will move to camera relative space.
-    float3 dPdx = ddx_fine(input.positionWS);
-    float3 dPdy = ddy_fine(input.positionWS);
-
-    float3 sigmaX = dPdx - dot(dPdx, vertexNormalWS) * vertexNormalWS;
-    float3 sigmaY = dPdy - dot(dPdy, vertexNormalWS) * vertexNormalWS;
-    //float flipSign = dot(sigmaY, cross(vertexNormalWS, sigmaX) ) ? -1.0 : 1.0;
-    float flipSign = dot(dPdy, cross(vertexNormalWS, dPdx)) < 0.0 ? -1.0 : 1.0; // gives same as the commented out line above
-
-    // TODO: Optimize! The compiler will not be able to remove the tangent space that are not use because it can't know due to our UVMapping constant we use for both base and details
-    // To solve this we should track which UVSet is use for normal mapping... Maybe not as simple as it sounds
-    SurfaceGradientGenBasisTB(vertexNormalWS, sigmaX, sigmaY, flipSign, input.texCoord1, layerTexCoord.vertexTangentWS1, layerTexCoord.vertexBitangentWS1);
-    #if defined(_REQUIRE_UV2) || defined(_REQUIRE_UV3)
-    SurfaceGradientGenBasisTB(vertexNormalWS, sigmaX, sigmaY, flipSign, input.texCoord2, layerTexCoord.vertexTangentWS2, layerTexCoord.vertexBitangentWS2);
-    #endif
-    #if defined(_REQUIRE_UV3)
-    SurfaceGradientGenBasisTB(vertexNormalWS, sigmaX, sigmaY, flipSign, input.texCoord3, layerTexCoord.vertexTangentWS3, layerTexCoord.vertexBitangentWS3);
-    #endif
-}
-#endif
-
-#ifndef LAYERED_LIT_SHADER
-
-// Want to use only one sampler for normalmap/bentnormalmap either we use OS or TS. And either we have normal map or bent normal or both.
-#ifdef _NORMALMAP_TANGENT_SPACE
-    #if defined(_NORMALMAP)
-    #define SAMPLER_NORMALMAP_IDX sampler_NormalMap
-    #elif defined(_BENTNORMALMAP)
-    #define SAMPLER_NORMALMAP_IDX sampler_BentNormalMap
-    #endif
-#else
-    #if defined(_NORMALMAP)
-    #define SAMPLER_NORMALMAP_IDX sampler_NormalMapOS
-    #elif defined(_BENTNORMALMAP)
-    #define SAMPLER_NORMALMAP_IDX sampler_BentNormalMapOS
-    #endif
-#endif
-
-#define SAMPLER_DETAILMAP_IDX sampler_DetailMap
-#define SAMPLER_MASKMAP_IDX sampler_MaskMap
-#define SAMPLER_HEIGHTMAP_IDX sampler_HeightMap
-
-#define SAMPLER_SUBSURFACE_MASKMAP_IDX sampler_SubsurfaceMaskMap
-#define SAMPLER_THICKNESSMAP_IDX sampler_ThicknessMap
-
-// include LitDataIndividualLayer to define GetSurfaceData
-#define LAYER_INDEX 0
-#define ADD_IDX(Name) Name
-#define ADD_ZERO_IDX(Name) Name
-#ifdef _NORMALMAP
-#define _NORMALMAP_IDX
-#endif
-#ifdef _NORMALMAP_TANGENT_SPACE
-#define _NORMALMAP_TANGENT_SPACE_IDX
-#endif
-#ifdef _DETAIL_MAP
-#define _DETAIL_MAP_IDX
-#endif
-#ifdef _SUBSURFACE_MASK_MAP
-#define _SUBSURFACE_MASK_MAP_IDX
-#endif
-#ifdef _THICKNESSMAP
-#define _THICKNESSMAP_IDX
-#endif
-#ifdef _MASKMAP
-#define _MASKMAP_IDX
-#endif
-#ifdef _BENTNORMALMAP
-#define _BENTNORMALMAP_IDX
-#endif
-#include "LitDataIndividualLayer.hlsl"
-
-// This maybe call directly by tessellation (domain) shader, thus all part regarding surface gradient must be done
-// in function with FragInputs input as parameters
-// layerTexCoord must have been initialize to 0 outside of this function
-void GetLayerTexCoord(float2 texCoord0, float2 texCoord1, float2 texCoord2, float2 texCoord3,
-                      float3 positionWS, float3 vertexNormalWS, inout LayerTexCoord layerTexCoord)
-{
-    layerTexCoord.vertexNormalWS = vertexNormalWS;
-    layerTexCoord.triplanarWeights = ComputeTriplanarWeights(vertexNormalWS);
-
-    int mappingType = UV_MAPPING_UVSET;
-#if defined(_MAPPING_PLANAR)
-    mappingType = UV_MAPPING_PLANAR;
-#elif defined(_MAPPING_TRIPLANAR)
-    mappingType = UV_MAPPING_TRIPLANAR;
-#endif
-
-    // Be sure that the compiler is aware that we don't use UV1 to UV3 for main layer so it can optimize code
-    ComputeLayerTexCoord(   texCoord0, texCoord1, texCoord2, texCoord3, float4(1.0, 0.0, 0.0, 0.0), _UVDetailsMappingMask,
-                            _BaseColorMap_ST.xy, _BaseColorMap_ST.zw, _DetailMap_ST.xy, _DetailMap_ST.zw, 1.0, _LinkDetailsWithBase,
-                            positionWS, _TexWorldScale,
-                            mappingType, layerTexCoord);
-}
-
-// This is call only in this file
-// layerTexCoord must have been initialize to 0 outside of this function
-void GetLayerTexCoord(FragInputs input, inout LayerTexCoord layerTexCoord)
-{
-#ifdef SURFACE_GRADIENT
-    GenerateLayerTexCoordBasisTB(input, layerTexCoord);
-#endif
-
-    GetLayerTexCoord(   input.texCoord0, input.texCoord1, input.texCoord2, input.texCoord3,
-                        input.positionWS, input.worldToTangent[2].xyz, layerTexCoord);
-}
-
-#include "LitDataDisplacement.hlsl"
-
-void GetSurfaceAndBuiltinData(FragInputs input, float3 V, inout PositionInputs posInput, out SurfaceData surfaceData, out BuiltinData builtinData)
-{
-#ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group
-    LODDitheringTransition(posInput.positionSS, unity_LODFade.x);
-#endif
-
-    ApplyDoubleSidedFlipOrMirror(input); // Apply double sided flip on the vertex normal
-
-    LayerTexCoord layerTexCoord;
-    ZERO_INITIALIZE(LayerTexCoord, layerTexCoord);
-    GetLayerTexCoord(input, layerTexCoord);
-
-    float depthOffset = ApplyPerPixelDisplacement(input, V, layerTexCoord);
-
-#ifdef _DEPTHOFFSET_ON
-    ApplyDepthOffsetPositionInput(V, depthOffset, GetWorldToHClipMatrix(), posInput);
-#endif
-
-    // We perform the conversion to world of the normalTS outside of the GetSurfaceData
-    // so it allow us to correctly deal with detail normal map and optimize the code for the layered shaders
-    float3 normalTS;
-    float3 bentNormalTS;
-    float3 bentNormalWS;
-    float alpha = GetSurfaceData(input, layerTexCoord, surfaceData, normalTS, bentNormalTS);
-    GetNormalWS(input, V, normalTS, surfaceData.normalWS);
-
-    // Ensure that the normal is front-facing.
-    float NdotV;
-    surfaceData.normalWS = GetViewReflectedNormal(surfaceData.normalWS, V, NdotV);
-
-    // Use bent normal to sample GI if available
-#ifdef _BENTNORMALMAP
-    GetNormalWS(input, V, bentNormalTS, bentNormalWS);
-#else
-    bentNormalWS = surfaceData.normalWS;
-#endif
-
-    // By default we use the ambient occlusion with Tri-ace trick (apply outside) for specular occlusion.
-    // If user provide bent normal then we process a better term
-#if defined(_BENTNORMALMAP) && defined(_ENABLESPECULAROCCLUSION)
-    // If we have bent normal and ambient occlusion, process a specular occlusion
-    surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData);
-#elif defined(_MASKMAP)
-    surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(NdotV, surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
-#else
-    surfaceData.specularOcclusion = 1.0;
-#endif
-
-    // This is use with anisotropic material
-    surfaceData.tangentWS = Orthonormalize(surfaceData.tangentWS, surfaceData.normalWS);
-
-    AddDecalContribution(posInput.positionSS, surfaceData);
-
-#if defined(DEBUG_DISPLAY)
-    if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)
-    {
-        surfaceData.baseColor = GetTextureDataDebug(_DebugMipMapMode, layerTexCoord.base.uv, _BaseColorMap, _BaseColorMap_TexelSize, _BaseColorMap_MipInfo, surfaceData.baseColor);
-        surfaceData.metallic = 0;
-    }
-#endif
-
-    // Caution: surfaceData must be fully initialize before calling GetBuiltinData
-    GetBuiltinData(input, surfaceData, alpha, bentNormalWS, depthOffset, builtinData);
-}
-
-#include "LitDataMeshModification.hlsl"
-
-#endif // #ifndef LAYERED_LIT_SHADER
+//-------------------------------------------------------------------------------------
+// Fill SurfaceData/Builtin data function
+//-------------------------------------------------------------------------------------
+#include "CoreRP/ShaderLibrary/Sampling/SampleUVMapping.hlsl"
+#include "../MaterialUtilities.hlsl"
+#include "../Decal/DecalUtilities.hlsl"
+
+// TODO: move this function to commonLighting.hlsl once validated it work correctly
+float GetSpecularOcclusionFromBentAO(float3 V, float3 bentNormalWS, SurfaceData surfaceData)
+{
+    // Retrieve cone angle
+    // Ambient occlusion is cosine weighted, thus use following equation. See slide 129
+    float cosAv = sqrt(1.0 - surfaceData.ambientOcclusion);
+    float roughness = max(PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness), 0.01); // Clamp to 0.01 to avoid edge cases
+    float cosAs = exp2((-log(10.0)/log(2.0)) * Sq(roughness));
+    float cosB = dot(bentNormalWS, reflect(-V, surfaceData.normalWS));
+
+    return SphericalCapIntersectionSolidArea(cosAv, cosAs, cosB) / (TWO_PI * (1.0 - cosAs));
+}
+
+// Struct that gather UVMapping info of all layers + common calculation
+// This is use to abstract the mapping that can differ on layers
+struct LayerTexCoord
+{
+#ifndef LAYERED_LIT_SHADER
+    UVMapping base;
+    UVMapping details;
+#else
+    // Regular texcoord
+    UVMapping base0;
+    UVMapping base1;
+    UVMapping base2;
+    UVMapping base3;
+
+    UVMapping details0;
+    UVMapping details1;
+    UVMapping details2;
+    UVMapping details3;
+
+    // Dedicated for blend mask
+    UVMapping blendMask;
+#endif
+
+    // Store information that will be share by all UVMapping
+    float3 vertexNormalWS; // TODO: store also object normal map for object triplanar
+    float3 triplanarWeights;
+
+#ifdef SURFACE_GRADIENT
+    // tangent basis for each UVSet - up to 4 for now
+    float3 vertexTangentWS0, vertexBitangentWS0;
+    float3 vertexTangentWS1, vertexBitangentWS1;
+    float3 vertexTangentWS2, vertexBitangentWS2;
+    float3 vertexTangentWS3, vertexBitangentWS3;
+#endif
+};
+
+#ifdef SURFACE_GRADIENT
+void GenerateLayerTexCoordBasisTB(FragInputs input, inout LayerTexCoord layerTexCoord)
+{
+    float3 vertexNormalWS = input.worldToTangent[2];
+
+    layerTexCoord.vertexTangentWS0 = input.worldToTangent[0];
+    layerTexCoord.vertexBitangentWS0 = input.worldToTangent[1];
+
+    // TODO: We should use relative camera position here - This will be automatic when we will move to camera relative space.
+    float3 dPdx = ddx_fine(input.positionWS);
+    float3 dPdy = ddy_fine(input.positionWS);
+
+    float3 sigmaX = dPdx - dot(dPdx, vertexNormalWS) * vertexNormalWS;
+    float3 sigmaY = dPdy - dot(dPdy, vertexNormalWS) * vertexNormalWS;
+    //float flipSign = dot(sigmaY, cross(vertexNormalWS, sigmaX) ) ? -1.0 : 1.0;
+    float flipSign = dot(dPdy, cross(vertexNormalWS, dPdx)) < 0.0 ? -1.0 : 1.0; // gives same as the commented out line above
+
+    // TODO: Optimize! The compiler will not be able to remove the tangent space that are not use because it can't know due to our UVMapping constant we use for both base and details
+    // To solve this we should track which UVSet is use for normal mapping... Maybe not as simple as it sounds
+    SurfaceGradientGenBasisTB(vertexNormalWS, sigmaX, sigmaY, flipSign, input.texCoord1, layerTexCoord.vertexTangentWS1, layerTexCoord.vertexBitangentWS1);
+    #if defined(_REQUIRE_UV2) || defined(_REQUIRE_UV3)
+    SurfaceGradientGenBasisTB(vertexNormalWS, sigmaX, sigmaY, flipSign, input.texCoord2, layerTexCoord.vertexTangentWS2, layerTexCoord.vertexBitangentWS2);
+    #endif
+    #if defined(_REQUIRE_UV3)
+    SurfaceGradientGenBasisTB(vertexNormalWS, sigmaX, sigmaY, flipSign, input.texCoord3, layerTexCoord.vertexTangentWS3, layerTexCoord.vertexBitangentWS3);
+    #endif
+}
+#endif
+
+#ifndef LAYERED_LIT_SHADER
+
+// Want to use only one sampler for normalmap/bentnormalmap either we use OS or TS. And either we have normal map or bent normal or both.
+#ifdef _NORMALMAP_TANGENT_SPACE
+    #if defined(_NORMALMAP)
+    #define SAMPLER_NORMALMAP_IDX sampler_NormalMap
+    #elif defined(_BENTNORMALMAP)
+    #define SAMPLER_NORMALMAP_IDX sampler_BentNormalMap
+    #endif
+#else
+    #if defined(_NORMALMAP)
+    #define SAMPLER_NORMALMAP_IDX sampler_NormalMapOS
+    #elif defined(_BENTNORMALMAP)
+    #define SAMPLER_NORMALMAP_IDX sampler_BentNormalMapOS
+    #endif
+#endif
+
+#define SAMPLER_DETAILMAP_IDX sampler_DetailMap
+#define SAMPLER_MASKMAP_IDX sampler_MaskMap
+#define SAMPLER_HEIGHTMAP_IDX sampler_HeightMap
+
+#define SAMPLER_SUBSURFACE_MASKMAP_IDX sampler_SubsurfaceMaskMap
+#define SAMPLER_THICKNESSMAP_IDX sampler_ThicknessMap
+
+// include LitDataIndividualLayer to define GetSurfaceData
+#define LAYER_INDEX 0
+#define ADD_IDX(Name) Name
+#define ADD_ZERO_IDX(Name) Name
+#ifdef _NORMALMAP
+#define _NORMALMAP_IDX
+#endif
+#ifdef _NORMALMAP_TANGENT_SPACE
+#define _NORMALMAP_TANGENT_SPACE_IDX
+#endif
+#ifdef _DETAIL_MAP
+#define _DETAIL_MAP_IDX
+#endif
+#ifdef _SUBSURFACE_MASK_MAP
+#define _SUBSURFACE_MASK_MAP_IDX
+#endif
+#ifdef _THICKNESSMAP
+#define _THICKNESSMAP_IDX
+#endif
+#ifdef _MASKMAP
+#define _MASKMAP_IDX
+#endif
+#ifdef _BENTNORMALMAP
+#define _BENTNORMALMAP_IDX
+#endif
+#include "LitDataIndividualLayer.hlsl"
+
+// This maybe call directly by tessellation (domain) shader, thus all part regarding surface gradient must be done
+// in function with FragInputs input as parameters
+// layerTexCoord must have been initialize to 0 outside of this function
+void GetLayerTexCoord(float2 texCoord0, float2 texCoord1, float2 texCoord2, float2 texCoord3,
+                      float3 positionWS, float3 vertexNormalWS, inout LayerTexCoord layerTexCoord)
+{
+    layerTexCoord.vertexNormalWS = vertexNormalWS;
+    layerTexCoord.triplanarWeights = ComputeTriplanarWeights(vertexNormalWS);
+
+    int mappingType = UV_MAPPING_UVSET;
+#if defined(_MAPPING_PLANAR)
+    mappingType = UV_MAPPING_PLANAR;
+#elif defined(_MAPPING_TRIPLANAR)
+    mappingType = UV_MAPPING_TRIPLANAR;
+#endif
+
+    // Be sure that the compiler is aware that we don't use UV1 to UV3 for main layer so it can optimize code
+    ComputeLayerTexCoord(   texCoord0, texCoord1, texCoord2, texCoord3, float4(1.0, 0.0, 0.0, 0.0), _UVDetailsMappingMask,
+                            _BaseColorMap_ST.xy, _BaseColorMap_ST.zw, _DetailMap_ST.xy, _DetailMap_ST.zw, 1.0, _LinkDetailsWithBase,
+                            positionWS, _TexWorldScale,
+                            mappingType, layerTexCoord);
+}
+
+// This is call only in this file
+// layerTexCoord must have been initialize to 0 outside of this function
+void GetLayerTexCoord(FragInputs input, inout LayerTexCoord layerTexCoord)
+{
+#ifdef SURFACE_GRADIENT
+    GenerateLayerTexCoordBasisTB(input, layerTexCoord);
+#endif
+
+    GetLayerTexCoord(   input.texCoord0, input.texCoord1, input.texCoord2, input.texCoord3,
+                        input.positionWS, input.worldToTangent[2].xyz, layerTexCoord);
+}
+
+#include "LitDataDisplacement.hlsl"
+#include "LitBuiltinData.hlsl"
+
+void GetSurfaceAndBuiltinData(FragInputs input, float3 V, inout PositionInputs posInput, out SurfaceData surfaceData, out BuiltinData builtinData)
+{
+#ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group
+    LODDitheringTransition(posInput.positionSS, unity_LODFade.x);
+#endif
+
+    ApplyDoubleSidedFlipOrMirror(input); // Apply double sided flip on the vertex normal
+
+    LayerTexCoord layerTexCoord;
+    ZERO_INITIALIZE(LayerTexCoord, layerTexCoord);
+    GetLayerTexCoord(input, layerTexCoord);
+
+    float depthOffset = ApplyPerPixelDisplacement(input, V, layerTexCoord);
+
+#ifdef _DEPTHOFFSET_ON
+    ApplyDepthOffsetPositionInput(V, depthOffset, GetWorldToHClipMatrix(), posInput);
+#endif
+
+    // We perform the conversion to world of the normalTS outside of the GetSurfaceData
+    // so it allow us to correctly deal with detail normal map and optimize the code for the layered shaders
+    float3 normalTS;
+    float3 bentNormalTS;
+    float3 bentNormalWS;
+    float alpha = GetSurfaceData(input, layerTexCoord, surfaceData, normalTS, bentNormalTS);
+    GetNormalWS(input, V, normalTS, surfaceData.normalWS);
+
+    // Ensure that the normal is front-facing.
+    float NdotV;
+    surfaceData.normalWS = GetViewReflectedNormal(surfaceData.normalWS, V, NdotV);
+
+    // Use bent normal to sample GI if available
+#ifdef _BENTNORMALMAP
+    GetNormalWS(input, V, bentNormalTS, bentNormalWS);
+#else
+    bentNormalWS = surfaceData.normalWS;
+#endif
+
+    // By default we use the ambient occlusion with Tri-ace trick (apply outside) for specular occlusion.
+    // If user provide bent normal then we process a better term
+#if defined(_BENTNORMALMAP) && defined(_ENABLESPECULAROCCLUSION)
+    // If we have bent normal and ambient occlusion, process a specular occlusion
+    surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData);
+#elif defined(_MASKMAP)
+    surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(NdotV, surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
+#else
+    surfaceData.specularOcclusion = 1.0;
+#endif
+
+    // This is use with anisotropic material
+    surfaceData.tangentWS = Orthonormalize(surfaceData.tangentWS, surfaceData.normalWS);
+
+    AddDecalContribution(posInput.positionSS, surfaceData);
+
+#if defined(DEBUG_DISPLAY)
+    if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)
+    {
+        surfaceData.baseColor = GetTextureDataDebug(_DebugMipMapMode, layerTexCoord.base.uv, _BaseColorMap, _BaseColorMap_TexelSize, _BaseColorMap_MipInfo, surfaceData.baseColor);
+        surfaceData.metallic = 0;
+    }
+#endif
+
+    // Caution: surfaceData must be fully initialize before calling GetBuiltinData
+    GetBuiltinData(input, surfaceData, alpha, bentNormalWS, depthOffset, builtinData);
+}
+
+#include "LitDataMeshModification.hlsl"
+
+#endif // #ifndef LAYERED_LIT_SHADER

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/LitProperties.hlsl

 // TODO: Fix the code in legacy unity so we can customize the beahvior for GI
 float3 _EmissionColor;
 float4 _EmissiveColorMap_ST;
+float _TexWorldScaleEmissive;
+float4 _UVMappingMaskEmissive;
 
 float4 _InvPrimScale; // Only XY are used
 
 float4 _BaseColor;
 float4 _BaseColorMap_ST;
 float4 _BaseColorMap_TexelSize;
-float4 _BaseColorMap_MipInfo;
+float4 _BaseColorMap_MipInfo;
 
 float _Metallic;
 float _Smoothness;
 float4 _BaseColorMap2_ST;
 float4 _BaseColorMap3_ST;
 
-float4 _BaseColorMap0_TexelSize;
-float4 _BaseColorMap0_MipInfo;
+float4 _BaseColorMap0_TexelSize;
+float4 _BaseColorMap0_MipInfo;
 
 PROP_DECL(float, _Metallic);
 PROP_DECL(float, _Smoothness);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/LitTessellation.shader

         [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVDetail("UV Set for detail", Float) = 0
         [HideInInspector] _UVDetailsMappingMask("_UVDetailsMappingMask", Color) = (1, 0, 0, 0)
         [ToggleOff] _LinkDetailsWithBase("LinkDetailsWithBase", Float) = 1.0
+
+        [Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3, Planar, 4, Triplanar, 5)] _UVEmissive("UV Set for emissive", Float) = 0
+        _TexWorldScaleEmissive("Scale to apply on world coordinate", Float) = 1.0
+        [HideInInspector] _UVMappingMaskEmissive("_UVMappingMaskEmissive", Color) = (1, 0, 0, 0)
 
         // Wind
         [ToggleOff]  _EnableWind("Enable Wind", Float) = 0.0
     #pragma shader_feature _ _TESSELLATION_PHONG
     #pragma shader_feature _ _REFRACTION_PLANE _REFRACTION_SPHERE
 
+    #pragma shader_feature _ _EMISSIVE_MAPPING_PLANAR _EMISSIVE_MAPPING_TRIPLANAR
     #pragma shader_feature _ _MAPPING_PLANAR _MAPPING_TRIPLANAR
     #pragma shader_feature _NORMALMAP_TANGENT_SPACE
     #pragma shader_feature _ _REQUIRE_UV2 _REQUIRE_UV3
 
     // enable dithering LOD crossfade
     #pragma multi_compile _ LOD_FADE_CROSSFADE
+
+    //enable GPU instancing support
+    #pragma multi_compile_instancing
 
     //-------------------------------------------------------------------------------------
     // Define

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Unlit/Unlit.shader

     #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
     //-------------------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Unlit/UnlitProperties.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
+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/ShaderPass/ShaderPassLightTransport.hlsl

 {
     VaryingsToPS output;
 
+    UNITY_SETUP_INSTANCE_ID(inputMesh);
+    UNITY_TRANSFER_INSTANCE_ID(inputMesh, output);
+
     // Output UV coordinate in vertex shader
     float2 uv;
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderPass/VaryingMesh.hlsl

 #ifdef ATTRIBUTES_NEED_COLOR
     float4 color        : COLOR;
 #endif
-
-    // UNITY_INSTANCE_ID
+    
+    UNITY_VERTEX_INPUT_INSTANCE_ID
 };
 
 struct VaryingsMeshToPS
 #ifdef VARYINGS_NEED_COLOR
     float4 color;
 #endif
+
+UNITY_VERTEX_INPUT_INSTANCE_ID
+
 };
 
 struct PackedVaryingsMeshToPS
 #if defined(VARYINGS_NEED_CULLFACE) && SHADER_STAGE_FRAGMENT
     FRONT_FACE_TYPE cullFace : FRONT_FACE_SEMANTIC;
 #endif
+
+    UNITY_VERTEX_INPUT_INSTANCE_ID
 };
 
 // Functions to pack data to use as few interpolator as possible, the ShaderGraph should generate these functions
 
+    UNITY_TRANSFER_INSTANCE_ID(input, output);
+
     output.positionCS = input.positionCS;
 
 #ifdef VARYINGS_NEED_POSITION_WS
     FragInputs output;
     ZERO_INITIALIZE(FragInputs, output);
 
+    UNITY_SETUP_INSTANCE_ID(input);
+
     // Init to some default value to make the computer quiet (else it output "divide by zero" warning even if value is not used).
     // TODO: this is a really poor workaround, but the variable is used in a bunch of places
     // to compute normals which are then passed on elsewhere to compute other values...
 #ifdef VARYINGS_DS_NEED_COLOR
     float4 color;
 #endif
+
+    UNITY_VERTEX_INPUT_INSTANCE_ID
 };
 
 struct PackedVaryingsMeshToDS
 #ifdef VARYINGS_DS_NEED_COLOR
     float4 interpolators5 : TEXCOORD2;
 #endif
+
+     UNITY_VERTEX_INPUT_INSTANCE_ID
 };
 
 // Functions to pack data to use as few interpolator as possible, the ShaderGraph should generate these functions
 
+    UNITY_TRANSFER_INSTANCE_ID(input, output)
+
     output.interpolators0 = input.positionWS;
     output.interpolators1 = input.normalWS;
 #ifdef VARYINGS_DS_NEED_TANGENT
 VaryingsMeshToDS UnpackVaryingsMeshToDS(PackedVaryingsMeshToDS input)
 {
     VaryingsMeshToDS output;
+    
+    UNITY_TRANSFER_INSTANCE_ID(input, output)
 
     output.positionWS = input.interpolators0;
     output.normalWS = input.interpolators1;
 VaryingsMeshToDS InterpolateWithBaryCoordsMeshToDS(VaryingsMeshToDS input0, VaryingsMeshToDS input1, VaryingsMeshToDS input2, float3 baryCoords)
 {
     VaryingsMeshToDS ouput;
+
+    UNITY_TRANSFER_INSTANCE_ID(input0, output)
 
     TESSELLATION_INTERPOLATE_BARY(positionWS, baryCoords);
     TESSELLATION_INTERPOLATE_BARY(normalWS, baryCoords);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderPass/VertMesh.hlsl

 {
     VaryingsMeshType output;
 
+    UNITY_SETUP_INSTANCE_ID(input);
+    UNITY_TRANSFER_INSTANCE_ID(input, output);
+
     float3 positionWS = TransformObjectToWorld(input.positionOS);
 #ifdef ATTRIBUTES_NEED_NORMAL
     float3 normalWS = TransformObjectToWorldNormal(input.normalOS);
 VaryingsMeshToPS VertMeshTesselation(VaryingsMeshToDS input)
 {
     VaryingsMeshToPS output;
+
+    UNITY_SETUP_INSTANCE_ID(input);
+    UNITY_TRANSFER_INSTANCE_ID(input, output);
 
     output.positionCS = TransformWorldToHClip(input.positionWS);
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderVariables.hlsl

     #include "ShaderVariablesMatrixDefsHDCamera.hlsl"
 #endif
 
+#include "CoreRP/ShaderLibrary/UnityInstancing.hlsl"
+
 #include "ShaderVariablesFunctions.hlsl"
 
 #endif // UNITY_SHADER_VARIABLES_INCLUDED

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/OpaqueAtmosphericScattering.shader

             #pragma vertex Vert
             #pragma fragment Frag
 
-            #pragma enable_d3d11_debug_symbols
+            // #pragma enable_d3d11_debug_symbols
 
             #include "CoreRP/ShaderLibrary/Common.hlsl"
             #include "../ShaderVariables.hlsl"

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/UnityInstancing.hlsl

+#ifndef UNITY_INSTANCING_INCLUDED
+#define UNITY_INSTANCING_INCLUDED
+
+#ifndef UNITY_SHADER_VARIABLES_INCLUDED
+    // We will redefine some built-in shader params e.g. unity_ObjectToWorld and unity_WorldToObject.
+    #error "Please include ShaderVariables.hlsl first."
+#endif
+
+#if SHADER_TARGET >= 35 && (defined(SHADER_API_D3D11) || defined(SHADER_API_GLES3) || defined(SHADER_API_GLCORE) || defined(SHADER_API_XBOXONE) || defined(SHADER_API_PSSL) || defined(SHADER_API_VULKAN) || defined(SHADER_API_METAL))
+    #define UNITY_SUPPORT_INSTANCING
+#endif
+
+#if defined(SHADER_API_SWITCH)
+    #define UNITY_SUPPORT_INSTANCING
+#endif
+
+#if defined(SHADER_API_D3D11)
+    #define UNITY_SUPPORT_STEREO_INSTANCING
+#endif
+
+#if defined(SHADER_API_D3D11) || defined(SHADER_API_GLCORE) || defined(SHADER_API_GLES3) || defined(SHADER_API_VULKAN) || defined(SHADER_API_XBOXONE) || defined(SHADER_API_PSSL) || defined(SHADER_API_METAL) || defined(SHADER_API_SWITCH)
+    #define UNITY_INSTANCING_AOS
+#endif
+
+// These platforms support dynamically adjusting the instancing CB size according to the current batch.
+#if defined(SHADER_API_D3D11) || defined(SHADER_API_GLCORE) || defined(SHADER_API_GLES3) || defined(SHADER_API_METAL) || defined(SHADER_API_PSSL) || defined(SHADER_API_VULKAN)
+    #define UNITY_INSTANCING_SUPPORT_FLEXIBLE_ARRAY_SIZE
+#endif
+
+#if defined(SHADER_TARGET_SURFACE_ANALYSIS) && defined(UNITY_SUPPORT_INSTANCING)
+    #undef UNITY_SUPPORT_INSTANCING
+#endif
+
+////////////////////////////////////////////////////////
+// instancing paths
+// - UNITY_INSTANCING_ENABLED               Defined if instancing path is taken.
+// - UNITY_PROCEDURAL_INSTANCING_ENABLED    Defined if procedural instancing path is taken.
+// - UNITY_STEREO_INSTANCING_ENABLED        Defined if stereo instancing path is taken.
+#if defined(UNITY_SUPPORT_INSTANCING) && defined(INSTANCING_ON)
+    #define UNITY_INSTANCING_ENABLED
+#endif
+#if defined(UNITY_SUPPORT_INSTANCING) && defined(PROCEDURAL_INSTANCING_ON)
+    #define UNITY_PROCEDURAL_INSTANCING_ENABLED
+#endif
+#if defined(UNITY_SUPPORT_STEREO_INSTANCING) && defined(STEREO_INSTANCING_ON)
+    #define UNITY_STEREO_INSTANCING_ENABLED
+#endif
+
+#if defined(SHADER_API_GLES3) || defined(SHADER_API_GLCORE) || defined(SHADER_API_METAL) || defined(SHADER_API_VULKAN)
+    // These platforms have constant buffers disabled normally, but not here (see CBUFFER_START/CBUFFER_END in HLSLSupport.cginc).
+    #define UNITY_INSTANCING_CBUFFER_SCOPE_BEGIN(name)  cbuffer name {
+    #define UNITY_INSTANCING_CBUFFER_SCOPE_END          }
+#else
+    #define UNITY_INSTANCING_CBUFFER_SCOPE_BEGIN(name)  CBUFFER_START(name)
+    #define UNITY_INSTANCING_CBUFFER_SCOPE_END          CBUFFER_END
+#endif
+
+////////////////////////////////////////////////////////
+// basic instancing setups
+// - UNITY_VERTEX_INPUT_INSTANCE_ID     Declare instance ID field in vertex shader input / output struct.
+// - UNITY_GET_INSTANCE_ID              (Internal) Get the instance ID from input struct.
+#if defined(UNITY_INSTANCING_ENABLED) || defined(UNITY_PROCEDURAL_INSTANCING_ENABLED) || defined(UNITY_STEREO_INSTANCING_ENABLED)
+
+    // A global instance ID variable that functions can directly access.
+    static uint unity_InstanceID;
+
+    // Don't make UnityDrawCallInfo an actual CB on GL
+    #if !defined(SHADER_API_GLES3) && !defined(SHADER_API_GLCORE)
+        UNITY_INSTANCING_CBUFFER_SCOPE_BEGIN(UnityDrawCallInfo)
+    #endif
+            int unity_BaseInstanceID;
+            int unity_InstanceCount;
+    #if !defined(SHADER_API_GLES3) && !defined(SHADER_API_GLCORE)
+        UNITY_INSTANCING_CBUFFER_SCOPE_END
+    #endif
+
+    #ifdef SHADER_API_PSSL
+        #define DEFAULT_UNITY_VERTEX_INPUT_INSTANCE_ID uint instanceID;
+        #define UNITY_GET_INSTANCE_ID(input)    _GETINSTANCEID(input)
+    #else
+        #define DEFAULT_UNITY_VERTEX_INPUT_INSTANCE_ID uint instanceID : SV_InstanceID;
+        #define UNITY_GET_INSTANCE_ID(input)    input.instanceID
+    #endif
+
+#else
+    #define DEFAULT_UNITY_VERTEX_INPUT_INSTANCE_ID
+#endif // UNITY_INSTANCING_ENABLED || UNITY_PROCEDURAL_INSTANCING_ENABLED || UNITY_STEREO_INSTANCING_ENABLED
+
+#if !defined(UNITY_VERTEX_INPUT_INSTANCE_ID)
+#   define UNITY_VERTEX_INPUT_INSTANCE_ID DEFAULT_UNITY_VERTEX_INPUT_INSTANCE_ID
+#endif
+
+////////////////////////////////////////////////////////
+// basic stereo instancing setups
+// - UNITY_VERTEX_OUTPUT_STEREO             Declare stereo target eye field in vertex shader output struct.
+// - UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO  Assign the stereo target eye.
+// - UNITY_TRANSFER_VERTEX_OUTPUT_STEREO    Copy stero target from input struct to output struct. Used in vertex shader.
+// - UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX
+#ifdef UNITY_STEREO_INSTANCING_ENABLED
+    #define DEFAULT_UNITY_VERTEX_OUTPUT_STEREO                          uint stereoTargetEyeIndex : SV_RenderTargetArrayIndex;
+    #define DEFAULT_UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output)       output.stereoTargetEyeIndex = unity_StereoEyeIndex
+    #define DEFAULT_UNITY_TRANSFER_VERTEX_OUTPUT_STEREO(input, output)  output.stereoTargetEyeIndex = input.stereoTargetEyeIndex;
+    #define DEFAULT_UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input) unity_StereoEyeIndex = input.stereoTargetEyeIndex;
+#elif defined(UNITY_STEREO_MULTIVIEW_ENABLED)
+    #define DEFAULT_UNITY_VERTEX_OUTPUT_STEREO float stereoTargetEyeIndex : BLENDWEIGHT0;
+    // HACK: Workaround for Mali shader compiler issues with directly using GL_ViewID_OVR (GL_OVR_multiview). This array just contains the values 0 and 1.
+    #define DEFAULT_UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output) output.stereoTargetEyeIndex = unity_StereoEyeIndices[unity_StereoEyeIndex].x;
+    #define DEFAULT_UNITY_TRANSFER_VERTEX_OUTPUT_STEREO(input, output) output.stereoTargetEyeIndex = input.stereoTargetEyeIndex;
+    #if defined(SHADER_STAGE_VERTEX)
+        #define DEFAULT_UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input)
+    #else
+        #define DEFAULT_UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input) unity_StereoEyeIndex = (uint) input.stereoTargetEyeIndex;
+    #endif
+#else
+    #define DEFAULT_UNITY_VERTEX_OUTPUT_STEREO
+    #define DEFAULT_UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output)
+    #define DEFAULT_UNITY_TRANSFER_VERTEX_OUTPUT_STEREO(input, output)
+    #define DEFAULT_UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input)
+#endif
+
+
+#if !defined(UNITY_VERTEX_OUTPUT_STEREO)
+#   define UNITY_VERTEX_OUTPUT_STEREO                           DEFAULT_UNITY_VERTEX_OUTPUT_STEREO
+#endif
+#if !defined(UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO)
+#   define UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output)        DEFAULT_UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output)
+#endif
+#if !defined(UNITY_TRANSFER_VERTEX_OUTPUT_STEREO)
+#   define UNITY_TRANSFER_VERTEX_OUTPUT_STEREO(input, output)   DEFAULT_UNITY_TRANSFER_VERTEX_OUTPUT_STEREO(input, output)
+#endif
+#if !defined(UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX)
+#   define UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input)      DEFAULT_UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input)
+#endif
+
+////////////////////////////////////////////////////////
+// - UNITY_SETUP_INSTANCE_ID        Should be used at the very beginning of the vertex shader / fragment shader,
+//                                  so that succeeding code can have access to the global unity_InstanceID.
+//                                  Also procedural function is called to setup instance data.
+// - UNITY_TRANSFER_INSTANCE_ID     Copy instance ID from input struct to output struct. Used in vertex shader.
+
+#if defined(UNITY_INSTANCING_ENABLED) || defined(UNITY_PROCEDURAL_INSTANCING_ENABLED) || defined(UNITY_STEREO_INSTANCING_ENABLED)
+    void UnitySetupInstanceID(uint inputInstanceID)
+    {
+        #ifdef UNITY_STEREO_INSTANCING_ENABLED
+            // stereo eye index is automatically figured out from the instance ID
+            unity_StereoEyeIndex = inputInstanceID & 0x01;
+            unity_InstanceID = unity_BaseInstanceID + (inputInstanceID >> 1);
+        #else
+            unity_InstanceID = inputInstanceID + unity_BaseInstanceID;
+        #endif
+    }
+    void UnitySetupCompoundMatrices();
+    #ifdef UNITY_PROCEDURAL_INSTANCING_ENABLED
+        #ifndef UNITY_INSTANCING_PROCEDURAL_FUNC
+            #error "UNITY_INSTANCING_PROCEDURAL_FUNC must be defined."
+        #else
+            void UNITY_INSTANCING_PROCEDURAL_FUNC(); // forward declaration of the procedural function
+            #define DEFAULT_UNITY_SETUP_INSTANCE_ID(input)      { UnitySetupInstanceID(UNITY_GET_INSTANCE_ID(input)); UNITY_INSTANCING_PROCEDURAL_FUNC(); UnitySetupCompoundMatrices(); }
+        #endif
+    #else
+        #define DEFAULT_UNITY_SETUP_INSTANCE_ID(input)          { UnitySetupInstanceID(UNITY_GET_INSTANCE_ID(input)); UnitySetupCompoundMatrices(); }
+    #endif
+    #define UNITY_TRANSFER_INSTANCE_ID(input, output)   output.instanceID = UNITY_GET_INSTANCE_ID(input)
+#else
+    #define DEFAULT_UNITY_SETUP_INSTANCE_ID(input)
+    #define UNITY_TRANSFER_INSTANCE_ID(input, output)
+#endif
+
+#if !defined(UNITY_SETUP_INSTANCE_ID)
+#   define UNITY_SETUP_INSTANCE_ID(input) DEFAULT_UNITY_SETUP_INSTANCE_ID(input)
+#endif
+
+////////////////////////////////////////////////////////
+// instanced property arrays
+#if defined(UNITY_INSTANCING_ENABLED)
+
+    #ifdef UNITY_FORCE_MAX_INSTANCE_COUNT
+        #define UNITY_INSTANCED_ARRAY_SIZE  UNITY_FORCE_MAX_INSTANCE_COUNT
+    #elif defined(UNITY_INSTANCING_SUPPORT_FLEXIBLE_ARRAY_SIZE)
+        #define UNITY_INSTANCED_ARRAY_SIZE  2 // minimum array size that ensures dynamic indexing
+    #elif defined(UNITY_MAX_INSTANCE_COUNT)
+        #define UNITY_INSTANCED_ARRAY_SIZE  UNITY_MAX_INSTANCE_COUNT
+    #else
+        #if defined(SHADER_API_VULKAN) && defined(SHADER_API_MOBILE)
+            #define UNITY_INSTANCED_ARRAY_SIZE  250
+        #else
+            #define UNITY_INSTANCED_ARRAY_SIZE  500
+        #endif
+    #endif
+
+    #ifdef UNITY_INSTANCING_AOS
+        #define UNITY_INSTANCING_BUFFER_START(buf)      UNITY_INSTANCING_CBUFFER_SCOPE_BEGIN(UnityInstancing_##buf) struct {
+        #define UNITY_INSTANCING_BUFFER_END(arr)        } arr##Array[UNITY_INSTANCED_ARRAY_SIZE]; UNITY_INSTANCING_CBUFFER_SCOPE_END
+        #define UNITY_DEFINE_INSTANCED_PROP(type, var)  type var;
+        #define UNITY_ACCESS_INSTANCED_PROP(arr, var)   arr##Array[unity_InstanceID].var
+    #else
+        #define UNITY_INSTANCING_BUFFER_START(buf)      UNITY_INSTANCING_CBUFFER_SCOPE_BEGIN(UnityInstancing_##buf)
+        #define UNITY_INSTANCING_BUFFER_END(arr)        UNITY_INSTANCING_CBUFFER_SCOPE_END
+        #define UNITY_DEFINE_INSTANCED_PROP(type, var)  type var[UNITY_INSTANCED_ARRAY_SIZE];
+        #define UNITY_ACCESS_INSTANCED_PROP(arr, var)   var[unity_InstanceID]
+    #endif
+
+    // Put worldToObject array to a separate CB if UNITY_ASSUME_UNIFORM_SCALING is defined. Most of the time it will not be used.
+    #ifdef UNITY_ASSUME_UNIFORM_SCALING
+        #define UNITY_WORLDTOOBJECTARRAY_CB 1
+    #else
+        #define UNITY_WORLDTOOBJECTARRAY_CB 0
+    #endif
+
+    #if defined(UNITY_INSTANCED_LOD_FADE) && (defined(LOD_FADE_PERCENTAGE) || defined(LOD_FADE_CROSSFADE))
+        #define UNITY_USE_LODFADE_ARRAY
+    #endif
+
+    #ifdef UNITY_INSTANCED_LIGHTMAPSTS
+        #ifdef LIGHTMAP_ON
+            #define UNITY_USE_LIGHTMAPST_ARRAY
+        #endif
+        #ifdef DYNAMICLIGHTMAP_ON
+            #define UNITY_USE_DYNAMICLIGHTMAPST_ARRAY
+        #endif
+    #endif
+
+    #if defined(UNITY_INSTANCED_SH) && !defined(LIGHTMAP_ON)
+        #if UNITY_SHOULD_SAMPLE_SH
+            #define UNITY_USE_SHCOEFFS_ARRAYS
+        #endif
+        #if defined(UNITY_PASS_DEFERRED) && defined(SHADOWS_SHADOWMASK) && (UNITY_ALLOWED_MRT_COUNT > 4)
+            #define UNITY_USE_PROBESOCCLUSION_ARRAY
+        #endif
+    #endif
+
+    UNITY_INSTANCING_BUFFER_START(PerDraw0)
+        UNITY_DEFINE_INSTANCED_PROP(float4x4, unity_ObjectToWorldArray)
+        #if UNITY_WORLDTOOBJECTARRAY_CB == 0
+            UNITY_DEFINE_INSTANCED_PROP(float4x4, unity_WorldToObjectArray)
+        #endif
+        #if defined(UNITY_USE_LODFADE_ARRAY) && defined(UNITY_INSTANCING_SUPPORT_FLEXIBLE_ARRAY_SIZE)
+            UNITY_DEFINE_INSTANCED_PROP(float, unity_LODFadeArray)
+            // the quantized fade value (unity_LODFade.y) is automatically used for cross-fading instances
+            #define unity_LODFade UNITY_ACCESS_INSTANCED_PROP(unity_Builtins0, unity_LODFadeArray).xxxx
+        #endif
+    UNITY_INSTANCING_BUFFER_END(unity_Builtins0)
+
+    UNITY_INSTANCING_BUFFER_START(PerDraw1)
+        #if UNITY_WORLDTOOBJECTARRAY_CB == 1
+            UNITY_DEFINE_INSTANCED_PROP(float4x4, unity_WorldToObjectArray)
+        #endif
+        #if defined(UNITY_USE_LODFADE_ARRAY) && !defined(UNITY_INSTANCING_SUPPORT_FLEXIBLE_ARRAY_SIZE)
+            UNITY_DEFINE_INSTANCED_PROP(float, unity_LODFadeArray)
+            // the quantized fade value (unity_LODFade.y) is automatically used for cross-fading instances
+            #define unity_LODFade UNITY_ACCESS_INSTANCED_PROP(unity_Builtins1, unity_LODFadeArray).xxxx
+        #endif
+    UNITY_INSTANCING_BUFFER_END(unity_Builtins1)
+
+    UNITY_INSTANCING_BUFFER_START(PerDraw2)
+        #ifdef UNITY_USE_LIGHTMAPST_ARRAY
+            UNITY_DEFINE_INSTANCED_PROP(float4, unity_LightmapSTArray)
+            #define unity_LightmapST UNITY_ACCESS_INSTANCED_PROP(unity_Builtins2, unity_LightmapSTArray)
+        #endif
+        #ifdef UNITY_USE_DYNAMICLIGHTMAPST_ARRAY
+            UNITY_DEFINE_INSTANCED_PROP(float4, unity_DynamicLightmapSTArray)
+            #define unity_DynamicLightmapST UNITY_ACCESS_INSTANCED_PROP(unity_Builtins2, unity_DynamicLightmapSTArray)
+        #endif
+        #ifdef UNITY_USE_SHCOEFFS_ARRAYS
+            UNITY_DEFINE_INSTANCED_PROP(half4, unity_SHArArray)
+            UNITY_DEFINE_INSTANCED_PROP(half4, unity_SHAgArray)
+            UNITY_DEFINE_INSTANCED_PROP(half4, unity_SHAbArray)
+            UNITY_DEFINE_INSTANCED_PROP(half4, unity_SHBrArray)
+            UNITY_DEFINE_INSTANCED_PROP(half4, unity_SHBgArray)
+            UNITY_DEFINE_INSTANCED_PROP(half4, unity_SHBbArray)
+            UNITY_DEFINE_INSTANCED_PROP(half4, unity_SHCArray)
+            #define unity_SHAr UNITY_ACCESS_INSTANCED_PROP(unity_Builtins2, unity_SHArArray)
+            #define unity_SHAg UNITY_ACCESS_INSTANCED_PROP(unity_Builtins2, unity_SHAgArray)
+            #define unity_SHAb UNITY_ACCESS_INSTANCED_PROP(unity_Builtins2, unity_SHAbArray)
+            #define unity_SHBr UNITY_ACCESS_INSTANCED_PROP(unity_Builtins2, unity_SHBrArray)
+            #define unity_SHBg UNITY_ACCESS_INSTANCED_PROP(unity_Builtins2, unity_SHBgArray)
+            #define unity_SHBb UNITY_ACCESS_INSTANCED_PROP(unity_Builtins2, unity_SHBbArray)
+            #define unity_SHC  UNITY_ACCESS_INSTANCED_PROP(unity_Builtins2, unity_SHCArray)
+        #endif
+        #ifdef UNITY_USE_PROBESOCCLUSION_ARRAY
+            UNITY_DEFINE_INSTANCED_PROP(half4, unity_ProbesOcclusionArray)
+            #define unity_ProbesOcclusion UNITY_ACCESS_INSTANCED_PROP(unity_Builtins2, unity_ProbesOcclusionArray)
+        #endif
+    UNITY_INSTANCING_BUFFER_END(unity_Builtins2)
+
+    #define unity_ObjectToWorld     UNITY_ACCESS_INSTANCED_PROP(unity_Builtins0, unity_ObjectToWorldArray)
+
+    #define MERGE_UNITY_BUILTINS_INDEX(X) unity_Builtins##X
+
+    #define unity_WorldToObject     UNITY_ACCESS_INSTANCED_PROP(MERGE_UNITY_BUILTINS_INDEX(UNITY_WORLDTOOBJECTARRAY_CB), unity_WorldToObjectArray)
+
+    inline float4 UnityObjectToClipPosInstanced(in float3 pos)
+    {
+        return mul(UNITY_MATRIX_VP, mul(unity_ObjectToWorld, float4(pos, 1.0)));
+    }
+    inline float4 UnityObjectToClipPosInstanced(float4 pos)
+    {
+        return UnityObjectToClipPosInstanced(pos.xyz);
+    }
+    #define UnityObjectToClipPos UnityObjectToClipPosInstanced
+
+#else // UNITY_INSTANCING_ENABLED
+
+    // in procedural mode we don't need cbuffer, and properties are not uniforms
+    #ifdef UNITY_PROCEDURAL_INSTANCING_ENABLED
+        #define UNITY_INSTANCING_BUFFER_START(buf)
+        #define UNITY_INSTANCING_BUFFER_END(arr)
+        #define UNITY_DEFINE_INSTANCED_PROP(type, var)      static type var;
+    #else
+        #define UNITY_INSTANCING_BUFFER_START(buf)          CBUFFER_START(buf)
+        #define UNITY_INSTANCING_BUFFER_END(arr)            CBUFFER_END
+        #define UNITY_DEFINE_INSTANCED_PROP(type, var)      type var;
+    #endif
+
+    #define UNITY_ACCESS_INSTANCED_PROP(arr, var)           var
+
+#endif // UNITY_INSTANCING_ENABLED
+
+#if defined(UNITY_INSTANCING_ENABLED) || defined(UNITY_PROCEDURAL_INSTANCING_ENABLED) || defined(UNITY_STEREO_INSTANCING_ENABLED)
+    // The following matrix evaluations depend on the static var unity_InstanceID & unity_StereoEyeIndex. They need to be initialized after UnitySetupInstanceID.
+    static float4x4 unity_MatrixMVP_Instanced;
+    static float4x4 unity_MatrixMV_Instanced;
+    static float4x4 unity_MatrixTMV_Instanced;
+    static float4x4 unity_MatrixITMV_Instanced;
+    void UnitySetupCompoundMatrices()
+    {
+        unity_MatrixMVP_Instanced = mul(UNITY_MATRIX_VP, unity_ObjectToWorld);
+        unity_MatrixMV_Instanced = mul(UNITY_MATRIX_V, unity_ObjectToWorld);
+        unity_MatrixTMV_Instanced = transpose(unity_MatrixMV_Instanced);
+        unity_MatrixITMV_Instanced = transpose(mul(unity_WorldToObject, unity_MatrixInvV));
+    }
+    #undef UNITY_MATRIX_MVP
+    #undef UNITY_MATRIX_MV
+    #undef UNITY_MATRIX_T_MV
+    #undef UNITY_MATRIX_IT_MV
+    #define UNITY_MATRIX_MVP    unity_MatrixMVP_Instanced
+    #define UNITY_MATRIX_MV     unity_MatrixMV_Instanced
+    #define UNITY_MATRIX_T_MV   unity_MatrixTMV_Instanced
+    #define UNITY_MATRIX_IT_MV  unity_MatrixITMV_Instanced
+#endif
+
+#endif // UNITY_INSTANCING_INCLUDED

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/UnityInstancing.hlsl.meta

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

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/LitBuiltinData.hlsl

+void GetBuiltinData(FragInputs input, SurfaceData surfaceData, float alpha, float3 bentNormalWS, float depthOffset, out BuiltinData builtinData)
+{
+    // Builtin Data
+    builtinData.opacity = alpha;
+
+    // TODO: Sample lightmap/lightprobe/volume proxy
+    // This should also handle projective lightmap
+    builtinData.bakeDiffuseLighting = SampleBakedGI(input.positionWS, bentNormalWS, input.texCoord1, input.texCoord2);
+
+    // It is safe to call this function here as surfaceData have been filled
+    // We want to know if we must enable transmission on GI for SSS material, if the material have no SSS, this code will be remove by the compiler.
+    BSDFData bsdfData = ConvertSurfaceDataToBSDFData(surfaceData);
+    if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
+    {
+        // For now simply recall the function with inverted normal, the compiler should be able to optimize the lightmap case to not resample the directional lightmap
+        // however it will not optimize the lightprobe case due to the proxy volume relying on dynamic if (we rely must get right of this dynamic if), not a problem for SH9, but a problem for proxy volume.
+        // TODO: optimize more this code.
+        // Add GI transmission contribution by resampling the GI for inverted vertex normal
+        builtinData.bakeDiffuseLighting += SampleBakedGI(input.positionWS, -input.worldToTangent[2], input.texCoord1, input.texCoord2) * bsdfData.transmittance;
+    }
+
+#ifdef SHADOWS_SHADOWMASK
+    float4 shadowMask = SampleShadowMask(input.positionWS, input.texCoord1);
+    builtinData.shadowMask0 = shadowMask.x;
+    builtinData.shadowMask1 = shadowMask.y;
+    builtinData.shadowMask2 = shadowMask.z;
+    builtinData.shadowMask3 = shadowMask.w;
+#else
+    builtinData.shadowMask0 = 0.0;
+    builtinData.shadowMask1 = 0.0;
+    builtinData.shadowMask2 = 0.0;
+    builtinData.shadowMask3 = 0.0;
+#endif
+
+    // 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; // We still store intensity here so we can reuse it with debug code
+
+    builtinData.emissiveColor = _EmissiveColor * builtinData.emissiveIntensity * lerp(float3(1.0, 1.0, 1.0), surfaceData.baseColor.rgb, _AlbedoAffectEmissive);
+#ifdef _EMISSIVE_COLOR_MAP
+
+    // Use layer0 of LayerTexCoord to retrieve emissive color mapping information
+    LayerTexCoord layerTexCoord;
+    ZERO_INITIALIZE(LayerTexCoord, layerTexCoord);
+    layerTexCoord.vertexNormalWS = input.worldToTangent[2].xyz;
+    layerTexCoord.triplanarWeights = ComputeTriplanarWeights(layerTexCoord.vertexNormalWS);
+
+    int mappingType = UV_MAPPING_UVSET;
+    #if defined(_EMISSIVE_MAPPING_PLANAR)
+    mappingType = UV_MAPPING_PLANAR;
+    #elif defined(_EMISSIVE_MAPPING_TRIPLANAR)
+    mappingType = UV_MAPPING_TRIPLANAR;
+    #endif
+
+    // Be sure that the compiler is aware that we don't use UV1 to UV3 for main layer so it can optimize code
+    #ifndef LAYERED_LIT_SHADER
+    ComputeLayerTexCoord(input.texCoord0, input.texCoord1, input.texCoord2, input.texCoord3, float4(1.0, 0.0, 0.0, 0.0), float4(1.0, 0.0, 0.0, 0.0),
+    #else
+    ComputeLayerTexCoord0(input.texCoord0, input.texCoord1, input.texCoord2, input.texCoord3, _UVMappingMaskEmissive, _UVMappingMaskEmissive,
+    #endif
+                            _EmissiveColorMap_ST.xy, _EmissiveColorMap_ST.zw, float2(0.0, 0.0), float2(0.0, 0.0), 1.0, false,
+                            input.positionWS, _TexWorldScaleEmissive,
+                            mappingType, layerTexCoord);
+
+    #ifndef LAYERED_LIT_SHADER
+    UVMapping emissiveMapMapping = layerTexCoord.base;
+    #else
+    UVMapping emissiveMapMapping = layerTexCoord.base0;
+    #endif
+
+    builtinData.emissiveColor *= SAMPLE_UVMAPPING_TEXTURE2D(_EmissiveColorMap, sampler_EmissiveColorMap, emissiveMapMapping).rgb;
+#endif // _EMISSIVE_COLOR_MAP
+
+    builtinData.velocity = float2(0.0, 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 = depthOffset;
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/LitBuiltinData.hlsl.meta

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