Merge branch 'master' into lw/shadow-optimization

# Conflicts:
#	ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs

.gitignore

 *.resS
 *.sdf
 *.sln
+*.sublime-project
+*.sublime-workspace
 *.suo
 *.userprefs

ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1102_Unlit_Distortion.unity.png.meta

   spriteMeshType: 1
   alignment: 0
   spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
-  spritePixelsToUnits: 100
+  spriteGenerateFallbackPhysicsShape: 1
   alphaUsage: 1
   alphaIsTransparency: 0
   spriteTessellationDetail: -1

ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1103_Unlit_Distortion_DepthTest.unity.png.meta

   spriteMeshType: 1
   alignment: 0
   spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
-  spritePixelsToUnits: 100
+  spriteGenerateFallbackPhysicsShape: 1
   alphaUsage: 1
   alphaIsTransparency: 0
   spriteTessellationDetail: -1

ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1201_Lit_Features.unity.png.meta

   serializedVersion: 5
   mipmaps:
     mipMapMode: 0
-    enableMipMap: 0
+    enableMipMap: 1
     sRGBTexture: 1
     linearTexture: 0
     fadeOut: 0
     filterMode: -1
     aniso: -1
     mipBias: -1
-    wrapU: 1
-    wrapV: 1
-    wrapW: 1
-  nPOTScale: 0
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
   lightmap: 0
   compressionQuality: 50
   spriteMode: 0
   spritePivot: {x: 0.5, y: 0.5}
-  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
-  alphaUsage: 0
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
   alphaIsTransparency: 0
   spriteTessellationDetail: -1
   textureType: 0
   platformSettings:
   - serializedVersion: 2
     buildTarget: DefaultTexturePlatform
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 0
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    androidETC2FallbackOverride: 0
-  - serializedVersion: 2
-    buildTarget: Standalone
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 0
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    androidETC2FallbackOverride: 0
-  - serializedVersion: 2
-    buildTarget: iPhone
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 0
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    androidETC2FallbackOverride: 0
-  - serializedVersion: 2
-    buildTarget: Windows Store Apps
     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1

ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1204_Lit_Transparent_Fog.unity.png.meta

   serializedVersion: 5
   mipmaps:
     mipMapMode: 0
-    enableMipMap: 0
+    enableMipMap: 1
     sRGBTexture: 1
     linearTexture: 0
     fadeOut: 0
     filterMode: -1
     aniso: -1
     mipBias: -1
-    wrapU: 1
-    wrapV: 1
-    wrapW: 1
-  nPOTScale: 0
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
   lightmap: 0
   compressionQuality: 50
   spriteMode: 0
   spritePivot: {x: 0.5, y: 0.5}
-  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
-  alphaUsage: 0
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
   alphaIsTransparency: 0
   spriteTessellationDetail: -1
   textureType: 0
   platformSettings:
   - serializedVersion: 2
     buildTarget: DefaultTexturePlatform
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 0
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    androidETC2FallbackOverride: 0
-  - serializedVersion: 2
-    buildTarget: Standalone
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 0
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    androidETC2FallbackOverride: 0
-  - serializedVersion: 2
-    buildTarget: iPhone
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 0
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    androidETC2FallbackOverride: 0
-  - serializedVersion: 2
-    buildTarget: Windows Store Apps
     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1

ImageTemplates/HDRenderPipeline/Scenes/2xxx_Lighting/2002_Dynamic_Mix.unity.png.meta

   spriteMeshType: 1
   alignment: 0
   spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
-  spritePixelsToUnits: 100
+  spriteGenerateFallbackPhysicsShape: 1
   alphaUsage: 1
   alphaIsTransparency: 0
   spriteTessellationDetail: -1

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Common.hlsl

 #define TEMPLATE_2_REAL TEMPLATE_2_HALF
 #define TEMPLATE_3_REAL TEMPLATE_3_HALF
 
+#define HAS_HALF 1
+
 #else
 
 #define real float
 #define TEMPLATE_2_REAL TEMPLATE_2_FLT
 #define TEMPLATE_3_REAL TEMPLATE_3_FLT
 
+#define HAS_HALF 0
+
 #endif // SHADER_API_MOBILE
 
 #endif // #ifndef real
 #ifdef  SHADER_STAGE_COMPUTE
 #   ifndef SHADER_TARGET
-#       if defined(SHADER_API_METAL) || defined(SHADER_API_VULKAN)
+#       if defined(SHADER_API_METAL)
 #       define SHADER_TARGET 45
 #       else
 #       define SHADER_TARGET 50

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/EntityLighting.hlsl

     return x2 + x3;
 }
 
-real3 SampleSH9(real4 SHCoefficients[7], real3 N)
+#if HAS_HALF
+half3 SampleSH9(half4 SHCoefficients[7], half3 N)
+{
+    half4 shAr = SHCoefficients[0];
+    half4 shAg = SHCoefficients[1];
+    half4 shAb = SHCoefficients[2];
+    half4 shBr = SHCoefficients[3];
+    half4 shBg = SHCoefficients[4];
+    half4 shBb = SHCoefficients[5];
+    half4 shCr = SHCoefficients[6];
+
+    // Linear + constant polynomial terms
+    half3 res = SHEvalLinearL0L1(N, shAr, shAg, shAb);
+
+    // Quadratic polynomials
+    res += SHEvalLinearL2(N, shBr, shBg, shBb, shCr);
+
+    return res;
+}
+#endif
+float3 SampleSH9(float4 SHCoefficients[7], float3 N)
-    real4 shAr = SHCoefficients[0];
-    real4 shAg = SHCoefficients[1];
-    real4 shAb = SHCoefficients[2];
-    real4 shBr = SHCoefficients[3];
-    real4 shBg = SHCoefficients[4];
-    real4 shBb = SHCoefficients[5];
-    real4 shCr = SHCoefficients[6];
+    float4 shAr = SHCoefficients[0];
+    float4 shAg = SHCoefficients[1];
+    float4 shAb = SHCoefficients[2];
+    float4 shBr = SHCoefficients[3];
+    float4 shBg = SHCoefficients[4];
+    float4 shBb = SHCoefficients[5];
+    float4 shCr = SHCoefficients[6];
-    real3 res = SHEvalLinearL0L1(N, shAr, shAg, shAb);
+    float3 res = SHEvalLinearL0L1(N, shAr, shAg, shAb);
 
     // Quadratic polynomials
     res += SHEvalLinearL2(N, shBr, shBg, shBb, shCr);
+
 
 // This sample a 3D volume storing SH
 // Volume is store as 3D texture with 4 R, G, B, Occ set of 4 coefficient store atlas in same 3D texture. Occ is use for occlusion.

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Filtering.hlsl

 // Compute weights & offsets for 4x bilinear taps for the biquadratic B-Spline filter.
 // The fractional coordinate should be in the [0, 1] range (centered on 0.5).
 // Inspired by: http://vec3.ca/bicubic-filtering-in-fewer-taps/
-void BiquadraticFilter(real2 fracCoord, out real2 weights[2], out real2 offsets[2])
+
+void BiquadraticFilter(float2 fracCoord, out float2 weights[2], out float2 offsets[2])
+{
+    float2 l = BSpline2IntLeft(fracCoord);
+    float2 m = BSpline2IntMiddle(fracCoord);
+    float2 r = 1 - l - m;
+
+    // Compute offsets for 4x bilinear taps for the quadratic B-Spline reconstruction kernel.
+    // 0: lerp between left and middle
+    // 1: lerp between middle and right
+    weights[0] = l + 0.5 * m;
+    weights[1] = r + 0.5 * m;
+    offsets[0] = -0.5 + 0.5 * m * rcp(weights[0]);
+    offsets[1] =  0.5 + r * rcp(weights[1]);
+}
+
+// If half is natively supported, create another variant
+#if HAS_HALF
+void BiquadraticFilter(half2 fracCoord, out half2 weights[2], out half2 offsets[2])
-    real2 l = BSpline2IntLeft(fracCoord);
-    real2 m = BSpline2IntMiddle(fracCoord);
-    real2 r = 1 - l - m;
+    half2 l = BSpline2IntLeft(fracCoord);
+    half2 m = BSpline2IntMiddle(fracCoord);
+    half2 r = 1 - l - m;
 
     // Compute offsets for 4x bilinear taps for the quadratic B-Spline reconstruction kernel.
     // 0: lerp between left and middle
     offsets[0] = -0.5 + 0.5 * m * rcp(weights[0]);
     offsets[1] =  0.5 + r * rcp(weights[1]);
 }
+#endif
 
 #endif // UNITY_FILTERING_INCLUDED

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Macros.hlsl

     half  FunctionName(half  Parameter1) { FunctionBody; } \
     half2 FunctionName(half2 Parameter1) { FunctionBody; } \
     half3 FunctionName(half3 Parameter1) { FunctionBody; } \
-    half4 FunctionName(half4 Parameter1) { FunctionBody; }
+    half4 FunctionName(half4 Parameter1) { FunctionBody; } \
+    float  FunctionName(float  Parameter1) { FunctionBody; } \
+    float2 FunctionName(float2 Parameter1) { FunctionBody; } \
+    float3 FunctionName(float3 Parameter1) { FunctionBody; } \
+    float4 FunctionName(float4 Parameter1) { FunctionBody; }
 
 #ifdef SHADER_API_GLES
     #define TEMPLATE_1_INT(FunctionName, Parameter1, FunctionBody) \
     half  FunctionName(half  Parameter1, half  Parameter2) { FunctionBody; } \
     half2 FunctionName(half2 Parameter1, half2 Parameter2) { FunctionBody; } \
     half3 FunctionName(half3 Parameter1, half3 Parameter2) { FunctionBody; } \
-    half4 FunctionName(half4 Parameter1, half4 Parameter2) { FunctionBody; }
+    half4 FunctionName(half4 Parameter1, half4 Parameter2) { FunctionBody; } \
+    float  FunctionName(float  Parameter1, float  Parameter2) { FunctionBody; } \
+    float2 FunctionName(float2 Parameter1, float2 Parameter2) { FunctionBody; } \
+    float3 FunctionName(float3 Parameter1, float3 Parameter2) { FunctionBody; } \
+    float4 FunctionName(float4 Parameter1, float4 Parameter2) { FunctionBody; }
 
 
 #ifdef SHADER_API_GLES
     half  FunctionName(half  Parameter1, half  Parameter2, half  Parameter3) { FunctionBody; } \
     half2 FunctionName(half2 Parameter1, half2 Parameter2, half2 Parameter3) { FunctionBody; } \
     half3 FunctionName(half3 Parameter1, half3 Parameter2, half3 Parameter3) { FunctionBody; } \
-    half4 FunctionName(half4 Parameter1, half4 Parameter2, half4 Parameter3) { FunctionBody; }
+    half4 FunctionName(half4 Parameter1, half4 Parameter2, half4 Parameter3) { FunctionBody; } \
+    float  FunctionName(float  Parameter1, float  Parameter2, float  Parameter3) { FunctionBody; } \
+    float2 FunctionName(float2 Parameter1, float2 Parameter2, float2 Parameter3) { FunctionBody; } \
+    float3 FunctionName(float3 Parameter1, float3 Parameter2, float3 Parameter3) { FunctionBody; } \
+    float4 FunctionName(float4 Parameter1, float4 Parameter2, float4 Parameter3) { FunctionBody; }
 
 #ifdef SHADER_API_GLES
     #define TEMPLATE_3_INT(FunctionName, Parameter1, Parameter2, Parameter3, FunctionBody) \
     void FunctionName(inout bool3  a, inout bool3  b) { bool3  t = a; a = b; b = t; } \
     void FunctionName(inout bool4  a, inout bool4  b) { bool4  t = a; a = b; b = t; }
 #else
-    #define TEMPLATE_SWAP(FunctionName) \
-    void FunctionName(inout real  a, inout real  b) { real  t = a; a = b; b = t; } \
-    void FunctionName(inout real2 a, inout real2 b) { real2 t = a; a = b; b = t; } \
-    void FunctionName(inout real3 a, inout real3 b) { real3 t = a; a = b; b = t; } \
-    void FunctionName(inout real4 a, inout real4 b) { real4 t = a; a = b; b = t; } \
-    void FunctionName(inout int    a, inout int    b) { int    t = a; a = b; b = t; } \
-    void FunctionName(inout int2   a, inout int2   b) { int2   t = a; a = b; b = t; } \
-    void FunctionName(inout int3   a, inout int3   b) { int3   t = a; a = b; b = t; } \
-    void FunctionName(inout int4   a, inout int4   b) { int4   t = a; a = b; b = t; } \
-    void FunctionName(inout uint   a, inout uint   b) { uint   t = a; a = b; b = t; } \
-    void FunctionName(inout uint2  a, inout uint2  b) { uint2  t = a; a = b; b = t; } \
-    void FunctionName(inout uint3  a, inout uint3  b) { uint3  t = a; a = b; b = t; } \
-    void FunctionName(inout uint4  a, inout uint4  b) { uint4  t = a; a = b; b = t; } \
-    void FunctionName(inout bool   a, inout bool   b) { bool   t = a; a = b; b = t; } \
-    void FunctionName(inout bool2  a, inout bool2  b) { bool2  t = a; a = b; b = t; } \
-    void FunctionName(inout bool3  a, inout bool3  b) { bool3  t = a; a = b; b = t; } \
-    void FunctionName(inout bool4  a, inout bool4  b) { bool4  t = a; a = b; b = t; }
+    #if HAS_HALF
+        #define TEMPLATE_SWAP(FunctionName) \
+        void FunctionName(inout real  a, inout real  b) { real  t = a; a = b; b = t; } \
+        void FunctionName(inout real2 a, inout real2 b) { real2 t = a; a = b; b = t; } \
+        void FunctionName(inout real3 a, inout real3 b) { real3 t = a; a = b; b = t; } \
+        void FunctionName(inout real4 a, inout real4 b) { real4 t = a; a = b; b = t; } \
+        void FunctionName(inout float  a, inout float  b) { float  t = a; a = b; b = t; } \
+        void FunctionName(inout float2 a, inout float2 b) { float2 t = a; a = b; b = t; } \
+        void FunctionName(inout float3 a, inout float3 b) { float3 t = a; a = b; b = t; } \
+        void FunctionName(inout float4 a, inout float4 b) { float4 t = a; a = b; b = t; } \
+        void FunctionName(inout int    a, inout int    b) { int    t = a; a = b; b = t; } \
+        void FunctionName(inout int2   a, inout int2   b) { int2   t = a; a = b; b = t; } \
+        void FunctionName(inout int3   a, inout int3   b) { int3   t = a; a = b; b = t; } \
+        void FunctionName(inout int4   a, inout int4   b) { int4   t = a; a = b; b = t; } \
+        void FunctionName(inout uint   a, inout uint   b) { uint   t = a; a = b; b = t; } \
+        void FunctionName(inout uint2  a, inout uint2  b) { uint2  t = a; a = b; b = t; } \
+        void FunctionName(inout uint3  a, inout uint3  b) { uint3  t = a; a = b; b = t; } \
+        void FunctionName(inout uint4  a, inout uint4  b) { uint4  t = a; a = b; b = t; } \
+        void FunctionName(inout bool   a, inout bool   b) { bool   t = a; a = b; b = t; } \
+        void FunctionName(inout bool2  a, inout bool2  b) { bool2  t = a; a = b; b = t; } \
+        void FunctionName(inout bool3  a, inout bool3  b) { bool3  t = a; a = b; b = t; } \
+        void FunctionName(inout bool4  a, inout bool4  b) { bool4  t = a; a = b; b = t; }
+    #else
+        #define TEMPLATE_SWAP(FunctionName) \
+        void FunctionName(inout real  a, inout real  b) { real  t = a; a = b; b = t; } \
+        void FunctionName(inout real2 a, inout real2 b) { real2 t = a; a = b; b = t; } \
+        void FunctionName(inout real3 a, inout real3 b) { real3 t = a; a = b; b = t; } \
+        void FunctionName(inout real4 a, inout real4 b) { real4 t = a; a = b; b = t; } \
+        void FunctionName(inout int    a, inout int    b) { int    t = a; a = b; b = t; } \
+        void FunctionName(inout int2   a, inout int2   b) { int2   t = a; a = b; b = t; } \
+        void FunctionName(inout int3   a, inout int3   b) { int3   t = a; a = b; b = t; } \
+        void FunctionName(inout int4   a, inout int4   b) { int4   t = a; a = b; b = t; } \
+        void FunctionName(inout uint   a, inout uint   b) { uint   t = a; a = b; b = t; } \
+        void FunctionName(inout uint2  a, inout uint2  b) { uint2  t = a; a = b; b = t; } \
+        void FunctionName(inout uint3  a, inout uint3  b) { uint3  t = a; a = b; b = t; } \
+        void FunctionName(inout uint4  a, inout uint4  b) { uint4  t = a; a = b; b = t; } \
+        void FunctionName(inout bool   a, inout bool   b) { bool   t = a; a = b; b = t; } \
+        void FunctionName(inout bool2  a, inout bool2  b) { bool2  t = a; a = b; b = t; } \
+        void FunctionName(inout bool3  a, inout bool3  b) { bool3  t = a; a = b; b = t; } \
+        void FunctionName(inout bool4  a, inout bool4  b) { bool4  t = a; a = b; b = t; }
+    #endif
 #endif
 
 

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

 	return EvalShadow_GetTexcoords( sd, positionWS, ndc, perspProj );
 }
 
-uint2 EvalShadow_GetTexcoords( ShadowData sd, real3 positionWS, out real2 closestSampleNDC, bool perspProj )
+real2 EvalShadow_GetTexcoords( ShadowData sd, real3 positionWS, out real2 closestSampleNDC, bool perspProj )
 {
 	real4 posCS = EvalShadow_WorldToShadow( sd, positionWS, perspProj );
 	real2 posNDC = perspProj ? (posCS.xy / posCS.w) : posCS.xy;
-	return uint2( (posTC * sd.scaleOffset.xy + sd.scaleOffset.zw) * sd.textureSize.xy );
+	return posTC * sd.scaleOffset.xy + sd.scaleOffset.zw;
+uint2 EvalShadow_GetIntTexcoords( ShadowData sd, real3 positionWS, out real2 closestSampleNDC, bool perspProj )
+{
+	real2 texCoords = EvalShadow_GetTexcoords(sd, positionWS, closestSampleNDC, perspProj);
+	return uint2(texCoords * sd.textureSize.xy);
+}
 
 //
 //	Biasing functions
 	sd = shadowContext.shadowDatas[index + faceIndex];
 
 	real4 closestNDC = { 0,0,0,1 };
-	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy, true );
+	uint2 texelIdx = EvalShadow_GetIntTexcoords( sd, positionWS, closestNDC.xy, true );
 
 	// load the texel
 	uint texIdx, sampIdx;
 	sd = shadowContext.shadowDatas[index + faceIndex];
 
 	real4 closestNDC = { 0,0,0,1 };
-	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy, true );
+	uint2 texelIdx = EvalShadow_GetIntTexcoords( sd, positionWS, closestNDC.xy, true );
 
 	// load the texel
 	closestNDC.z = LOAD_TEXTURE2D_ARRAY_LOD( tex, texelIdx, sd.slice, 0 ).x;
 	ShadowData sd = shadowContext.shadowDatas[index];
 
 	real4 closestNDC = { 0,0,0,1 };
-	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy, true );
+	uint2 texelIdx = EvalShadow_GetIntTexcoords( sd, positionWS, closestNDC.xy, true );
 
 	// load the texel
 	uint texIdx, sampIdx;
 	ShadowData sd = shadowContext.shadowDatas[index];
 
 	real4 closestNDC = { 0,0,0,1 };
-	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy, true );
+	uint2 texelIdx = EvalShadow_GetIntTexcoords( sd, positionWS, closestNDC.xy, true );
 
 	// load the texel
 	closestNDC.z = LOAD_TEXTURE2D_ARRAY_LOD( tex, texelIdx, sd.slice, 0 ).x;
 	sd = shadowContext.shadowDatas[index + faceIndex];
 
 	real4 closestNDC = { 0,0,0,1 };
-	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy, true );
+	uint2 texelIdx = EvalShadow_GetIntTexcoords( sd, positionWS, closestNDC.xy, true );
 
 	// load the texel
 	uint texIdx, sampIdx;
 	sd = shadowContext.shadowDatas[index + faceIndex];
 
 	real4 closestNDC = { 0,0,0,1 };
-	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy, true );
+	uint2 texelIdx = EvalShadow_GetIntTexcoords( sd, positionWS, closestNDC.xy, true );
 
 	// load the texel
 	closestNDC.z = LOAD_TEXTURE2D_ARRAY_LOD( tex, texelIdx, sd.slice, 0 ).x;
 	return closestWS.xyz / closestWS.w;
 }
 
+real EvalShadow_SampleClosestDistance_Punctual( ShadowContext shadowContext, Texture2DArray tex, SamplerState sampl,
+												real3 positionWS, int index, real3 L, real3 lightPositionWS )
+{
+	// get the algorithm
+	ShadowData sd = shadowContext.shadowDatas[index];
+	uint shadowType;
+	UnpackShadowType( sd.shadowType, shadowType );
+	// load the right shadow data for the current face
+	int faceIndex = shadowType == GPUSHADOWTYPE_POINT ? (CubeMapFaceID( -L ) + 1) : 0;
+	sd = shadowContext.shadowDatas[index + faceIndex];
+
+	real4 closestNDC = { 0,0,0,1 };
+	real2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy, true );
+
+	// sample the shadow map
+	closestNDC.z = SAMPLE_TEXTURE2D_ARRAY_LOD( tex, sampl, texelIdx, sd.slice, 0 ).x;
+
+	// reconstruct depth position
+	real4 closestWS = mul( closestNDC, sd.shadowToWorld );
+	real3 occluderPosWS = closestWS.xyz / closestWS.w;
+
+	return distance( occluderPosWS, lightPositionWS );
+}
+
 real3 EvalShadow_GetClosestSample_Cascade( ShadowContext shadowContext, real3 positionWS, real3 normalWS, int index, real4 L )
 {
 	// load the right shadow data for the current face
 	
 	if( shadowSplitIndex < 0 )
-		return 1.0;
+		return 0.0;
-	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy, false );
+	uint2 texelIdx = EvalShadow_GetIntTexcoords( sd, positionWS, closestNDC.xy, false );
 
 	// load the texel
 	uint texIdx, sampIdx;
 	int  shadowSplitIndex = EvalShadow_GetSplitIndex( shadowContext, index, positionWS, payloadOffset, alpha );
 	
 	if( shadowSplitIndex < 0 )
-		return 1.0;
+		return 0.0;
-	uint2 texelIdx = EvalShadow_GetTexcoords( sd, positionWS, closestNDC.xy, false );
+	uint2 texelIdx = EvalShadow_GetIntTexcoords( sd, positionWS, closestNDC.xy, false );
 
 	// load the texel
 	uint texIdx, sampIdx;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/HDReflectionProbeUI.Drawers.cs

 
         static void Drawer_AdditionalSettings(HDReflectionProbeUI s, SerializedHDReflectionProbe p, Editor owner)
         {
-            EditorGUILayout.PropertyField(p.dimmer);
+            EditorGUILayout.PropertyField(p.weight);
+
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(p.multiplier);
+            if (EditorGUI.EndChangeCheck())
+                p.multiplier.floatValue = Mathf.Max(0.0f, p.multiplier.floatValue);
 
             if (p.so.targetObjects.Length == 1)
             {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/PlanarReflectionProbeUI.Drawers.cs

 
         static void Drawer_SectionInfluenceSettings(PlanarReflectionProbeUI s, SerializedPlanarReflectionProbe d, Editor o)
         {
-            EditorGUILayout.PropertyField(d.dimmer, _.GetContent("Dimmer"));
+            EditorGUILayout.PropertyField(d.weight, _.GetContent("Weight"));
+           
+
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(d.multiplier, _.GetContent("Multiplier"));
+            if (EditorGUI.EndChangeCheck())
+                d.multiplier.floatValue = Mathf.Max(0.0f, d.multiplier.floatValue);
         }
 
         static void Drawer_FieldCaptureType(PlanarReflectionProbeUI s, SerializedPlanarReflectionProbe d, Editor o)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/SerializedHDReflectionProbe.cs

         internal SerializedProperty blendNormalDistanceNegative;
         internal SerializedProperty boxSideFadePositive;
         internal SerializedProperty boxSideFadeNegative;
-        internal SerializedProperty dimmer;
+        internal SerializedProperty weight;
+        internal SerializedProperty multiplier;
 
         internal SerializedProperty proxyVolumeComponent;
 
             boxReprojectionVolumeSize = addso.Find((HDAdditionalReflectionData d) => d.boxReprojectionVolumeSize);
             boxReprojectionVolumeCenter = addso.Find((HDAdditionalReflectionData d) => d.boxReprojectionVolumeCenter);
             sphereReprojectionVolumeRadius = addso.Find((HDAdditionalReflectionData d) => d.sphereReprojectionVolumeRadius);
-            dimmer = addso.Find((HDAdditionalReflectionData d) => d.dimmer);
+            weight = addso.Find((HDAdditionalReflectionData d) => d.weight);
+            multiplier = addso.Find((HDAdditionalReflectionData d) => d.multiplier);
             blendDistancePositive = addso.Find((HDAdditionalReflectionData d) => d.blendDistancePositive);
             blendDistanceNegative = addso.Find((HDAdditionalReflectionData d) => d.blendDistanceNegative);
             blendNormalDistancePositive = addso.Find((HDAdditionalReflectionData d) => d.blendNormalDistancePositive);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/SerializedPlanarReflectionProbe.cs

         public SerializedProperty capturePositionMode;
         public SerializedProperty captureMirrorPlaneLocalPosition;
         public SerializedProperty captureMirrorPlaneLocalNormal;
-        public SerializedProperty dimmer;
+        public SerializedProperty weight;
+        public SerializedProperty multiplier;
         public SerializedProperty mode;
         public SerializedProperty refreshMode;
         public SerializedProperty customTexture;
             capturePositionMode = serializedObject.Find((PlanarReflectionProbe p) => p.capturePositionMode);
             captureMirrorPlaneLocalPosition = serializedObject.Find((PlanarReflectionProbe p) => p.captureMirrorPlaneLocalPosition);
             captureMirrorPlaneLocalNormal = serializedObject.Find((PlanarReflectionProbe p) => p.captureMirrorPlaneLocalNormal);
-            dimmer = serializedObject.Find((PlanarReflectionProbe p) => p.dimmer);
+            weight = serializedObject.Find((PlanarReflectionProbe p) => p.weight);
+            multiplier = serializedObject.Find((PlanarReflectionProbe p) => p.multiplier);
             mode = serializedObject.Find((PlanarReflectionProbe p) => p.mode);
             refreshMode = serializedObject.Find((PlanarReflectionProbe p) => p.refreshMode);
             customTexture = serializedObject.Find((PlanarReflectionProbe p) => p.customTexture);

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

                     float amplitude = (heightMax[layerIndex].floatValue - heightMin[layerIndex].floatValue);
 
                     heightAmplitude[layerIndex].floatValue = amplitude * 0.01f; // Conversion centimeters to meters.
-                    heightCenter[layerIndex].floatValue = -(heightMin[layerIndex].floatValue + offset) / amplitude;
+                    heightCenter[layerIndex].floatValue = -(heightMin[layerIndex].floatValue + offset) / Mathf.Max(1e-6f, amplitude);
-                    heightCenter[layerIndex].floatValue = -heightOffset[layerIndex].floatValue / amplitude + heightTessCenter[layerIndex].floatValue;
+                    heightCenter[layerIndex].floatValue = -heightOffset[layerIndex].floatValue / Mathf.Max(1e-6f, amplitude) + heightTessCenter[layerIndex].floatValue;
                 }
             }
         }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

             }
         }
 
+        bool IsConsolePlatform()
+        {
+            return  SystemInfo.graphicsDeviceType == GraphicsDeviceType.PlayStation4 ||
+                    SystemInfo.graphicsDeviceType == GraphicsDeviceType.XboxOne ||
+                    SystemInfo.graphicsDeviceType == GraphicsDeviceType.XboxOneD3D12;
+        }
+
-            // For now we consider only PS4 to be able to read from a bound depth buffer.
-            // TODO: test/implement for other platforms.
-            return SystemInfo.graphicsDeviceType != GraphicsDeviceType.PlayStation4 &&
-                    SystemInfo.graphicsDeviceType != GraphicsDeviceType.XboxOne &&
-                    SystemInfo.graphicsDeviceType != GraphicsDeviceType.XboxOneD3D12;
+            // For now we consider all console to be able to read from a bound depth buffer.
+            return !IsConsolePlatform();
         }
 
         bool NeedStencilBufferCopy()
             {
                 RenderTargetIdentifier source = m_CameraColorBuffer;
 
-#if UNITY_EDITOR
-                bool tempHACK = true;
-#else
-                // In theory in the player the only place where we have post process is the main camera with the RTHandle reference size, so we won't need to copy.
-                bool tempHACK = false;
-#endif
+                // For console we are not allowed to resize the windows, so don't use our hack.
+                bool tempHACK = !IsConsolePlatform();
+
                 if (tempHACK)
                 {
                     // TEMPORARY:

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightDefinition.cs

 
         public Vector3 boxSideFadePositive;
         public Vector3 boxSideFadeNegative;
-        public float dimmer;
-        public float unused01;
+        public float weight;
+        public float multiplier;
 
         public Vector3 sampleDirectionDiscardWS;
         // Sampling properties

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightDefinition.cs.hlsl

     float3 blendNormalDistanceNegative;
     float3 boxSideFadePositive;
     float3 boxSideFadeNegative;
-    float dimmer;
-    float unused01;
+    float weight;
+    float multiplier;
     float3 sampleDirectionDiscardWS;
     int envIndex;
 };
 {
 	return value.boxSideFadeNegative;
 }
-float GetDimmer(EnvLightData value)
+float GetWeight(EnvLightData value)
-	return value.dimmer;
+	return value.weight;
-float GetUnused01(EnvLightData value)
+float GetMultiplier(EnvLightData value)
-	return value.unused01;
+	return value.multiplier;
 }
 float3 GetSampleDirectionDiscardWS(EnvLightData value)
 {

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

     return max(g_fClustBase, suggested_base);
 }
 
+uint GenerateLogBaseBufferIndex(uint2 tileIndex, uint numTilesX, uint numTilesY, uint eyeIndex)
+{
+    uint eyeOffset = eyeIndex * numTilesX * numTilesY;
+    return (eyeOffset + (tileIndex.y * numTilesX) + tileIndex.x);
+}
+
+uint GenerateLayeredOffsetBufferIndex(uint lightCategory, uint2 tileIndex, uint clusterIndex, uint numTilesX, uint numTilesY, int numClusters, uint eyeIndex)
+{
+    // Each eye is split into category, cluster, x, y
+
+    uint eyeOffset = eyeIndex * LIGHTCATEGORY_COUNT * numClusters * numTilesX * numTilesY;
+    int lightOffset = ((lightCategory * numClusters + clusterIndex) * numTilesY + tileIndex.y) * numTilesX + tileIndex.x;
+
+    return (eyeOffset + lightOffset);
+}
+
 #endif

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

 
 
             envLightData.influenceShapeType = probe.influenceShapeType;
-            envLightData.dimmer = probe.dimmer;
+            envLightData.weight = probe.weight;
+            envLightData.multiplier = probe.multiplier;
             envLightData.influenceExtents = probe.influenceExtents;
             envLightData.blendNormalDistancePositive = probe.blendNormalDistancePositive;
             envLightData.blendNormalDistanceNegative = probe.blendNormalDistanceNegative;
             return (uint)logVolume << 20 | (uint)lightVolumeType << 17 | listType << 16 | ((uint)probeIndex & 0xFFFF);
         }
 
-        void VoxelLightListGeneration(CommandBuffer cmd, HDCamera hdCamera, Matrix4x4 projscr, Matrix4x4 invProjscr, RenderTargetIdentifier cameraDepthBufferRT)
+        void VoxelLightListGeneration(CommandBuffer cmd, HDCamera hdCamera, Matrix4x4[] projscrArr, Matrix4x4[] invProjscrArr, RenderTargetIdentifier cameraDepthBufferRT)
         {
             Camera camera = hdCamera.camera;
             // clear atomic offset index
             cmd.SetComputeIntParam(buildPerVoxelLightListShader, HDShaderIDs._EnvLightIndexShift, m_lightList.lights.Count);
             cmd.SetComputeIntParam(buildPerVoxelLightListShader, HDShaderIDs._DecalIndexShift, m_lightList.lights.Count + m_lightList.envLights.Count);
             cmd.SetComputeIntParam(buildPerVoxelLightListShader, HDShaderIDs.g_iNrVisibLights, m_lightCount);
-            cmd.SetComputeMatrixParam(buildPerVoxelLightListShader, HDShaderIDs.g_mScrProjection, projscr);
-            cmd.SetComputeMatrixParam(buildPerVoxelLightListShader, HDShaderIDs.g_mInvScrProjection, invProjscr);
+            cmd.SetComputeMatrixArrayParam(buildPerVoxelLightListShader, HDShaderIDs.g_mScrProjectionArr, projscrArr);
+            cmd.SetComputeMatrixArrayParam(buildPerVoxelLightListShader, HDShaderIDs.g_mInvScrProjectionArr, invProjscrArr);
 
             cmd.SetComputeIntParam(buildPerVoxelLightListShader, HDShaderIDs.g_iLog2NumClusters, k_Log2NumClusters);
 
 
             var numTilesX = GetNumTileClusteredX(hdCamera);
             var numTilesY = GetNumTileClusteredY(hdCamera);
-            cmd.DispatchCompute(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, numTilesX, numTilesY, 1);
+            int numEyes = m_FrameSettings.enableStereo ? 2 : 1;
+            //cmd.DispatchCompute(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, numTilesX, numTilesY, 1);
+            cmd.DispatchCompute(buildPerVoxelLightListShader, s_GenListPerVoxelKernel, numTilesX, numTilesY, numEyes);
         }
 
         public void BuildGPULightListsCommon(HDCamera hdCamera, CommandBuffer cmd, RenderTargetIdentifier cameraDepthBufferRT, RenderTargetIdentifier stencilTextureRT, bool skyEnabled)
             var invProjscrArr = new Matrix4x4[2];
             if (m_FrameSettings.enableStereo)
             {
+                // XRTODO: If possible, we could generate a non-oblique stereo projection
+                // matrix.  It's ok if it's not the exact same matrix, as long as it encompasses
+                // the same FOV as the original projection matrix (which would mean padding each half
+                // of the frustum with the max half-angle). We don't need the light information in 
+                // real projection space.  We just use screen space to figure out what is proximal
+                // to a cluster or tile.
+                // Once we generate this non-oblique projection matrix, it can be shared across both eyes (un-array)
                 for (int eyeIndex = 0; eyeIndex < 2; eyeIndex++)
                 {
                     projArr[eyeIndex] = CameraProjectionStereoLHS(hdCamera.camera, (Camera.StereoscopicEye)eyeIndex);
             }
 
             // Cluster
-            VoxelLightListGeneration(cmd, hdCamera, projscrArr[0], invProjscrArr[0], cameraDepthBufferRT);
+            VoxelLightListGeneration(cmd, hdCamera, projscrArr, invProjscrArr, cameraDepthBufferRT);
 
             if (enableFeatureVariants)
             {

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

 // these uniforms are only needed for when OPAQUES_ONLY is NOT defined
 // but there's a problem with our front-end compilation of compute shaders with multiple kernels causing it to error
 //#ifdef USE_CLUSTERED_LIGHTLIST
-float4x4 g_mInvScrProjection;
+float4x4 g_mInvScrProjection; // TODO: remove, unused in HDRP
 
 float g_fClustScale;
 float g_fClustBase;
 TEXTURE2D_ARRAY(_Env2DTextures);
 float4x4 _Env2DCaptureVP[MAX_ENV2D_LIGHT];
 
+// XRTODO: Need to stereo-ize access
 TEXTURE2D(_DeferredShadowTexture);
 
 CBUFFER_START(UnityPerLightLoop)
     float logBase = g_fClustBase;
     if (g_isLogBaseBufferEnabled)
     {
+        // XRTODO: Stereo-ize access to g_logBaseBuffer
         logBase = g_logBaseBuffer[tileIndex.y * _NumTileClusteredX + tileIndex.x];
     }
 
     float logBase = g_fClustBase;
     if (g_isLogBaseBufferEnabled)
     {
-        logBase = g_logBaseBuffer[tileIndex.y * _NumTileClusteredX + tileIndex.x];
+        const uint logBaseIndex = GenerateLogBaseBufferIndex(tileIndex, _NumTileClusteredX, _NumTileClusteredY, unity_StereoEyeIndex);
+        logBase = g_logBaseBuffer[logBaseIndex];
     }
 
     return SnapToClusterIdxFlex(linearDepth, logBase, g_isLogBaseBufferEnabled != 0);
 {
     int nrClusters = (1 << g_iLog2NumClusters);
-    const int idx = ((lightCategory * nrClusters + clusterIndex) * _NumTileClusteredY + tileIndex.y) * _NumTileClusteredX + tileIndex.x;
+
+    const int idx = GenerateLayeredOffsetBufferIndex(lightCategory, tileIndex, clusterIndex, _NumTileClusteredX, _NumTileClusteredY, nrClusters, unity_StereoEyeIndex);
+
     uint dataPair = g_vLayeredOffsetsBuffer[idx];
     start = dataPair & 0x7ffffff;
     lightCount = (dataPair >> 27) & 31;
 {
+    // Note: XR depends on unity_StereoEyeIndex already being defined,
+    // which means ShaderVariables.hlsl needs to be defined ahead of this!
+
     uint2 tileIndex    = posInput.tileCoord;
     uint  clusterIndex = GetLightClusterIndex(tileIndex, posInput.linearDepth);
 

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

 {
 	return EvalShadow_GetClosestSample_Punctual( shadowContext, shadowContext.tex2DArray[SHADOW_DISPATCH_PUNC_TEX], positionWS, index, L );
 }
+
+float GetPunctualShadowClosestDistance( ShadowContext shadowContext, SamplerState sampl, real3 positionWS, int index, float3 L, float3 lightPositionWS)
+{
+	return EvalShadow_SampleClosestDistance_Punctual( shadowContext, shadowContext.tex2DArray[SHADOW_DISPATCH_PUNC_TEX], sampl, positionWS, index, L, lightPositionWS );
+}
+
 #endif
 
 // cleanup the defines

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/lightlistbuild-bigtile.compute

 	uint2 viTilLL = 64*tileIDX;
 	uint2 viTilUR = min( viTilLL+uint2(64,64), uint2(iWidth, iHeight) );			// not width and height minus 1 since viTilUR represents the end of the tile corner.
 
-    // 'Normalized' coordinates of tile
+    // 'Normalized' coordinates of tile, for use with AABB bounds in g_vBoundsBuffer
 	float2 vTileLL = float2(viTilLL.x/(float) iWidth, viTilLL.y/(float) iHeight);
 	float2 vTileUR = float2(viTilUR.x/(float) iWidth, viTilUR.y/(float) iHeight);
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/lightlistbuild-clustered.compute

 #include "ShaderBase.hlsl"
 #include "LightLoop.cs.hlsl"
 #include "LightingConvexHullUtils.hlsl"
+#include "LightCullUtils.hlsl"
 
 #if !defined(SHADER_API_XBOXONE) && !defined(SHADER_API_PSSL)
 #include "SortingComputeUtils.hlsl"
 
 CBUFFER_START(UnityLightListClustered)
 int g_iNrVisibLights;
-float4x4 g_mInvScrProjection;
-float4x4 g_mScrProjection;
+
+float4x4 g_mInvScrProjectionArr[2];
+float4x4 g_mScrProjectionArr[2];
+
 uint g_isOrthographic;
 int _EnvLightIndexShift;
 int _DecalIndexShift;
 
 CBUFFER_END
 
+// ClusteredUtils.hlsl is dependent on the constants declared in UnityLightListClustered :/
+// g_fClustBase, g_fNearPlane, g_fFarPlane, g_iLog2NumClusters
-
 
 #ifdef MSAA_ENABLED
 Texture2DMS<float> g_depth_tex : register( t0 );
 
 #define NR_THREADS			64
 
-// output buffer
 RWStructuredBuffer<uint> g_vLayeredLightList : register( u0 );			// don't support RWBuffer yet in unity
 RWStructuredBuffer<uint> g_LayeredOffset : register( u1 );				// don't support RWBuffer yet in unity
 RWStructuredBuffer<uint> g_LayeredSingleIdxBuffer : register( u2 );		// don't support RWBuffer yet in unity
 
 groupshared unsigned int coarseList[MAX_NR_COARSE_ENTRIES];
 groupshared unsigned int clusterIdxs[MAX_NR_COARSE_ENTRIES/2];
-groupshared float4 lightPlanes[4*6];
+groupshared float4 lightPlanes[4*6]; // Each plane is defined by a float4. 6 planes per light, 4 lights (24 planes)
 
 groupshared uint lightOffs;
 
 groupshared uint lightOffsSph;
 #endif
 
-float GetLinearDepth(float zDptBufSpace)    // 0 is near 1 is far
+float GetLinearDepth(float zDptBufSpace, uint eyeIndex)    // 0 is near 1 is far
+    float4x4 g_mInvScrProjection = g_mInvScrProjectionArr[eyeIndex];
+
     // for perspective projection m22 is zero and m23 is +1/-1 (depends on left/right hand proj)
 	// however this function must also work for orthographic projection so we keep it like this.
     float m22 = g_mInvScrProjection[2].z, m23 = g_mInvScrProjection[2].w;
     //return v4Pres.z / v4Pres.w;
 }
 
-float3 GetViewPosFromLinDepth(float2 v2ScrPos, float fLinDepth)
+float3 GetViewPosFromLinDepth(float2 v2ScrPos, float fLinDepth, uint eyeIndex)
+    float4x4 g_mScrProjection = g_mScrProjectionArr[eyeIndex];
+
 	bool isOrthographic = g_isOrthographic!=0;
 	float fSx = g_mScrProjection[0].x;
 	float fSy = g_mScrProjection[1].y;
 	return float3(isOrthographic ? p.xy : (fLinDepth*p.xy), fLinDepth);
 }
 
-float GetOnePixDiagWorldDistAtDepthOne()
+float GetOnePixDiagWorldDistAtDepthOne(uint eyeIndex)
+    float4x4 g_mScrProjection = g_mScrProjectionArr[eyeIndex];
 	float fSx = g_mScrProjection[0].x;
 	float fSy = g_mScrProjection[1].y;
 
+// SphericalIntersectionTests and CullByExactEdgeTests are close to the versions
+// in lightlistbuild-bigtile.compute.  But would need more re-factoring than needed
+// right now.
+
-int CullByExactEdgeTests(uint threadID, int iNrCoarseLights, uint2 viTilLL, uint2 viTilUR, float fTileFarPlane);
+int CullByExactEdgeTests(uint threadID, int iNrCoarseLights, uint2 viTilLL, uint2 viTilUR, float fTileFarPlane, uint eyeIndex);
-int SphericalIntersectionTests(uint threadID, int iNrCoarseLights, float2 screenCoordinate);
+int SphericalIntersectionTests(uint threadID, int iNrCoarseLights, float2 screenCoordinate, uint eyeIndex);
-float4 FetchPlane(int l, int p);
+float4 FetchPlane(int l, int p, uint eyeIndex);
-
-bool CheckIntersection(int l, int k, uint2 viTilLL, uint2 viTilUR, float suggestedBase)
+bool CheckIntersection(int l, int k, uint2 viTilLL, uint2 viTilUR, float suggestedBase, uint eyeIndex)
+    // If this light's screen space depth bounds intersect this cluster...simple cluster test
+    // TODO: Unify this code with the code in CheckIntersectionBasic...
 	unsigned int val = (clusterIdxs[l>>1]>>(16*(l&1)))&0xffff;
 	bool bIsHit = ((val>>0)&0xff)<=((uint) k) && ((uint) k)<=((val>>8)&0xff);
 	if(bIsHit)
 				float x = (i&1)==0 ? viTilLL.x : viTilUR.x;
 				float y = (i&2)==0 ? viTilLL.y : viTilUR.y;
 				float z = (i&4)==0 ? depthAtNearZ : depthAtFarZ;
-				float3 vP = GetViewPosFromLinDepth( float2(x, y), z);
+                float3 vP = GetViewPosFromLinDepth( float2(x, y), z, eyeIndex);
+                // Test each corner of the cluster against the light bounding box planes
 				bAllInvisib = bAllInvisib && dot(plane, float4(vP,1.0))>0;
 			}
 
 	return bIsHit;
 }
 
+// l is the coarse light index, k is the cluster index
 bool CheckIntersectionBasic(int l, int k)
 {
 	unsigned int val = (clusterIdxs[l>>1]>>(16*(l&1)))&0xffff;
 [numthreads(NR_THREADS, 1, 1)]
 void LIGHTLISTGEN(uint threadID : SV_GroupIndex, uint3 u3GroupID : SV_GroupID)
 {
+    uint eyeIndex = u3GroupID.z;
+
 	uint2 tileIDX = u3GroupID.xy;
 	uint t=threadID;
 
 
+    // Screen space coordinates of clustered tile
 	uint2 viTilLL = TILE_SIZE_CLUSTERED*tileIDX;
 	uint2 viTilUR = min( viTilLL+uint2(TILE_SIZE_CLUSTERED,TILE_SIZE_CLUSTERED), uint2(g_screenSize.x, g_screenSize.y) );		// not width and height minus 1 since viTilUR represents the end of the tile corner.
 
 
 	for(int idx=t; idx<(TILE_SIZE_CLUSTERED*TILE_SIZE_CLUSTERED); idx+=NR_THREADS)
 	{
+        // XRTODO: We need to stereo-ize access to g_depth_tex for texture arrays.
+
+        // TODO: For stereo double-wide, I need a proper way to insert the second eye width offset. Right now, I can just
+        // use g_screenSize.x, but that's kinda cheating.
+        // Additionally, we're going to have a method to select between a doublewide texture or texture array. Doubling
+        // the kernels seems like a bad idea.  We could branch our texture read to switch between different texture declarations.
+        uint stereoDWOffset = eyeIndex * g_screenSize.x;
+        uPixCrd.x += stereoDWOffset;
 #ifdef MSAA_ENABLED
 		for(int i=0; i<g_iNumSamplesMSAA; i++)
 		{
 #endif
 	}
 
+    // Why is this a uint? Doesn't InterlockedMax support shared mem floats?
 	InterlockedMax(ldsZMax, asuint(dpt_ma) );
 
 
 	if(dpt_ma<=0.0) dpt_ma = VIEWPORT_SCALE_Z;		// assume sky pixel
 #endif
 
+    // 'Normalized' coordinates of tile, for use with AABB bounds in g_vBoundsBuffer
 	float2 vTileLL = float2(viTilLL.x/g_screenSize.x, viTilLL.y/g_screenSize.y);
 	float2 vTileUR = float2(viTilUR.x/g_screenSize.x, viTilUR.y/g_screenSize.y);
 
 
-	int NrBigTilesX = (nrTilesX+((1<<log2BigTileToClustTileRatio)-1))>>log2BigTileToClustTileRatio;
-	const int bigTileIdx = (tileIDX.y>>log2BigTileToClustTileRatio)*NrBigTilesX + (tileIDX.x>>log2BigTileToClustTileRatio);		// map the idx to 64x64 tiles
-	int nrBigTileLights = g_vBigTileLightList[MAX_NR_BIG_TILE_LIGHTS_PLUS_ONE*bigTileIdx+0];
+    int NrBigTilesX = (nrTilesX + ((1<<log2BigTileToClustTileRatio)-1)) >> log2BigTileToClustTileRatio;
+    int NrBigTilesY = (nrTilesY + ((1<<log2BigTileToClustTileRatio)-1)) >> log2BigTileToClustTileRatio;
+    const int bigTileBase = eyeIndex * NrBigTilesX * NrBigTilesY;
+	const int bigTileIdx = bigTileBase + ((tileIDX.y>>log2BigTileToClustTileRatio)*NrBigTilesX) + (tileIDX.x>>log2BigTileToClustTileRatio);		// map the idx to 64x64 tiles
+	
+    int nrBigTileLights = g_vBigTileLightList[MAX_NR_BIG_TILE_LIGHTS_PLUS_ONE*bigTileIdx+0];
 	for(int l0=(int) t; l0<(int) nrBigTileLights; l0 += NR_THREADS)
 	{
 		int l = g_vBigTileLightList[MAX_NR_BIG_TILE_LIGHTS_PLUS_ONE*bigTileIdx+l0+1];
 #endif
-		const float2 vMi = g_vBoundsBuffer[l].xy;
-		const float2 vMa = g_vBoundsBuffer[l+g_iNrVisibLights].xy;
+        // TODO: Seems kinda funny that we repeat this exact code here, bigtile, and FPTL...
+
+        const ScreenSpaceBoundsIndices boundsIndices = GenerateScreenSpaceBoundsIndices(l, g_iNrVisibLights, eyeIndex);
+        const float2 vMi = g_vBoundsBuffer[boundsIndices.min].xy;
+        const float2 vMa = g_vBoundsBuffer[boundsIndices.max].xy;
 
 		if( all(vMa>vTileLL) && all(vMi<vTileUR))
 		{
 	int iNrCoarseLights = min(lightOffs,MAX_NR_COARSE_ENTRIES);
 
 #ifdef PERFORM_SPHERICAL_INTERSECTION_TESTS
-	iNrCoarseLights = SphericalIntersectionTests( t, iNrCoarseLights, float2(min(viTilLL.xy+uint2(TILE_SIZE_CLUSTERED/2,TILE_SIZE_CLUSTERED/2), uint2(g_screenSize.x-1, g_screenSize.y-1))) );
+	iNrCoarseLights = SphericalIntersectionTests( t, iNrCoarseLights, float2(min(viTilLL.xy+uint2(TILE_SIZE_CLUSTERED/2,TILE_SIZE_CLUSTERED/2), uint2(g_screenSize.x-1, g_screenSize.y-1))), eyeIndex );
-	float fTileFarPlane = GetLinearDepth(dpt_ma);
-#else
-	float fTileFarPlane = -GetLinearDepth(dpt_ma);
+    float fTileFarPlane = GetLinearDepth(dpt_ma, eyeIndex);
+#else // USE_LEFT_HAND_CAMERA_SPACE
+    float fTileFarPlane = -GetLinearDepth(dpt_ma, eyeIndex);
-#else
+#else // ENABLE_DEPTH_TEXTURE_BACKPLANE
 	float fTileFarPlane = g_fFarPlane;
 	float suggestedBase = g_fClustBase;
 #endif
-	iNrCoarseLights = CullByExactEdgeTests(t, iNrCoarseLights, viTilLL.xy, viTilUR.xy, fTileFarPlane);
+    iNrCoarseLights = CullByExactEdgeTests(t, iNrCoarseLights, viTilLL.xy, viTilUR.xy, fTileFarPlane, eyeIndex);
+    // NOTE: Why not sort on console?
 #if !defined(SHADER_API_XBOXONE) && !defined(SHADER_API_PSSL)
 	SORTLIST(coarseList, iNrCoarseLights, MAX_NR_COARSE_ENTRIES, t, NR_THREADS);
 #endif
+        // TODO: We should write some encode/decode functions to help put cluster indices into the shared mem buffer,
+        // and extract them later.  The code that reads from clusterIdx is hairy.
+
-			const unsigned int clustIdxMi0 = (const unsigned int) min(255,SnapToClusterIdx(GetLinearDepth(g_vBoundsBuffer[l0].z), suggestedBase));
-			const unsigned int clustIdxMa0 = (const unsigned int) min(255,SnapToClusterIdx(GetLinearDepth(g_vBoundsBuffer[l0+g_iNrVisibLights].z), suggestedBase));
-			const unsigned int clustIdxMi1 = (const unsigned int) min(255,SnapToClusterIdx(GetLinearDepth(g_vBoundsBuffer[l1].z), suggestedBase));
-			const unsigned int clustIdxMa1 = (const unsigned int) min(255,SnapToClusterIdx(GetLinearDepth(g_vBoundsBuffer[l1+g_iNrVisibLights].z), suggestedBase));
+            const ScreenSpaceBoundsIndices l0Bounds = GenerateScreenSpaceBoundsIndices(l0, g_iNrVisibLights, eyeIndex);
+            const ScreenSpaceBoundsIndices l1Bounds = GenerateScreenSpaceBoundsIndices(l1, g_iNrVisibLights, eyeIndex);
+            const unsigned int clustIdxMi0 = (const unsigned int)min(255, SnapToClusterIdx(GetLinearDepth(g_vBoundsBuffer[l0Bounds.min].z, eyeIndex), suggestedBase));
+            const unsigned int clustIdxMa0 = (const unsigned int)min(255, SnapToClusterIdx(GetLinearDepth(g_vBoundsBuffer[l0Bounds.max].z, eyeIndex), suggestedBase));
+            const unsigned int clustIdxMi1 = (const unsigned int)min(255, SnapToClusterIdx(GetLinearDepth(g_vBoundsBuffer[l1Bounds.min].z, eyeIndex), suggestedBase));
+            const unsigned int clustIdxMa1 = (const unsigned int)min(255, SnapToClusterIdx(GetLinearDepth(g_vBoundsBuffer[l1Bounds.max].z, eyeIndex), suggestedBase));
 			clusterIdxs[l] = (clustIdxMa1<<24) | (clustIdxMi1<<16) | (clustIdxMa0<<8) | (clustIdxMi0<<0);
 		}
 	}
 	int iSum = 0;
 	if(i<nrClusters)
 	{
+        // Each thread checks it's respective cluster against all coarse lights for intersection.
+        // At the end, 'iSum' represents the number of lights that intersect this cluster!
+        // We have a limit to the number of lights we will track in a cluster (128). This is how much memory we
+        // want to allocate out of g_LayeredSingleIdxBuffer.
 		iSpaceAvail = min(iSum,MAX_NR_COARSE_ENTRIES);							// combined storage for both direct lights and reflection
 		InterlockedAdd(g_LayeredSingleIdxBuffer[0], (uint) iSpaceAvail, start);		// alloc list memory
 	}
 	int shiftIndex[LIGHTCATEGORY_COUNT];
 	ZERO_INITIALIZE_ARRAY(int, shiftIndex, LIGHTCATEGORY_COUNT);
+    // NOTE: Why is this indexed like this?
+
-		if(i<24) lightPlanes[6*m+p] = FetchPlane(min(iNrCoarseLights-1,ll+m), p);
+		if(i<24) lightPlanes[6*m+p] = FetchPlane(min(iNrCoarseLights-1,ll+m), p, eyeIndex);
+
 #if !defined(SHADER_API_XBOXONE) && !defined(SHADER_API_PSSL)
 		GroupMemoryBarrierWithGroupSync();
 #endif
-			if(offs<(start+iSpaceAvail) && i<nrClusters && CheckIntersection(l, i, viTilLL.xy, viTilUR.xy, suggestedBase) )
+			if(offs<(start+iSpaceAvail) && i<nrClusters && CheckIntersection(l, i, viTilLL.xy, viTilUR.xy, suggestedBase, eyeIndex) )
-				uint lightCategory = _LightVolumeData[coarseList[l]].lightCategory;
+                const int lightVolIndex = GenerateLightCullDataIndex(coarseList[l], g_iNrVisibLights, eyeIndex);
+                uint lightCategory = _LightVolumeData[lightVolIndex].lightCategory;
-			}
+            }
 		}
 
 #if !defined(SHADER_API_XBOXONE) && !defined(SHADER_API_PSSL)
 
 	uint localOffs=0;
-	offs = i*nrTilesX*nrTilesY + tileIDX.y*nrTilesX + tileIDX.x;
+
+    offs = GenerateLayeredOffsetBufferIndex(0, tileIDX, i, nrTilesX, nrTilesY, nrClusters, eyeIndex);
 	for(int category=0; category<LIGHTCATEGORY_COUNT; category++)
 	{
 		int numLights = min(categoryListCount[category],31);		// only allow 5 bits
 	}
 
 #ifdef ENABLE_DEPTH_TEXTURE_BACKPLANE
-	if(threadID==0) g_logBaseBuffer[tileIDX.y*nrTilesX + tileIDX.x] = suggestedBase;
+    const uint logBaseIndex = GenerateLogBaseBufferIndex(tileIDX, nrTilesX, nrTilesY, eyeIndex);
+	if(threadID==0) g_logBaseBuffer[logBaseIndex] = suggestedBase;
-float4 FetchPlane(int l, int p)
+float4 FetchPlane(int l, int p, uint eyeIndex)
-	SFiniteLightBound lgtDat = g_data[coarseList[l]];
+    const int lightBoundIndex = GenerateLightCullDataIndex(coarseList[l], g_iNrVisibLights, eyeIndex);
+    SFiniteLightBound lgtDat = g_data[lightBoundIndex];
 
 	const float3 boxX = lgtDat.boxAxisX.xyz;
 	const float3 boxY = lgtDat.boxAxisY.xyz;
 
 
 
-
-int SphericalIntersectionTests(uint threadID, int iNrCoarseLights, float2 screenCoordinate)
+int SphericalIntersectionTests(uint threadID, int iNrCoarseLights, float2 screenCoordinate, uint eyeIndex)
-	float3 V = GetViewPosFromLinDepth( screenCoordinate, 1.0);
+    float3 V = GetViewPosFromLinDepth( screenCoordinate, 1.0, eyeIndex);
-	float3 V = GetViewPosFromLinDepth( screenCoordinate, -1.0);
+	float3 V = GetViewPosFromLinDepth( screenCoordinate, -1.0, eyeIndex);
-	float onePixDiagDist = GetOnePixDiagWorldDistAtDepthOne();
+    float onePixDiagDist = GetOnePixDiagWorldDistAtDepthOne(eyeIndex);
-		SFiniteLightBound lgtDat = g_data[coarseList[l]];
+        const int lightBoundIndex = GenerateLightCullDataIndex(coarseList[l], g_iNrVisibLights, eyeIndex);
+        SFiniteLightBound lgtDat = g_data[lightBoundIndex];
 
 		if( !DoesSphereOverlapTile(V, halfTileSizeAtZDistOne, lgtDat.center.xyz, lgtDat.radius, g_isOrthographic!=0) )
 			coarseList[l]=UINT_MAX;
 
 #ifdef EXACT_EDGE_TESTS
 
-float3 GetTileVertex(uint2 viTilLL, uint2 viTilUR, int i, float fTileFarPlane)
+float3 GetTileVertex(uint2 viTilLL, uint2 viTilUR, int i, float fTileFarPlane, uint eyeIndex)
 {
 	float x = (i&1)==0 ? viTilLL.x : viTilUR.x;
 	float y = (i&2)==0 ? viTilLL.y : viTilUR.y;
 #endif
-	return GetViewPosFromLinDepth( float2(x, y), z);
+    return GetViewPosFromLinDepth( float2(x, y), z, eyeIndex);
-void GetFrustEdge(out float3 vP0, out float3 vE0, const int e0, uint2 viTilLL, uint2 viTilUR, float fTileFarPlane)
+void GetFrustEdge(out float3 vP0, out float3 vE0, const int e0, uint2 viTilLL, uint2 viTilUR, float fTileFarPlane, uint eyeIndex)
-	vP0 = GetTileVertex(uint2(viTilLL.x, viTilUR.y), uint2(viTilUR.x, viTilLL.y), i, fTileFarPlane);
+    vP0 = GetTileVertex(uint2(viTilLL.x, viTilUR.y), uint2(viTilUR.x, viTilLL.y), i, fTileFarPlane, eyeIndex);
 
 #if USE_LEFT_HAND_CAMERA_SPACE
 	float3 edgeSectionZero = g_isOrthographic==0 ? vP0 : float3(0.0,0.0,1.0);
 	vE0 = iSection == 0 ? edgeSectionZero : (((iSwizzle & 0x2) == 0 ? 1.0f : (-1.0f)) * ((int)(iSwizzle & 0x1) == (iSwizzle >> 1) ? float3(1, 0, 0) : float3(0, 1, 0)));
 }
 
-int CullByExactEdgeTests(uint threadID, int iNrCoarseLights, uint2 viTilLL, uint2 viTilUR, float fTileFarPlane)
+int CullByExactEdgeTests(uint threadID, int iNrCoarseLights, uint2 viTilLL, uint2 viTilUR, float fTileFarPlane, uint eyeIndex)
 {
 	if(threadID==0) lightOffs2 = 0;
 
 #if !defined(SHADER_API_XBOXONE) && !defined(SHADER_API_PSSL)
 		GroupMemoryBarrierWithGroupSync();
 #endif
-		const int idxCoarse = coarseList[l];
-		UNITY_BRANCH if (_LightVolumeData[idxCoarse].lightVolume != LIGHTVOLUMETYPE_SPHERE)		// don't bother doing edge tests for sphere lights since these have camera aligned bboxes.
+        const int lightCullIndex = GenerateLightCullDataIndex(coarseList[l], g_iNrVisibLights, eyeIndex);
+		UNITY_BRANCH if (_LightVolumeData[lightCullIndex].lightVolume != LIGHTVOLUMETYPE_SPHERE)		// don't bother doing edge tests for sphere lights since these have camera aligned bboxes.
-			SFiniteLightBound lgtDat = g_data[idxCoarse];
+            SFiniteLightBound lgtDat = g_data[lightCullIndex];
 
 			const float3 boxX = lgtDat.boxAxisX.xyz;
 			const float3 boxY = lgtDat.boxAxisY.xyz;
 
 
 				float3 vP1, vE1;
-				GetFrustEdge(vP1, vE1, e1, viTilLL, viTilUR, fTileFarPlane);
+                GetFrustEdge(vP1, vE1, e1, viTilLL, viTilUR, fTileFarPlane, eyeIndex);
 
 				// potential separation plane
 				float3 vN = cross(vE0, vE1);
 				positive=0; negative=0;
 				for(int j=0; j<8; j++)
 				{
-					float3 vPf = GetTileVertex(viTilLL, viTilUR, j, fTileFarPlane);
+                    float3 vPf = GetTileVertex(viTilLL, viTilUR, j, fTileFarPlane, eyeIndex);
 					float fSignDist = dot(vN, vPf-vP0);
 					if(fSignDist>0) ++positive; else if(fSignDist<0) ++negative;
 				}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightUtilities.hlsl

     output.influenceRight = float3(1.0, 0.0, 0.0);
     output.influencePositionWS = float3(0.0, 0.0, 0.0);
 
-    output.dimmer = 1.0;
+    output.weight = 1.0;
+    output.multiplier = 1.0;
 
     // proxy
     output.proxyForward = float3(0.0, 0.0, 1.0);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Reflection/HDAdditionalReflectionData.cs

-using UnityEngine.Experimental.Rendering.HDPipeline;
+using UnityEngine.Serialization;
+using UnityEngine.Experimental.Rendering.HDPipeline;
 
 namespace UnityEngine.Experimental.Rendering
 {
 #pragma warning restore 414
 
         public ShapeType influenceShape;
-        [Range(0.0f,1.0f)]
-        public float dimmer = 1.0f;
+        [FormerlySerializedAsAttribute("dimmer")]
+        public float multiplier = 1.0f;
+        [Range(0.0f, 1.0f)]
+        public float weight = 1.0f;
         public float influenceSphereRadius = 3.0f;
         public float sphereReprojectionVolumeRadius = 1.0f;
         public bool useSeparateProjectionVolume = false;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Reflection/PlanarReflectionProbe.cs

-using UnityEngine.Rendering;
+using UnityEngine.Serialization;
+using UnityEngine.Rendering;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
         [SerializeField]
         Vector3 m_CaptureLocalPosition;
         [SerializeField]
-        [Range(0, 1)]
-        float m_Dimmer = 1;
+        [FormerlySerializedAsAttribute("m_Dimmer")]
+        float m_Multiplier = 1.0f;
+        [SerializeField]
+        [Range(0.0f, 1.0f)]
+        float m_Weight = 1.0f;
         [SerializeField]
         ReflectionProbeMode m_Mode = ReflectionProbeMode.Baked;
         [SerializeField]
         }
         public Bounds bounds { get { return m_InfluenceVolume.GetBoundsAt(transform); } }
         public Vector3 captureLocalPosition { get { return m_CaptureLocalPosition; } set { m_CaptureLocalPosition = value; } }
-        public float dimmer { get { return m_Dimmer; } }
+        public float weight { get { return m_Weight; } }
+        public float multiplier { get { return m_Multiplier; } }
         public ReflectionProbeMode mode { get { return m_Mode; } }
         public Matrix4x4 influenceToWorld
         {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Reflection/ProbeWrapper.cs

         public abstract ReflectionProbeMode mode { get; }
         public abstract Texture texture { get; }
         // Position of the center of the probe in capture space
-        public abstract float dimmer { get; }
+        public abstract float weight { get; }
+        public abstract float multiplier { get; }
         public abstract Matrix4x4 influenceToWorld { get; }
         public abstract EnvShapeType influenceShapeType { get; }
         public abstract Vector3 influenceExtents { get; }
         public override Texture texture { get { return probe.texture; } }
         public override ReflectionProbeMode mode { get { return probe.probe.mode; } }
         public override EnvShapeType influenceShapeType { get { return ConvertShape(additional.influenceShape); } }
-        public override float dimmer { get { return additional.dimmer; } }
+        public override float weight { get { return additional.weight; } }
+        public override float multiplier { get { return additional.multiplier; } }
         public override Vector3 influenceExtents
         {
             get
         public override Matrix4x4 influenceToWorld { get { return planarReflectionProbe.influenceToWorld; } }
         public override Texture texture { get { return planarReflectionProbe.texture; } }
         public override EnvShapeType influenceShapeType { get { return ConvertShape(planarReflectionProbe.influenceVolume.shapeType); } }
-        public override float dimmer { get { return planarReflectionProbe.dimmer; } }
+        public override float weight { get { return planarReflectionProbe.weight; } }
+        public override float multiplier { get { return planarReflectionProbe.multiplier; } }
         public override Vector3 influenceExtents
         {
             get

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

 // Additional bits set in 'bsdfData.materialFeatures' to save registers and simplify feature tracking.
 #define MATERIAL_FEATURE_FLAGS_SSS_OUTPUT_SPLIT_LIGHTING         ((MATERIAL_FEATURE_MASK_FLAGS + 1) << 0)
 #define MATERIAL_FEATURE_FLAGS_SSS_TEXTURING_MODE_OFFSET FastLog2((MATERIAL_FEATURE_MASK_FLAGS + 1) << 1) // 2 bits
-#define MATERIAL_FEATURE_FLAGS_TRANSMISSION_MODE_AUTO_THICKNESS  ((MATERIAL_FEATURE_MASK_FLAGS + 1) << 3)
+#define MATERIAL_FEATURE_FLAGS_TRANSMISSION_MODE_MIXED_THICKNESS ((MATERIAL_FEATURE_MASK_FLAGS + 1) << 3)
 
 uint FeatureFlagsToTileVariant(uint featureFlags)
 {
     // the current object. That's not a problem, since large thickness will result in low intensity.
     bool useThinObjectMode = IsBitSet(asuint(_TransmissionFlags), diffusionProfile);
 
-    bsdfData.materialFeatures |= useThinObjectMode ? 0 : MATERIAL_FEATURE_FLAGS_TRANSMISSION_MODE_AUTO_THICKNESS;
+    bsdfData.materialFeatures |= useThinObjectMode ? 0 : MATERIAL_FEATURE_FLAGS_TRANSMISSION_MODE_MIXED_THICKNESS;
 
     // Compute transmittance using baked thickness here. It may be overridden for direct lighting
     // in the auto-thickness mode (but is always be used for indirect lighting).
     // Decompress feature-agnostic data from the G-Buffer.
     float3 baseColor = inGBuffer0.rgb;
 
-    bsdfData.specularOcclusion   = inGBuffer0.a; // Later possibly overwritten by SSS
-    bsdfData.perceptualRoughness = inGBuffer1.a;
-
+    bsdfData.perceptualRoughness = inGBuffer1.a;
 
     bakeDiffuseLighting = inGBuffer3.rgb;
 
             FillMaterialTransmission(sssData.diffusionProfile, inGBuffer2.g, bsdfData);
         }
     }
+    else
+    {
+        bsdfData.specularOcclusion = inGBuffer0.a;
+    }
 
     // Special handling for anisotropy: When anisotropy is present in a tile, the whole tile will use anisotropy to avoid divergent evaluation of GGX that increase the cost
     // 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)
 // - we integrate the diffuse reflectance profile w.r.t. the radius (while also accounting
 //   for the thickness) to compute the transmittance;
 // - we multiply the transmitted radiance by the transmittance.
-float3 EvaluateTransmission(BSDFData bsdfData, float3 transmittance, float NdotL, float NdotV, float attenuation)
+float3 EvaluateTransmission(BSDFData bsdfData, float3 transmittance, float NdotL, float NdotV, float LdotV, float attenuation)
+    // Apply wrapped lighting to better handle thin objects at grazing angles.
-    float negatedNdotL = -NdotL;
-
-    // Apply wrapped lighting to better handle thin objects (cards) at grazing angles.
-    bool  autoThicknessMode = HasFeatureFlag(bsdfData.materialFeatures, MATERIAL_FEATURE_FLAGS_TRANSMISSION_MODE_AUTO_THICKNESS);
-    float backNdotL         = autoThicknessMode ? negatedNdotL : wrappedNdotL;
 
     // Apply BSDF-specific diffuse transmission to attenuation. See also: [SSS-NOTE-TRSM]
     // We don't multiply by 'bsdfData.diffuseColor' here. It's done only once in PostEvaluateBSDF().
-    attenuation *= INV_PI * F_Transm_Schlick(0, 0.5, NdotV) * F_Transm_Schlick(0, 0.5, abs(backNdotL));
+    attenuation *= DisneyDiffuse(NdotV, max(0, -NdotL), LdotV, bsdfData.perceptualRoughness);
-    float intensity = max(0, attenuation * backNdotL); // Warning: attenuation can be greater than 1 due to the inverse square attenuation (when position is close to light)
-
+    float intensity = attenuation * wrappedNdotL;
     return intensity * transmittance;
 }
 
 
     float3 N     = bsdfData.normalWS;
     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
-
-    float3 transmittance     = bsdfData.transmittance;
-    bool   autoThicknessMode = HasFeatureFlag(bsdfData.materialFeatures, MATERIAL_FEATURE_FLAGS_TRANSMISSION_MODE_AUTO_THICKNESS);
-
-    UNITY_BRANCH
-    if (autoThicknessMode && NdotL < 0 && lightData.shadowIndex >= 0)
-    {
-        // TODO: perform bilinear filtering of the shadow map.
-        // Recompute transmittance using the thickness value computed from the shadow map.
-        float3 occluderPosWS = GetDirectionalShadowClosestSample(lightLoopContext.shadowContext, posInput.positionWS, bsdfData.normalWS, lightData.shadowIndex, float4(L, 0));
-
-        float thicknessInUnits       = distance(posInput.positionWS, occluderPosWS);
-        float thicknessInMeters      = thicknessInUnits * _WorldScales[bsdfData.diffusionProfile].x;
-        float thicknessInMillimeters = thicknessInMeters * MILLIMETERS_PER_METER;
-
-        // TODO: optimize.
-    #if SHADEROPTIONS_USE_DISNEY_SSS
-        transmittance = ComputeTransmittanceDisney(_ShapeParams[bsdfData.diffusionProfile].rgb,
-                                                   _TransmissionTintsAndFresnel0[bsdfData.diffusionProfile].rgb,
-                                                   thicknessInMillimeters);
-    #else
-        transmittance = ComputeTransmittanceJimenez(_HalfRcpVariancesAndWeights[bsdfData.diffusionProfile][0].rgb,
-                                                    _HalfRcpVariancesAndWeights[bsdfData.diffusionProfile][0].a,
-                                                    _HalfRcpVariancesAndWeights[bsdfData.diffusionProfile][1].rgb,
-                                                    _HalfRcpVariancesAndWeights[bsdfData.diffusionProfile][1].a,
-                                                    _TransmissionTintsAndFresnel0[bsdfData.diffusionProfile].rgb,
-                                                    thicknessInMillimeters);
-    #endif
-
-        // Make sure we do not sample the shadow map twice.
-        lightData.shadowIndex = -1;
-        // Note: we do not modify the distance to the light, or the light angle for the back face.
-        // This is a performance-saving optimization which makes sense as long as the thickness is small.
-    }
+    float  NdotV = ClampNdotV(preLightData.NdotV);
+    float  NdotL = dot(N, L);
+    float  LdotV = dot(L, V);
 
     float3 color;
     float attenuation;
         lighting.specular *= intensity * lightData.specularScale;
     }
 
-    // TODO: move this before BSDF() to save VGPRs.
-    if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
+    // The mixed thickness mode is not supported by directional lights due to poor quality and high performance impact.
+    bool mixedThicknessMode = HasFeatureFlag(bsdfData.materialFeatures, MATERIAL_FEATURE_FLAGS_TRANSMISSION_MODE_MIXED_THICKNESS);
+
+    if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION) && !mixedThicknessMode)
-        lighting.diffuse += EvaluateTransmission(bsdfData, transmittance, NdotL, ClampNdotV(preLightData.NdotV), attenuation * lightData.diffuseScale);
+        lighting.diffuse += EvaluateTransmission(bsdfData, bsdfData.transmittance, NdotL, NdotV, LdotV, attenuation * lightData.diffuseScale);
     }
 
     // Save ALU by applying light and cookie colors only once.
     }
 
     float3 N     = bsdfData.normalWS;
+    float  NdotV = ClampNdotV(preLightData.NdotV);
+    float  LdotV = dot(L, V);
-    float3 transmittance     = bsdfData.transmittance;
-    bool   autoThicknessMode = HasFeatureFlag(bsdfData.materialFeatures, MATERIAL_FEATURE_FLAGS_TRANSMISSION_MODE_AUTO_THICKNESS);
+    bool mixedThicknessMode = HasFeatureFlag(bsdfData.materialFeatures, MATERIAL_FEATURE_FLAGS_TRANSMISSION_MODE_MIXED_THICKNESS)
+                              && NdotL < 0 && lightData.shadowIndex >= 0;
+
+    // Save the original version for the transmission code below.
+    int originalShadowIndex = lightData.shadowIndex;
-    UNITY_BRANCH
-    if (autoThicknessMode && NdotL < 0 && lightData.shadowIndex >= 0)
+    if (mixedThicknessMode)
-        // TODO: perform bilinear filtering of the shadow map.
-        // Recompute transmittance using the thickness value computed from the shadow map.
-        float3 occluderPosWS = GetPunctualShadowClosestSample(lightLoopContext.shadowContext, posInput.positionWS, lightData.shadowIndex, L);
-
-        float thicknessInUnits       = distance(posInput.positionWS, occluderPosWS);
-        float thicknessInMeters      = thicknessInUnits * _WorldScales[bsdfData.diffusionProfile].x;
-        float thicknessInMillimeters = thicknessInMeters * MILLIMETERS_PER_METER;
-
-        // TODO: optimize.
-    #if SHADEROPTIONS_USE_DISNEY_SSS
-        transmittance = ComputeTransmittanceDisney(_ShapeParams[bsdfData.diffusionProfile].rgb,
-                                                   _TransmissionTintsAndFresnel0[bsdfData.diffusionProfile].rgb,
-                                                   thicknessInMillimeters);
-    #else
-        transmittance = ComputeTransmittanceJimenez(_HalfRcpVariancesAndWeights[bsdfData.diffusionProfile][0].rgb,
-                                                    _HalfRcpVariancesAndWeights[bsdfData.diffusionProfile][0].a,
-                                                    _HalfRcpVariancesAndWeights[bsdfData.diffusionProfile][1].rgb,
-                                                    _HalfRcpVariancesAndWeights[bsdfData.diffusionProfile][1].a,
-                                                    _TransmissionTintsAndFresnel0[bsdfData.diffusionProfile].rgb,
-                                                    thicknessInMillimeters);
-    #endif
-
-        // Note: we do not modify the distance to the light, or the light angle for the back face.
-        // This is a performance-saving optimization which makes sense as long as the thickness is small.
     }
 
     float3 color;
+
+    // Restore the original shadow index.
+    lightData.shadowIndex = originalShadowIndex;
 
     float intensity = max(0, attenuation * NdotL); // Warning: attenuation can be greater than 1 due to the inverse square attenuation (when position is close to light)
 
         lighting.specular *= intensity * lightData.specularScale;
     }
 
-    // TODO: move this before BSDF() to save VGPRs.
+        float3 transmittance = bsdfData.transmittance;
+
+        if (mixedThicknessMode)
+        {
+            // Recompute transmittance using the thickness value computed from the shadow map.
+
+            // Compute the distance from the light to the back face of the object along the light direction.
+            float distBackFaceToLight = GetPunctualShadowClosestDistance(lightLoopContext.shadowContext, s_linear_clamp_sampler,
+                                                                         posInput.positionWS, lightData.shadowIndex, L, lightData.positionWS);
+
+            // Our subsurface scattering models use the semi-infinite planar slab assumption.
+            // Therefore, we need to find the thickness along the normal.
+            float distFrontFaceToLight   = distances.x;
+            float thicknessInUnits       = (distFrontFaceToLight - distBackFaceToLight) * -NdotL;
+            float thicknessInMeters      = thicknessInUnits * _WorldScales[bsdfData.diffusionProfile].x;
+            float thicknessInMillimeters = thicknessInMeters * MILLIMETERS_PER_METER;
+
+        #if SHADEROPTIONS_USE_DISNEY_SSS
+            // We need to make sure it's not less than the baked thickness to minimize light leaking.
+            float thicknessDelta = max(0, thicknessInMillimeters - bsdfData.thickness);
+
+            float3 S = _ShapeParams[bsdfData.diffusionProfile].rgb;
+
+            // Approximate the decrease of transmittance by e^(-1/3 * dt * S).
+        #if 0
+            float3 expOneThird = exp(((-1.0 / 3.0) * thicknessDelta) * S);
+        #else
+            // Help the compiler.
+            float  k = (-1.0 / 3.0) * LOG2_E;
+            float3 p = (k * thicknessDelta) * S;
+            float3 expOneThird = exp2(p);
+        #endif
+
+            transmittance *= expOneThird;
+
+        #else // SHADEROPTIONS_USE_DISNEY_SSS
+
+            // We need to make sure it's not less than the baked thickness to minimize light leaking.
+            thicknessInMillimeters = max(thicknessInMillimeters, bsdfData.thickness);
+
+            transmittance = ComputeTransmittanceJimenez(_HalfRcpVariancesAndWeights[bsdfData.diffusionProfile][0].rgb,
+                                                        _HalfRcpVariancesAndWeights[bsdfData.diffusionProfile][0].a,
+                                                        _HalfRcpVariancesAndWeights[bsdfData.diffusionProfile][1].rgb,
+                                                        _HalfRcpVariancesAndWeights[bsdfData.diffusionProfile][1].a,
+                                                        _TransmissionTintsAndFresnel0[bsdfData.diffusionProfile].rgb,
+                                                        thicknessInMillimeters);
+        #endif // SHADEROPTIONS_USE_DISNEY_SSS
+        }
+
+        // Note: we do not modify the distance to the light, or the light angle for the back face.
+        // This is a performance-saving optimization which makes sense as long as the thickness is small.
-        lighting.diffuse += EvaluateTransmission(bsdfData, transmittance, NdotL, ClampNdotV(preLightData.NdotV), attenuation * lightData.diffuseScale);
+        lighting.diffuse += EvaluateTransmission(bsdfData, transmittance, NdotL, NdotV, LdotV, attenuation * lightData.diffuseScale);
     }
 
     // Save ALU by applying light and cookie colors only once.
 
 #endif // LIT_DISPLAY_REFERENCE_IBL
 
+    weight *= lightData.weight;
-    envLighting *= weight * lightData.dimmer;
+    envLighting *= weight * lightData.multiplier;
 
     if (GPUImageBasedLightingType == GPUIMAGEBASEDLIGHTINGTYPE_REFLECTION)
         lighting.specularReflected = envLighting;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/MaterialUtilities.hlsl

     if (unity_ProbeVolumeParams.x == 0.0)
     {
         // TODO: pass a tab of coefficient instead!
-        float4 SHCoefficients[7];
+        real4 SHCoefficients[7];
         SHCoefficients[0] = unity_SHAr;
         SHCoefficients[1] = unity_SHAg;
         SHCoefficients[2] = unity_SHAb;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/SkyRenderingContext.cs

                 hash = hash * 23 + light.colorTemperature.GetHashCode();
                 hash = hash * 23 + light.intensity.GetHashCode();
                 hash = hash * 23 + light.range.GetHashCode();
-                if(light.cookie != null)
+                if (light.cookie != null)
+                {
-                hash = hash * 23 + ald.lightDimmer.GetHashCode();
+                    hash = hash * 23 + (int)light.cookie.GetInstanceID();
+                }
+                if (ald != null)
+                {
+                    hash = hash * 23 + ald.lightDimmer.GetHashCode();
+                }
 
                 return hash;
             }

ScriptableRenderPipeline/LightweightPipeline/LWRP/Data/LightweightPipelineAsset.cs

         private Material GetMaterial(DefaultMaterialType materialType)
         {
 #if UNITY_EDITOR
+            if (editorResources == null)
+                return null;
 
             switch (materialType)
             {

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGUI/LightweightStandardSimpleLightingGUI.cs

         StandardSimpleLightingUpgrader.UpdateMaterialKeywords(material);
     }
 
+    private bool RequiresAlpha()
+    {
+        SurfaceType surfaceType = (SurfaceType) surfaceTypeProp.floatValue;
+        return alphaClip.floatValue > 0.0f || surfaceType == SurfaceType.Transparent;
+    }
+
     private void DoSurfaceArea()
     {
         int surfaceTypeValue = (int)surfaceTypeProp.floatValue;
         bool alphaClipEnabled = EditorGUILayout.Toggle(Styles.alphaClipLabel, alphaClip.floatValue == 1);
         if (EditorGUI.EndChangeCheck())
             alphaClip.floatValue = alphaClipEnabled ? 1 : 0;
-        
+
         EditorGUILayout.Space();
 
         if ((SurfaceType)surfaceTypeValue == SurfaceType.Opaque)
             m_MaterialEditor.TexturePropertySingleLine(Styles.specularGlossMapLabels[(int)glossinessSourceProp.floatValue], specularGlossMapProp, hasSpecularMap ? null : specularColorProp);
 
             EditorGUI.indentLevel += 2;
-            GUI.enabled = hasSpecularMap;
-            int glossinessSource = hasSpecularMap ? (int)glossinessSourceProp.floatValue : (int)GlossinessSource.BaseAlpha;
-            EditorGUI.BeginChangeCheck();
-            glossinessSource = EditorGUILayout.Popup(Styles.glossinessSourceLabel, glossinessSource, Styles.glossinessSourceNames);
-            if (EditorGUI.EndChangeCheck())
-                glossinessSourceProp.floatValue = glossinessSource;
-            GUI.enabled = true;
+            if (RequiresAlpha())
+            {
+                GUI.enabled = false;
+                glossinessSourceProp.floatValue = (float)EditorGUILayout.Popup(Styles.glossinessSourceLabel, (int) GlossinessSource.SpecularAlpha, Styles.glossinessSourceNames);
+                GUI.enabled = true;
+            }
+            else
+            {
+                int glossinessSource = (int)glossinessSourceProp.floatValue;
+                EditorGUI.BeginChangeCheck();
+                glossinessSource = EditorGUILayout.Popup(Styles.glossinessSourceLabel, glossinessSource, Styles.glossinessSourceNames);
+                if (EditorGUI.EndChangeCheck())
+                    glossinessSourceProp.floatValue = glossinessSource;
+                GUI.enabled = true;
+            }
-                    kMinShininessValue, 1.0f);
+                kMinShininessValue, 1.0f);
             if (EditorGUI.EndChangeCheck())
                 shininessProp.floatValue = shininess;
             EditorGUI.indentLevel -= 2;

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightPBRExtraPasses.template

 Pass
 {
-    Tags{"LightMode" = "ShadowCaster"}
+	Tags{"LightMode" = "ShadowCaster"}
-    ZWrite On
-    ZTest LEqual
-    Cull ${Culling}
+	ZWrite On
+	ZTest LEqual
+	Cull ${Culling}
-    HLSLPROGRAM
-    // Required to compile gles 2.0 with standard srp library
-    #pragma prefer_hlslcc gles
-    #pragma target 2.0
-    
-    //--------------------------------------
-    // GPU Instancing
-    #pragma multi_compile_instancing
+	HLSLPROGRAM
+	// Required to compile gles 2.0 with standard srp library
+	#pragma prefer_hlslcc gles
+	#pragma target 2.0
+
+	//--------------------------------------
+	// GPU Instancing
+	#pragma multi_compile_instancing
+
+	#pragma vertex ShadowPassVertex
+	#pragma fragment ShadowPassFragment
-    #pragma vertex ShadowPassVertex
-    #pragma fragment LitPassFragmentNull
+	#include "LWRP/ShaderLibrary/LightweightPassShadow.hlsl"
-    #include "LWRP/ShaderLibrary/LightweightPassShadow.hlsl"
-    ENDHLSL
+	ENDHLSL
-    Tags{"LightMode" = "DepthOnly"}
+	Tags{"LightMode" = "DepthOnly"}
+
+	ZWrite On
+	ColorMask 0
-    ZWrite On
-    ColorMask 0
+	HLSLPROGRAM
+	// Required to compile gles 2.0 with standard srp library
+	#pragma prefer_hlslcc gles
+	#pragma target 2.0
-    HLSLPROGRAM
-    // Required to compile gles 2.0 with standard srp library
-    #pragma prefer_hlslcc gles
-    #pragma target 2.0
-    
-    //--------------------------------------
-    // GPU Instancing
-    #pragma multi_compile_instancing
+	#pragma vertex DepthOnlyVertex
+	#pragma fragment DepthOnlyFragment
-    #pragma vertex LitPassVertex
-    #pragma fragment LitPassFragmentNull
+	//--------------------------------------
+	// GPU Instancing
+	#pragma multi_compile_instancing
-    #include "LWRP/ShaderLibrary/LightweightPassLit.hlsl"
-    ENDHLSL
+	#include "LWRP/ShaderLibrary/LightweightPassDepthOnly.hlsl"
+	ENDHLSL
-    Tags{"LightMode" = "Meta"}
+	Tags{"LightMode" = "Meta"}
-    Cull Off
+	Cull Off
-    HLSLPROGRAM
-    // Required to compile gles 2.0 with standard srp library
-    #pragma prefer_hlslcc gles
+	HLSLPROGRAM
+	// Required to compile gles 2.0 with standard srp library
+	#pragma prefer_hlslcc gles
-    #pragma vertex LightweightVertexMeta
-    #pragma fragment LightweightFragmentMeta
+	#pragma vertex LightweightVertexMeta
+	#pragma fragment LightweightFragmentMeta
-    #pragma shader_feature _SPECULAR_SETUP
-    #pragma shader_feature _EMISSION
-    #pragma shader_feature _METALLICSPECGLOSSMAP
-    #pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
-    #pragma shader_feature EDITOR_VISUALIZATION
+	#pragma shader_feature _SPECULAR_SETUP
+	#pragma shader_feature _EMISSION
+	#pragma shader_feature _METALLICSPECGLOSSMAP
+	#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+	#pragma shader_feature EDITOR_VISUALIZATION
-    #pragma shader_feature _SPECGLOSSMAP
+	#pragma shader_feature _SPECGLOSSMAP
-    #include "LWRP/ShaderLibrary/LightweightPassMeta.hlsl"
-    ENDHLSL
+	#include "LWRP/ShaderLibrary/LightweightPassMeta.hlsl"
+	ENDHLSL
 }

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightUnlitExtraPasses.template

 Pass
 {
-    Tags{"LightMode" = "ShadowCaster"}
+	Tags{"LightMode" = "ShadowCaster"}
-    ZWrite On
-    ZTest LEqual
-    Cull ${Culling}
+	ZWrite On
+	ZTest LEqual
+	Cull ${Culling}
-    HLSLPROGRAM
-    // Required to compile gles 2.0 with standard srp library
-    #pragma prefer_hlslcc gles
-    #pragma target 2.0
-    
-    //--------------------------------------
-    // GPU Instancing
-    #pragma multi_compile_instancing
+	HLSLPROGRAM
+	// Required to compile gles 2.0 with standard srp library
+	#pragma prefer_hlslcc gles
+	#pragma target 2.0
-    #pragma vertex ShadowPassVertex
-    #pragma fragment LitPassFragmentNull
+	//--------------------------------------
+	// GPU Instancing
+	#pragma multi_compile_instancing
-    #include "LWRP/ShaderLibrary/LightweightPassShadow.hlsl"
-    ENDHLSL
+	#pragma vertex ShadowPassVertex
+	#pragma fragment ShadowPassFragment
+
+	#include "LWRP/ShaderLibrary/LightweightPassShadow.hlsl"
+
+	ENDHLSL
-    Tags{"LightMode" = "DepthOnly"}
+	Tags{"LightMode" = "DepthOnly"}
-    ZWrite On
-    ColorMask 0
+	ZWrite On
+	ColorMask 0
-    HLSLPROGRAM
-    // Required to compile gles 2.0 with standard srp library
-    #pragma prefer_hlslcc gles
-    #pragma target 2.0
-    
-    //--------------------------------------
-    // GPU Instancing
-    #pragma multi_compile_instancing
+	HLSLPROGRAM
+	// Required to compile gles 2.0 with standard srp library
+	#pragma prefer_hlslcc gles
+	#pragma target 2.0
+
+	#pragma vertex DepthOnlyVertex
+	#pragma fragment DepthOnlyFragment
-    #pragma vertex LitPassVertex
-    #pragma fragment LitPassFragmentNull
+	//--------------------------------------
+	// GPU Instancing
+	#pragma multi_compile_instancing
-    #include "LWRP/ShaderLibrary/LightweightPassLit.hlsl"
-    ENDHLSL
+	#include "LWRP/ShaderLibrary/LightweightPassDepthOnly.hlsl"
+	ENDHLSL
 }

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs

         public Vector3  directionalLightCascades;
         public float    directionalLightNearPlaneOffset;
 
-        public RenderTextureFormat renderTextureFormat;
+        public RenderTextureFormat shadowmapTextureFormat;
+        public RenderTextureFormat screenspaceShadowmapTextureFormat;
 
         static ShadowSettings defaultShadowSettings = null;
 
                     defaultShadowSettings.directionalLightCascades = new Vector3(0.05F, 0.2F, 0.3F);
                     defaultShadowSettings.directionalLightNearPlaneOffset = 5;
                     defaultShadowSettings.maxShadowDistance = 1000.0F;
-                    defaultShadowSettings.renderTextureFormat = RenderTextureFormat.Shadowmap;
+                    defaultShadowSettings.shadowmapTextureFormat = RenderTextureFormat.Shadowmap;
+                    defaultShadowSettings.screenspaceShadowmapTextureFormat = RenderTextureFormat.R8;
                 }
                 return defaultShadowSettings;
             }
                 if (!shadows)
                 {
                     var setRT = CommandBufferPool.Get("Generate Small Shadow Buffer");
-                    int shadowmapID = m_ShadowSettings.screenSpace ? m_ScreenSpaceShadowMapRTID : m_ShadowMapRTID;
-                    setRT.GetTemporaryRT(shadowmapID, 4, 4, 0, FilterMode.Bilinear, RenderTextureFormat.ARGB32);
+                    if (m_ShadowSettings.screenSpace)
+                        setRT.GetTemporaryRT(m_ScreenSpaceShadowMapRTID, 4, 4, 0, FilterMode.Bilinear, m_ShadowSettings.screenspaceShadowmapTextureFormat);
+                    else
+                        setRT.GetTemporaryRT(m_ShadowMapRTID, 4, 4, 0, FilterMode.Bilinear, m_ShadowSettings.shadowmapTextureFormat);
                     setRT.Blit(Texture2D.whiteTexture, m_ScreenSpaceShadowMapRT);
                     context.ExecuteCommandBuffer(setRT);
                 }
             {
                 var desc = XRSettings.eyeTextureDesc;
                 desc.depthBufferBits = 0;
-                desc.colorFormat = RenderTextureFormat.R8;
+                desc.colorFormat = m_ShadowSettings.screenspaceShadowmapTextureFormat;
-                cmd.GetTemporaryRT(m_ScreenSpaceShadowMapRTID, m_CurrCamera.pixelWidth, m_CurrCamera.pixelHeight, 0, FilterMode.Bilinear, RenderTextureFormat.R8);
+                cmd.GetTemporaryRT(m_ScreenSpaceShadowMapRTID, m_CurrCamera.pixelWidth, m_CurrCamera.pixelHeight, 0, FilterMode.Bilinear, m_ShadowSettings.screenspaceShadowmapTextureFormat);
-            // Note: The source isn't actually 'used', but there's an engine peculiarity (bug) that 
+            // Note: The source isn't actually 'used', but there's an engine peculiarity (bug) that
             // doesn't like null sources when trying to determine a stereo-ized blit.  So for proper
             // stereo functionality, we use the screen-space shadow map as the source (until we have
             // a better solution).
             m_ShadowSettings.shadowAtlasWidth = m_Asset.ShadowAtlasResolution;
             m_ShadowSettings.shadowAtlasHeight = m_Asset.ShadowAtlasResolution;
             m_ShadowSettings.maxShadowDistance = m_Asset.ShadowDistance;
-            m_ShadowSettings.renderTextureFormat = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.Shadowmap)
+            m_ShadowSettings.shadowmapTextureFormat = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.Shadowmap)
+
+            m_ShadowSettings.screenspaceShadowmapTextureFormat = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.R8)
+                    ? RenderTextureFormat.R8
+                    : RenderTextureFormat.ARGB32;
 
             switch (m_ShadowSettings.directionalLightCascadeCount)
             {
 
             var cmd = CommandBufferPool.Get("Prepare Shadowmap");
             RenderTextureDescriptor shadowmapDescriptor = new RenderTextureDescriptor(m_ShadowSettings.shadowAtlasWidth,
-                m_ShadowSettings.shadowAtlasHeight, m_ShadowSettings.renderTextureFormat, kShadowBufferBits);
+                m_ShadowSettings.shadowAtlasHeight, m_ShadowSettings.shadowmapTextureFormat, kShadowBufferBits);
             shadowmapDescriptor.shadowSamplingMode = ShadowSamplingMode.CompareDepths;
             m_ShadowMapRT = RenderTexture.GetTemporary(shadowmapDescriptor);
             m_ShadowMapRT.filterMode = FilterMode.Bilinear;
                     depthRT = m_DepthRT;
             }
 
-            if (ForceClear())
+            ClearFlag clearFlag = ClearFlag.None;
+            CameraClearFlags cameraClearFlags = m_CurrCamera.clearFlags;
+            if (cameraClearFlags != CameraClearFlags.Nothing)
-                SetRenderTarget(cmd, colorRT, depthRT, ClearFlag.All);
+                clearFlag |= ClearFlag.Depth;
+                if (cameraClearFlags == CameraClearFlags.Color || cameraClearFlags == CameraClearFlags.Skybox)
+                    clearFlag |= ClearFlag.Color;
-            else
-            {
-                ClearFlag clearFlag = ClearFlag.None;
-                CameraClearFlags cameraClearFlags = m_CurrCamera.clearFlags;
-                if (cameraClearFlags != CameraClearFlags.Nothing)
-                {
-                    clearFlag |= ClearFlag.Depth;
-                    if (cameraClearFlags == CameraClearFlags.Color || cameraClearFlags == CameraClearFlags.Skybox)
-                        clearFlag |= ClearFlag.Color;
-                }
-                SetRenderTarget(cmd, colorRT, depthRT, clearFlag);
-            }
+            SetRenderTarget(cmd, colorRT, depthRT, clearFlag);
 
             // If rendering to an intermediate RT we resolve viewport on blit due to offset not being supported
             // while rendering to a RT.
         private int GetLightUnsortedIndex(int index)
         {
             return (index < m_SortedLightIndexMap.Count) ? m_SortedLightIndexMap[index] : index;
-        }
-
-        private bool ForceClear()
-        {
-            // Clear RenderTarget to avoid tile initialization on mobile GPUs
-            // https://community.arm.com/graphics/b/blog/posts/mali-performance-2-how-to-correctly-handle-framebuffers
-            return (Application.platform == RuntimePlatform.Android || Application.platform == RuntimePlatform.IPhonePlayer);
         }
 
         private void Blit(CommandBuffer cmd, FrameRenderingConfiguration renderingConfig, RenderTargetIdentifier sourceRT, RenderTargetIdentifier destRT, Material material = null)

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/InputSurface.hlsl

 ///////////////////////////////////////////////////////////////////////////////
 //                      Material Property Helpers                            //
 ///////////////////////////////////////////////////////////////////////////////
-inline half Alpha(half albedoAlpha)
+float2 TransformMainTextureCoord(float2 uv)
-#if defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A)
-    half alpha = _Color.a;
-#else
+    return TRANSFORM_TEX(uv, _MainTex);
+}
+
+half Alpha(half albedoAlpha)
+{
+#if !defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A) && !defined(_GLOSSINESS_FROM_BASE_ALPHA)
+#else
+    half alpha = _Color.a;
 #endif
 
 #if defined(_ALPHATEST_ON)
     return alpha;
+}
+
+half4 MainTexture(float2 uv)
+{
+    return SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv);
 }
 
 half3 Normal(float2 uv)
 
 inline void InitializeStandardLitSurfaceData(float2 uv, out SurfaceData outSurfaceData)
 {
-    half4 albedoAlpha = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv);
+    half4 albedoAlpha = MainTexture(uv);
 
     half4 specGloss = MetallicSpecGloss(uv, albedoAlpha.a);
     outSurfaceData.albedo = albedoAlpha.rgb * _Color.rgb;

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassLit.hlsl

     UNITY_TRANSFER_INSTANCE_ID(v, o);
     UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
 
-    o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
+    o.uv = TransformMainTextureCoord(v.texcoord);
 
     o.posWSShininess.xyz = TransformObjectToWorld(v.vertex.xyz);
     o.posWSShininess.w = _Shininess * 128.0;
     return color;
 }
 
-// Used for Standard shader
-half4 LitPassFragmentNull(LightweightVertexOutput IN) : SV_Target
-{
-    LitPassFragment(IN);
-    return 0;
-}
-
 // Used for StandardSimpleLighting shader
 half4 LitPassFragmentSimple(LightweightVertexOutput IN) : SV_Target
 {
 
     return LightweightFragmentBlinnPhong(inputData, diffuse, specularGloss, shininess, emission, alpha);
 };
-
-
-// Used for StandardSimpleLighting shader
-half4 LitPassFragmentSimpleNull(LightweightVertexOutput IN) : SV_Target
-{
-    half4 result = LitPassFragmentSimple(IN);
-    return result.a;
-}
 
 #endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassShadow.hlsl

 #ifndef LIGHTWEIGHT_PASS_SHADOW_INCLUDED
 #define LIGHTWEIGHT_PASS_SHADOW_INCLUDED
 
-#include "LWRP/ShaderLibrary/LightweightPassLit.hlsl"
+#include "LWRP/ShaderLibrary/Core.hlsl"
+#include "LWRP/ShaderLibrary/InputSurface.hlsl"
-LightweightVertexOutput ShadowPassVertex(LightweightVertexInput v)
+struct VertexInput
+{
+    float4 position     : POSITION;
+    float3 normal       : NORMAL;
+    float2 texcoord     : TEXCOORD0;
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+struct VertexOutput
+{
+    float2 uv           : TEXCOORD0;
+    float4 clipPos      : SV_POSITION;
+};
+
+float4 GetShadowPositionHClip(VertexInput v)
-    LightweightVertexOutput o = LitPassVertex(v);
+    float3 positionWS = TransformObjectToWorld(v.position.xyz);
+    float3 normalWS = TransformObjectToWorldDir(v.normal);
-    float invNdotL = 1.0 - saturate(dot(_LightDirection, o.normal));
+    float invNdotL = 1.0 - saturate(dot(_LightDirection, normalWS));
-    o.posWSShininess.xyz = o.normal * scale.xxx + o.posWSShininess.xyz;
-    float4 clipPos = TransformWorldToHClip(o.posWSShininess.xyz);
+    positionWS = normalWS * scale.xxx + positionWS;
+    float4 clipPos = TransformWorldToHClip(positionWS);
 
     // _ShadowBias.x sign depens on if platform has reversed z buffer
     clipPos.z += _ShadowBias.x;
     clipPos.z = max(clipPos.z, clipPos.w * UNITY_NEAR_CLIP_VALUE);
 #endif
 
-    o.clipPos = clipPos;
+    return clipPos;
+}
+
+VertexOutput ShadowPassVertex(VertexInput v)
+{
+    VertexOutput o;
+    UNITY_SETUP_INSTANCE_ID(v);
+
+    o.uv = TransformMainTextureCoord(v.texcoord);
+    o.clipPos = GetShadowPositionHClip(v);
+
+half4 ShadowPassFragment(VertexOutput IN) : SV_TARGET
+{
+    Alpha(MainTexture(IN.uv).a);
+    return 0;
+}
+
 #endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Particles.hlsl

 {
 #if defined(_NORMALMAP)
     #if BUMP_SCALE_NOT_SUPPORTED
-        return UnpackNormal(readTexture(_BumpMap, sampler_BumpMap, IN));
+        return UnpackNormal(readTexture(TEXTURE2D_PARAM(_BumpMap, sampler_BumpMap), IN));
-        return UnpackNormalScale(readTexture(_BumpMap, sampler_BumpMap, IN), _BumpScale);
+        return UnpackNormalScale(readTexture(TEXTURE2D_PARAM(_BumpMap, sampler_BumpMap), IN), _BumpScale);
     #endif
 #else
     return half3(0.0h, 0.0h, 1.0h);
 half3 Emission(VertexOutputLit IN)
 {
 #if defined(_EMISSION)
-    return readTexture(_EmissionMap, sampler_EmissionMap, IN).rgb * _EmissionColor.rgb;
+    return readTexture(TEXTURE2D_PARAM(_EmissionMap, sampler_EmissionMap), IN).rgb * _EmissionColor.rgb;
 #else
     return half3(0.0h, 0.0h, 0.0h);
 #endif
 {
     half4 specularGloss = half4(0.0h, 0.0h, 0.0h, 1.0h);
 #ifdef _SPECGLOSSMAP
-    specularGloss = readTexture(_SpecGlossMap, sampler_SpecGlossMap, IN);
+    specularGloss = readTexture(TEXTURE2D_PARAM(_SpecGlossMap, sampler_SpecGlossMap), IN);
 #elif defined(_SPECULAR_COLOR)
     specularGloss = _SpecColor;
 #endif
     half4 albedo = Albedo(IN);
 
 #if defined(_METALLICGLOSSMAP)
-    half2 metallicGloss = readTexture(_MetallicGlossMap, sampler_MetallicGlossMap, IN).ra * half2(1.0, _Glossiness);
+    half2 metallicGloss = readTexture(TEXTURE2D_PARAM(_MetallicGlossMap, sampler_MetallicGlossMap), IN).ra * half2(1.0, _Glossiness);
 #else
     half2 metallicGloss = half2(_Metallic, _Glossiness);
 #endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Shadows.hlsl

         attenuation = dot(attenuation4, 0.25);
     #else
         #ifdef _SHADOWS_CASCADE //Assume screen space shadows when cascades enabled
-            real fetchesWeights[16];
-            real2 fetchesUV[16];
+            float fetchesWeights[16];
+            float2 fetchesUV[16];
-            attenuation  = fetchesWeights[0]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[0].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[1]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[1].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[2]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[2].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[3]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[3].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[4]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[4].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[5]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[5].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[6]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[6].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[7]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[7].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[8]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[8].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[9]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[9].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[10] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[10].xy, shadowCoord.z));
-            attenuation += fetchesWeights[11] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[11].xy, shadowCoord.z));
-            attenuation += fetchesWeights[12] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[12].xy, shadowCoord.z));
-            attenuation += fetchesWeights[13] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[13].xy, shadowCoord.z));
-            attenuation += fetchesWeights[14] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[14].xy, shadowCoord.z));
-            attenuation += fetchesWeights[15] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[15].xy, shadowCoord.z));
+            attenuation  = fetchesWeights[0]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[0].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[1]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[1].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[2]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[2].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[3]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[3].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[4]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[4].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[5]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[5].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[6]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[6].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[7]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[7].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[8]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[8].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[9]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[9].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[10] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[10].xy, shadowCoord.z));
+            attenuation += fetchesWeights[11] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[11].xy, shadowCoord.z));
+            attenuation += fetchesWeights[12] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[12].xy, shadowCoord.z));
+            attenuation += fetchesWeights[13] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[13].xy, shadowCoord.z));
+            attenuation += fetchesWeights[14] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[14].xy, shadowCoord.z));
+            attenuation += fetchesWeights[15] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[15].xy, shadowCoord.z));
-            real fetchesWeights[9];
-            real2 fetchesUV[9];
+            float fetchesWeights[9];
+            float2 fetchesUV[9];
-            attenuation  = fetchesWeights[0] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[0].xy, shadowCoord.z));
-            attenuation += fetchesWeights[1] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[1].xy, shadowCoord.z));
-            attenuation += fetchesWeights[2] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[2].xy, shadowCoord.z));
-            attenuation += fetchesWeights[3] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[3].xy, shadowCoord.z));
-            attenuation += fetchesWeights[4] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[4].xy, shadowCoord.z));
-            attenuation += fetchesWeights[5] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[5].xy, shadowCoord.z));
-            attenuation += fetchesWeights[6] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[6].xy, shadowCoord.z));
-            attenuation += fetchesWeights[7] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[7].xy, shadowCoord.z));
-            attenuation += fetchesWeights[8] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[8].xy, shadowCoord.z));
+            attenuation  = fetchesWeights[0] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[0].xy, shadowCoord.z));
+            attenuation += fetchesWeights[1] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[1].xy, shadowCoord.z));
+            attenuation += fetchesWeights[2] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[2].xy, shadowCoord.z));
+            attenuation += fetchesWeights[3] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[3].xy, shadowCoord.z));
+            attenuation += fetchesWeights[4] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[4].xy, shadowCoord.z));
+            attenuation += fetchesWeights[5] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[5].xy, shadowCoord.z));
+            attenuation += fetchesWeights[6] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[6].xy, shadowCoord.z));
+            attenuation += fetchesWeights[7] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[7].xy, shadowCoord.z));
+            attenuation += fetchesWeights[8] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[8].xy, shadowCoord.z));
         #endif
     #endif
 #else

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightScreenSpaceShadows.shader

         HLSLINCLUDE
 
         #pragma prefer_hlslcc gles
-        //Keep compiler quiet about Shadows.hlsl. 
+        //Keep compiler quiet about Shadows.hlsl.
         #include "CoreRP/ShaderLibrary/Common.hlsl"
         #include "CoreRP/ShaderLibrary/EntityLighting.hlsl"
         #include "CoreRP/ShaderLibrary/ImageBasedLighting.hlsl"
-        SCREENSPACE_TEXTURE(_CameraDepthTexture);
+#if defined(UNITY_STEREO_INSTANCING_ENABLED) || defined(UNITY_STEREO_MULTIVIEW_ENABLED)
+        TEXTURE2D_ARRAY(_CameraDepthTexture);
+#else
+        TEXTURE2D(_CameraDepthTexture);
+#endif // defined(UNITY_STEREO_INSTANCING_ENABLED) || defined(UNITY_STEREO_MULTIVIEW_ENABLED)
+
         SAMPLER(sampler_CameraDepthTexture);
 
         struct VertexInput

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandard.shader

             // -------------------------------------
             // Material Keywords
             #pragma shader_feature _NORMALMAP
-            #pragma shader_feature _ALPHATEST_ON 
+            #pragma shader_feature _ALPHATEST_ON
             #pragma shader_feature _ALPHAPREMULTIPLY_ON
             #pragma shader_feature _EMISSION
             #pragma shader_feature _METALLICSPECGLOSSMAP
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles
             #pragma target 2.0
-            
+
-            #pragma shader_feature _NORMALMAP
-            #pragma shader_feature _ALPHATEST_ON 
-            #pragma shader_feature _ALPHAPREMULTIPLY_ON
-            #pragma shader_feature _EMISSION
-            #pragma shader_feature _METALLICSPECGLOSSMAP
+            #pragma shader_feature _ALPHATEST_ON
-            #pragma shader_feature _OCCLUSIONMAP
-
-            #pragma shader_feature _SPECULARHIGHLIGHTS_OFF
-            #pragma shader_feature _GLOSSYREFLECTIONS_OFF
-            #pragma shader_feature _SPECULAR_SETUP
 
             //--------------------------------------
             // GPU Instancing
-            #pragma fragment LitPassFragmentNull
+            #pragma fragment ShadowPassFragment
 
             #include "LWRP/ShaderLibrary/LightweightPassShadow.hlsl"
             ENDHLSL
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles
             #pragma target 2.0
-            
+
+            #pragma vertex DepthOnlyVertex
+            #pragma fragment DepthOnlyFragment
+
-            #pragma shader_feature _NORMALMAP
-            #pragma shader_feature _ALPHATEST_ON 
-            #pragma shader_feature _ALPHAPREMULTIPLY_ON
-            #pragma shader_feature _EMISSION
-            #pragma shader_feature _METALLICSPECGLOSSMAP
+            #pragma shader_feature _ALPHATEST_ON
-            #pragma shader_feature _OCCLUSIONMAP
-
-            #pragma shader_feature _SPECULARHIGHLIGHTS_OFF
-            #pragma shader_feature _GLOSSYREFLECTIONS_OFF
-            #pragma shader_feature _SPECULAR_SETUP
-            #pragma vertex LitPassVertex
-            #pragma fragment LitPassFragmentNull
-
-            #include "LWRP/ShaderLibrary/LightweightPassLit.hlsl"
+            #include "LWRP/ShaderLibrary/LightweightPassDepthOnly.hlsl"
             ENDHLSL
         }
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardSimpleLighting.shader

 
             // -------------------------------------
             // Material Keywords
-            #pragma shader_feature _ALPHATEST_ON 
+            #pragma shader_feature _ALPHATEST_ON
-            #pragma shader_feature _ _GLOSSINESS_FROM_BASE_ALPHA
+            #pragma shader_feature _GLOSSINESS_FROM_BASE_ALPHA
             #pragma shader_feature _NORMALMAP
             #pragma shader_feature _EMISSION
 
 
         Pass
         {
-            Tags{"Lightmode" = "ShadowCaster"}
+            Tags{"LightMode" = "ShadowCaster"}
 
             ZWrite On
             ZTest LEqual
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles
             #pragma target 2.0
-            
+
-            #pragma shader_feature _ALPHATEST_ON 
-            #pragma shader_feature _ALPHAPREMULTIPLY_ON
-            #pragma shader_feature _ _SPECGLOSSMAP _SPECULAR_COLOR
-            #pragma shader_feature _ _GLOSSINESS_FROM_BASE_ALPHA
-            #pragma shader_feature _NORMALMAP
-            #pragma shader_feature _EMISSION
+            #pragma shader_feature _ALPHATEST_ON
+            #pragma shader_feature _GLOSSINESS_FROM_BASE_ALPHA
 
             //--------------------------------------
             // GPU Instancing
-            #pragma fragment LitPassFragmentSimpleNull
+            #pragma fragment ShadowPassFragment
-            #define BUMP_SCALE_NOT_SUPPORTED 1
             #include "LWRP/ShaderLibrary/LightweightPassShadow.hlsl"
             ENDHLSL
         }
-            Tags{"Lightmode" = "DepthOnly"}
+            Tags{"LightMode" = "DepthOnly"}
 
             ZWrite On
             ColorMask 0
             #pragma prefer_hlslcc gles
             #pragma target 2.0
 
+            #pragma vertex DepthOnlyVertex
+            #pragma fragment DepthOnlyFragment
+
-            #pragma shader_feature _ALPHATEST_ON 
-            #pragma shader_feature _ALPHAPREMULTIPLY_ON
-            #pragma shader_feature _ _SPECGLOSSMAP _SPECULAR_COLOR
-            #pragma shader_feature _ _GLOSSINESS_FROM_BASE_ALPHA
-            #pragma shader_feature _NORMALMAP
-            #pragma shader_feature _EMISSION
+            #pragma shader_feature _ALPHATEST_ON
+            #pragma shader_feature _GLOSSINESS_FROM_BASE_ALPHA
-            #pragma vertex LitPassVertex
-            #pragma fragment LitPassFragmentSimpleNull
-        
-            #define BUMP_SCALE_NOT_SUPPORTED 1
-            #include "LWRP/ShaderLibrary/LightweightPassLit.hlsl"
+            #include "LWRP/ShaderLibrary/LightweightPassDepthOnly.hlsl"
             ENDHLSL
         }
 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/SkySettings/HDRP_Black_Sky_Shadow50.asset

   m_EditorClassIdentifier: 
   active: 1
   rotation:
-    m_OverrideState: 0
+    m_OverrideState: 1
-    m_OverrideState: 0
+    m_OverrideState: 1
-    m_OverrideState: 0
+    m_OverrideState: 1
-    m_OverrideState: 0
+    m_OverrideState: 1
-    m_OverrideState: 0
+    m_OverrideState: 1
-  skyHDRI:
+  hdriSky:
     m_OverrideState: 1
     m_Value: {fileID: 8900000, guid: 75f8ba90acb52d14d9ead53b2a9e4190, type: 3}
 --- !u!114 &114436604167779146
     m_OverrideState: 0
     m_Value: 500
     min: 0
+  cascadeShadowSplitCount:
+    m_OverrideState: 0
+    m_Value: 4
+    min: 1
+    max: 4
+  cascadeShadowSplit0:
+    m_OverrideState: 0
+    m_Value: 0.05
+    min: 0
+    max: 1
+  cascadeShadowSplit1:
+    m_OverrideState: 0
+    m_Value: 0.15
+    min: 0
+    max: 1
+  cascadeShadowSplit2:
+    m_OverrideState: 0
+    m_Value: 0.3
+    min: 0
+    max: 1
+  cascadeShadowBorder0:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder1:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder2:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder3:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
 --- !u!114 &114660440207994068
 MonoBehaviour:
   m_ObjectHideFlags: 3
     m_OverrideState: 1
     m_Value: 50
     min: 0
+  cascadeShadowSplitCount:
+    m_OverrideState: 0
+    m_Value: 4
+    min: 1
+    max: 4
+  cascadeShadowSplit0:
+    m_OverrideState: 0
+    m_Value: 0.05
+    min: 0
+    max: 1
+  cascadeShadowSplit1:
+    m_OverrideState: 0
+    m_Value: 0.15
+    min: 0
+    max: 1
+  cascadeShadowSplit2:
+    m_OverrideState: 0
+    m_Value: 0.3
+    min: 0
+    max: 1
+  cascadeShadowBorder0:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder1:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder2:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder3:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/SkySettings/HDRP_Black_Sky_Shadow500.asset

   m_EditorClassIdentifier: 
   active: 1
   rotation:
-    m_OverrideState: 0
+    m_OverrideState: 1
-    m_OverrideState: 0
+    m_OverrideState: 1
-    m_OverrideState: 0
+    m_OverrideState: 1
-    m_OverrideState: 0
+    m_OverrideState: 1
-    m_OverrideState: 0
+    m_OverrideState: 1
-  useForBaking: 1
-  skyHDRI:
+  hdriSky:
     m_OverrideState: 1
     m_Value: {fileID: 8900000, guid: 75f8ba90acb52d14d9ead53b2a9e4190, type: 3}
 --- !u!114 &114436604167779146
     m_OverrideState: 0
     m_Value: 500
     min: 0
+  cascadeShadowSplitCount:
+    m_OverrideState: 0
+    m_Value: 4
+    min: 1
+    max: 4
+  cascadeShadowSplit0:
+    m_OverrideState: 0
+    m_Value: 0.05
+    min: 0
+    max: 1
+  cascadeShadowSplit1:
+    m_OverrideState: 0
+    m_Value: 0.15
+    min: 0
+    max: 1
+  cascadeShadowSplit2:
+    m_OverrideState: 0
+    m_Value: 0.3
+    min: 0
+    max: 1
+  cascadeShadowBorder0:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder1:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder2:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder3:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
 --- !u!114 &114660440207994068
 MonoBehaviour:
   m_ObjectHideFlags: 3
     m_OverrideState: 1
     m_Value: 500
     min: 0
+  cascadeShadowSplitCount:
+    m_OverrideState: 0
+    m_Value: 4
+    min: 1
+    max: 4
+  cascadeShadowSplit0:
+    m_OverrideState: 0
+    m_Value: 0.05
+    min: 0
+    max: 1
+  cascadeShadowSplit1:
+    m_OverrideState: 0
+    m_Value: 0.15
+    min: 0
+    max: 1
+  cascadeShadowSplit2:
+    m_OverrideState: 0
+    m_Value: 0.3
+    min: 0
+    max: 1
+  cascadeShadowBorder0:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder1:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder2:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder3:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/SkySettings/HDRP_Default_Sky.asset

   active: 1
   rotation:
     m_OverrideState: 1
-    m_Value: 160
+    m_Value: 200
     min: 0
     max: 360
   exposure:

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/SkySettings/HDRP_Default_Sky_2.asset

   active: 1
   rotation:
     m_OverrideState: 1
-    m_Value: 160
+    m_Value: 200
     min: 0
     max: 360
   exposure:

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/SkySettings/HDRP_Default_Sky_3.asset

   active: 1
   rotation:
     m_OverrideState: 1
-    m_Value: 160
+    m_Value: 200
     min: 0
     max: 360
   exposure:

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/SkySettings/HDRP_Default_Sky_4.asset

   active: 1
   rotation:
     m_OverrideState: 1
-    m_Value: 160
+    m_Value: 200
     min: 0
     max: 360
   exposure:

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1301_SubSurfaceScattering.unity

   m_ReflectionIntensity: 1
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.03660911, g: 0.038467497, b: 0.04252398, a: 1}
+  m_IndirectSpecularColor: {r: 0, g: 0, b: 0, a: 1}
   m_UseRadianceAmbientProbe: 0
 --- !u!157 &3
 LightmapSettings:
       objectReference: {fileID: 0}
     - target: {fileID: 4295600896743834, guid: b186ef7597e8a464c9a4af7b87825a5f, type: 2}
       propertyPath: m_LocalScale.z
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 114663566010530930, guid: b186ef7597e8a464c9a4af7b87825a5f,
+        type: 2}
+      propertyPath: m_Enabled
       value: 1
       objectReference: {fileID: 0}
     m_RemovedComponents: []
   shadowCascadeCount: 4
   shadowCascadeRatios:
   - 0.05
-  - 0.05
-  - 0.05
+  - 0.15
+  - 0.3
-  - 0.2
-  - 0.2
-  - 0.2
-  - 0.2
+  - 0
+  - 0
+  - 0
+  - 0
   shadowAlgorithm: 0
   shadowVariant: 3
   shadowPrecision: 0

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1301_SubSurfaceScattering/GroundLeaf_Transmission-Regular.mat

         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _MaskMap:
-        m_Texture: {fileID: 2800000, guid: b24f69ff4ace9194fb0d9eee4f5cf1a4, type: 3}
+        m_Texture: {fileID: 2800000, guid: bb365ecc385707e4393520c6e7893cc8, type: 3}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _NormalMap:

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2002_Dynamic_Mix.unity

   m_ReflectionIntensity: 1
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.3661957, g: 0.3847838, b: 0.4253666, a: 1}
+  m_IndirectSpecularColor: {r: 0.36615336, g: 0.38474482, b: 0.42534754, a: 1}
   m_UseRadianceAmbientProbe: 0
 --- !u!157 &3
 LightmapSettings:
   shadowResolution: 512
   shadowDimmer: 1
   shadowFadeDistance: 10000
-  viewBiasMin: 0.5
+  viewBiasMin: 2.25
-  viewBiasScale: 1
+  viewBiasScale: 8
   normalBiasMin: 0.2
   normalBiasMax: 4
   normalBiasScale: 1

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2102_GI_Emission.unity

   m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
   m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
   m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
-  m_AmbientIntensity: 1
+  m_AmbientIntensity: 0
   m_AmbientMode: 0
   m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
   m_SkyboxMaterial: {fileID: 0}
   m_DefaultReflectionMode: 0
   m_DefaultReflectionResolution: 128
   m_ReflectionBounces: 1
-  m_ReflectionIntensity: 1
+  m_ReflectionIntensity: 0
-  m_IndirectSpecularColor: {r: 0, g: 0, b: 0, a: 1}
+  m_IndirectSpecularColor: {r: 0, g: 0, b: 0, a: 0}
   m_UseRadianceAmbientProbe: 0
 --- !u!157 &3
 LightmapSettings:
     - target: {fileID: 4209882255362944, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
       propertyPath: m_LocalPosition.z
       value: -7.36
+      objectReference: {fileID: 0}
+    - target: {fileID: 114482499083377642, guid: c07ace9ab142ca9469fa377877c2f1e7,
+        type: 2}
+      propertyPath: backgroundColorHDR.r
+      value: 0.18447503
+      objectReference: {fileID: 0}
+    - target: {fileID: 114482499083377642, guid: c07ace9ab142ca9469fa377877c2f1e7,
+        type: 2}
+      propertyPath: backgroundColorHDR.g
+      value: 0.18447503
+      objectReference: {fileID: 0}
+    - target: {fileID: 114482499083377642, guid: c07ace9ab142ca9469fa377877c2f1e7,
+        type: 2}
+      propertyPath: backgroundColorHDR.b
+      value: 0.18447503
       objectReference: {fileID: 0}
     m_RemovedComponents: []
   m_ParentPrefab: {fileID: 100100000, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2201_ReflectionProbes_Priority.unity

   m_EditorClassIdentifier: 
   m_Version: 1
   influenceShape: 0
-  dimmer: 1
+  multiplier: 1
+  weight: 1
   influenceSphereRadius: 3
   sphereReprojectionVolumeRadius: 1
   useSeparateProjectionVolume: 0
   m_EditorClassIdentifier: 
   m_Version: 1
   influenceShape: 0
-  dimmer: 1
+  multiplier: 1
+  weight: 1
   influenceSphereRadius: 3
   sphereReprojectionVolumeRadius: 1
   useSeparateProjectionVolume: 0
   m_EditorClassIdentifier: 
   m_Version: 1
   influenceShape: 0
-  dimmer: 1
+  multiplier: 1
+  weight: 1
   influenceSphereRadius: 3
   sphereReprojectionVolumeRadius: 1
   useSeparateProjectionVolume: 0
   m_EditorClassIdentifier: 
   m_Version: 1
   influenceShape: 0
-  dimmer: 1
+  multiplier: 1
+  weight: 1
   influenceSphereRadius: 3
   sphereReprojectionVolumeRadius: 1
   useSeparateProjectionVolume: 0
   m_EditorClassIdentifier: 
   m_Version: 1
   influenceShape: 0
-  dimmer: 1
+  multiplier: 1
+  weight: 1
   influenceSphereRadius: 3
   sphereReprojectionVolumeRadius: 1
   useSeparateProjectionVolume: 0
   m_EditorClassIdentifier: 
   m_Version: 1
   influenceShape: 0
-  dimmer: 1
+  multiplier: 1
+  weight: 1
   influenceSphereRadius: 3
   sphereReprojectionVolumeRadius: 1
   useSeparateProjectionVolume: 0
   m_EditorClassIdentifier: 
   m_Version: 1
   influenceShape: 0
-  dimmer: 1
+  multiplier: 1
+  weight: 1
   influenceSphereRadius: 3
   sphereReprojectionVolumeRadius: 1
   useSeparateProjectionVolume: 0
   m_EditorClassIdentifier: 
   m_Version: 1
   influenceShape: 0
-  dimmer: 1
+  multiplier: 1
+  weight: 1
   influenceSphereRadius: 3
   sphereReprojectionVolumeRadius: 1
   useSeparateProjectionVolume: 0
   m_EditorClassIdentifier: 
   m_Version: 1
   influenceShape: 0
-  dimmer: 1
+  multiplier: 1
+  weight: 1
   influenceSphereRadius: 3
   sphereReprojectionVolumeRadius: 1
   useSeparateProjectionVolume: 0
   m_EditorClassIdentifier: 
   m_Version: 1
   influenceShape: 0
-  dimmer: 1
+  multiplier: 1
+  weight: 1
   influenceSphereRadius: 3
   sphereReprojectionVolumeRadius: 1
   useSeparateProjectionVolume: 0
       propertyPath: m_LocalEulerAnglesHint.x
       value: 60.000004
       objectReference: {fileID: 0}
+    - target: {fileID: 114482499083377642, guid: c07ace9ab142ca9469fa377877c2f1e7,
+        type: 2}
+      propertyPath: backgroundColorHDR.r
+      value: 0.05448028
+      objectReference: {fileID: 0}
+    - target: {fileID: 114482499083377642, guid: c07ace9ab142ca9469fa377877c2f1e7,
+        type: 2}
+      propertyPath: backgroundColorHDR.g
+      value: 0.05448028
+      objectReference: {fileID: 0}
+    - target: {fileID: 114482499083377642, guid: c07ace9ab142ca9469fa377877c2f1e7,
+        type: 2}
+      propertyPath: backgroundColorHDR.b
+      value: 0.05448028
+      objectReference: {fileID: 0}
     m_RemovedComponents: []
   m_ParentPrefab: {fileID: 100100000, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
   m_IsPrefabParent: 0
   m_EditorClassIdentifier: 
   m_Version: 1
   influenceShape: 0
-  dimmer: 1
+  multiplier: 1
+  weight: 1
   influenceSphereRadius: 3
   sphereReprojectionVolumeRadius: 1
   useSeparateProjectionVolume: 0

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2301_Shadow_Mask/HDRP_Black_Sky.asset

   m_EditorClassIdentifier: 
   active: 1
   rotation:
-    m_OverrideState: 0
+    m_OverrideState: 1
-    m_OverrideState: 0
+    m_OverrideState: 1
-    m_OverrideState: 0
+    m_OverrideState: 1
-    m_OverrideState: 0
+    m_OverrideState: 1
-    m_OverrideState: 0
+    m_OverrideState: 1
-  skyHDRI:
+  hdriSky:
     m_OverrideState: 1
     m_Value: {fileID: 8900000, guid: 75f8ba90acb52d14d9ead53b2a9e4190, type: 3}
 --- !u!114 &114436604167779146
     m_OverrideState: 0
     m_Value: 500
     min: 0
+  cascadeShadowSplitCount:
+    m_OverrideState: 0
+    m_Value: 4
+    min: 1
+    max: 4
+  cascadeShadowSplit0:
+    m_OverrideState: 0
+    m_Value: 0.05
+    min: 0
+    max: 1
+  cascadeShadowSplit1:
+    m_OverrideState: 0
+    m_Value: 0.15
+    min: 0
+    max: 1
+  cascadeShadowSplit2:
+    m_OverrideState: 0
+    m_Value: 0.3
+    min: 0
+    max: 1
+  cascadeShadowBorder0:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder1:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder2:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder3:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
 --- !u!114 &114660440207994068
 MonoBehaviour:
   m_ObjectHideFlags: 3
     m_OverrideState: 1
     m_Value: 10
     min: 0
+  cascadeShadowSplitCount:
+    m_OverrideState: 1
+    m_Value: 4
+    min: 1
+    max: 4
+  cascadeShadowSplit0:
+    m_OverrideState: 1
+    m_Value: 0.05
+    min: 0
+    max: 1
+  cascadeShadowSplit1:
+    m_OverrideState: 1
+    m_Value: 0.15
+    min: 0
+    max: 1
+  cascadeShadowSplit2:
+    m_OverrideState: 1
+    m_Value: 0.3
+    min: 0
+    max: 1
+  cascadeShadowBorder0:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder1:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder2:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder3:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2401_Light_on_Tesselation/HDRP_Default_Sky_SmallDist.asset

     m_OverrideState: 1
     m_Value: 20
     min: 0
+  cascadeShadowSplitCount:
+    m_OverrideState: 0
+    m_Value: 4
+    min: 1
+    max: 4
+  cascadeShadowSplit0:
+    m_OverrideState: 0
+    m_Value: 0.05
+    min: 0
+    max: 1
+  cascadeShadowSplit1:
+    m_OverrideState: 0
+    m_Value: 0.15
+    min: 0
+    max: 1
+  cascadeShadowSplit2:
+    m_OverrideState: 0
+    m_Value: 0.3
+    min: 0
+    max: 1
+  cascadeShadowBorder0:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder1:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder2:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  cascadeShadowBorder3:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
 --- !u!114 &114408460862325740
 MonoBehaviour:
   m_ObjectHideFlags: 3
   active: 1
   rotation:
     m_OverrideState: 1
-    m_Value: 160
+    m_Value: 200
     min: 0
     max: 360
   exposure:
     m_OverrideState: 1
     m_Value: 0
     min: 0
-  skyHDRI:
+  hdriSky:
     m_OverrideState: 1
     m_Value: {fileID: 8900000, guid: fb0bf2eac2381484187ba8a68cdca165, type: 3}
 --- !u!114 &114827887035766406

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassDepthOnly.hlsl

+#ifndef LIGHTWEIGHT_PASS_DEPTH_ONLY_INCLUDED
+#define LIGHTWEIGHT_PASS_DEPTH_ONLY_INCLUDED
+
+#include "LWRP/ShaderLibrary/Core.hlsl"
+#include "LWRP/ShaderLibrary/InputSurface.hlsl"
+
+struct VertexInput
+{
+    float4 position     : POSITION;
+    float2 texcoord     : TEXCOORD0;
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+struct VertexOutput
+{
+    float2 uv           : TEXCOORD0;
+    float4 clipPos      : SV_POSITION;
+};
+
+VertexOutput DepthOnlyVertex(VertexInput v)
+{
+    VertexOutput o = (VertexOutput)0;
+    UNITY_SETUP_INSTANCE_ID(v);
+
+    o.uv = TransformMainTextureCoord(v.texcoord);
+    o.clipPos = TransformObjectToHClip(v.position.xyz);
+    return o;
+}
+
+half4 DepthOnlyFragment(VertexOutput IN) : SV_TARGET
+{
+    Alpha(MainTexture(IN.uv).a);
+    return 0;
+}
+#endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassDepthOnly.hlsl.meta

+fileFormatVersion: 2
+guid: 0acd4fdbcf0cf654a9cdf3e9ccc2edce
+timeCreated: 1488965025
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: