Merge remote-tracking branch 'origin/master' into HDRP_GraphicTests

# Conflicts:
#	Tests/Scripts/Editor/GraphicTests/HDRenderPipeline/DebugViewController_Editor.cs.meta

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/CommonLighting.hlsl

 // Attenuation functions
 //-----------------------------------------------------------------------------
 
-// Ref: Moving Frostbite to PBR
-real SmoothDistanceAttenuation(real squaredDistance, real invSqrAttenuationRadius)
+// Ref: Moving Frostbite to PBR.
+real QuadraticAttenuation(real attenuation)
+{
+    return attenuation * attenuation;
+}
+
+// Non physically based hack to limit light influence to attenuationRadius.
+real DistanceAttenuation(real squaredDistance, real invSqrAttenuationRadius)
-    real smoothFactor = saturate(1.0 - factor * factor);
-    return smoothFactor * smoothFactor;
+    return saturate(1.0 - factor * factor);
+}
+
+real SmoothDistanceAttenuation(real squaredDistance, real invSqrAttenuationRadius)
+{
+    real smoothFactor = DistanceAttenuation(squaredDistance, invSqrAttenuationRadius);
+    return QuadraticAttenuation(smoothFactor);
-real GetDistanceAttenuation(real sqrDist, real invSqrAttenuationRadius)
+real SmoothQuadraticDistanceAttenuation(real distSq, real distRcp, real invSqrAttenuationRadius)
-    real attenuation = 1.0 / (max(PUNCTUAL_LIGHT_THRESHOLD * PUNCTUAL_LIGHT_THRESHOLD, sqrDist));
-    // Non physically based hack to limit light influence to attenuationRadius.
-    attenuation *= SmoothDistanceAttenuation(sqrDist, invSqrAttenuationRadius);
-    return attenuation;
+    // Becomes quadratic after the call to QuadraticAttenuation().
+    real attenuation  = min(distRcp, 1.0 / PUNCTUAL_LIGHT_THRESHOLD);
+         attenuation *= DistanceAttenuation(distSq, invSqrAttenuationRadius);
+    return QuadraticAttenuation(attenuation);
-real GetDistanceAttenuation(real3 unL, real invSqrAttenuationRadius)
+real SmoothQuadraticDistanceAttenuation(real3 unL, real invSqrAttenuationRadius)
-    real sqrDist = dot(unL, unL);
-    return GetDistanceAttenuation(sqrDist, invSqrAttenuationRadius);
+    real distSq  = dot(unL, unL);
+    real distRcp = rsqrt(distSq);
+    return SmoothQuadraticDistanceAttenuation(distSq, distRcp, invSqrAttenuationRadius);
-real GetAngleAttenuation(real3 L, real3 lightDir, real lightAngleScale, real lightAngleOffset)
+real AngleAttenuation(real cosFwd, real lightAngleScale, real lightAngleOffset)
-    real cd = dot(lightDir, L);
-    real attenuation = saturate(cd * lightAngleScale + lightAngleOffset);
-    // smooth the transition
-    attenuation *= attenuation;
+    return saturate(cosFwd * lightAngleScale + lightAngleOffset);
+}
-    return attenuation;
+real SmoothAngleAttenuation(real cosFwd, real lightAngleScale, real lightAngleOffset)
+{
+    real attenuation = AngleAttenuation(cosFwd, lightAngleScale, lightAngleOffset);
+    return QuadraticAttenuation(attenuation);
+}
+
+real SmoothAngleAttenuation(real3 L, real3 lightFwdDir, real lightAngleScale, real lightAngleOffset)
+{
+    real cosFwd = dot(-L, lightFwdDir);
+    return SmoothAngleAttenuation(cosFwd, lightAngleScale, lightAngleOffset);
+}
+
+// Combines SmoothQuadraticDistanceAttenuation() and SmoothAngleAttenuation() in an efficient manner.
+// distances = {d, d^2, 1/d, d_proj}, where d_proj = dot(lightToSample, lightData.forward).
+real SmoothPunctualLightAttenuation(real4 distances, real invSqrAttenuationRadius,
+                                     real lightAngleScale, real lightAngleOffset)
+{
+    real distSq   = distances.y;
+    real distRcp  = distances.z;
+    real distProj = distances.w;
+    real cosFwd   = distProj * distRcp;
+
+    real attenuation  = min(distRcp, 1.0 / PUNCTUAL_LIGHT_THRESHOLD);
+         attenuation *= DistanceAttenuation(distSq, invSqrAttenuationRadius);
+         attenuation *= AngleAttenuation(cosFwd, lightAngleScale, lightAngleOffset);
+
+    return QuadraticAttenuation(attenuation);
 }
 
 // Applies SmoothDistanceAttenuation() after transforming the attenuation ellipsoid into a sphere.
 // 'unL' should be computed from the center of the ellipsoid.
-real GetEllipsoidalDistanceAttenuation(real3 unL,  real invSqRadius,
-                                       real3 axis, real invAspectRatio)
+real EllipsoidalDistanceAttenuation(real3 unL,  real invSqRadius,
+                                    real3 axis, real invAspectRatio)
 {
     // Project the unnormalized light vector onto the axis.
     real projL = dot(unL, axis);
 // Applies SmoothDistanceAttenuation() using the axis-aligned ellipsoid of the given dimensions.
 // Both the ellipsoid and 'unL' should be in the same coordinate system.
 // 'unL' should be computed from the center of the ellipsoid.
-real GetEllipsoidalDistanceAttenuation(real3 unL, real3 invHalfDim)
+real EllipsoidalDistanceAttenuation(real3 unL, real3 invHalfDim)
 {
     // Transform the light vector so that we can work with
     // with the ellipsoid as if it was a unit sphere.
 // If the diagonal of the box is 'd', invHalfDim = rcp(0.5 * d).
 // Both the box and 'unL' should be in the same coordinate system.
 // 'unL' should be computed from the center of the box.
-real GetBoxDistanceAttenuation(real3 unL, real3 invHalfDim)
+real BoxDistanceAttenuation(real3 unL, real3 invHalfDim)
 {
     // Transform the light vector so that we can work with
     // with the box as if it was a [-1, 1]^2 cube.

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Debug.hlsl

-#ifndef UNITY_DEBUG_INCLUDED
-#define UNITY_DEBUG_INCLUDED
-
-// Given an enum (represented by an int here), return a color.
-// Use for DebugView of enum
-real3 GetIndexColor(int index)
-{
-    real3 outColor = real3(1.0, 0.0, 0.0);
-
-    if (index == 0)
-        outColor = real3(1.0, 0.5, 0.5);
-    else if (index == 1)
-        outColor = real3(0.5, 1.0, 0.5);
-    else if (index == 2)
-        outColor = real3(0.5, 0.5, 1.0);
-    else if (index == 3)
-        outColor = real3(1.0, 1.0, 0.5);
-    else if (index == 4)
-        outColor = real3(1.0, 0.5, 1.0);
-    else if (index == 5)
-        outColor = real3(0.5, 1.0, 1.0);
-    else if (index == 6)
-        outColor = real3(0.25, 0.75, 1.0);
-    else if (index == 7)
-        outColor = real3(1.0, 0.75, 0.25);
-    else if (index == 8)
-        outColor = real3(0.75, 1.0, 0.25);
-    else if (index == 9)
-        outColor = real3(0.75, 0.25, 1.0);
-
-    return outColor;
-}
-
-bool SampleDebugFont(int2 pixCoord, uint digit)
-{
-    if (pixCoord.x < 0 || pixCoord.y < 0 || pixCoord.x >= 5 || pixCoord.y >= 9 || digit > 9)
-        return false;
-
-#define PACK_BITS25(_x0,_x1,_x2,_x3,_x4,_x5,_x6,_x7,_x8,_x9,_x10,_x11,_x12,_x13,_x14,_x15,_x16,_x17,_x18,_x19,_x20,_x21,_x22,_x23,_x24) (_x0|(_x1<<1)|(_x2<<2)|(_x3<<3)|(_x4<<4)|(_x5<<5)|(_x6<<6)|(_x7<<7)|(_x8<<8)|(_x9<<9)|(_x10<<10)|(_x11<<11)|(_x12<<12)|(_x13<<13)|(_x14<<14)|(_x15<<15)|(_x16<<16)|(_x17<<17)|(_x18<<18)|(_x19<<19)|(_x20<<20)|(_x21<<21)|(_x22<<22)|(_x23<<23)|(_x24<<24))
-#define _ 0
-#define x 1
-    uint fontData[9][2] = {
-        { PACK_BITS25(_,_,x,_,_,        _,_,x,_,_,      _,x,x,x,_,      x,x,x,x,x,      _,_,_,x,_), PACK_BITS25(x,x,x,x,x,      _,x,x,x,_,      x,x,x,x,x,      _,x,x,x,_,      _,x,x,x,_) },
-        { PACK_BITS25(_,x,_,x,_,        _,x,x,_,_,      x,_,_,_,x,      _,_,_,_,x,      _,_,_,x,_), PACK_BITS25(x,_,_,_,_,      x,_,_,_,x,      _,_,_,_,x,      x,_,_,_,x,      x,_,_,_,x) },
-        { PACK_BITS25(x,_,_,_,x,        x,_,x,_,_,      x,_,_,_,x,      _,_,_,x,_,      _,_,x,x,_), PACK_BITS25(x,_,_,_,_,      x,_,_,_,_,      _,_,_,x,_,      x,_,_,_,x,      x,_,_,_,x) },
-        { PACK_BITS25(x,_,_,_,x,        _,_,x,_,_,      _,_,_,_,x,      _,_,x,_,_,      _,x,_,x,_), PACK_BITS25(x,_,x,x,_,      x,_,_,_,_,      _,_,_,x,_,      x,_,_,_,x,      x,_,_,_,x) },
-        { PACK_BITS25(x,_,_,_,x,        _,_,x,_,_,      _,_,_,x,_,      _,x,x,x,_,      _,x,_,x,_), PACK_BITS25(x,x,_,_,x,      x,x,x,x,_,      _,_,x,_,_,      _,x,x,x,_,      _,x,x,x,x) },
-        { PACK_BITS25(x,_,_,_,x,        _,_,x,_,_,      _,_,x,_,_,      _,_,_,_,x,      x,_,_,x,_), PACK_BITS25(_,_,_,_,x,      x,_,_,_,x,      _,_,x,_,_,      x,_,_,_,x,      _,_,_,_,x) },
-        { PACK_BITS25(x,_,_,_,x,        _,_,x,_,_,      _,x,_,_,_,      _,_,_,_,x,      x,x,x,x,x), PACK_BITS25(_,_,_,_,x,      x,_,_,_,x,      _,x,_,_,_,      x,_,_,_,x,      _,_,_,_,x) },
-        { PACK_BITS25(_,x,_,x,_,        _,_,x,_,_,      x,_,_,_,_,      x,_,_,_,x,      _,_,_,x,_), PACK_BITS25(x,_,_,_,x,      x,_,_,_,x,      _,x,_,_,_,      x,_,_,_,x,      x,_,_,_,x) },
-        { PACK_BITS25(_,_,x,_,_,        x,x,x,x,x,      x,x,x,x,x,      _,x,x,x,_,      _,_,_,x,_), PACK_BITS25(_,x,x,x,_,      _,x,x,x,_,      _,x,_,_,_,      _,x,x,x,_,      _,x,x,x,_) }
-    };
-#undef _
-#undef x
-#undef PACK_BITS25
-    return (fontData[8 - pixCoord.y][digit >= 5] >> ((digit % 5) * 5 + pixCoord.x)) & 1;
-}
-
-bool SampleDebugFontNumber(int2 pixCoord, uint number)
-{
-    pixCoord.y -= 4;
-    if (number <= 9)
-    {
-        return SampleDebugFont(pixCoord - int2(6, 0), number);
-    }
-    else
-    {
-        return (SampleDebugFont(pixCoord, number / 10) | SampleDebugFont(pixCoord - int2(6, 0), number % 10));
-    }
-}
-
+#ifndef UNITY_DEBUG_INCLUDED
+#define UNITY_DEBUG_INCLUDED
+
+// Given an enum (represented by an int here), return a color.
+// Use for DebugView of enum
+real3 GetIndexColor(int index)
+{
+    real3 outColor = real3(1.0, 0.0, 0.0);
+
+    if (index == 0)
+        outColor = real3(1.0, 0.5, 0.5);
+    else if (index == 1)
+        outColor = real3(0.5, 1.0, 0.5);
+    else if (index == 2)
+        outColor = real3(0.5, 0.5, 1.0);
+    else if (index == 3)
+        outColor = real3(1.0, 1.0, 0.5);
+    else if (index == 4)
+        outColor = real3(1.0, 0.5, 1.0);
+    else if (index == 5)
+        outColor = real3(0.5, 1.0, 1.0);
+    else if (index == 6)
+        outColor = real3(0.25, 0.75, 1.0);
+    else if (index == 7)
+        outColor = real3(1.0, 0.75, 0.25);
+    else if (index == 8)
+        outColor = real3(0.75, 1.0, 0.25);
+    else if (index == 9)
+        outColor = real3(0.75, 0.25, 1.0);
+
+    return outColor;
+}
+
+bool SampleDebugFont(int2 pixCoord, uint digit)
+{
+    if (pixCoord.x < 0 || pixCoord.y < 0 || pixCoord.x >= 5 || pixCoord.y >= 9 || digit > 9)
+        return false;
+
+#define PACK_BITS25(_x0,_x1,_x2,_x3,_x4,_x5,_x6,_x7,_x8,_x9,_x10,_x11,_x12,_x13,_x14,_x15,_x16,_x17,_x18,_x19,_x20,_x21,_x22,_x23,_x24) (_x0|(_x1<<1)|(_x2<<2)|(_x3<<3)|(_x4<<4)|(_x5<<5)|(_x6<<6)|(_x7<<7)|(_x8<<8)|(_x9<<9)|(_x10<<10)|(_x11<<11)|(_x12<<12)|(_x13<<13)|(_x14<<14)|(_x15<<15)|(_x16<<16)|(_x17<<17)|(_x18<<18)|(_x19<<19)|(_x20<<20)|(_x21<<21)|(_x22<<22)|(_x23<<23)|(_x24<<24))
+#define _ 0
+#define x 1
+    uint fontData[9][2] = {
+        { PACK_BITS25(_,_,x,_,_,        _,_,x,_,_,      _,x,x,x,_,      x,x,x,x,x,      _,_,_,x,_), PACK_BITS25(x,x,x,x,x,      _,x,x,x,_,      x,x,x,x,x,      _,x,x,x,_,      _,x,x,x,_) },
+        { PACK_BITS25(_,x,_,x,_,        _,x,x,_,_,      x,_,_,_,x,      _,_,_,_,x,      _,_,_,x,_), PACK_BITS25(x,_,_,_,_,      x,_,_,_,x,      _,_,_,_,x,      x,_,_,_,x,      x,_,_,_,x) },
+        { PACK_BITS25(x,_,_,_,x,        x,_,x,_,_,      x,_,_,_,x,      _,_,_,x,_,      _,_,x,x,_), PACK_BITS25(x,_,_,_,_,      x,_,_,_,_,      _,_,_,x,_,      x,_,_,_,x,      x,_,_,_,x) },
+        { PACK_BITS25(x,_,_,_,x,        _,_,x,_,_,      _,_,_,_,x,      _,_,x,_,_,      _,x,_,x,_), PACK_BITS25(x,_,x,x,_,      x,_,_,_,_,      _,_,_,x,_,      x,_,_,_,x,      x,_,_,_,x) },
+        { PACK_BITS25(x,_,_,_,x,        _,_,x,_,_,      _,_,_,x,_,      _,x,x,x,_,      _,x,_,x,_), PACK_BITS25(x,x,_,_,x,      x,x,x,x,_,      _,_,x,_,_,      _,x,x,x,_,      _,x,x,x,x) },
+        { PACK_BITS25(x,_,_,_,x,        _,_,x,_,_,      _,_,x,_,_,      _,_,_,_,x,      x,_,_,x,_), PACK_BITS25(_,_,_,_,x,      x,_,_,_,x,      _,_,x,_,_,      x,_,_,_,x,      _,_,_,_,x) },
+        { PACK_BITS25(x,_,_,_,x,        _,_,x,_,_,      _,x,_,_,_,      _,_,_,_,x,      x,x,x,x,x), PACK_BITS25(_,_,_,_,x,      x,_,_,_,x,      _,x,_,_,_,      x,_,_,_,x,      _,_,_,_,x) },
+        { PACK_BITS25(_,x,_,x,_,        _,_,x,_,_,      x,_,_,_,_,      x,_,_,_,x,      _,_,_,x,_), PACK_BITS25(x,_,_,_,x,      x,_,_,_,x,      _,x,_,_,_,      x,_,_,_,x,      x,_,_,_,x) },
+        { PACK_BITS25(_,_,x,_,_,        x,x,x,x,x,      x,x,x,x,x,      _,x,x,x,_,      _,_,_,x,_), PACK_BITS25(_,x,x,x,_,      _,x,x,x,_,      _,x,_,_,_,      _,x,x,x,_,      _,x,x,x,_) }
+    };
+#undef _
+#undef x
+#undef PACK_BITS25
+    return (fontData[8 - pixCoord.y][digit >= 5] >> ((digit % 5) * 5 + pixCoord.x)) & 1;
+}
+
+bool SampleDebugFontNumber(int2 pixCoord, uint number)
+{
+    pixCoord.y -= 4;
+    if (number <= 9)
+    {
+        return SampleDebugFont(pixCoord - int2(6, 0), number);
+    }
+    else
+    {
+        return (SampleDebugFont(pixCoord, number / 10) | SampleDebugFont(pixCoord - int2(6, 0), number % 10));
+    }
+}
+
-{
-    // alpha is amount to blend with source color (0.0 = use original, 1.0 = use new color)
+{
+    // alpha is amount to blend with source color (0.0 = use original, 1.0 = use new color)
-    // mipInfo :
-    // x = quality setings minStreamingMipLevel
-    // y = original mip count for texture
-    // z = desired on screen mip level
-    // w = 0
+    // mipInfo :
+    // x = quality setings minStreamingMipLevel
+    // y = original mip count for texture
+    // z = desired on screen mip level
+    // w = 0
-
-    // If material/shader mip info (original mip level) has not been set its not a streamed texture
-    if (originalTextureMipCount == 0)
-        return float4(1.0, 1.0, 1.0, 0.0);
-
+
+    // If material/shader mip info (original mip level) has not been set its not a streamed texture
+    if (originalTextureMipCount == 0)
+        return float4(1.0, 1.0, 1.0, 0.0);
+
-    uint mipCountDesired = uint(originalTextureMipCount)-uint(desiredMipLevel);
-    if (mipCount == 0)
-    {
-        // Magenta if mip count invalid
-        return float4(1.0, 0.0, 1.0, 1.0);
-    }
-    else if (mipCount < mipCountDesired)
-    {
-        // red tones when not at the desired mip level (reduction due to budget). Brighter is further from original, alpha 0 when at desired
-        float ratioToDesired = float(mipCount) / float(mipCountDesired);
-        return float4(1.0, 0.0, 0.0, 1.0 - ratioToDesired);
-    }
-    else if (mipCount >= originalTextureMipCount)
-    {
-        // original color when at (or beyond) original mip count
-        return float4(1.0, 1.0, 1.0, 0.0);
-    }
-    else
-    {
-        // green tones when not at the original mip level. Brighter is closer to original, alpha 0 when at original
-        float ratioToOriginal = float(mipCount) / float(originalTextureMipCount);
-        return float4(0.0, 1.0, 0.0, 1.0 - ratioToOriginal);
-    }
+    uint mipCountDesired = uint(originalTextureMipCount)-uint(desiredMipLevel);
+    if (mipCount == 0)
+    {
+        // Magenta if mip count invalid
+        return float4(1.0, 0.0, 1.0, 1.0);
+    }
+    else if (mipCount < mipCountDesired)
+    {
+        // red tones when not at the desired mip level (reduction due to budget). Brighter is further from original, alpha 0 when at desired
+        float ratioToDesired = float(mipCount) / float(mipCountDesired);
+        return float4(1.0, 0.0, 0.0, 1.0 - ratioToDesired);
+    }
+    else if (mipCount >= originalTextureMipCount)
+    {
+        // original color when at (or beyond) original mip count
+        return float4(1.0, 1.0, 1.0, 0.0);
+    }
+    else
+    {
+        // green tones when not at the original mip level. Brighter is closer to original, alpha 0 when at original
+        float ratioToOriginal = float(mipCount) / float(originalTextureMipCount);
+        return float4(0.0, 1.0, 0.0, 1.0 - ratioToOriginal);
+    }
-{
-    // Grey scale for mip counts where mip count of 12 = white
-    float mipCountColor = float(mipCount) / 12.0;
-    float4 color = float4(mipCountColor, mipCountColor, mipCountColor, 1.0f);
-
-    // alpha is amount to blend with source color (0.0 = use original, 1.0 = use new color)
-    // 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 );
+{
+    // Grey scale for mip counts where mip count of 12 = white
+    float mipCountColor = float(mipCount) / 12.0;
+    float4 color = float4(mipCountColor, mipCountColor, mipCountColor, 1.0f);
+
+    // alpha is amount to blend with source color (0.0 = use original, 1.0 = use new color)
+    // 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 );
-    // Push down into colors list to "optimal level" in following table.
-    // .zw is texture width,height so *2 is down one mip, *4 is down two mips
-    texelSize.zw *= 4.0;
+    // Push down into colors list to "optimal level" in following table.
+    // .zw is texture width,height so *2 is down one mip, *4 is down two mips
+    texelSize.zw *= 4.0;
-    float mipLevel = ComputeTextureLOD(uv, texelSize.wz);
+    float mipLevel = ComputeTextureLOD(uv, texelSize.wz);
-    float4 colors[6] = {
+    float4 colors[6] = {
         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 color = lerp(a, b, t);
 
     return color;
-}
-
-float3 GetDebugMipColor(float3 originalColor, Texture2D tex, float4 texelSize, float2 uv)
+}
+
+float3 GetDebugMipColor(float3 originalColor, Texture2D tex, float4 texelSize, float2 uv)
-    return lerp(originalColor, mipColor.rgb, mipColor.a);
-}
-
-float3 GetDebugMipCountColor(float3 originalColor, Texture2D tex)
+    return lerp(originalColor, mipColor.rgb, mipColor.a);
+}
+
+float3 GetDebugMipCountColor(float3 originalColor, Texture2D tex)
-    uint mipCount = GetMipCount(tex);
-
+    uint mipCount = GetMipCount(tex);
+
-    return lerp(originalColor, mipColor.rgb, mipColor.a);
-}
-
-float3 GetDebugStreamingMipColor(Texture2D tex, float4 mipInfo)
+    return lerp(originalColor, mipColor.rgb, mipColor.a);
+}
+
+float3 GetDebugStreamingMipColor(Texture2D tex, float4 mipInfo)
-    uint mipCount = GetMipCount(tex);
+    uint mipCount = GetMipCount(tex);
-}
-
-float3 GetDebugStreamingMipColorBlended(float3 originalColor, Texture2D tex, float4 mipInfo)
+}
+
+float3 GetDebugStreamingMipColorBlended(float3 originalColor, Texture2D tex, float4 mipInfo)
-    uint mipCount = GetMipCount(tex);
+    uint mipCount = GetMipCount(tex);
-    return lerp(originalColor, mipColor.rgb, mipColor.a);
-}
-
-float3 GetDebugMipColorIncludingMipReduction(float3 originalColor, Texture2D tex, float4 texelSize, float2 uv, float4 mipInfo)
+    return lerp(originalColor, mipColor.rgb, mipColor.a);
+}
+
+float3 GetDebugMipColorIncludingMipReduction(float3 originalColor, Texture2D tex, float4 texelSize, float2 uv, float4 mipInfo)
-    uint originalTextureMipCount = uint(mipInfo.y);
-    if (originalTextureMipCount != 0)
-    {
-        // mipInfo :
-        // x = quality setings minStreamingMipLevel
-        // y = original mip count for texture
-        // z = desired on screen mip level
-        // w = 0
-
-        // Mip count has been reduced but the texelSize was not updated to take that into account
-        uint mipCount = GetMipCount(tex);
-        uint mipReductionLevel = originalTextureMipCount - mipCount;
-        uint mipReductionFactor = 1 << mipReductionLevel;
-        if (mipReductionFactor)
-        {
-            float oneOverMipReductionFactor = 1.0 / mipReductionFactor;
-            // texelSize.xy *= mipReductionRatio;   // Unused in GetDebugMipColor so lets not re-calculate it
-            texelSize.zw *= oneOverMipReductionFactor;
-        }
-    }
-    return GetDebugMipColor(originalColor, tex, texelSize, uv);
-}
-
-float3 GetDebugMipReductionColor(Texture2D tex, float4 mipInfo)
+    uint originalTextureMipCount = uint(mipInfo.y);
+    if (originalTextureMipCount != 0)
+    {
+        // mipInfo :
+        // x = quality setings minStreamingMipLevel
+        // y = original mip count for texture
+        // z = desired on screen mip level
+        // w = 0
+
+        // Mip count has been reduced but the texelSize was not updated to take that into account
+        uint mipCount = GetMipCount(tex);
+        uint mipReductionLevel = originalTextureMipCount - mipCount;
+        uint mipReductionFactor = 1 << mipReductionLevel;
+        if (mipReductionFactor)
+        {
+            float oneOverMipReductionFactor = 1.0 / mipReductionFactor;
+            // texelSize.xy *= mipReductionRatio;   // Unused in GetDebugMipColor so lets not re-calculate it
+            texelSize.zw *= oneOverMipReductionFactor;
+        }
+    }
+    return GetDebugMipColor(originalColor, tex, texelSize, uv);
+}
+
+float3 GetDebugMipReductionColor(Texture2D tex, float4 mipInfo)
-    uint originalTextureMipCount = uint(mipInfo.y);
-    if (originalTextureMipCount != 0)
-    {
-        // mipInfo :
-        // x = quality setings minStreamingMipLevel
-        // y = original mip count for texture
-        // z = desired on screen mip level
-        // w = 0
-
-        // Mip count has been reduced but the texelSize was not updated to take that into account
-        uint mipCount = GetMipCount(tex);
-        uint mipReductionLevel = originalTextureMipCount - mipCount;
-
-        float mipCol = float(mipReductionLevel) / 12.0;
-        return float3(0, mipCol, 0);
-    }
-
-    // Can't calculate without original mip count - return magenta
-    return float3(1.0, 0.0, 1.0);
-}
-
-#ifdef DEBUG_DISPLAY
+    uint originalTextureMipCount = uint(mipInfo.y);
+    if (originalTextureMipCount != 0)
+    {
+        // mipInfo :
+        // x = quality setings minStreamingMipLevel
+        // y = original mip count for texture
+        // z = desired on screen mip level
+        // w = 0
+
+        // Mip count has been reduced but the texelSize was not updated to take that into account
+        uint mipCount = GetMipCount(tex);
+        uint mipReductionLevel = originalTextureMipCount - mipCount;
+
+        float mipCol = float(mipReductionLevel) / 12.0;
+        return float3(0, mipCol, 0);
+    }
+
+    // Can't calculate without original mip count - return magenta
+    return float3(1.0, 0.0, 1.0);
+}
+
+#ifdef DEBUG_DISPLAY
-    case DEBUGMIPMAPMODE_MIP_RATIO:
-        return GetDebugMipColorIncludingMipReduction(originalColor, tex, texelSize, uv, mipInfo);
-    case DEBUGMIPMAPMODE_MIP_COUNT:
-        return GetDebugMipCountColor(originalColor, tex);
-    case DEBUGMIPMAPMODE_MIP_COUNT_REDUCTION:
-        return GetDebugMipReductionColor(tex, mipInfo);
-    case DEBUGMIPMAPMODE_STREAMING_MIP_BUDGET:
-        return GetDebugStreamingMipColor(tex, mipInfo);
-    case DEBUGMIPMAPMODE_STREAMING_MIP:
-        return GetDebugStreamingMipColorBlended(originalColor, tex, mipInfo);
-    }
-
+    case DEBUGMIPMAPMODE_MIP_RATIO:
+        return GetDebugMipColorIncludingMipReduction(originalColor, tex, texelSize, uv, mipInfo);
+    case DEBUGMIPMAPMODE_MIP_COUNT:
+        return GetDebugMipCountColor(originalColor, tex);
+    case DEBUGMIPMAPMODE_MIP_COUNT_REDUCTION:
+        return GetDebugMipReductionColor(tex, mipInfo);
+    case DEBUGMIPMAPMODE_STREAMING_MIP_BUDGET:
+        return GetDebugStreamingMipColor(tex, mipInfo);
+    case DEBUGMIPMAPMODE_STREAMING_MIP:
+        return GetDebugStreamingMipColorBlended(originalColor, tex, mipInfo);
+    }
+
-}
+}
-
-#endif // UNITY_DEBUG_INCLUDED
+
+#endif // UNITY_DEBUG_INCLUDED

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Shadow/Shadow.hlsl

 }
 
 // shadow sampling prototypes
-real GetPunctualShadowAttenuation( ShadowContext shadowContext, real3 positionWS, real3 normalWS, int shadowDataIndex, real4 L );
-real GetPunctualShadowAttenuation( ShadowContext shadowContext, real3 positionWS, real3 normalWS, int shadowDataIndex, real4 L, real2 positionSS );
+real GetPunctualShadowAttenuation( ShadowContext shadowContext, real3 positionWS, real3 normalWS, int shadowDataIndex, real3 lightPositionWS, real3 L );
+real GetPunctualShadowAttenuation( ShadowContext shadowContext, real3 positionWS, real3 normalWS, int shadowDataIndex, real3 lightPositionWS, real3 L, real2 positionSS );
 
 // shadow sampling prototypes with screenspace info
 real GetDirectionalShadowAttenuation( ShadowContext shadowContext, real3 positionWS, real3 normalWS, int shadowDataIndex, real3 L );
 #include "ShadowAlgorithms.hlsl"		// engine default algorithms (don't modify)
 
 #ifndef SHADOW_DISPATCH_USE_CUSTOM_PUNCTUAL
-real GetPunctualShadowAttenuation( ShadowContext shadowContext, real3 positionWS, real3 normalWS, int shadowDataIndex, real4 L )
+real GetPunctualShadowAttenuation( ShadowContext shadowContext, real3 positionWS, real3 normalWS, int shadowDataIndex, real3 lightPositionWS, real3 L )
-    return EvalShadow_PunctualDepth(shadowContext, positionWS, normalWS, shadowDataIndex, L);
+    return EvalShadow_PunctualDepth(shadowContext, positionWS, normalWS, shadowDataIndex, lightPositionWS, L);
-real GetPunctualShadowAttenuation( ShadowContext shadowContext, real3 positionWS, real3 normalWS, int shadowDataIndex, real4 L, real2 positionSS )
+real GetPunctualShadowAttenuation( ShadowContext shadowContext, real3 positionWS, real3 normalWS, int shadowDataIndex, real3 lightPositionWS, real3 L, real2 positionSS )
-    return GetPunctualShadowAttenuation( shadowContext, positionWS, normalWS, shadowDataIndex, L );
+    return GetPunctualShadowAttenuation( shadowContext, positionWS, normalWS, shadowDataIndex, lightPositionWS, L );
 }
 #endif
 
 
 real GetDirectionalShadowAttenuation( ShadowContext shadowContext, real3 positionWS, real3 normalWS, int shadowDataIndex, real3 L, real2 positionSS )
 {
-    return GetDirectionalShadowAttenuation( shadowContext, positionWS, normalWS, shadowDataIndex, L );
+    return GetDirectionalShadowAttenuation( shadowContext, positionWS, normalWS, shadowDataIndex, lightPositionWS, L );
 }
 #endif
 

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Shadow/ShadowAlgorithms.hlsl

 //
 //	Point shadows
 //
-real EvalShadow_PointDepth( ShadowContext shadowContext, real3 positionWS, real3 normalWS, int index, real4 L )
+real EvalShadow_PointDepth( ShadowContext shadowContext, real3 positionWS, real3 normalWS, int index, real3 lightPositionWS, real3 L )
-	real3 biased_posWS = positionWS + EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L.xyz ) ), sd.texelSizeRcp.zw, sd.normalBias );
-	real3 lpos   = positionWS + L.xyz * L.w;
+	real3 biased_posWS = positionWS + EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );
+	real3 lpos    = lightPositionWS;
 	positionWS    = biased_posWS;
 	int faceIndex = EvalShadow_GetCubeFaceID( lpos - biased_posWS ) + 1;
 	// load the right shadow data for the current face
-	positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L.xyz ) ), sd.texelSizeRcp.zw, sd.normalBias );
+	positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );
 	// get shadowmap texcoords
 	real3 posTC = EvalShadow_GetTexcoords( sd, positionWS );
 	// get the algorithm
 }
 
 #define EvalShadow_PointDepth_( _samplerType )																																			\
-	real EvalShadow_PointDepth( ShadowContext shadowContext, uint shadowAlgorithm, Texture2DArray tex, _samplerType samp, real3 positionWS, real3 normalWS, int index, real4 L )	\
+	real EvalShadow_PointDepth( ShadowContext shadowContext, uint shadowAlgorithm, Texture2DArray tex, _samplerType samp, real3 positionWS, real3 normalWS, int index, real3 lightPositionWS, real3 L )	\
-		real3 biased_posWS = positionWS + EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L.xyz ) ), sd.texelSizeRcp.zw, sd.normalBias );                                    \
-		real3 lpos   = positionWS + L.xyz * L.w;                                                                                                                                       \
+		real3 biased_posWS = positionWS + EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );                                    \
+		real3 lpos    = lightPositionWS;                                                                                                                                       \
 		positionWS    = biased_posWS;                                                                                                                                                   \
 		int faceIndex = EvalShadow_GetCubeFaceID( lpos - biased_posWS ) + 1;                                                                                                            \
 		/* load the right shadow data for the current face */																															\
-		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L.xyz ) ), sd.texelSizeRcp.zw, sd.normalBias );															\
+		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );															\
 		/* get shadowmap texcoords */																																					\
 		real3 posTC = EvalShadow_GetTexcoords( sd, positionWS );																														\
 		/* sample the texture */																																						\
 //
 //	Punctual shadows for Point and Spot
 //
-real EvalShadow_PunctualDepth( ShadowContext shadowContext, real3 positionWS, real3 normalWS, int index, real4 L )
+real EvalShadow_PunctualDepth( ShadowContext shadowContext, real3 positionWS, real3 normalWS, int index, real3 lightPositionWS, real3 L )
 {
 	// load the right shadow data for the current face
 	int faceIndex = 0;
 	[branch]
 	if( shadowType == GPUSHADOWTYPE_POINT )
 	{
-		real3 biased_posWS = positionWS + EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L.xyz ) ), sd.texelSizeRcp.zw, sd.normalBias );
-		real3 lpos = positionWS + L.xyz * L.w;
-		positionWS  = biased_posWS;
-		faceIndex   = EvalShadow_GetCubeFaceID( lpos - biased_posWS ) + 1;
+		real3 biased_posWS = positionWS + EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );
+		real3 lpos = lightPositionWS;
+		positionWS = biased_posWS;
+		faceIndex  = EvalShadow_GetCubeFaceID( lpos - biased_posWS ) + 1;
-		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L.xyz ) ), sd.texelSizeRcp.zw, sd.normalBias );
+		positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );
 
 	sd = shadowContext.shadowDatas[index + faceIndex];
 	uint payloadOffset = GetPayloadOffset( sd );
 }
 
 #define EvalShadow_PunctualDepth_( _samplerType )																																		\
-	real EvalShadow_PunctualDepth( ShadowContext shadowContext, uint shadowAlgorithm, Texture2DArray tex, _samplerType samp, real3 positionWS, real3 normalWS, int index, real4 L )	\
+	real EvalShadow_PunctualDepth( ShadowContext shadowContext, uint shadowAlgorithm, Texture2DArray tex, _samplerType samp, real3 positionWS, real3 normalWS, int index, real3 lightPositionWS, real3 L )	\
 	{																																													\
 		/* load the right shadow data for the current face */																															\
 		int faceIndex = 0;																																								\
 		[branch]																																										\
 		if( shadowType == GPUSHADOWTYPE_POINT )																																			\
 		{																																												\
-			real3 biased_posWS = positionWS + EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L.xyz ) ), sd.texelSizeRcp.zw, sd.normalBias );                                \
-			real3 lpos = positionWS + L.xyz * L.w;                                                                                                                                     \
-			positionWS  = biased_posWS;                                                                                                                                                 \
-			faceIndex   = EvalShadow_GetCubeFaceID( lpos - biased_posWS ) + 1;																											\
+			real3 biased_posWS = positionWS + EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );                                \
+			real3 lpos = lightPositionWS;                                                                                                                                     \
+			positionWS = biased_posWS;                                                                                                                                                 \
+			faceIndex  = EvalShadow_GetCubeFaceID( lpos - biased_posWS ) + 1;																											\
-			positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L.xyz ) ), sd.texelSizeRcp.zw, sd.normalBias );														\
+			positionWS += EvalShadow_NormalBias( normalWS, saturate( dot( normalWS, L ) ), sd.texelSizeRcp.zw, sd.normalBias );														\
 																																														\
 		sd = shadowContext.shadowDatas[index + faceIndex];																													            \
 		uint payloadOffset = GetPayloadOffset( sd );																																	\
 	return closestWS.xyz / closestWS.w;
 }
 
-real3 EvalShadow_GetClosestSample_Cascade( ShadowContext shadowContext, real3 positionWS, real3 normalWS, int index, real4 L )
+real3 EvalShadow_GetClosestSample_Cascade( ShadowContext shadowContext, real3 positionWS, real3 normalWS, int index, real3 lightPositionWS, real3 L )
 {
 	// load the right shadow data for the current face
 	real4 dirShadowSplitSpheres[4];
 	return closestWS.xyz / closestWS.w;
 }
 
-real3 EvalShadow_GetClosestSample_Cascade( ShadowContext shadowContext, Texture2DArray tex, real3 positionWS, real3 normalWS, int index, real4 L )
+real3 EvalShadow_GetClosestSample_Cascade( ShadowContext shadowContext, Texture2DArray tex, real3 positionWS, real3 normalWS, int index, real3 lightPositionWS, real3 L )
 {
 	// load the right shadow data for the current face
 	real4 dirShadowSplitSpheres[4];

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCamera.cs

         public Vector4[] frustumPlaneEquations;
         public Camera camera;
         public uint taaFrameIndex;
+        public Vector2 taaFrameRotation;
         public Vector4 viewParam;
         public PostProcessRenderContext postprocessRenderContext;
 
 
             const uint taaFrameCount = 8;
             taaFrameIndex = taaEnabled ? (uint)Time.renderedFrameCount % taaFrameCount : 0;
+            taaFrameRotation = new Vector2(Mathf.Sin(taaFrameIndex * (0.5f * Mathf.PI)),
+                                           Mathf.Cos(taaFrameIndex * (0.5f * Mathf.PI)));
 
             viewMatrix = gpuView;
             projMatrix = gpuProj;
             cmd.SetGlobalMatrix(HDShaderIDs._PrevViewProjMatrix, prevViewProjMatrix);
             cmd.SetGlobalVectorArray(HDShaderIDs._FrustumPlanes, frustumPlaneEquations);
             cmd.SetGlobalInt(HDShaderIDs._TaaFrameIndex, (int)taaFrameIndex);
+            cmd.SetGlobalVector(HDShaderIDs._TaaFrameRotation, taaFrameRotation);
         }
 
         // TODO: We should set all the value below globally and not let it under the control of Unity,

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/MaterialDebug.cs

-using System.Collections.Generic;
-using UnityEngine;
-using System;
-
-namespace UnityEngine.Experimental.Rendering.HDPipeline
-{
-    namespace Attributes
-    {
-        // 0 is reserved!
-        [GenerateHLSL]
-        public enum DebugViewVarying
-        {
-            None = 0,
-            Texcoord0 = 1,
-            Texcoord1,
-            Texcoord2,
-            Texcoord3,
-            VertexTangentWS,
-            VertexBitangentWS,
-            VertexNormalWS,
-            VertexColor,
-            VertexColorAlpha,
-            Last,
-        };
-
-        // Number must be contiguous
-        [GenerateHLSL]
-        public enum DebugViewGbuffer
-        {
-            None = 0,
-            Depth = DebugViewVarying.Last,
-            BakeDiffuseLightingWithAlbedoPlusEmissive,
-            BakeShadowMask0,
-            BakeShadowMask1,
-            BakeShadowMask2,
-            BakeShadowMask3,
-            Last,
-        }
-
-        // Number must be contiguous
-        [GenerateHLSL]
-        public enum DebugViewProperties
-        {
-            None = 0,
-            Tessellation = DebugViewGbuffer.Last,
-            PixelDisplacement,
-            VertexDisplacement,
-            TessellationDisplacement,
-            DepthOffset,
-            Lightmap,
-            Last,
-        }
-    }
-
-    [Serializable]
-    public class MaterialDebugSettings
-    {
-        private static bool isDebugViewMaterialInit = false;
-
-        public static GUIContent[] debugViewMaterialStrings = null;
-        public static int[] debugViewMaterialValues = null;
-        public static GUIContent[] debugViewEngineStrings = null;
-        public static int[] debugViewEngineValues = null;
-        public static GUIContent[] debugViewMaterialVaryingStrings = null;
-        public static int[] debugViewMaterialVaryingValues = null;
-        public static GUIContent[] debugViewMaterialPropertiesStrings = null;
-        public static int[] debugViewMaterialPropertiesValues = null;
-        public static GUIContent[] debugViewMaterialTextureStrings = null;
+using System.Collections.Generic;
+using UnityEngine;
+using System;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    namespace Attributes
+    {
+        // 0 is reserved!
+        [GenerateHLSL]
+        public enum DebugViewVarying
+        {
+            None = 0,
+            Texcoord0 = 1,
+            Texcoord1,
+            Texcoord2,
+            Texcoord3,
+            VertexTangentWS,
+            VertexBitangentWS,
+            VertexNormalWS,
+            VertexColor,
+            VertexColorAlpha,
+            Last,
+        };
+
+        // Number must be contiguous
+        [GenerateHLSL]
+        public enum DebugViewGbuffer
+        {
+            None = 0,
+            Depth = DebugViewVarying.Last,
+            BakeDiffuseLightingWithAlbedoPlusEmissive,
+            BakeShadowMask0,
+            BakeShadowMask1,
+            BakeShadowMask2,
+            BakeShadowMask3,
+            Last,
+        }
+
+        // Number must be contiguous
+        [GenerateHLSL]
+        public enum DebugViewProperties
+        {
+            None = 0,
+            Tessellation = DebugViewGbuffer.Last,
+            PixelDisplacement,
+            VertexDisplacement,
+            TessellationDisplacement,
+            DepthOffset,
+            Lightmap,
+            Last,
+        }
+    }
+
+    [Serializable]
+    public class MaterialDebugSettings
+    {
+        private static bool isDebugViewMaterialInit = false;
+
+        public static GUIContent[] debugViewMaterialStrings = null;
+        public static int[] debugViewMaterialValues = null;
+        public static GUIContent[] debugViewEngineStrings = null;
+        public static int[] debugViewEngineValues = null;
+        public static GUIContent[] debugViewMaterialVaryingStrings = null;
+        public static int[] debugViewMaterialVaryingValues = null;
+        public static GUIContent[] debugViewMaterialPropertiesStrings = null;
+        public static int[] debugViewMaterialPropertiesValues = null;
+        public static GUIContent[] debugViewMaterialTextureStrings = null;
-        public static GUIContent[] debugViewMaterialGBufferStrings = null;
-        public static int[] debugViewMaterialGBufferValues = null;
-
-        public MaterialDebugSettings()
-        {
-            BuildDebugRepresentation();
-        }
-
-        // className include the additional "/"
-        void FillWithProperties(Type type, GUIContent[] debugViewMaterialStrings, int[] debugViewMaterialValues, string className, ref int index)
-        {
-            var attributes = type.GetCustomAttributes(true);
-            // Get attribute to get the start number of the value for the enum
-            var attr = attributes[0] as GenerateHLSL;
-
-            if (!attr.needParamDebug)
-            {
-                return;
-            }
-
-            var fields = type.GetFields();
-
-            var localIndex = 0;
-            foreach (var field in fields)
-            {
-                var fieldName = field.Name;
-
-                // Check if the display name have been override by the users
-                if (Attribute.IsDefined(field, typeof(SurfaceDataAttributes)))
-                {
-                    var propertyAttr = (SurfaceDataAttributes[])field.GetCustomAttributes(typeof(SurfaceDataAttributes), false);
-                    if (propertyAttr[0].displayName != "")
-                    {
-                        fieldName = propertyAttr[0].displayName;
-                    }
-                }
-
-                fieldName = className + fieldName;
-
-                debugViewMaterialStrings[index] = new GUIContent(fieldName);
-                debugViewMaterialValues[index] = attr.paramDefinesStart + (int)localIndex;
-                index++;
-                localIndex++;
-            }
-        }
-
-        void FillWithPropertiesEnum(Type type, GUIContent[] debugViewMaterialStrings, int[] debugViewMaterialValues, string prefix, ref int index)
-        {
-            var names = Enum.GetNames(type);
-
-            var localIndex = 0;
-            foreach (var value in Enum.GetValues(type))
-            {
-                var valueName = prefix + names[localIndex];
-
-                debugViewMaterialStrings[index] = new GUIContent(valueName);
-                debugViewMaterialValues[index] = (int)value;
-                index++;
-                localIndex++;
-            }
-        }
-
-        public class MaterialItem
-        {
-            public String className;
-            public Type surfaceDataType;
-            public Type bsdfDataType;
-        };
-
-        void BuildDebugRepresentation()
-        {
-            if (!isDebugViewMaterialInit)
-            {
-                List<RenderPipelineMaterial> materialList = HDUtils.GetRenderPipelineMaterialList();
-
-                // TODO: Share this code to retrieve deferred material with HDRenderPipeline
-                // Find first material that have non 0 Gbuffer count and assign it as deferredMaterial
-                Type bsdfDataDeferredType = null;
-                foreach (RenderPipelineMaterial material in materialList)
-                {
-                    if (material.GetMaterialGBufferCount() > 0)
-                    {
-                        bsdfDataDeferredType = material.GetType().GetNestedType("BSDFData");
-                    }
-                }
-
-                // TODO: Handle the case of no Gbuffer material
-                Debug.Assert(bsdfDataDeferredType != null);
-
-                List<MaterialItem> materialItems = new List<MaterialItem>();
-
-                int numSurfaceDataFields = 0;
-                int numBSDFDataFields = 0;
-                foreach (RenderPipelineMaterial material in materialList)
-                {
-                    MaterialItem item = new MaterialItem();
-
-                    item.className = material.GetType().Name + "/";
-
-                    item.surfaceDataType = material.GetType().GetNestedType("SurfaceData");
-                    numSurfaceDataFields += item.surfaceDataType.GetFields().Length;
-
-                    item.bsdfDataType = material.GetType().GetNestedType("BSDFData");
-                    numBSDFDataFields += item.bsdfDataType.GetFields().Length;
-
-                    materialItems.Add(item);
-                }
-
-                // Material properties debug
-                var num =   typeof(Builtin.BuiltinData).GetFields().Length * materialList.Count // BuildtinData are duplicated for each material
-                            + numSurfaceDataFields + 1; // +1 for None case
-
-                debugViewMaterialStrings = new GUIContent[num];
-                debugViewMaterialValues = new int[num];
-                // Special case for None since it cannot be inferred from SurfaceData/BuiltinData
-                debugViewMaterialStrings[0] = new GUIContent("None");
-                debugViewMaterialValues[0] = 0;
-                var index = 1;
-                // 0 is a reserved number and should not be used (allow to track error)
-                foreach (MaterialItem item in materialItems)
-                {
-                    // BuiltinData are duplicated for each material
-                    FillWithProperties(typeof(Builtin.BuiltinData), debugViewMaterialStrings, debugViewMaterialValues, item.className, ref index);
-                    FillWithProperties(item.surfaceDataType, debugViewMaterialStrings, debugViewMaterialValues, item.className, ref index);
-                }
-
-                // Engine properties debug
-                num = numBSDFDataFields + 1; // +1 for None case
-                debugViewEngineStrings = new GUIContent[num];
-                debugViewEngineValues = new int[num];
-                // 0 is a reserved number and should not be used (allow to track error)
-                debugViewEngineStrings[0] = new GUIContent("None");
-                debugViewEngineValues[0] = 0;
-                index = 1;
-                foreach (MaterialItem item in materialItems)
-                {
-                    FillWithProperties(item.bsdfDataType, debugViewEngineStrings, debugViewEngineValues, item.className, ref index);
-                }
-
-                // Attributes debug
-                var varyingNames = Enum.GetNames(typeof(Attributes.DebugViewVarying));
-                debugViewMaterialVaryingStrings = new GUIContent[varyingNames.Length];
-                debugViewMaterialVaryingValues = new int[varyingNames.Length];
-                index = 0;
-                FillWithPropertiesEnum(typeof(Attributes.DebugViewVarying), debugViewMaterialVaryingStrings, debugViewMaterialVaryingValues, "", ref index);
-
-                // Properties debug
-                var propertiesNames = Enum.GetNames(typeof(Attributes.DebugViewProperties));
-                debugViewMaterialPropertiesStrings = new GUIContent[propertiesNames.Length];
-                debugViewMaterialPropertiesValues = new int[propertiesNames.Length];
-                index = 0;
-                FillWithPropertiesEnum(typeof(Attributes.DebugViewProperties), debugViewMaterialPropertiesStrings, debugViewMaterialPropertiesValues, "", ref index);
-
-                // Gbuffer debug
-                var gbufferNames = Enum.GetNames(typeof(Attributes.DebugViewGbuffer));
-                debugViewMaterialGBufferStrings = new GUIContent[gbufferNames.Length + bsdfDataDeferredType.GetFields().Length];
-                debugViewMaterialGBufferValues = new int[gbufferNames.Length + bsdfDataDeferredType.GetFields().Length];
-                index = 0;
-                FillWithPropertiesEnum(typeof(Attributes.DebugViewGbuffer), debugViewMaterialGBufferStrings, debugViewMaterialGBufferValues, "", ref index);
-                FillWithProperties(typeof(Lit.BSDFData), debugViewMaterialGBufferStrings, debugViewMaterialGBufferValues, "", ref index);
-
-                isDebugViewMaterialInit = true;
-            }
-        }
-
-        public int debugViewMaterial { get { return m_DebugViewMaterial; } }
-        public int debugViewEngine { get { return m_DebugViewEngine; } }
-        public Attributes.DebugViewVarying debugViewVarying { get { return m_DebugViewVarying; } }
-        public Attributes.DebugViewProperties debugViewProperties { get { return m_DebugViewProperties; } }
-        public int debugViewGBuffer { get { return m_DebugViewGBuffer; } }
-
-        int                             m_DebugViewMaterial = 0; // No enum there because everything is generated from materials.
-        int                             m_DebugViewEngine = 0;  // No enum there because everything is generated from BSDFData
-        Attributes.DebugViewVarying     m_DebugViewVarying = Attributes.DebugViewVarying.None;
-        Attributes.DebugViewProperties  m_DebugViewProperties = Attributes.DebugViewProperties.None;
-        int                             m_DebugViewGBuffer = 0; // Can't use GBuffer enum here because the values are actually split between this enum and values from Lit.BSDFData
-
-        public int GetDebugMaterialIndex()
-        {
-            // This value is used in the shader for the actual debug display.
-            // There is only one uniform parameter for that so we just add all of them
-            // They are all mutually exclusive so return the sum will return the right index.
-            return m_DebugViewGBuffer + m_DebugViewMaterial + m_DebugViewEngine + (int)m_DebugViewVarying + (int)m_DebugViewProperties;
-        }
-
-        public void DisableMaterialDebug()
-        {
-            m_DebugViewMaterial = 0;
-            m_DebugViewEngine = 0;
-            m_DebugViewVarying = Attributes.DebugViewVarying.None;
-            m_DebugViewProperties = Attributes.DebugViewProperties.None;
-            m_DebugViewGBuffer = 0;
-        }
-
-        public void SetDebugViewMaterial(int value)
-        {
-            if (value != 0)
-                DisableMaterialDebug();
-            m_DebugViewMaterial = value;
-        }
-
-        public void SetDebugViewEngine(int value)
-        {
-            if (value != 0)
-                DisableMaterialDebug();
-            m_DebugViewEngine = value;
-        }
-
-        public void SetDebugViewVarying(Attributes.DebugViewVarying value)
-        {
-            if (value != 0)
-                DisableMaterialDebug();
-            m_DebugViewVarying = value;
-        }
-        public void SetDebugViewProperties(Attributes.DebugViewProperties value)
-        {
-            if (value != 0)
-                DisableMaterialDebug();
-            m_DebugViewProperties = value;
-        }
-
-        public void SetDebugViewGBuffer(int value)
-        {
-            if (value != 0)
-                DisableMaterialDebug();
-            m_DebugViewGBuffer = value;
-        }
-
-
-        public bool IsDebugGBufferEnabled()
-        {
-            return m_DebugViewGBuffer != 0;
-        }
-
-        public bool IsDebugDisplayEnabled()
-        {
-            return (m_DebugViewEngine != 0 || m_DebugViewMaterial != 0 || m_DebugViewVarying != Attributes.DebugViewVarying.None || m_DebugViewProperties != Attributes.DebugViewProperties.None || m_DebugViewGBuffer != 0);
-        }
-    }
-}
+        public static GUIContent[] debugViewMaterialGBufferStrings = null;
+        public static int[] debugViewMaterialGBufferValues = null;
+
+        public MaterialDebugSettings()
+        {
+            BuildDebugRepresentation();
+        }
+
+        // className include the additional "/"
+        void FillWithProperties(Type type, GUIContent[] debugViewMaterialStrings, int[] debugViewMaterialValues, string className, ref int index)
+        {
+            var attributes = type.GetCustomAttributes(true);
+            // Get attribute to get the start number of the value for the enum
+            var attr = attributes[0] as GenerateHLSL;
+
+            if (!attr.needParamDebug)
+            {
+                return;
+            }
+
+            var fields = type.GetFields();
+
+            var localIndex = 0;
+            foreach (var field in fields)
+            {
+                var fieldName = field.Name;
+
+                // Check if the display name have been override by the users
+                if (Attribute.IsDefined(field, typeof(SurfaceDataAttributes)))
+                {
+                    var propertyAttr = (SurfaceDataAttributes[])field.GetCustomAttributes(typeof(SurfaceDataAttributes), false);
+                    if (propertyAttr[0].displayName != "")
+                    {
+                        fieldName = propertyAttr[0].displayName;
+                    }
+                }
+
+                fieldName = className + fieldName;
+
+                debugViewMaterialStrings[index] = new GUIContent(fieldName);
+                debugViewMaterialValues[index] = attr.paramDefinesStart + (int)localIndex;
+                index++;
+                localIndex++;
+            }
+        }
+
+        void FillWithPropertiesEnum(Type type, GUIContent[] debugViewMaterialStrings, int[] debugViewMaterialValues, string prefix, ref int index)
+        {
+            var names = Enum.GetNames(type);
+
+            var localIndex = 0;
+            foreach (var value in Enum.GetValues(type))
+            {
+                var valueName = prefix + names[localIndex];
+
+                debugViewMaterialStrings[index] = new GUIContent(valueName);
+                debugViewMaterialValues[index] = (int)value;
+                index++;
+                localIndex++;
+            }
+        }
+
+        public class MaterialItem
+        {
+            public String className;
+            public Type surfaceDataType;
+            public Type bsdfDataType;
+        };
+
+        void BuildDebugRepresentation()
+        {
+            if (!isDebugViewMaterialInit)
+            {
+                List<RenderPipelineMaterial> materialList = HDUtils.GetRenderPipelineMaterialList();
+
+                // TODO: Share this code to retrieve deferred material with HDRenderPipeline
+                // Find first material that have non 0 Gbuffer count and assign it as deferredMaterial
+                Type bsdfDataDeferredType = null;
+                foreach (RenderPipelineMaterial material in materialList)
+                {
+                    if (material.GetMaterialGBufferCount() > 0)
+                    {
+                        bsdfDataDeferredType = material.GetType().GetNestedType("BSDFData");
+                    }
+                }
+
+                // TODO: Handle the case of no Gbuffer material
+                Debug.Assert(bsdfDataDeferredType != null);
+
+                List<MaterialItem> materialItems = new List<MaterialItem>();
+
+                int numSurfaceDataFields = 0;
+                int numBSDFDataFields = 0;
+                foreach (RenderPipelineMaterial material in materialList)
+                {
+                    MaterialItem item = new MaterialItem();
+
+                    item.className = material.GetType().Name + "/";
+
+                    item.surfaceDataType = material.GetType().GetNestedType("SurfaceData");
+                    numSurfaceDataFields += item.surfaceDataType.GetFields().Length;
+
+                    item.bsdfDataType = material.GetType().GetNestedType("BSDFData");
+                    numBSDFDataFields += item.bsdfDataType.GetFields().Length;
+
+                    materialItems.Add(item);
+                }
+
+                // Material properties debug
+                var num =   typeof(Builtin.BuiltinData).GetFields().Length * materialList.Count // BuildtinData are duplicated for each material
+                            + numSurfaceDataFields + 1; // +1 for None case
+
+                debugViewMaterialStrings = new GUIContent[num];
+                debugViewMaterialValues = new int[num];
+                // Special case for None since it cannot be inferred from SurfaceData/BuiltinData
+                debugViewMaterialStrings[0] = new GUIContent("None");
+                debugViewMaterialValues[0] = 0;
+                var index = 1;
+                // 0 is a reserved number and should not be used (allow to track error)
+                foreach (MaterialItem item in materialItems)
+                {
+                    // BuiltinData are duplicated for each material
+                    FillWithProperties(typeof(Builtin.BuiltinData), debugViewMaterialStrings, debugViewMaterialValues, item.className, ref index);
+                    FillWithProperties(item.surfaceDataType, debugViewMaterialStrings, debugViewMaterialValues, item.className, ref index);
+                }
+
+                // Engine properties debug
+                num = numBSDFDataFields + 1; // +1 for None case
+                debugViewEngineStrings = new GUIContent[num];
+                debugViewEngineValues = new int[num];
+                // 0 is a reserved number and should not be used (allow to track error)
+                debugViewEngineStrings[0] = new GUIContent("None");
+                debugViewEngineValues[0] = 0;
+                index = 1;
+                foreach (MaterialItem item in materialItems)
+                {
+                    FillWithProperties(item.bsdfDataType, debugViewEngineStrings, debugViewEngineValues, item.className, ref index);
+                }
+
+                // Attributes debug
+                var varyingNames = Enum.GetNames(typeof(Attributes.DebugViewVarying));
+                debugViewMaterialVaryingStrings = new GUIContent[varyingNames.Length];
+                debugViewMaterialVaryingValues = new int[varyingNames.Length];
+                index = 0;
+                FillWithPropertiesEnum(typeof(Attributes.DebugViewVarying), debugViewMaterialVaryingStrings, debugViewMaterialVaryingValues, "", ref index);
+
+                // Properties debug
+                var propertiesNames = Enum.GetNames(typeof(Attributes.DebugViewProperties));
+                debugViewMaterialPropertiesStrings = new GUIContent[propertiesNames.Length];
+                debugViewMaterialPropertiesValues = new int[propertiesNames.Length];
+                index = 0;
+                FillWithPropertiesEnum(typeof(Attributes.DebugViewProperties), debugViewMaterialPropertiesStrings, debugViewMaterialPropertiesValues, "", ref index);
+
+                // Gbuffer debug
+                var gbufferNames = Enum.GetNames(typeof(Attributes.DebugViewGbuffer));
+                debugViewMaterialGBufferStrings = new GUIContent[gbufferNames.Length + bsdfDataDeferredType.GetFields().Length];
+                debugViewMaterialGBufferValues = new int[gbufferNames.Length + bsdfDataDeferredType.GetFields().Length];
+                index = 0;
+                FillWithPropertiesEnum(typeof(Attributes.DebugViewGbuffer), debugViewMaterialGBufferStrings, debugViewMaterialGBufferValues, "", ref index);
+                FillWithProperties(typeof(Lit.BSDFData), debugViewMaterialGBufferStrings, debugViewMaterialGBufferValues, "", ref index);
+
+                isDebugViewMaterialInit = true;
+            }
+        }
+
+        public int debugViewMaterial { get { return m_DebugViewMaterial; } }
+        public int debugViewEngine { get { return m_DebugViewEngine; } }
+        public Attributes.DebugViewVarying debugViewVarying { get { return m_DebugViewVarying; } }
+        public Attributes.DebugViewProperties debugViewProperties { get { return m_DebugViewProperties; } }
+        public int debugViewGBuffer { get { return m_DebugViewGBuffer; } }
+
+        int                             m_DebugViewMaterial = 0; // No enum there because everything is generated from materials.
+        int                             m_DebugViewEngine = 0;  // No enum there because everything is generated from BSDFData
+        Attributes.DebugViewVarying     m_DebugViewVarying = Attributes.DebugViewVarying.None;
+        Attributes.DebugViewProperties  m_DebugViewProperties = Attributes.DebugViewProperties.None;
+        int                             m_DebugViewGBuffer = 0; // Can't use GBuffer enum here because the values are actually split between this enum and values from Lit.BSDFData
+
+        public int GetDebugMaterialIndex()
+        {
+            // This value is used in the shader for the actual debug display.
+            // There is only one uniform parameter for that so we just add all of them
+            // They are all mutually exclusive so return the sum will return the right index.
+            return m_DebugViewGBuffer + m_DebugViewMaterial + m_DebugViewEngine + (int)m_DebugViewVarying + (int)m_DebugViewProperties;
+        }
+
+        public void DisableMaterialDebug()
+        {
+            m_DebugViewMaterial = 0;
+            m_DebugViewEngine = 0;
+            m_DebugViewVarying = Attributes.DebugViewVarying.None;
+            m_DebugViewProperties = Attributes.DebugViewProperties.None;
+            m_DebugViewGBuffer = 0;
+        }
+
+        public void SetDebugViewMaterial(int value)
+        {
+            if (value != 0)
+                DisableMaterialDebug();
+            m_DebugViewMaterial = value;
+        }
+
+        public void SetDebugViewEngine(int value)
+        {
+            if (value != 0)
+                DisableMaterialDebug();
+            m_DebugViewEngine = value;
+        }
+
+        public void SetDebugViewVarying(Attributes.DebugViewVarying value)
+        {
+            if (value != 0)
+                DisableMaterialDebug();
+            m_DebugViewVarying = value;
+        }
+        public void SetDebugViewProperties(Attributes.DebugViewProperties value)
+        {
+            if (value != 0)
+                DisableMaterialDebug();
+            m_DebugViewProperties = value;
+        }
+
+        public void SetDebugViewGBuffer(int value)
+        {
+            if (value != 0)
+                DisableMaterialDebug();
+            m_DebugViewGBuffer = value;
+        }
+
+
+        public bool IsDebugGBufferEnabled()
+        {
+            return m_DebugViewGBuffer != 0;
+        }
+
+        public bool IsDebugDisplayEnabled()
+        {
+            return (m_DebugViewEngine != 0 || m_DebugViewMaterial != 0 || m_DebugViewVarying != Attributes.DebugViewVarying.None || m_DebugViewProperties != Attributes.DebugViewProperties.None || m_DebugViewGBuffer != 0);
+        }
+    }
+}

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;
+            }
+
-            EditorGUI.indentLevel--;
+
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField(StylesBaseUnlit.advancedText, EditorStyles.boldLabel);
+            // NB RenderQueue editor is not shown on purpose: we want to override it based on blend mode
+            EditorGUI.indentLevel++;
+            EditorGUI.indentLevel--;
 
             if (layerChanged || optionsChanged)
             {

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

             public static readonly string[] tessellationModeNames = Enum.GetNames(typeof(TessellationMode));
 
             public static GUIContent tessellationText = new GUIContent("Tessellation options", "Tessellation options");
-            public static GUIContent tessellationFactorText = new GUIContent("Tessellation factor", "This value is the tessellation factor use for tessellation, higher mean more tessellated");
+            public static GUIContent tessellationFactorText = new GUIContent("Tessellation factor", "This value is the tessellation factor use for tessellation, higher mean more tessellated. Above 15 is costly. Maximum tessellation factor is 15 on XBone / PS4");
             public static GUIContent tessellationFactorMinDistanceText = new GUIContent("Start fade distance", "Distance (in unity unit) at which the tessellation start to fade out. Must be inferior at Max distance");
             public static GUIContent tessellationFactorMaxDistanceText = new GUIContent("End fade distance", "Maximum distance (in unity unit) to the camera where triangle are tessellated");
             public static GUIContent tessellationFactorTriangleSizeText = new GUIContent("Triangle size", "Desired screen space sized of triangle (in pixel). Smaller value mean smaller triangle.");

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)
+            EditorGUI.indentLevel++;
             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)
-            EditorGUI.indentLevel++;
+
+            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/HDStringConstants.cs

         public static readonly int _ScreenSize = Shader.PropertyToID("_ScreenSize");
         public static readonly int _PrevViewProjMatrix = Shader.PropertyToID("_PrevViewProjMatrix");
         public static readonly int _FrustumPlanes = Shader.PropertyToID("_FrustumPlanes");
-        public static readonly int _TaaFrameIndex = Shader.PropertyToID("_TaaFrameIndex");
+        public static readonly int _TaaFrameIndex    = Shader.PropertyToID("_TaaFrameIndex");
+        public static readonly int _TaaFrameRotation = Shader.PropertyToID("_TaaFrameRotation");
 
         public static readonly int _DepthTexture                   = Shader.PropertyToID("_DepthTexture");
         public static readonly int _CameraColorTexture             = Shader.PropertyToID("_CameraColorTexture");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Deferred.shader

             // Include
             //-------------------------------------------------------------------------------------
 
+            #include "../ShaderPass/ShaderPass.cs.hlsl"
+            #define SHADERPASS SHADERPASS_DEFERRED_LIGHTING
+
             #include "CoreRP/ShaderLibrary/Common.hlsl"
             #include "../Debug/DebugDisplay.hlsl"
 
 
                 BSDFData bsdfData;
                 BakeLightingData bakeLightingData;
-                DECODE_FROM_GBUFFER(posInput.positionSS, MATERIAL_FEATURE_MASK_FLAGS, bsdfData, bakeLightingData.bakeDiffuseLighting);
+                DECODE_FROM_GBUFFER(posInput.positionSS, UINT_MAX, bsdfData, bakeLightingData.bakeDiffuseLighting);
                 #ifdef SHADOWS_SHADOWMASK
                 DecodeShadowMask(LOAD_TEXTURE2D(_ShadowMaskTexture, posInput.positionSS), bakeLightingData.bakeShadowMask);
                 #endif
                 Outputs outputs;
 
             #ifdef OUTPUT_SPLIT_LIGHTING
-                if ((_EnableSubsurfaceScattering != 0) && HaveSubsurfaceScattering(bsdfData))
+                if (_EnableSubsurfaceScattering != 0 && PixelHasSubsurfaceScattering(bsdfData))
                 {
                     outputs.specularLighting = float4(specularLighting, 1.0);
                     outputs.diffuseLighting  = TagLightingForSSS(diffuseLighting);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/HDAdditionalLightData.cs

         [SerializeField]
         float m_Version = 1.0f;
  #pragma warning restore 414
-            
+
-        [FormerlySerializedAs("m_innerSpotPercent")]
         public float m_InnerSpotPercent = 0.0f; // To display this field in the UI this need to be public
 
         public float GetInnerSpotPercent01()
         public bool affectDiffuse = true;
         public bool affectSpecular = true;
 
-        [FormerlySerializedAs("archetype")]
         public LightTypeExtent lightTypeExtent = LightTypeExtent.Punctual;
 
         // Only for Spotlight, should be hide for other light
-        [FormerlySerializedAs("lightWidth")]
-        [FormerlySerializedAs("lightHeight")]
         public float shapeHeight = 0.5f;
 
         // Only for pyramid projector

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightEvaluation.hlsl

 //-----------------------------------------------------------------------------
 
 float3 EvaluateCookie_Directional(LightLoopContext lightLoopContext, DirectionalLightData lightData,
-                                  float3 positionWS)
+                                  float3 lightToSample)
-    float3   lightToSample = positionWS - lightData.positionWS;
     float3x3 lightToWorld  = float3x3(lightData.right, lightData.up, lightData.forward);
     float3   positionLS    = mul(lightToSample, transpose(lightToWorld));
 
     float  shadowMask = 1.0;
 
     color       = lightData.color;
-    attenuation = 1.0;
+    attenuation = 1.0; // Note: no volumetric attenuation along shadow rays for directional lights
+
+    [branch] if (lightData.cookieIndex >= 0)
+    {
+        float3 lightToSample = positionWS - lightData.positionWS;
+        float3 cookie = EvaluateCookie_Directional(lightLoopContext, lightData, lightToSample);
+
+        color *= cookie;
+    }
 
 #ifdef SHADOWS_SHADOWMASK
     // shadowMaskSelector.x is -1 if there is no shadow mask
 #endif
     }
 
-    // Note: no volumetric attenuation along shadow rays for directional lights.
-
-    [branch] if (lightData.cookieIndex >= 0)
-    {
-        float3 cookie = EvaluateCookie_Directional(lightLoopContext, lightData, positionWS);
-
-        color *= cookie;
-    }
 }
 
 //-----------------------------------------------------------------------------
 float4 EvaluateCookie_Punctual(LightLoopContext lightLoopContext, LightData lightData,
-                               float3 positionWS)
+                               float3 lightToSample)
-    float3   lightToSample = positionWS - lightData.positionWS;
-    float3x3 lightToWorld  = float3x3(lightData.right, lightData.up, lightData.forward);
-    float3   positionLS    = mul(lightToSample, transpose(lightToWorld));
+    float3x3 lightToWorld = float3x3(lightData.right, lightData.up, lightData.forward);
+    float3   positionLS   = mul(lightToSample, transpose(lightToWorld));
 
     float4 cookie;
 
     return cookie;
 }
 
-float GetPunctualShapeAttenuation(LightData lightData, float3 L, float distSq)
-{
-    // Note: lightData.invSqrAttenuationRadius is 0 when applyRangeAttenuation is false
-    float attenuation = GetDistanceAttenuation(distSq, lightData.invSqrAttenuationRadius);
-    // Reminder: lights are oriented backward (-Z)
-    return attenuation * GetAngleAttenuation(L, -lightData.forward, lightData.angleScale, lightData.angleOffset);
-}
-
+// distances = {d, d^2, 1/d, d_proj}, where d_proj = dot(lightToSample, lightData.forward).
-                            float3 N, float3 L, float dist, float distSq,
+                            float3 N, float3 L, float3 lightToSample, float4 distances,
                             out float3 color, out float attenuation)
 {
     float3 positionWS = posInput.positionWS;
     color       = lightData.color;
-    attenuation = GetPunctualShapeAttenuation(lightData, L, distSq);
+    attenuation = SmoothPunctualLightAttenuation(distances, lightData.invSqrAttenuationRadius,
+                                                 lightData.angleScale, lightData.angleOffset);
+
+#if (SHADEROPTIONS_VOLUMETRIC_LIGHTING_PRESET != 0)
+    float distVol = (lightData.lightType == GPULIGHTTYPE_PROJECTOR_BOX) ? distances.w : distances.x;
+    attenuation *= TransmittanceHomogeneousMedium(_GlobalFog_Extinction, distVol);
+#endif
+
+    // Projector lights always have cookies, so we can perform clipping inside the if().
+    [branch] if (lightData.cookieIndex >= 0)
+    {
+        float4 cookie = EvaluateCookie_Punctual(lightLoopContext, lightData, lightToSample);
+
+        color       *= cookie.rgb;
+        attenuation *= cookie.a;
+    }
 
 #ifdef SHADOWS_SHADOWMASK
     // shadowMaskSelector.x is -1 if there is no shadow mask
     {
         // TODO: make projector lights cast shadows.
         float3 offset = float3(0.0, 0.0, 0.0); // GetShadowPosOffset(nDotL, normal);
-        float4 L_dist = float4(L, dist);
-        shadow = GetPunctualShadowAttenuation(lightLoopContext.shadowContext, positionWS + offset, N, lightData.shadowIndex, L_dist, posInput.positionSS);
+        shadow = GetPunctualShadowAttenuation(lightLoopContext.shadowContext, positionWS + offset, N, lightData.shadowIndex, lightData.positionWS, L, posInput.positionSS);
 #ifdef SHADOWS_SHADOWMASK
         // Note: Legacy Unity have two shadow mask mode. ShadowMask (ShadowMask contain static objects shadow and ShadowMap contain only dynamic objects shadow, final result is the minimun of both value)
         // and ShadowMask_Distance (ShadowMask contain static objects shadow and ShadowMap contain everything and is blend with ShadowMask based on distance (Global distance setup in QualitySettigns)).
 #endif
     }
 
-#if (SHADEROPTIONS_VOLUMETRIC_LIGHTING_PRESET != 0)
-    [flatten] if (lightData.lightType == GPULIGHTTYPE_PROJECTOR_BOX)
-    {
-        float3 lightToSample = positionWS - lightData.positionWS;
-        dist = dot(-lightToSample, L);
-    }
-    shadow *= TransmittanceHomogeneousMedium(_GlobalFog_Extinction, dist);
-#endif
-
-    // Projector lights always have cookies, so we can perform clipping inside the if().
-    [branch] if (lightData.cookieIndex >= 0)
-    {
-        float4 cookie = EvaluateCookie_Punctual(lightLoopContext, lightData, positionWS);
-
-        color       *= cookie.rgb;
-        attenuation *= cookie.a;
-    }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/Deferred.compute

 // Include
 //-------------------------------------------------------------------------------------
 
+#include "../../ShaderPass/ShaderPass.cs.hlsl"
+#define SHADERPASS SHADERPASS_DEFERRED_LIGHTING
+
 #include "CoreRP/ShaderLibrary/Common.hlsl"
 #include "../../Debug/DebugDisplay.hlsl"
 
 
 StructuredBuffer<uint> g_TileList;
 // Indirect
-[numthreads(16, 16, 1)]
+[numthreads(TILE_SIZE_FPTL, TILE_SIZE_FPTL, 1)]
-    uint tileIndex = g_TileList[g_TileListOffset + groupId];
-    uint2 tileCoord = uint2(tileIndex & 0xFFFF, tileIndex >> 16);
-    uint2 pixelCoord = tileCoord * GetTileSize() + groupThreadId;
+    uint  tileIndex   = g_TileList[g_TileListOffset + groupId];
+    uint2 tileCoord   = uint2(tileIndex & ((1 << TILE_SIZE_FPTL) - 1), tileIndex >> TILE_SIZE_FPTL);
+    uint2 pixelCoord  = tileCoord * GetTileSize() + groupThreadId;
-    uint featureFlags = TileVariantToFeatureFlags(VARIANT);
+    uint screenWidth  = (uint)_ScreenSize.x;
+    uint numTilesX    = (screenWidth + (TILE_SIZE_FPTL) - 1) / TILE_SIZE_FPTL;
+    uint featureFlags = TileVariantToFeatureFlags(VARIANT, tileCoord.x + tileCoord.y * numTilesX);
-[numthreads(16, 16, 1)]
+[numthreads(TILE_SIZE_FPTL, TILE_SIZE_FPTL, 1)]
-    uint2 tileCoord = (16 * groupId) / GetTileSize();
-    uint2 pixelCoord = dispatchThreadId;
-	uint featureFlags = LIGHT_FEATURE_MASK_FLAGS_OPAQUE | MATERIAL_FEATURE_MASK_FLAGS;
+    uint2 tileCoord    = (TILE_SIZE_FPTL * groupId) / GetTileSize();
+    uint2 pixelCoord   = dispatchThreadId;
+	uint  featureFlags = UINT_MAX;
 
 #endif
 
     float3 specularLighting;
     LightLoop(V, posInput, preLightData, bsdfData, bakeLightingData, featureFlags, diffuseLighting, specularLighting);
 
-    if ((_EnableSubsurfaceScattering != 0) && HaveSubsurfaceScattering(bsdfData))
+    if (_EnableSubsurfaceScattering != 0 && PixelHasSubsurfaceScattering(bsdfData))
     {
         specularLightingUAV[pixelCoord] = float4(specularLighting, 1.0);
         diffuseLightingUAV[pixelCoord]  = TagLightingForSSS(diffuseLighting);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightLoop.cs

 
             lightData.positionWS = light.light.transform.position;
             // Setting 0 for invSqrAttenuationRadius mean we have no range attenuation, but still have inverse square attenuation.
-            lightData.invSqrAttenuationRadius = additionalLightData.applyRangeAttenuation ? 1.0f / (light.range * light.range) : 0.0f;
+            bool applyRangeAttenuation = additionalLightData.applyRangeAttenuation && (gpuLightType != GPULightType.ProjectorBox);
+            lightData.invSqrAttenuationRadius = applyRangeAttenuation ? 1.0f / (light.range * light.range) : 0.0f;
             lightData.color = GetLightColor(light);
 
             lightData.forward = light.light.transform.forward; // Note: Light direction is oriented backward (-Z)
 
                         if (enableFeatureVariants)
                         {
+                            cmd.SetComputeBufferParam(deferredComputeShader, kernel, HDShaderIDs.g_TileFeatureFlags, s_TileFeatureFlags);
                             cmd.SetComputeIntParam(deferredComputeShader, HDShaderIDs.g_TileListOffset, variant * numTiles);
                             cmd.SetComputeBufferParam(deferredComputeShader, kernel, HDShaderIDs.g_TileList, s_TileList);
                             cmd.DispatchCompute(deferredComputeShader, kernel, s_DispatchIndirectBuffer, (uint)variant * 3 * sizeof(uint));

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightLoopDef.hlsl

 StructuredBuffer<float> g_logBaseBuffer;            // don't support Buffer yet in unity
 //#endif
 
+#ifdef USE_INDIRECT
+    StructuredBuffer<uint> g_TileFeatureFlags;
+#endif
+
 StructuredBuffer<DirectionalLightData> _DirectionalLightDatas;
 StructuredBuffer<LightData>            _LightDatas;
 StructuredBuffer<EnvLightData>         _EnvLightDatas;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/Shadow.hlsl

 
 // example of overriding punctual lights
 #ifdef  SHADOW_DISPATCH_USE_CUSTOM_PUNCTUAL
-float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L )
+float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 lightPositionWS, float3 L)
 {
 #ifdef SHADOW_DISPATCH_USE_SEPARATE_PUNC_ALGOS
 	// example for choosing different algos for point and spot lights
 		Texture2DArray			tex      = shadowContext.tex2DArray[SHADOW_DISPATCH_POINT_TEX];
 		SamplerComparisonState	compSamp = shadowContext.compSamplers[SHADOW_DISPATCH_POINT_SMP];
 		uint					algo     = SHADOW_DISPATCH_POINT_ALG;
-		return EvalShadow_PointDepth( shadowContext, algo, tex, compSamp, positionWS, normalWS, shadowDataIndex, L );
+		return EvalShadow_PointDepth( shadowContext, algo, tex, compSamp, positionWS, normalWS, shadowDataIndex, lightPositionWS, L );
 	}
 	else
 	{
-		return EvalShadow_SpotDepth( shadowContext, algo, tex, compSamp, positionWS, normalWS, shadowDataIndex, L );
+		return EvalShadow_SpotDepth( shadowContext, algo, tex, compSamp, positionWS, normalWS, shadowDataIndex, lightPositionWS, L );
 	}
 #else
 	// example for choosing the same algo
-	return EvalShadow_PunctualDepth( shadowContext, algo, tex, compSamp, positionWS, normalWS, shadowDataIndex, L );
+	return EvalShadow_PunctualDepth( shadowContext, algo, tex, compSamp, positionWS, normalWS, shadowDataIndex, lightPositionWS, L );
-float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L, float2 positionSS )
+float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 lightPositionWS, float3 L, float2 positionSS )
-	return GetPunctualShadowAttenuation( shadowContext, positionWS, normalWS, shadowDataIndex, L );
+	return GetPunctualShadowAttenuation( shadowContext, positionWS, normalWS, shadowDataIndex, lightPositionWS, L );
 }
 #endif
 

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
 
                         posInput.positionWS = GetPointAtDistance(ray, t);
 
                         float3 lightToSample = posInput.positionWS - light.positionWS;
-                        float  dist          = sqrt(distSq);
-                        float3 L             = -lightToSample * rsqrt(distSq);
+                        float  distRcp       = rsqrt(distSq);
+                        float  dist          = distSq * distRcp;
+                        float  distProj      = dot(lightToSample, light.forward);
+                        float4 distances     = float4(dist, distSq, distRcp, distProj);
+                        float3 L             = -lightToSample * distRcp;
-                        EvaluateLight_Punctual(context, posInput, light, unused, 0, L, dist, distSq,
-                                               color, attenuation);
+                        EvaluateLight_Punctual(context, posInput, light, unused, 0, L, lightToSample,
+                                               distances, color, attenuation);
 
                         float intensity = attenuation * rcpPdf;
 
                         float t = tEntr + tOffset;
                         posInput.positionWS = GetPointAtDistance(ray, t);
 
-                        float3 L = -light.forward;
+                        float3 L             = -light.forward;
+                        float3 lightToSample = posInput.positionWS - light.positionWS;
+                        float  distProj      = dot(lightToSample, light.forward);
+                        float4 distances     = float4(1, 1, 1, distProj);
-                        EvaluateLight_Punctual(context, posInput, light, unused, 0, L, 1, 1,
-                                               color, attenuation);
+                        EvaluateLight_Punctual(context, posInput, light, unused, 0, L, lightToSample,
+                                               distances, color, attenuation);
 
                         // Note: the 'weight' accounts for transmittance from 'tEntr' to 't'.
                         float intensity = attenuation * weight;

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/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
 
         // Tessellation specific
         [Enum(None, 0, Phong, 1)] _TessellationMode("Tessellation mode", Float) = 0
-        _TessellationFactor("Tessellation Factor", Range(0.0, 15.0)) = 4.0
+        _TessellationFactor("Tessellation Factor", Range(0.0, 64.0)) = 4.0
         _TessellationFactorMinDistance("Tessellation start fading distance", Float) = 20.0
         _TessellationFactorMaxDistance("Tessellation end fading distance", Float) = 50.0
         _TessellationFactorTriangleSize("Tessellation triangle size", Float) = 100.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.hlsl

     return NUM_FEATURE_VARIANTS - 1;
 }
 
-// This function need to return a compile time value, else there is no optimization
-uint TileVariantToFeatureFlags(uint variant)
+#ifdef USE_INDIRECT
+
+uint TileVariantToFeatureFlags(uint variant, uint tileIndex)
-    return kFeatureVariantFlags[variant];
+    if (variant == NUM_FEATURE_VARIANTS - 1)
+    {
+        // We don't have any compile-time feature information.
+        // Therefore, we load the feature classification data at runtime to avoid
+        // entering every single branch based on feature flags.
+        return g_TileFeatureFlags[tileIndex];
+    }
+    else
+    {
+        // Return the compile-time feature flags.
+        return kFeatureVariantFlags[variant];
+    }
+#endif // USE_INDIRECT
+
 //-----------------------------------------------------------------------------
 // Helper functions/variable specific to this material
 //-----------------------------------------------------------------------------
 
 // This method allows us to know at compile time what material features should be removed from the code by Tile (Indepenently of the value of material feature flag per pixel).
 // This is only useful for classification during lighting, so it's not needed in EncodeIntoGBuffer and ConvertSurfaceDataToBSDFData (where we always know exactly what the material feature is)
-bool HasMaterialFeatureFlag(uint featureFlags, uint flag)
+bool HasFeatureFlag(uint featureFlags, uint flag)
 {
     return ((featureFlags & flag) != 0);
 }
 
     bsdfData.thickness = _ThicknessRemaps[diffusionProfile].x + _ThicknessRemaps[diffusionProfile].y * thickness;
     uint transmissionMode = BitFieldExtract(asuint(_TransmissionFlags), 2u * diffusionProfile, 2u);
-    bsdfData.useThickObjectMode = transmissionMode != TRANSMISSION_MODE_THIN;
 
 #if SHADEROPTIONS_USE_DISNEY_SSS
     bsdfData.transmittance = ComputeTransmittanceDisney(    _ShapeParams[diffusionProfile].rgb,
                                                             _TransmissionTintsAndFresnel0[diffusionProfile].rgb,
                                                             bsdfData.thickness);
 #endif
+
+    // Apply the transmission mode. Only the thick object mode performs the thickness displacement.
+    bsdfData.useThickObjectMode = transmissionMode != TRANSMISSION_MODE_THIN;
+
+    if (bsdfData.useThickObjectMode)
+    {
+        // Compute the thickness in world units along the normal.
+        float thicknessInMeters = bsdfData.thickness * METERS_PER_MILLIMETER;
+        float thicknessInUnits  = thicknessInMeters * _WorldScales[bsdfData.diffusionProfile].y;
+
+        bsdfData.thickness = thicknessInUnits;
+    }
+    else
+    {
+        // Apply no displacement.
+        bsdfData.thickness = 0;
+    }
+
 }
 
 // Assume bsdfData.normalWS is init
     bsdfData.materialFeatures       = surfaceData.materialFeatures | MATERIALFEATUREFLAGS_LIT_STANDARD; // Not really needed but for consistency with deferred path
 
     // Standard material
-    bsdfData.specularOcclusion      = surfaceData.specularOcclusion;
-    bsdfData.normalWS               = surfaceData.normalWS;
-    bsdfData.perceptualRoughness    = PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness);
+    bsdfData.specularOcclusion   = surfaceData.specularOcclusion;
+    bsdfData.normalWS            = surfaceData.normalWS;
+    bsdfData.perceptualRoughness = PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness);
-    float metallic = HasMaterialFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR | MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING | MATERIALFEATUREFLAGS_LIT_TRANSMISSION | MATERIALFEATUREFLAGS_LIT_IRIDESCENCE) ?
-                        0.0 : surfaceData.metallic;
+    float metallic = HasFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR | MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING | MATERIALFEATUREFLAGS_LIT_TRANSMISSION) ? 0.0 : surfaceData.metallic;
-    bsdfData.diffuseColor           = ComputeDiffuseColor(surfaceData.baseColor, metallic);
-    bsdfData.fresnel0               = HasMaterialFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR) ? surfaceData.specularColor : ComputeFresnel0(surfaceData.baseColor, surfaceData.metallic, DEFAULT_SPECULAR_VALUE);
+    bsdfData.diffuseColor = ComputeDiffuseColor(surfaceData.baseColor, metallic);
+    bsdfData.fresnel0     = HasFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR) ? surfaceData.specularColor : ComputeFresnel0(surfaceData.baseColor, surfaceData.metallic, DEFAULT_SPECULAR_VALUE);
-    bsdfData.diffusionProfile       = surfaceData.diffusionProfile;
+    bsdfData.diffusionProfile = surfaceData.diffusionProfile;
     // Note: we have ZERO_INITIALIZE the struct so bsdfData.anisotropy == 0.0
 
     // In forward everything is statically know and we could theorically cumulate all the material features. So the code reflect it.
-    if (HasMaterialFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING))
+    if (HasFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING))
-    if (HasMaterialFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
+    if (HasFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
-    if (HasMaterialFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_ANISOTROPY))
+    if (HasFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_ANISOTROPY))
-    if (HasMaterialFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_IRIDESCENCE))
+    if (HasFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_IRIDESCENCE))
-    if (HasMaterialFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
+    if (HasFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
     {
         // Modify fresnel0 and perceptualRoughness
         FillMaterialClearCoatData(surfaceData.coatMask, bsdfData);
     // The priority of feature is handled in the code here and reflect in the UI (see LitUI.cs)
 
     // Process SSS and Transmission together as they encode almost the same data, negligible cost
-    if (HasMaterialFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING | MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
+    if (HasFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING | MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
     {
         metallic15 = GBUFFER_LIT_SSS_OR_TRANSMISSION;
         // Special case: For SSS we will store the profile id and the subsurface radius at the location of the specular occlusion (in alpha channel of GBuffer0)
-        outGBuffer2.rgb = float3(surfaceData.specularOcclusion, surfaceData.thickness, HasMaterialFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING) ? 1.0 : 0.0); // thickness for Transmission
+        outGBuffer2.rgb = float3(surfaceData.specularOcclusion, surfaceData.thickness, HasFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING) ? 1.0 : 0.0); // thickness for Transmission
-        if (HasMaterialFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR))
+        if (HasFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR))
-        else if (HasMaterialFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_ANISOTROPY))
+        else if (HasFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_ANISOTROPY))
-        else if (HasMaterialFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_IRIDESCENCE))
+        else if (HasFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_IRIDESCENCE))
         {
             metallic15 = GBUFFER_LIT_IRIDESCENCE;
             outGBuffer2.rgb = float3(0.0, surfaceData.thicknessIrid, 0.0);
     }
 
     // Encode coatMask (4bit) / mettalic (4bit)
-    outGBuffer2.a = PackFloatInt8bit(HasMaterialFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT) ? surfaceData.coatMask : 0.0, metallic15, 16.0);
+    outGBuffer2.a = PackFloatInt8bit(HasFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT) ? surfaceData.coatMask : 0.0, metallic15, 16.0);
-void DecodeFromGBuffer(uint2 positionSS, uint featureFlags, out BSDFData bsdfData, out float3 bakeDiffuseLighting, out uint outMaterialFeatures)
+// Fills the BSDFData. Also returns the (per-pixel) material feature flags inferred
+// from the contents of the G-buffer, which can be used by the feature classification system.
+// 'tileFeatureFlags' are compile-time flags provided by the feature classification system.
+// If you're not using the feature classification system, pass 0.
+uint DecodeFromGBuffer(uint2 positionSS, uint tileFeatureFlags, out BSDFData bsdfData, out float3 bakeDiffuseLighting)
+    ZERO_INITIALIZE(BSDFData, bsdfData);
+
+    // Isolate material features.
+    tileFeatureFlags &= MATERIAL_FEATURE_MASK_FLAGS;
+
+    bsdfData.materialFeatures = tileFeatureFlags; // Only tile-uniform feature evaluation
+
-    ZERO_INITIALIZE(BSDFData, bsdfData);
-
-    // If any of the flags of featureFlags is not set, it mean we know statically that
-    // the material feature is not used, so the compiler can optimize related code.
-    // Else we don't know if the material feature will be use, it is a dynamic condition.
-    bool enableSpecularColor =  (metallic15 == GBUFFER_LIT_SPECULAR_COLOR); // This is always a dynamic test as it is very cheap
-
-    outMaterialFeatures = MATERIALFEATUREFLAGS_LIT_STANDARD; // It is mandatory to identity ourselve as standard shader, else we are consider as sky/background element
-    outMaterialFeatures |= (metallic15 == GBUFFER_LIT_SSS_OR_TRANSMISSION && inGBuffer2.g > 0.0) ? featureFlags & MATERIALFEATUREFLAGS_LIT_TRANSMISSION : 0;                  // Thickness > 0
-    outMaterialFeatures |= (metallic15 == GBUFFER_LIT_SSS_OR_TRANSMISSION && inGBuffer2.b > 0.0) ? featureFlags & MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING : 0;         // TagSSS > 0
-    outMaterialFeatures |= (metallic15 <= GBUFFER_LIT_ANISOTROPIC_UPPER_BOUND && abs(inGBuffer2.b - 0.5) > 0.01) ? featureFlags & MATERIALFEATUREFLAGS_LIT_ANISOTROPY : 0;   // Anisotropy != 0 (small tolerrance as 0.5 can be correctly encoded)
-    outMaterialFeatures |= (metallic15 == GBUFFER_LIT_IRIDESCENCE) ? featureFlags & MATERIALFEATUREFLAGS_LIT_IRIDESCENCE : 0;
-    outMaterialFeatures |= coatMask > 0.0 ? featureFlags & MATERIALFEATUREFLAGS_LIT_CLEAR_COAT : 0;
+    uint pixelFeatureFlags     = MATERIALFEATUREFLAGS_LIT_STANDARD; // Only sky/background do not have the Standard material flag
+    bool pixelHasSpecularColor = (metallic15 == GBUFFER_LIT_SPECULAR_COLOR); // This is always a dynamic test as it is very cheap
+    bool pixelHasTransmission  = (metallic15 == GBUFFER_LIT_SSS_OR_TRANSMISSION && inGBuffer2.g > 0); // Thickness > 0
+    bool pixelHasSubsurface    = (metallic15 == GBUFFER_LIT_SSS_OR_TRANSMISSION && inGBuffer2.b > 0); // TagSSS > 0
+    bool pixelHasAnisotropy    = (metallic15 <= GBUFFER_LIT_ANISOTROPIC_UPPER_BOUND && (inGBuffer2.b - 0.5) >= 1.0/255.0); // Anisotropy > 0
+    bool pixelHasIridescence   = (metallic15 == GBUFFER_LIT_IRIDESCENCE);
+    bool pixelHasClearCoat     = (coatMask > 0);
-    // Save for material classification
-    bsdfData.materialFeatures = outMaterialFeatures;
+    // Disable pixel features disabled by the tile.
+    pixelFeatureFlags |= tileFeatureFlags & (pixelHasSpecularColor ? MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR        : 0);
+    pixelFeatureFlags |= tileFeatureFlags & (pixelHasTransmission  ? MATERIALFEATUREFLAGS_LIT_TRANSMISSION          : 0);
+    pixelFeatureFlags |= tileFeatureFlags & (pixelHasSubsurface    ? MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING : 0);
+    pixelFeatureFlags |= tileFeatureFlags & (pixelHasAnisotropy    ? MATERIALFEATUREFLAGS_LIT_ANISOTROPY            : 0);
+    pixelFeatureFlags |= tileFeatureFlags & (pixelHasIridescence   ? MATERIALFEATUREFLAGS_LIT_IRIDESCENCE           : 0);
+    pixelFeatureFlags |= tileFeatureFlags & (pixelHasClearCoat     ? MATERIALFEATUREFLAGS_LIT_CLEAR_COAT            : 0);
 
     // Start decompressing GBuffer
     float3 baseColor = inGBuffer0.rgb;
 
     bsdfData.normalWS = UnpackNormalOctEncode(float2(inGBuffer1.r, inGBuffer1.g));
 
-    // metallic15 is range [0..12] if mettallic data is needed
-    float metallic = (metallic15 <= GBUFFER_LIT_ANISOTROPIC_UPPER_BOUND) ? metallic15 * (1.0 / GBUFFER_LIT_ANISOTROPIC_UPPER_BOUND) : 0.0;
+    // metallic15 is range [0..12] if metallic data is needed
+    bool pixelHasNoMetallic = HasFeatureFlag(pixelFeatureFlags, MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR | MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING | MATERIALFEATUREFLAGS_LIT_TRANSMISSION);
+    float metallic = pixelHasNoMetallic ? 0 : metallic15 * (1.0 / GBUFFER_LIT_ANISOTROPIC_UPPER_BOUND);
-    bsdfData.fresnel0 = enableSpecularColor ? Gamma20ToLinear(inGBuffer2.rgb) : ComputeFresnel0(baseColor, metallic, DEFAULT_SPECULAR_VALUE);
+    bsdfData.fresnel0 = HasFeatureFlag(pixelFeatureFlags, MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR) ? Gamma20ToLinear(inGBuffer2.rgb) : ComputeFresnel0(baseColor, metallic, DEFAULT_SPECULAR_VALUE);
-    // Note: we have ZERO_INITIALIZE the struct, so bsdfData.diffusionProfile == DIFFUSION_PROFILE_NEUTRAL_ID, bsdfData.anisotropy == 0.0, bsdfData.SubsurfaceMask == 0.0 etc...
+    // Note: we have ZERO_INITIALIZE the struct, so bsdfData.diffusionProfile == DIFFUSION_PROFILE_NEUTRAL_ID, bsdfData.anisotropy == 0, bsdfData.subsurfaceMask == 0 etc...
-    if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING | MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
+    if (HasFeatureFlag(pixelFeatureFlags, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING | MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
     {
         // First we must extract the diffusion profile
 
 
         bsdfData.diffusionProfile = sssData.diffusionProfile;
 
-        if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING))
+        // The neutral value of subsurfaceMask is 0 (handled by ZERO_INITIALIZE).
+        if (HasFeatureFlag(pixelFeatureFlags, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING))
-        if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
+        // The neutral value of thickness and transmittance is 0 (handled by ZERO_INITIALIZE).
+        if (HasFeatureFlag(pixelFeatureFlags, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
         {
             FillMaterialTransmission(inGBuffer2.g, bsdfData);
         }
     // Note that it mean that when we have the worse case, we always use Anisotropy and shader like deferred.shader are always the worst case (but only used for debugging)
-    if (HasMaterialFeatureFlag(featureFlags, MATERIALFEATUREFLAGS_LIT_ANISOTROPY))
+    if (HasFeatureFlag(tileFeatureFlags, MATERIALFEATUREFLAGS_LIT_ANISOTROPY))
-        if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_ANISOTROPY))
+        if (HasFeatureFlag(pixelFeatureFlags, MATERIALFEATUREFLAGS_LIT_ANISOTROPY))
         {
             anisotropy = inGBuffer2.b * 2.0 - 1.0;
             tangentWS  = UnpackNormalOctEncode(inGBuffer2.rg * 2.0 - 1.0);
         }
 
         FillMaterialAnisotropy(anisotropy, tangentWS, bsdfData);
-
-        // Force the compiler to use the anisotropy path all the time
-        bsdfData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_ANISOTROPY;
-    if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_IRIDESCENCE))
+    if (HasFeatureFlag(pixelFeatureFlags, MATERIALFEATUREFLAGS_LIT_IRIDESCENCE))
-    if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
+    // The neutral value of coatMask is 0 (handled by ZERO_INITIALIZE).
+    if (HasFeatureFlag(pixelFeatureFlags, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
     {
         // Modify fresnel0 and perceptualRoughness
         FillMaterialClearCoatData(coatMask, bsdfData);
     ConvertAnisotropyToClampRoughness(bsdfData.perceptualRoughness, bsdfData.anisotropy, bsdfData.roughnessT, bsdfData.roughnessB);
 
     bakeDiffuseLighting = inGBuffer3.rgb;
-}
-void DecodeFromGBuffer(uint2 positionSS, uint featureFlags, out BSDFData bsdfData, out float3 bakeDiffuseLighting)
-{
-    uint unsused;
-    DecodeFromGBuffer(positionSS, featureFlags, bsdfData, bakeDiffuseLighting, unsused);
+    return pixelFeatureFlags;
 }
 
 // Function call from the material classification compute shader
     float3 unused;
     // Call the regular function, compiler will optimized out everything not used.
     // Note that all material feature flag bellow are in the same GBuffer (inGBuffer2) and thus material classification only sample one Gbuffer
-    uint materialFeatures;
-    DecodeFromGBuffer(positionSS, MATERIAL_FEATURE_MASK_FLAGS, bsdfData, unused, materialFeatures);
-
-    return materialFeatures;
+    return DecodeFromGBuffer(positionSS, UINT_MAX, bsdfData, unused);
-
 
 //-----------------------------------------------------------------------------
 // Debug method (use to display values)
     preLightData.clampNdotV = NdotV; // Caution: The handling of edge cases where N is directed away from the screen is handled during Gbuffer/forward pass, so here do nothing
     preLightData.iblPerceptualRoughness = bsdfData.perceptualRoughness;
 
-    if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
+    if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
     {
         preLightData.coatPartLambdaV = GetSmithJointGGXPartLambdaV(NdotV, CLEAR_COAT_ROUGHNESS);
         preLightData.coatIblR = reflect(-V, N);
 
     // We avoid divergent evaluation of the GGX, as that nearly doubles the cost.
     // If the tile has anisotropy, all the pixels within the tile are evaluated as anisotropic.
-    if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_ANISOTROPY))
+    if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_ANISOTROPY))
     {
         float TdotV = dot(bsdfData.tangentWS,   V);
         float BdotV = dot(bsdfData.bitangentWS, V);
     // to match the reference for rough metals, but further darkens dielectrics.
     preLightData.ltcMagnitudeFresnel = bsdfData.fresnel0 * ltcGGXFresnelMagnitudeDiff + (float3)ltcGGXFresnelMagnitude;
 
-    if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
+    if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
     {
         float2 uv = LTC_LUT_OFFSET + LTC_LUT_SCALE * float2(CLEAR_COAT_PERCEPTUAL_ROUGHNESS, theta * INV_HALF_PI);
 
 // This function require the 3 structure surfaceData, builtinData, bsdfData because it may require both the engine side data, and data that will not be store inside the gbuffer.
 float3 GetBakedDiffuseLigthing(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData, PreLightData preLightData)
 {
-    if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING))
+    if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING))
     {
         bsdfData.diffuseColor = ApplySubsurfaceScatteringTexturingMode(bsdfData.diffuseColor, bsdfData.diffusionProfile);
     }
 // Subsurface Scattering functions
 //-----------------------------------------------------------------------------
 
-bool HaveSubsurfaceScattering(BSDFData bsdfData)
+bool PixelHasSubsurfaceScattering(BSDFData bsdfData)
-    return HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING);
+    return bsdfData.subsurfaceMask != 0 && HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING);
 }
 
 //-----------------------------------------------------------------------------
 // BSDF share between directional light, punctual light and area light (reference)
 //-----------------------------------------------------------------------------
 
-// This function apply BSDF
-void BSDF(  float3 V, float3 L, float3 positionWS, PreLightData preLightData, BSDFData bsdfData,
+// This function apply BSDF. Assumes that NdotL is positive.
+void BSDF(  float3 V, float3 L, float NdotL, float3 positionWS, PreLightData preLightData, BSDFData bsdfData,
             out float3 diffuseLighting,
             out float3 specularLighting)
 {
     // Optimized math. Ref: PBR Diffuse Lighting for GGX + Smith Microsurfaces (slide 114).
-    float NdotL = saturate(dot(N, L)); // Must have the same value without the clamp
 
     float LdotV = dot(L, V);
     float invLenLV = rsqrt(max(2.0 * LdotV + 2.0, FLT_EPS));  // invLenLV = rcp(length(L + V)) - caution about the case where V and L are opposite, it can happen, use max to avoid this
     float3 F = F_Schlick(bsdfData.fresnel0, LdotH);
     float DV;
 
-    if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_ANISOTROPY))
+    if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_ANISOTROPY))
     {
         float3 H = (L + V) * invLenLV;
         // For anisotropy we must not saturate these values
     // We don't multiply by 'bsdfData.diffuseColor' here. It's done only once in PostEvaluateBSDF().
     diffuseLighting = diffuseTerm;
 
-    if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
+    if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
     {
         // Apply isotropic GGX for clear coat
         // Note: coat F is scalar as it is a dieletric
         // Note: The modification of the base roughness and fresnel0 by the clear coat is already handled in FillMaterialClearCoatData
 
         // Very coarse attempt at doing energy conservation for the diffuse layer based on NdotL. No science.
-        diffuseLighting *= F_Schlick(CLEAR_COAT_F0, NdotL);
+        diffuseLighting *= lerp(1, F_Schlick(CLEAR_COAT_F0, NdotL), bsdfData.coatMask);
     }
 }
 
 // OR transmitted (back) lighting, never both at the same time. For transmitted lighting,
 // we need to push the shading position back to avoid self-shadowing problems.
+// Note: 'bsdfData.thickness' is in world units, and already accounts for the transmission mode.
-    float displacement = 0;
-
-    [flatten] if (bsdfData.useThickObjectMode && NdotL < 0)
-    {
-        // Compute the thickness in world units along the normal.
-        float thicknessInMeters = bsdfData.thickness * METERS_PER_MILLIMETER;
-        float thicknessInUnits  = thicknessInMeters * _WorldScales[bsdfData.diffusionProfile].y;
-
-        // Compute the thickness in world units along the light vector.
-        displacement = thicknessInUnits / -NdotL;
-    }
+    // Compute the thickness in world units along the light vector.
+    // We need a max(x, 0) here, but the saturate() is free,
+    // and we don't expect the total displacement of over 1 meter.
+    float displacement = saturate(bsdfData.thickness / -NdotL);
 
     return displacement * L;
 }
 float3 EvaluateTransmission(BSDFData bsdfData, float NdotL, float NdotV, float attenuation)
 {
     float wrappedNdotL = ComputeWrappedDiffuseLighting(-NdotL, SSS_WRAP_LIGHT);
-    float negatedNdotL = saturate(-NdotL);
+    float negatedNdotL = -NdotL;
 
     // Apply wrapped lighting to better handle thin objects (cards) at grazing angles.
     float backNdotL = bsdfData.useThickObjectMode ? negatedNdotL : wrappedNdotL;
 #ifdef LIT_DIFFUSE_LAMBERT_BRDF
     attenuation *= Lambert();
 #else
-    attenuation *= INV_PI * F_Transm_Schlick(0, 0.5, NdotV) * F_Transm_Schlick(0, 0.5, backNdotL);
+    attenuation *= INV_PI * F_Transm_Schlick(0, 0.5, NdotV) * F_Transm_Schlick(0, 0.5, abs(backNdotL));
-    float intensity = attenuation * backNdotL;
+    float intensity = max(0, attenuation * backNdotL); // Warning: attenuation can be greater than 1
 
     return intensity * bsdfData.transmittance;
 }
     float3 L     = -lightData.forward; // Lights point backward in Unity
     float  NdotL = dot(N, L); // Note: Ideally this N here should be vertex normal - use for transmisison
 
-    // Compute displacement for fake thickObject transmission
-    posInput.positionWS += ComputeThicknessDisplacement(bsdfData, L, NdotL);
+    if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
+    {
+        // Compute displacement for fake thickObject transmission
+        posInput.positionWS += ComputeThicknessDisplacement(bsdfData, L, NdotL);
+    }
-    float intensity = attenuation * saturate(NdotL);
+    float intensity = max(0, attenuation * NdotL); // Warning: attenuation can be greater than 1
-        BSDF(V, L, posInput.positionWS, preLightData, bsdfData, lighting.diffuse, lighting.specular);
+        BSDF(V, L, NdotL, posInput.positionWS, preLightData, bsdfData, lighting.diffuse, lighting.specular);
-    [branch] if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
+    [branch] if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
     {
         // We use diffuse lighting for accumulation since it is going to be blurred during the SSS pass.
         lighting.diffuse += EvaluateTransmission(bsdfData, NdotL, preLightData.clampNdotV, attenuation * lightData.diffuseScale);
     float3 lightToSample = posInput.positionWS - lightData.positionWS;
     int    lightType     = lightData.lightType;
 
-    float3 unL     = (lightType != GPULIGHTTYPE_PROJECTOR_BOX) ? -lightToSample : -lightData.forward;
-    float  distSq  = dot(unL, unL);
-    float  distRcp = rsqrt(distSq);
-    float  dist    = distSq * distRcp;
-    float3 N       = bsdfData.normalWS;
-    float3 L       = unL * distRcp;
-    float  NdotL   = dot(N, L);
+    float3 L;
+    float4 distances; // {d, d^2, 1/d, d_proj}
+    distances.w = dot(lightToSample, lightData.forward);
-    // Compute displacement for fake thickObject transmission
-    posInput.positionWS += ComputeThicknessDisplacement(bsdfData, L, NdotL);
+    if (lightType == GPULIGHTTYPE_PROJECTOR_BOX)
+    {
+        L = -lightData.forward;
+        distances.xyz = 1; // No distance or angle attenuation
+    }
+    else
+    {
+        float3 unL     = -lightToSample;
+        float  distSq  = dot(unL, unL);
+        float  distRcp = rsqrt(distSq);
+        float  dist    = distSq * distRcp;
+
+        L = unL * distRcp;
+        distances.xyz = float3(dist, distSq, distRcp);
+    }
+
+    float3 N     = bsdfData.normalWS;
+    float  NdotL = dot(N, L);
+
+    if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
+    {
+        // Compute displacement for fake thickObject transmission
+        // Warning: distances computed above are NOT modified!
+        // This is not correct, of course, but is done for performance reasons.
+        posInput.positionWS += ComputeThicknessDisplacement(bsdfData, L, NdotL);
+    }
-    EvaluateLight_Punctual(lightLoopContext, posInput, lightData, bakeLightingData, N, L, dist, distSq, color, attenuation);
+    EvaluateLight_Punctual(lightLoopContext, posInput, lightData, bakeLightingData, N, L,
+                           lightToSample, distances, color, attenuation);
-    float intensity = attenuation * saturate(NdotL);
+    float intensity = max(0, attenuation * NdotL); // Warning: attenuation can be greater than 1
 
     // Note: We use NdotL here to early out, but in case of clear coat this is not correct. But we are ok with this
     [branch] if (intensity > 0.0)
         bsdfData.roughnessT = max(bsdfData.roughnessT, lightData.minRoughness);
         bsdfData.roughnessB = max(bsdfData.roughnessB, lightData.minRoughness);
 
-        BSDF(V, L, posInput.positionWS, preLightData, bsdfData, lighting.diffuse, lighting.specular);
+        BSDF(V, L, NdotL, posInput.positionWS, preLightData, bsdfData, lighting.diffuse, lighting.specular);
-    [branch] if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
+    [branch] if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
     {
         // We use diffuse lighting for accumulation since it is going to be blurred during the SSS pass.
         lighting.diffuse += EvaluateTransmission(bsdfData, NdotL, preLightData.clampNdotV, attenuation * lightData.diffuseScale);
     float invAspectRatio = radius / (radius + (0.5 * len));
 
     // Compute the light attenuation.
-    float intensity = GetEllipsoidalDistanceAttenuation(unL,  lightData.invSqrAttenuationRadius,
-                                                        axis, invAspectRatio);
+    float intensity = EllipsoidalDistanceAttenuation(unL, lightData.invSqrAttenuationRadius,
+                                                     axis, invAspectRatio);
 
     // Terminate if the shaded point is too far away.
     if (intensity == 0.0)
     // We don't multiply by 'bsdfData.diffuseColor' here. It's done only once in PostEvaluateBSDF().
     lighting.diffuse = preLightData.ltcMagnitudeDiffuse * ltcValue;
 
-    [branch] if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
+    [branch] if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
     {
         // Flip the view vector and the normal. The bitangent stays the same.
         float3x3 flipMatrix = float3x3(-1,  0,  0,
     lighting.specular = preLightData.ltcMagnitudeFresnel * ltcValue;
 
     // Evaluate the coat part
-    if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
+    if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
     {
         lighting.diffuse *= (1.0 - preLightData.ltcMagnitudeCoatFresnel);
         lighting.specular *= (1.0 - preLightData.ltcMagnitudeCoatFresnel);
 #ifdef ELLIPSOIDAL_ATTENUATION
     // The attenuation volume is an axis-aligned ellipsoid s.t.
     // r1 = (r + w / 2), r2 = (r + h / 2), r3 = r.
-    float intensity = GetEllipsoidalDistanceAttenuation(unL, invHalfDim);
+    float intensity = EllipsoidalDistanceAttenuation(unL, invHalfDim);
-    float intensity = GetBoxDistanceAttenuation(unL, invHalfDim);
+    float intensity = BoxDistanceAttenuation(unL, invHalfDim);
 #endif
 
     // Terminate if the shaded point is too far away.
     // We don't multiply by 'bsdfData.diffuseColor' here. It's done only once in PostEvaluateBSDF().
     lighting.diffuse = preLightData.ltcMagnitudeDiffuse * ltcValue;
 
-    [branch] if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
+    [branch] if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
     {
         // Flip the view vector and the normal. The bitangent stays the same.
         float3x3 flipMatrix = float3x3(-1,  0,  0,
     lighting.specular += preLightData.ltcMagnitudeFresnel * ltcValue;
 
     // Evaluate the coat part
-    if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
+    if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
     {
         lighting.diffuse *= (1.0 - preLightData.ltcMagnitudeCoatFresnel);
         lighting.specular *= (1.0 - preLightData.ltcMagnitudeCoatFresnel);
         R = (positionWS + projectionDistance * R) - lightData.positionWS;
 
         // Test again for clear coat
-        if (GPUImageBasedLightingType == GPUIMAGEBASEDLIGHTINGTYPE_REFLECTION && HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
+        if (GPUImageBasedLightingType == GPUIMAGEBASEDLIGHTINGTYPE_REFLECTION && HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
         {
             dirLS = mul(coatR, worldToLocal);
             projectionDistance = IntersectRaySphereSimple(positionLS, dirLS, sphereOuterDistance);
         // TODO: add distance based roughness
 
         // Test again for clear coat
-        if (GPUImageBasedLightingType == GPUIMAGEBASEDLIGHTINGTYPE_REFLECTION && HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
+        if (GPUImageBasedLightingType == GPUIMAGEBASEDLIGHTINGTYPE_REFLECTION && HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
         {
             dirLS = mul(coatR, worldToLocal);
             projectionDistance = IntersectRayAABBSimple(positionLS, dirLS, -boxOuterDistance, boxOuterDistance);
         envLighting = F * preLD.rgb;
 
         // Evaluate the Clear Coat component if needed
-        if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
+        if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
         {
             // No correction needed for coatR as it is smooth
             // Note: coat F is scalar as it is a dieletric
 #endif
 
     float3 modifiedDiffuseColor;
-    if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING))
+    if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING))
         modifiedDiffuseColor = ApplySubsurfaceScatteringTexturingMode(bsdfData.diffuseColor, bsdfData.diffusionProfile);
     else
         modifiedDiffuseColor = bsdfData.diffuseColor;

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

-// ===========================================================================
-//                              WARNING:
-// On PS4, texture/sampler declarations need to be outside of CBuffers
-// Otherwise those parameters are not bound correctly at runtime.
-// ===========================================================================
-
-TEXTURE2D(_DistortionVectorMap);
-SAMPLER(sampler_DistortionVectorMap);
-
-TEXTURE2D(_EmissiveColorMap);
-SAMPLER(sampler_EmissiveColorMap);
-
-#ifndef LAYERED_LIT_SHADER
-
-TEXTURE2D(_DiffuseLightingMap);
-SAMPLER(sampler_DiffuseLightingMap);
-
-TEXTURE2D(_BaseColorMap);
-SAMPLER(sampler_BaseColorMap);
-
-TEXTURE2D(_MaskMap);
-SAMPLER(sampler_MaskMap);
-TEXTURE2D(_BentNormalMap); // Reuse sampler from normal map
-SAMPLER(sampler_BentNormalMap);
-
-TEXTURE2D(_NormalMap);
-SAMPLER(sampler_NormalMap);
-TEXTURE2D(_NormalMapOS);
-SAMPLER(sampler_NormalMapOS);
-
-TEXTURE2D(_DetailMap);
-SAMPLER(sampler_DetailMap);
-
-TEXTURE2D(_HeightMap);
-SAMPLER(sampler_HeightMap);
-
-TEXTURE2D(_TangentMap);
-SAMPLER(sampler_TangentMap);
-TEXTURE2D(_TangentMapOS);
-SAMPLER(sampler_TangentMapOS);
-
-TEXTURE2D(_AnisotropyMap);
-SAMPLER(sampler_AnisotropyMap);
-
-TEXTURE2D(_SubsurfaceMaskMap);
-SAMPLER(sampler_SubsurfaceMaskMap);
-TEXTURE2D(_ThicknessMap);
-SAMPLER(sampler_ThicknessMap);
-
-TEXTURE2D(_SpecularColorMap);
-SAMPLER(sampler_SpecularColorMap);
-
-TEXTURE2D(_TransmittanceColorMap);
-SAMPLER(sampler_TransmittanceColorMap);
-
-#else
-
-// Set of users variables
-#define PROP_DECL(type, name) type name##0, name##1, name##2, name##3
-// sampler are share by texture type inside a layered material but we need to support that a particualr layer have no texture, so we take the first sampler of available texture as the share one
-// mean we must declare all sampler
-#define PROP_DECL_TEX2D(name)\
-    TEXTURE2D(MERGE_NAME(name, 0)); \
-    SAMPLER(MERGE_NAME(MERGE_NAME(sampler, name), 0)); \
-    TEXTURE2D(MERGE_NAME(name, 1)); \
-    SAMPLER(MERGE_NAME(MERGE_NAME(sampler, name), 1)); \
-    TEXTURE2D(MERGE_NAME(name, 2)); \
-    SAMPLER(MERGE_NAME(MERGE_NAME(sampler, name), 2)); \
-    TEXTURE2D(MERGE_NAME(name, 3)); \
-    SAMPLER(MERGE_NAME(MERGE_NAME(sampler, name), 3))
-
-
-PROP_DECL_TEX2D(_BaseColorMap);
-PROP_DECL_TEX2D(_MaskMap);
-PROP_DECL_TEX2D(_BentNormalMap);
-PROP_DECL_TEX2D(_NormalMap);
-PROP_DECL_TEX2D(_NormalMapOS);
-PROP_DECL_TEX2D(_DetailMap);
-PROP_DECL_TEX2D(_HeightMap);
-
-PROP_DECL_TEX2D(_SubsurfaceMaskMap);
-PROP_DECL_TEX2D(_ThicknessMap);
-
-TEXTURE2D(_LayerMaskMap);
-SAMPLER(sampler_LayerMaskMap);
-TEXTURE2D(_LayerInfluenceMaskMap);
-SAMPLER(sampler_LayerInfluenceMaskMap);
-
-#endif
-
-CBUFFER_START(UnityPerMaterial)
-
-// shared constant between lit and layered lit
-float _AlphaCutoff;
-float _AlphaCutoffPrepass;
-float _AlphaCutoffPostpass;
-float4 _DoubleSidedConstants;
-float _DistortionScale;
-float _DistortionVectorScale;
-float _DistortionVectorBias;
-float _DistortionBlurScale;
-float _DistortionBlurRemapMin;
-float _DistortionBlurRemapMax;
-
-float _PPDMaxSamples;
-float _PPDMinSamples;
-float _PPDLodThreshold;
-
-float3 _EmissiveColor;
-float _EmissiveIntensity;
-float _AlbedoAffectEmissive;
-
-float _EnableSpecularOcclusion;
-
-// Transparency
-float3 _TransmittanceColor;
-float _IOR;
-float _ATDistance;
-float _ThicknessMultiplier;
-
-// 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
-float3 _EmissionColor;
-float4 _EmissiveColorMap_ST;
-
-float4 _InvPrimScale; // Only XY are used
-
-// Wind
-float _InitialBend;
-float _Stiffness;
-float _Drag;
-float _ShiverDrag;
-float _ShiverDirectionality;
-
-#ifndef LAYERED_LIT_SHADER
-
-// Set of users variables
-float4 _BaseColor;
-float4 _BaseColorMap_ST;
-float4 _BaseColorMap_TexelSize;
+// ===========================================================================
+//                              WARNING:
+// On PS4, texture/sampler declarations need to be outside of CBuffers
+// Otherwise those parameters are not bound correctly at runtime.
+// ===========================================================================
+
+TEXTURE2D(_DistortionVectorMap);
+SAMPLER(sampler_DistortionVectorMap);
+
+TEXTURE2D(_EmissiveColorMap);
+SAMPLER(sampler_EmissiveColorMap);
+
+#ifndef LAYERED_LIT_SHADER
+
+TEXTURE2D(_DiffuseLightingMap);
+SAMPLER(sampler_DiffuseLightingMap);
+
+TEXTURE2D(_BaseColorMap);
+SAMPLER(sampler_BaseColorMap);
+
+TEXTURE2D(_MaskMap);
+SAMPLER(sampler_MaskMap);
+TEXTURE2D(_BentNormalMap); // Reuse sampler from normal map
+SAMPLER(sampler_BentNormalMap);
+
+TEXTURE2D(_NormalMap);
+SAMPLER(sampler_NormalMap);
+TEXTURE2D(_NormalMapOS);
+SAMPLER(sampler_NormalMapOS);
+
+TEXTURE2D(_DetailMap);
+SAMPLER(sampler_DetailMap);
+
+TEXTURE2D(_HeightMap);
+SAMPLER(sampler_HeightMap);
+
+TEXTURE2D(_TangentMap);
+SAMPLER(sampler_TangentMap);
+TEXTURE2D(_TangentMapOS);
+SAMPLER(sampler_TangentMapOS);
+
+TEXTURE2D(_AnisotropyMap);
+SAMPLER(sampler_AnisotropyMap);
+
+TEXTURE2D(_SubsurfaceMaskMap);
+SAMPLER(sampler_SubsurfaceMaskMap);
+TEXTURE2D(_ThicknessMap);
+SAMPLER(sampler_ThicknessMap);
+
+TEXTURE2D(_SpecularColorMap);
+SAMPLER(sampler_SpecularColorMap);
+
+TEXTURE2D(_TransmittanceColorMap);
+SAMPLER(sampler_TransmittanceColorMap);
+
+#else
+
+// Set of users variables
+#define PROP_DECL(type, name) type name##0, name##1, name##2, name##3
+// sampler are share by texture type inside a layered material but we need to support that a particualr layer have no texture, so we take the first sampler of available texture as the share one
+// mean we must declare all sampler
+#define PROP_DECL_TEX2D(name)\
+    TEXTURE2D(MERGE_NAME(name, 0)); \
+    SAMPLER(MERGE_NAME(MERGE_NAME(sampler, name), 0)); \
+    TEXTURE2D(MERGE_NAME(name, 1)); \
+    SAMPLER(MERGE_NAME(MERGE_NAME(sampler, name), 1)); \
+    TEXTURE2D(MERGE_NAME(name, 2)); \
+    SAMPLER(MERGE_NAME(MERGE_NAME(sampler, name), 2)); \
+    TEXTURE2D(MERGE_NAME(name, 3)); \
+    SAMPLER(MERGE_NAME(MERGE_NAME(sampler, name), 3))
+
+
+PROP_DECL_TEX2D(_BaseColorMap);
+PROP_DECL_TEX2D(_MaskMap);
+PROP_DECL_TEX2D(_BentNormalMap);
+PROP_DECL_TEX2D(_NormalMap);
+PROP_DECL_TEX2D(_NormalMapOS);
+PROP_DECL_TEX2D(_DetailMap);
+PROP_DECL_TEX2D(_HeightMap);
+
+PROP_DECL_TEX2D(_SubsurfaceMaskMap);
+PROP_DECL_TEX2D(_ThicknessMap);
+
+TEXTURE2D(_LayerMaskMap);
+SAMPLER(sampler_LayerMaskMap);
+TEXTURE2D(_LayerInfluenceMaskMap);
+SAMPLER(sampler_LayerInfluenceMaskMap);
+
+#endif
+
+CBUFFER_START(UnityPerMaterial)
+
+// shared constant between lit and layered lit
+float _AlphaCutoff;
+float _AlphaCutoffPrepass;
+float _AlphaCutoffPostpass;
+float4 _DoubleSidedConstants;
+float _DistortionScale;
+float _DistortionVectorScale;
+float _DistortionVectorBias;
+float _DistortionBlurScale;
+float _DistortionBlurRemapMin;
+float _DistortionBlurRemapMax;
+
+float _PPDMaxSamples;
+float _PPDMinSamples;
+float _PPDLodThreshold;
+
+float3 _EmissiveColor;
+float _EmissiveIntensity;
+float _AlbedoAffectEmissive;
+
+float _EnableSpecularOcclusion;
+
+// Transparency
+float3 _TransmittanceColor;
+float _IOR;
+float _ATDistance;
+float _ThicknessMultiplier;
+
+// 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
+float3 _EmissionColor;
+float4 _EmissiveColorMap_ST;
+float _TexWorldScaleEmissive;
+float4 _UVMappingMaskEmissive;
+
+float4 _InvPrimScale; // Only XY are used
+
+// Wind
+float _InitialBend;
+float _Stiffness;
+float _Drag;
+float _ShiverDrag;
+float _ShiverDirectionality;
+
+#ifndef LAYERED_LIT_SHADER
+
+// Set of users variables
+float4 _BaseColor;
+float4 _BaseColorMap_ST;
+float4 _BaseColorMap_TexelSize;
-
-float _Metallic;
-float _Smoothness;
-float _SmoothnessRemapMin;
-float _SmoothnessRemapMax;
-float _AORemapMin;
-float _AORemapMax;
-
-float _NormalScale;
-
-float4 _DetailMap_ST;
-float _DetailAlbedoScale;
-float _DetailNormalScale;
-float _DetailSmoothnessScale;
-
-float4 _HeightMap_TexelSize; // Unity facility. This will provide the size of the heightmap to the shader
-
-float _HeightAmplitude;
-float _HeightCenter;
-
-float _Anisotropy;
-
-int   _DiffusionProfile;
-float _SubsurfaceMask;
-float _Thickness;
-float4 _ThicknessRemap;
-
-float _CoatMask;
-
-float4 _SpecularColor;
-
-float _TexWorldScale;
-float _InvTilingScale;
-float4 _UVMappingMask;
-float4 _UVDetailsMappingMask;
-float _LinkDetailsWithBase;
-
-#else // LAYERED_LIT_SHADER
-
-// Set of users variables
-PROP_DECL(float4, _BaseColor);
-float4 _BaseColorMap0_ST;
-float4 _BaseColorMap1_ST;
-float4 _BaseColorMap2_ST;
-float4 _BaseColorMap3_ST;
-
+
+float _Metallic;
+float _Smoothness;
+float _SmoothnessRemapMin;
+float _SmoothnessRemapMax;
+float _AORemapMin;
+float _AORemapMax;
+
+float _NormalScale;
+
+float4 _DetailMap_ST;
+float _DetailAlbedoScale;
+float _DetailNormalScale;
+float _DetailSmoothnessScale;
+
+float4 _HeightMap_TexelSize; // Unity facility. This will provide the size of the heightmap to the shader
+
+float _HeightAmplitude;
+float _HeightCenter;
+
+float _Anisotropy;
+
+int   _DiffusionProfile;
+float _SubsurfaceMask;
+float _Thickness;
+float4 _ThicknessRemap;
+
+float _CoatMask;
+
+float4 _SpecularColor;
+
+float _TexWorldScale;
+float _InvTilingScale;
+float4 _UVMappingMask;
+float4 _UVDetailsMappingMask;
+float _LinkDetailsWithBase;
+
+#else // LAYERED_LIT_SHADER
+
+// Set of users variables
+PROP_DECL(float4, _BaseColor);
+float4 _BaseColorMap0_ST;
+float4 _BaseColorMap1_ST;
+float4 _BaseColorMap2_ST;
+float4 _BaseColorMap3_ST;
+
-
-PROP_DECL(float, _Metallic);
-PROP_DECL(float, _Smoothness);
-PROP_DECL(float, _SmoothnessRemapMin);
-PROP_DECL(float, _SmoothnessRemapMax);
-PROP_DECL(float, _AORemapMin);
-PROP_DECL(float, _AORemapMax);
-
-PROP_DECL(float, _NormalScale);
-float4 _NormalMap0_TexelSize; // Unity facility. This will provide the size of the base normal to the shader
-
-float4 _HeightMap0_TexelSize;
-float4 _HeightMap1_TexelSize;
-float4 _HeightMap2_TexelSize;
-float4 _HeightMap3_TexelSize;
-
-float4 _DetailMap0_ST;
-float4 _DetailMap1_ST;
-float4 _DetailMap2_ST;
-float4 _DetailMap3_ST;
-PROP_DECL(float, _UVDetail);
-PROP_DECL(float, _DetailAlbedoScale);
-PROP_DECL(float, _DetailNormalScale);
-PROP_DECL(float, _DetailSmoothnessScale);
-
-PROP_DECL(float, _HeightAmplitude);
-PROP_DECL(float, _HeightCenter);
-
-PROP_DECL(int, _DiffusionProfile);
-PROP_DECL(float, _SubsurfaceMask);
-PROP_DECL(float, _Thickness);
-PROP_DECL(float4, _ThicknessRemap);
-
-PROP_DECL(float, _OpacityAsDensity);
-float _InheritBaseNormal1;
-float _InheritBaseNormal2;
-float _InheritBaseNormal3;
-float _InheritBaseHeight1;
-float _InheritBaseHeight2;
-float _InheritBaseHeight3;
-float _InheritBaseColor1;
-float _InheritBaseColor2;
-float _InheritBaseColor3;
-PROP_DECL(float, _HeightOffset);
-float _HeightTransition;
-
-float4 _LayerMaskMap_ST;
-float _TexWorldScaleBlendMask;
-PROP_DECL(float, _TexWorldScale);
-PROP_DECL(float, _InvTilingScale);
-float4 _UVMappingMaskBlendMask;
-PROP_DECL(float4, _UVMappingMask);
-PROP_DECL(float4, _UVDetailsMappingMask);
-PROP_DECL(float, _LinkDetailsWithBase);
-
-#endif // LAYERED_LIT_SHADER
-
-// Tessellation specific
-
-#ifdef TESSELLATION_ON
-float _TessellationFactor;
-float _TessellationFactorMinDistance;
-float _TessellationFactorMaxDistance;
-float _TessellationFactorTriangleSize;
-float _TessellationShapeFactor;
-float _TessellationBackFaceCullEpsilon;
-float _TessellationObjectScale;
-float _TessellationTilingScale;
-#endif
-
-CBUFFER_END
+
+PROP_DECL(float, _Metallic);
+PROP_DECL(float, _Smoothness);
+PROP_DECL(float, _SmoothnessRemapMin);
+PROP_DECL(float, _SmoothnessRemapMax);
+PROP_DECL(float, _AORemapMin);
+PROP_DECL(float, _AORemapMax);
+
+PROP_DECL(float, _NormalScale);
+float4 _NormalMap0_TexelSize; // Unity facility. This will provide the size of the base normal to the shader
+
+float4 _HeightMap0_TexelSize;
+float4 _HeightMap1_TexelSize;
+float4 _HeightMap2_TexelSize;
+float4 _HeightMap3_TexelSize;
+
+float4 _DetailMap0_ST;
+float4 _DetailMap1_ST;
+float4 _DetailMap2_ST;
+float4 _DetailMap3_ST;
+PROP_DECL(float, _UVDetail);
+PROP_DECL(float, _DetailAlbedoScale);
+PROP_DECL(float, _DetailNormalScale);
+PROP_DECL(float, _DetailSmoothnessScale);
+
+PROP_DECL(float, _HeightAmplitude);
+PROP_DECL(float, _HeightCenter);
+
+PROP_DECL(int, _DiffusionProfile);
+PROP_DECL(float, _SubsurfaceMask);
+PROP_DECL(float, _Thickness);
+PROP_DECL(float4, _ThicknessRemap);
+
+PROP_DECL(float, _OpacityAsDensity);
+float _InheritBaseNormal1;
+float _InheritBaseNormal2;
+float _InheritBaseNormal3;
+float _InheritBaseHeight1;
+float _InheritBaseHeight2;
+float _InheritBaseHeight3;
+float _InheritBaseColor1;
+float _InheritBaseColor2;
+float _InheritBaseColor3;
+PROP_DECL(float, _HeightOffset);
+float _HeightTransition;
+
+float4 _LayerMaskMap_ST;
+float _TexWorldScaleBlendMask;
+PROP_DECL(float, _TexWorldScale);
+PROP_DECL(float, _InvTilingScale);
+float4 _UVMappingMaskBlendMask;
+PROP_DECL(float4, _UVMappingMask);
+PROP_DECL(float4, _UVDetailsMappingMask);
+PROP_DECL(float, _LinkDetailsWithBase);
+
+#endif // LAYERED_LIT_SHADER
+
+// Tessellation specific
+
+#ifdef TESSELLATION_ON
+float _TessellationFactor;
+float _TessellationFactorMinDistance;
+float _TessellationFactorMaxDistance;
+float _TessellationFactorTriangleSize;
+float _TessellationShapeFactor;
+float _TessellationBackFaceCullEpsilon;
+float _TessellationObjectScale;
+float _TessellationTilingScale;
+#endif
+
+CBUFFER_END

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

         {
             float3 lightDiff, lightSpec;
 
-            BSDF(V, L, positionWS, preLightData, bsdfData, lightDiff, lightSpec);
+            BSDF(V, L, NdotL, positionWS, preLightData, bsdfData, lightDiff, lightSpec);
 
             diffuseLighting  += lightDiff * (sinLT / dist2 * NdotL);
             specularLighting += lightSpec * (sinLT / dist2 * NdotL);
         float cosLNs = saturate(dot(-L, Ns));
 
         // We calculate area reference light with the area integral rather than the solid angle one.
-        float illuminance = cosLNs * saturate(dot(bsdfData.normalWS, L)) / (sqrDist * lightPdf);
+        float NdotL = saturate(dot(bsdfData.normalWS, L));
+        float illuminance = cosLNs * NdotL / (sqrDist * lightPdf);
 
         float3 localDiffuseLighting = float3(0.0, 0.0, 0.0);
         float3 localSpecularLighting = float3(0.0, 0.0, 0.0);
-            BSDF(V, L, positionWS, preLightData, bsdfData, localDiffuseLighting, localSpecularLighting);
+            BSDF(V, L, NdotL, positionWS, preLightData, bsdfData, localDiffuseLighting, localSpecularLighting);
             localDiffuseLighting *= lightData.color * illuminance * lightData.diffuseScale;
             localSpecularLighting *= lightData.color * illuminance * lightData.specularScale;
         }
 {
     float3x3 localToWorld;
 
-    if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_ANISOTROPY))
+    if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_ANISOTROPY))
     {
         localToWorld = float3x3(bsdfData.tangentWS, bsdfData.bitangentWS, bsdfData.normalWS);
     }
         float weightOverPdf;
 
         // GGX BRDF
-        if (HasMaterialFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_ANISOTROPY))
+        if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_ANISOTROPY))
         {
             ImportanceSampleAnisoGGX(u, V, localToWorld, bsdfData.roughnessT, bsdfData.roughnessB, NdotV, L, VdotH, NdotL, weightOverPdf);
         }

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
 
         // Tessellation specific
         [Enum(None, 0, Phong, 1)] _TessellationMode("Tessellation mode", Float) = 0
-        _TessellationFactor("Tessellation Factor", Range(0.0, 15.0)) = 4.0
+        _TessellationFactor("Tessellation Factor", Range(0.0, 64.0)) = 4.0
         _TessellationFactorMinDistance("Tessellation start fading distance", Float) = 20.0
         _TessellationFactorMaxDistance("Tessellation end fading distance", Float) = 50.0
         _TessellationFactorTriangleSize("Tessellation triangle size", Float) = 100.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/SubsurfaceScattering/SubsurfaceScattering.compute

 #define SSS_USE_LDS_CACHE     1
 #define SSS_TAA_INTEGRATION   1 // Smoother results at the cost of a tiny amount of flickering in under-sampled areas
 #define SSS_ENABLE_NEAR_FIELD 0 // Greatly increases the number of samples. Comes at a high cost.
-#define SSS_SAMPLE_TEST_HTILE 0 // Potential optimization. YMMV.
 #define SSS_USE_TANGENT_PLANE 0 // Improves the accuracy of the approximation(0 -> 1st order). High cost. Does not work with back-facing normals.
 #define SSS_CLAMP_ARTIFACT    0 // Reduces bleeding. Use with SSS_USE_TANGENT_PLANE.
 #define SSS_DEBUG_LOD         0
                     float3 tangentX, float3 tangentY, float4x4 projMatrix,
                     inout float3 totalIrradiance, inout float3 totalWeight)
 {
-    float  r   = _FilterKernels[profileID][i][iR];
+    float r   = _FilterKernels[profileID][i][iR];
-    float  phi = SampleDiskFibonacci(i, n).y;
+    float phi = SampleDiskFibonacci(i, n).y;
-    phi += VanDerCorputBase2(_TaaFrameIndex % 4) * TWO_PI;
-#endif
+    float sinPsi = _TaaFrameRotation.x;
+    float cosPsi = _TaaFrameRotation.y;
+
+    // The angle 'psi' is loop-invariant. All the trigonometry is done at compile time.
+    // cos(a + b) = cos(a) * cos(b) - sin(a) * sin(b)
+    // sin(a + b) = sin(a) * cos(b) + cos(a) * sin(b)
+    float cosSum = cos(phi) * cosPsi - sin(phi) * sinPsi;
+    float sinSum = sin(phi) * cosPsi + cos(phi) * sinPsi;
+
+    float2 vec = r * float2(cosSum, sinSum);
+#else
+#endif
 
     // Compute the screen-space position and the squared distance (in mm) in the image plane.
     int2 position; float xy2;

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/RenderPipelineResources/DefaultHDMaterial.mat

     - _SubsurfaceRadius: 1
     - _SurfaceType: 0
     - _TexWorldScale: 1
+    - _TexWorldScaleEmissive: 1
     - _Thickness: 1
     - _ThicknessMultiplier: 1
     - _TransparentBackfaceEnable: 0
     - _UVDetail: 0
+    - _UVEmissive: 0
     - _UVSec: 0
     - _ZTestMode: 8
     - _ZWrite: 1
     - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderPass/ShaderPass.cs

         GBuffer,
         Forward,
         ForwardUnlit,
+        DeferredLighting,
         DepthOnly,
         Velocity,
         Distortion,

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderPass/ShaderPass.cs.hlsl

 #define SHADERPASS_GBUFFER (0)
 #define SHADERPASS_FORWARD (1)
 #define SHADERPASS_FORWARD_UNLIT (2)
-#define SHADERPASS_DEPTH_ONLY (3)
-#define SHADERPASS_VELOCITY (4)
-#define SHADERPASS_DISTORTION (5)
-#define SHADERPASS_LIGHT_TRANSPORT (6)
-#define SHADERPASS_SHADOWS (7)
-#define SHADERPASS_SUBSURFACE_SCATTERING (8)
-#define SHADERPASS_VOLUMETRIC_LIGHTING (9)
-#define SHADERPASS_DBUFFER (10)
+#define SHADERPASS_DEFERRED_LIGHTING (3)
+#define SHADERPASS_DEPTH_ONLY (4)
+#define SHADERPASS_VELOCITY (5)
+#define SHADERPASS_DISTORTION (6)
+#define SHADERPASS_LIGHT_TRANSPORT (7)
+#define SHADERPASS_SHADOWS (8)
+#define SHADERPASS_SUBSURFACE_SCATTERING (9)
+#define SHADERPASS_VOLUMETRIC_LIGHTING (10)
+#define SHADERPASS_DBUFFER (11)
 
 
 #endif

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderPass/ShaderPassForward.hlsl

         LightLoop(V, posInput, preLightData, bsdfData, bakeLightingData, featureFlags, diffuseLighting, specularLighting);
 
 #ifdef OUTPUT_SPLIT_LIGHTING
-        if ((_EnableSubsurfaceScattering != 0) && HaveSubsurfaceScattering(bsdfData))
+        if (_EnableSubsurfaceScattering != 0 && PixelHasSubsurfaceScattering(bsdfData))
         {
             outColor = float4(specularLighting, 1.0);
             outDiffuseLighting = float4(TagLightingForSSS(diffuseLighting), 1.0);

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/TessellationShare.hlsl

+#if defined(SHADER_API_XBOXONE) || defined(SHADER_API_PSSL)
+#else
+#define MAX_TESSELLATION_FACTORS 64.0
+#endif
 
 struct TessellationFactors
 {

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

     int unity_StereoEyeIndex;
 #endif
 
-    float3 unity_ShadowColor;
-    uint _TaaFrameIndex;      // [0, 7]
+    float4 unity_ShadowColor;
+    float2 _TaaFrameRotation; // {x = sin(_TaaFrameIndex * PI/2), y = cos(_TaaFrameIndex * PI/2), z = unused}
+    uint   _TaaFrameIndex;    // [0, 7]
+    uint   _Align128;         // Pad for 128-bit alignment
     // Volumetric lighting. Should be a struct in 'UnityPerFrame'.
     // Unfortunately, structures inside constant buffers are not supported by Unity.
     float3 _GlobalFog_Scattering;
 #else
     #include "ShaderVariablesMatrixDefsHDCamera.hlsl"
 #endif
+
+#include "CoreRP/ShaderLibrary/UnityInstancing.hlsl"
 
 #include "ShaderVariablesFunctions.hlsl"
 

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"

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/3DObjects/CornelBox/Cornell Box.fbx.meta

     2186277476908879422: ImportLogs
     2186277476908879424: ImportLogs
     2186277476908879426: ImportLogs
+    2186277476908879428: ImportLogs
+    2186277476908879430: ImportLogs
   externalObjects:
   - first:
       type: UnityEngine:Material

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/3DObjects/Sphere/Sphere.fbx.meta

     2186277476908879424: ImportLogs
     2186277476908879426: ImportLogs
     2186277476908879428: ImportLogs
+    2186277476908879430: ImportLogs
+    2186277476908879432: ImportLogs
   externalObjects: {}
   materials:
     importMaterials: 0

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/Materials/HDRP_Default_Material.mat

     - _SubsurfaceRadius: 1
     - _SurfaceType: 0
     - _TexWorldScale: 1
+    - _TexWorldScaleEmissive: 1
     - _Thickness: 1
     - _ThicknessMultiplier: 1
     - _TransparentBackfaceEnable: 0
     - _UVDetail: 0
+    - _UVEmissive: 0
     - _ZTestMode: 8
     - _ZWrite: 1
     m_Colors:
     - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 0, g: 0, b: 0, a: 0}
+    - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0}

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1210_Lit_BentNormal/BentNormal_Tangent.mat

     - _SubsurfaceRadius: 1
     - _SurfaceType: 0
     - _TexWorldScale: 1
+    - _TexWorldScaleEmissive: 1
     - _Thickness: 1
     - _ThicknessMultiplier: 1
     - _TransparentBackfaceEnable: 0
     - _UVDetail: 0
+    - _UVEmissive: 0
     - _ZTestMode: 4
     - _ZWrite: 1
     m_Colors:
     - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0}

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1210_Lit_BentNormal/Green_Emissive.mat

     - _SubsurfaceRadius: 1
     - _SurfaceType: 0
     - _TexWorldScale: 1
+    - _TexWorldScaleEmissive: 1
     - _Thickness: 1
     - _ThicknessMultiplier: 1
     - _TransparentBackfaceEnable: 0
     - _UVDetail: 0
+    - _UVEmissive: 0
     - _ZTestMode: 4
     - _ZWrite: 1
     m_Colors:
     - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0}

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1210_Lit_BentNormal/Red_Emissive.mat

     - _SubsurfaceRadius: 1
     - _SurfaceType: 0
     - _TexWorldScale: 1
+    - _TexWorldScaleEmissive: 1
     - _Thickness: 1
     - _ThicknessMultiplier: 1
     - _TransparentBackfaceEnable: 0
     - _UVDetail: 0
+    - _UVEmissive: 0
     - _ZTestMode: 4
     - _ZWrite: 1
     m_Colors:
     - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Assets/CommonAssets/Cornell Box.fbx.meta

     7400000: Take 001
     9500000: //RootNode
     2186277476908879412: ImportLogs
+    2186277476908879414: ImportLogs
+    2186277476908879416: ImportLogs
   externalObjects:
   - first:
       type: UnityEngine:Material

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/040_UpgradeScene/Models/Environment/Floor.fbx.meta

     7400000: Take 001
     9500000: //RootNode
     2186277476908879412: ImportLogs
+    2186277476908879414: ImportLogs
+    2186277476908879416: ImportLogs
   externalObjects:
   - first:
       type: UnityEngine:Material

Tests/Scripts/Editor.meta

-fileFormatVersion: 2
-guid: 0f6887a1ff514ed690ada3786867d216
-timeCreated: 1512986333
+fileFormatVersion: 2
+guid: 2ea8802fb7f2fa641a567a661fb6a58e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/Scripts/Editor/GraphicTests/HDRenderPipeline/DebugViewController_Editor.cs.meta

 fileFormatVersion: 2
-guid: de99fe47e69d2ee449e0c6d3b3885b27
+guid: da59c0df09fb17e4f99a667936fce895
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

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 (HasFeatureFlag(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: