Merge upstream/master

ScriptableRenderPipeline/HDRenderPipeline/CHANGELOG.md

 ## [2018.1 undecided]
 
 ### Improvements
-- Configure the volumetric lighting code path to be on by default
+- Configure the VolumetricLightingSystem code path to be on by default
+- Add 3D texture support for DensityVolumes
+- Add a better mapping of roughness to mipmap for planar reflection
+- The VolumetricLightingSystem now uses RTHandles, which allows to save memory by sharing buffers between different cameras (history buffers are not shared), and reduce reallocation frequency by reallocating buffers only if the rendering resolution increases (and suballocating within existing buffers if the rendering resolution decreases)
+- Rename _MainDepthTexture to _CameraDepthTexture
+- The VolumetricLightingController has been moved to the Interpolation Volume framework and now functions similarly to the VolumetricFog settings
-- Fix the bug preventing decals from coexisting with density volumes 
+- Fix the bug preventing decals from coexisting with density volumes
+- Fix issue with alpha tested geometry using planar/triplanar mapping not render correctly or flickering (due to being wrongly alpha tested in depth prepass)
 
 ## [2018.1.0f2]
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugViewMaterialGBuffer.shader

             float4 Frag(Varyings input) : SV_Target
             {
                 // input.positionCS is SV_Position
-                float depth = LOAD_TEXTURE2D(_MainDepthTexture, input.positionCS.xy).x;
+                float depth = LOAD_TEXTURE2D(_CameraDepthTexture, input.positionCS.xy).x;
                 PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw, depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_V);
 
                 BSDFData bsdfData;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugViewTiles.shader

             float4 Frag(Varyings input) : SV_Target
             {
                 // positionCS is SV_Position
-                float depth = LOAD_TEXTURE2D(_MainDepthTexture, input.positionCS.xy).x;
+                float depth = LOAD_TEXTURE2D(_CameraDepthTexture, input.positionCS.xy).x;
                 PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw, depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_V, uint2(input.positionCS.xy) / GetTileSize());
 
                 int2 pixelCoord = posInput.positionSS.xy;
                 int maxLights = 32;
                 if (tileCoord.y < LIGHTCATEGORY_COUNT && tileCoord.x < maxLights + 3)
                 {
-                    float depthMouse = LOAD_TEXTURE2D(_MainDepthTexture, _MousePixelCoord.xy).x;
+                    float depthMouse = LOAD_TEXTURE2D(_CameraDepthTexture, _MousePixelCoord.xy).x;
                     PositionInputs mousePosInput = GetPositionInput(_MousePixelCoord.xy, _ScreenSize.zw, depthMouse, UNITY_MATRIX_I_VP, UNITY_MATRIX_V, mouseTileCoord);
 
                     uint category = (LIGHTCATEGORY_COUNT - 1) - tileCoord.y;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

 
                     RenderObjectsVelocity(m_CullResults, hdCamera, renderContext, cmd);
 
+                    // This will bind the depth buffer if needed for DBuffer)
                     RenderDBuffer(hdCamera, cmd);
 
 					RenderGBuffer(m_CullResults, hdCamera, enableBakeShadowMask, renderContext, cmd);
 
                     RenderCameraVelocity(m_CullResults, hdCamera, renderContext, cmd);
 
-                    // Depth texture is now ready, bind it.
-                    cmd.SetGlobalTexture(HDShaderIDs._MainDepthTexture, GetDepthTexture());
+                    // Depth texture is now ready, bind it (Depth buffer could have been bind before if DBuffer is enable)
+                    cmd.SetGlobalTexture(HDShaderIDs._CameraDepthTexture, GetDepthTexture());
 
                     // Caution: We require sun light here as some skies use the sun light to render, it means that UpdateSkyEnvironment must be called after PrepareLightsForGPU.
                     // TODO: Try to arrange code so we can trigger this call earlier and use async compute here to run sky convolution during other passes (once we move convolution shader to compute).
                 CopyDepthBufferIfNeeded(cmd);
 
                 // Depth texture is now ready, bind it.
-                cmd.SetGlobalTexture(HDShaderIDs._MainDepthTexture, GetDepthTexture());
+                cmd.SetGlobalTexture(HDShaderIDs._CameraDepthTexture, GetDepthTexture());
                 m_DbufferManager.ClearTargets(cmd, camera);
 				HDUtils.SetRenderTarget(cmd, camera, m_DbufferManager.GetBuffersRTI(), m_CameraDepthStencilBuffer); // do not clear anymore
                 m_DbufferManager.SetHTile(m_DbufferManager.bufferCount, cmd);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDStringConstants.cs

         public static readonly int _LtcDisneyDiffuseMatrix = Shader.PropertyToID("_LtcDisneyDiffuseMatrix");
         public static readonly int _LtcMultiGGXFresnelDisneyDiffuse = Shader.PropertyToID("_LtcMultiGGXFresnelDisneyDiffuse");
 
-        public static readonly int _MainDepthTexture = Shader.PropertyToID("_MainDepthTexture");
-
         public static readonly int _DeferredShadowTexture = Shader.PropertyToID("_DeferredShadowTexture");
         public static readonly int _DeferredShadowTextureUAV = Shader.PropertyToID("_DeferredShadowTextureUAV");
         public static readonly int _DirectionalShadowIndex = Shader.PropertyToID("_DirectionalShadowIndex");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Deferred.shader

                 // This need to stay in sync with deferred.compute
 
                 // input.positionCS is SV_Position
-                float depth = LOAD_TEXTURE2D(_MainDepthTexture, input.positionCS.xy).x;
+                float depth = LOAD_TEXTURE2D(_CameraDepthTexture, input.positionCS.xy).x;
                 PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw, depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_V, uint2(input.positionCS.xy) / GetTileSize());
                 float3 V = GetWorldSpaceNormalizeViewDir(posInput.positionWS);
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/DeferredDirectionalShadow.compute

 
 #include "CoreRP/ShaderLibrary/Common.hlsl"
 #include "../ShaderVariables.hlsl"
-#include "Lighting.hlsl" 
+#include "Lighting.hlsl"
 
 #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 
 	float2 startUV = rayStartCS.xy * 0.5f + 0.5f;
 	startUV.y = 1.0 - startUV.y;
 
-	// Pixel to light ray in 
+	// Pixel to light ray in
 	float2 rayUV = rayCS.xy * 0.5f;
 	rayUV.y = -rayUV.y;
 
 		float raySampleDepth = startDepth + rayDepth * sampleStep;
 
 		// Depth buffer depth for this sample
-		float sampleDepth = SAMPLE_TEXTURE2D_LOD(_MainDepthTexture, sampler_MainDepthTexture, sampleUV, 0.0).x;
+		float sampleDepth = SAMPLE_TEXTURE2D_LOD(_CameraDepthTexture, s_point_clamp_sampler, sampleUV, 0.0).x;
 
 		bool Hit = false;
 		float depthDiff = sampleDepth - raySampleDepth;
 	uint2 pixelCoord = groupId * DEFERRED_SHADOW_TILE_SIZE + groupThreadId;
 	uint2 tileCoord = groupId;
 
-	float depth = LOAD_TEXTURE2D(_MainDepthTexture, pixelCoord.xy).x;
+	float depth = LOAD_TEXTURE2D(_CameraDepthTexture, pixelCoord.xy).x;
 
 	if (depth == UNITY_RAW_FAR_CLIP_VALUE)
 		return;

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

 
     // This need to stay in sync with deferred.shader
 
-    float depth = LOAD_TEXTURE2D(_MainDepthTexture, pixelCoord.xy).x;
+    float depth = LOAD_TEXTURE2D(_CameraDepthTexture, pixelCoord.xy).x;
     PositionInputs posInput = GetPositionInput(pixelCoord.xy, _ScreenSize.zw, depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_V, tileCoord);
 
     // For indirect case: we can still overlap inside a tile with the sky/background, reject it

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

         public int pointCookieSize = 128;
         public int cubeCookieTexArraySize = 16;
 
-        public int reflectionProbeCacheSize = 2;
-        public int planarReflectionProbeCacheSize = 1024;
+        public int planarReflectionProbeCacheSize = 2;
+        public int planarReflectionTextureSize = 1024;
+        public int reflectionProbeCacheSize = 128;
-        public int planarReflectionTextureSize = 128;
         public bool reflectionCacheCompressed = false;
         public bool planarReflectionCacheCompressed = false;
         public SkyResolution skyReflectionSize = SkyResolution.SkyResolution256;

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

                 cmd.SetComputeIntParam(deferredDirectionalShadowComputeShader, HDShaderIDs._DirectionalShadowIndex, m_CurrentSunLightShadowIndex);
                 cmd.SetComputeVectorParam(deferredDirectionalShadowComputeShader, HDShaderIDs._DirectionalLightDirection, -m_CurrentSunLight.transform.forward);
                 cmd.SetComputeTextureParam(deferredDirectionalShadowComputeShader, kernel, HDShaderIDs._DeferredShadowTextureUAV, deferredShadowRT);
-                cmd.SetComputeTextureParam(deferredDirectionalShadowComputeShader, kernel, HDShaderIDs._MainDepthTexture, depthTexture);
+                cmd.SetComputeTextureParam(deferredDirectionalShadowComputeShader, kernel, HDShaderIDs._CameraDepthTexture, depthTexture);
 
                 int deferredShadowTileSize = 16; // Must match DeferreDirectionalShadow.compute
                 int numTilesX = (hdCamera.actualWidth + (deferredShadowTileSize - 1)) / deferredShadowTileSize;
                             }
                         }
 
-                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._MainDepthTexture, depthTexture);
+                        cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs._CameraDepthTexture, depthTexture);
 
                         // TODO: Is it possible to setup this outside the loop ? Can figure out how, get this: Property (specularLightingUAV) at kernel index (21) is not set
                         cmd.SetComputeTextureParam(deferredComputeShader, kernel, HDShaderIDs.specularLightingUAV, colorBuffers[0]);

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

 #define SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES 0
 #define SINGLE_PASS_CONTEXT_SAMPLE_SKY 1
 
+// The EnvLightData of the sky light contains a bunch of compile-time constants.
+// This function sets them directly to allow the compiler to propagate them and optimize the code.
+EnvLightData InitSkyEnvLightData(int envIndex)
+{
+    EnvLightData output;
+    ZERO_INITIALIZE(EnvLightData, output);
+    output.influenceShapeType = ENVSHAPETYPE_SKY;
+    // 31 bit index, 1 bit cache type
+    output.envIndex = ENVCACHETYPE_CUBEMAP | (envIndex << 1);
+
+    output.influenceForward = float3(0.0, 0.0, 1.0);
+    output.influenceUp = float3(0.0, 1.0, 0.0);
+    output.influenceRight = float3(1.0, 0.0, 0.0);
+    output.influencePositionWS = float3(0.0, 0.0, 0.0);
+
+    output.weight = 1.0;
+    output.multiplier = 1.0;
+
+    // proxy
+    output.proxyForward = float3(0.0, 0.0, 1.0);
+    output.proxyUp = float3(0.0, 1.0, 0.0);
+    output.proxyRight = float3(1.0, 0.0, 0.0);
+    output.minProjectionDistance = 65504.0f;
+
+    return output;
+}
+
 bool IsEnvIndexCubemap(int index)   { return (index & 1) == ENVCACHETYPE_CUBEMAP; }
 bool IsEnvIndexTexture2D(int index) { return (index & 1) == ENVCACHETYPE_TEXTURE2D; }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Lighting.hlsl

 #define HAS_LIGHTLOOP // Allow to not define LightLoop related function in Material.hlsl
 
 #include "../Lighting/LightDefinition.cs.hlsl"
-#include "../Lighting/LightUtilities.hlsl"
 
 #include "LightLoop/Shadow.hlsl"
 

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

     R = lerp(R, preLightData.iblR, saturate(smoothstep(0, 1, roughness * roughness)));
 
     float3 F = preLightData.specularFGD;
-    float iblMipLevel = PerceptualRoughnessToMipmapLevel(preLightData.iblPerceptualRoughness);
-    // Specific case for Texture2Ds, their convolution is a gaussian one and not a GGX one.
-    // So we use another roughness mip mapping.
+    float iblMipLevel;
+    // TODO: We need to match the PerceptualRoughnessToMipmapLevel formula for planar, so we don't do this test (which is specific to our current lightloop)
+    // Specific case for Texture2Ds, their convolution is a gaussian one and not a GGX one - So we use another roughness mip mapping.
+    }
+    else
+    {
+        iblMipLevel = PerceptualRoughnessToMipmapLevel(preLightData.iblPerceptualRoughness);
     }
 
     float4 preLD = SampleEnv(lightLoopContext, lightData.envIndex, R, iblMipLevel);

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

 // Varying - Use for pixel shader
 // This second set of define allow to say which varyings will be output in the vertex (no more tesselation)
 #if REQUIRE_TANGENT_TO_WORLD
-#define VARYINGS_NEED_POSITION_WS // Required to get view vector
-#define VARYINGS_NEED_TEXCOORD0
-    #ifdef LAYERED_LIT_SHADER
+    #define VARYINGS_NEED_POSITION_WS // Required to get view vector and to get planar/triplanar mapping working
+    #define VARYINGS_NEED_TEXCOORD0
-        #if defined(_REQUIRE_UV2) || defined(_REQUIRE_UV3)
-        #define VARYINGS_NEED_TEXCOORD2
-        #endif
-        #if defined(_REQUIRE_UV3)
-        #define VARYINGS_NEED_TEXCOORD3
-        #endif
+    #ifdef ATTRIBUTES_NEED_TEXCOORD2
+    #define VARYINGS_NEED_TEXCOORD2
+    #endif
+    #ifdef ATTRIBUTES_NEED_TEXCOORD3
+    #define VARYINGS_NEED_TEXCOORD3
+    #endif
+    #ifdef ATTRIBUTES_NEED_COLOR
+    #define VARYINGS_NEED_COLOR
-#endif
-
-#if REQUIRE_VERTEX_COLOR
-#define VARYINGS_NEED_COLOR
 #endif
 
 // This include will define the various Attributes/Varyings structure

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

 #endif
 
 // Attributes
-#define REQUIRE_UV_FOR_TESSELATION (defined(TESSELLATION_ON) && defined(_TESSELLATION_DISPLACEMENT))
-#define REQUIRE_VERTEX_COLOR_FOR_TESSELATION REQUIRE_UV_FOR_TESSELATION
-#define REQUIRE_TANGENT_TO_WORLD (defined(_HEIGHTMAP) && defined(_PIXEL_DISPLACEMENT))
+#define REQUIRE_TANGENT_TO_WORLD defined(_PIXEL_DISPLACEMENT)
+#define REQUIRE_NORMAL defined(TESSELLATION_ON) || REQUIRE_TANGENT_TO_WORLD || defined(_VERTEX_WIND) || defined(_VERTEX_DISPLACEMENT)
+#define REQUIRE_VERTEX_COLOR (defined(_VERTEX_DISPLACEMENT) || defined(_TESSELLATION_DISPLACEMENT) || (defined(LAYERED_LIT_SHADER) && (defined(_LAYER_MASK_VERTEX_COLOR_MUL) || defined(_LAYER_MASK_VERTEX_COLOR_ADD))) || defined(_VERTEX_WIND))
-#if defined(TESSELLATION_ON) || REQUIRE_TANGENT_TO_WORLD || defined(_VERTEX_WIND)
+#if REQUIRE_NORMAL
-
-#ifdef _VERTEX_WIND
+#if REQUIRE_VERTEX_COLOR
 #define ATTRIBUTES_NEED_COLOR
 #endif
 
-#define ATTRIBUTES_NEED_TEXCOORD0
+#define ATTRIBUTES_NEED_TEXCOORD0 // Always present, distortion use TexCoord0
-#if REQUIRE_UV_FOR_TESSELATION || REQUIRE_TANGENT_TO_WORLD || defined(_ALPHATEST_ON)
+#if defined(_VERTEX_DISPLACEMENT) || REQUIRE_TANGENT_TO_WORLD || defined(_ALPHATEST_ON) || defined(_TESSELLATION_DISPLACEMENT)
     #define ATTRIBUTES_NEED_TEXCOORD1
     #if defined(_REQUIRE_UV2) || defined(_REQUIRE_UV3)
         #define ATTRIBUTES_NEED_TEXCOORD2
     #endif
 #endif
 
-#if REQUIRE_VERTEX_COLOR_FOR_TESSELATION
-#define ATTRIBUTES_NEED_COLOR
-#endif
-
+#define VARYINGS_NEED_POSITION_WS // Can be require if we have planar or triplanar distortion
+
-#define VARYINGS_NEED_POSITION_WS // Required to get view vector
-#define VARYINGS_NEED_TEXCOORD0
+#define VARYINGS_NEED_TEXCOORD0 // Always use with distortion
-    #ifdef LAYERED_LIT_SHADER
-        #if defined(_REQUIRE_UV2) || defined(_REQUIRE_UV3)
-        #define VARYINGS_NEED_TEXCOORD2
-        #endif
-        #if defined(_REQUIRE_UV3)
-        #define VARYINGS_NEED_TEXCOORD3
-        #endif
+    #ifdef ATTRIBUTES_NEED_TEXCOORD2
+    #define VARYINGS_NEED_TEXCOORD2
+    #endif
+    #ifdef ATTRIBUTES_NEED_TEXCOORD3
+    #define VARYINGS_NEED_TEXCOORD3
+    #endif
+    #ifdef ATTRIBUTES_NEED_COLOR
+    #define VARYINGS_NEED_COLOR
     #endif
 #endif
 

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

 
 // Varying - Use for pixel shader
 // This second set of define allow to say which varyings will be output in the vertex (no more tesselation)
-#define VARYINGS_NEED_POSITION_WS
+#define VARYINGS_NEED_POSITION_WS // Can be require if we have planar or triplanar distortion
 
 #if REQUIRE_TANGENT_TO_WORLD
 #define VARYINGS_NEED_TANGENT_TO_WORLD
-#define VARYINGS_NEED_TEXCOORD0
-    #ifdef LAYERED_LIT_SHADER
+    #define VARYINGS_NEED_TEXCOORD0
-        #if defined(_REQUIRE_UV2) || defined(_REQUIRE_UV3)
-        #define VARYINGS_NEED_TEXCOORD2
-        #endif
-        #if defined(_REQUIRE_UV3)
-        #define VARYINGS_NEED_TEXCOORD3
-        #endif
+    #ifdef ATTRIBUTES_NEED_TEXCOORD2
+    #define VARYINGS_NEED_TEXCOORD2
+    #endif
+    #ifdef ATTRIBUTES_NEED_TEXCOORD3
+    #define VARYINGS_NEED_TEXCOORD3
+    #endif
+    #ifdef ATTRIBUTES_NEED_COLOR
+    #define VARYINGS_NEED_COLOR
-#endif
-
-#if REQUIRE_VERTEX_COLOR
-#define VARYINGS_NEED_COLOR
 #endif
 
 // This include will define the various Attributes/Varyings structure

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

         R[i] = lerp(R[i], preLightData.iblR[i], saturate(smoothstep(0, 1, roughness * roughness)));
 
 
-        float iblMipLevel = PerceptualRoughnessToMipmapLevel(preLightData.iblPerceptualRoughness[i]);
+        float iblMipLevel;
+        // TODO: We need to match the PerceptualRoughnessToMipmapLevel formula for planar, so we don't do this test (which is specific to our current lightloop)
+        // Specific case for Texture2Ds, their convolution is a gaussian one and not a GGX one - So we use another roughness mip mapping.
+        if (IsEnvIndexTexture2D(lightData.envIndex))
+        {
+            // Empirical remapping
+            iblMipLevel = PositivePow(preLightData.iblPerceptualRoughness[i], 0.8) * uint(max(_ColorPyramidScale.z - 1, 0));
+        }
+        else
+        {
+            iblMipLevel = PerceptualRoughnessToMipmapLevel(preLightData.iblPerceptualRoughness[i]);
+        }
+
         float4 preLD = SampleEnv(lightLoopContext, lightData.envIndex, R[i], iblMipLevel);
 
         // Used by planar reflection to discard pixel:

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/SubsurfaceScattering.shader

                 // Reconstruct the view-space position.
                 float2 centerPosSS = posInput.positionNDC;
                 float2 cornerPosSS = centerPosSS + 0.5 * _ScreenSize.zw;
-                float  centerDepth = LOAD_TEXTURE2D(_MainDepthTexture, centerPosition).r;
+                float  centerDepth = LOAD_TEXTURE2D(_CameraDepthTexture, centerPosition).r;
                 float3 centerPosVS = ComputeViewSpacePosition(centerPosSS, centerDepth, UNITY_MATRIX_I_P);
                 float3 cornerPosVS = ComputeViewSpacePosition(cornerPosSS, centerDepth, UNITY_MATRIX_I_P);
 
                         // Apply bilateral weighting.
                         // Ref #1: Skin Rendering by Pseudo–Separable Cross Bilateral Filtering.
                         // Ref #2: Separable SSS, Supplementary Materials, Section E.
-                        float rawDepth    = LOAD_TEXTURE2D(_MainDepthTexture, samplePosition).r;
+                        float rawDepth    = LOAD_TEXTURE2D(_CameraDepthTexture, samplePosition).r;
                         float sampleDepth = LinearEyeDepth(rawDepth, _ZBufferParams);
                         float zDistance   = centimPerUnit * sampleDepth - (centimPerUnit * centerPosVS.z);
                         sampleWeight     *= exp(-zDistance * zDistance * halfRcpVariance);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/SubsurfaceScatteringManager.cs

                         HDUtils.SetRenderTarget(cmd, hdCamera, m_HTile, ClearFlag.Color, CoreUtils.clearColorAllBlack);
 
                         HDUtils.SetRenderTarget(cmd, hdCamera, depthStencilBufferRT); // No need for color buffer here
-                        cmd.SetRandomWriteTarget(1, m_HTile);
+                        cmd.SetRandomWriteTarget(1, m_HTile); // This need to be done AFTER SetRenderTarget
                         // Generate HTile for the split lighting stencil usage. Don't write into stencil texture (shaderPassId = 2)
                         // Use ShaderPassID 1 => "Pass 2 - Export HTILE for stencilRef to output"
                         CoreUtils.DrawFullScreen(cmd, m_CopyStencilForSplitLighting, null, 2);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/CameraMotionVectors.shader

 
         float4 Frag(Varyings input) : SV_Target
         {
-            float depth = LOAD_TEXTURE2D(_MainDepthTexture, input.positionCS.xy).x;
-        
+            float depth = LOAD_TEXTURE2D(_CameraDepthTexture, input.positionCS.xy).x;
+
             PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw, depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_V);
 
             float4 worldPos = float4(posInput.positionWS, 1.0);
     SubShader
     {
         Tags{ "RenderPipeline" = "HDRenderPipeline" }
-        
+
         Pass
         {
             // We will perform camera motion velocity only where there is no object velocity

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderPass/ShaderPassDBuffer.hlsl

 {
     FragInputs input = UnpackVaryingsMeshToFragInputs(packedInput.vmesh);
 
-    float depth = LOAD_TEXTURE2D(_MainDepthTexture, input.positionSS.xy).x;
+    float depth = LOAD_TEXTURE2D(_CameraDepthTexture, input.positionSS.xy).x;
     PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_V);
 
     // Transform from world space to decal space (DS) to clip the decal.

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderVariables.hlsl

 
 // ----------------------------------------------------------------------------
 
-TEXTURE2D(_MainDepthTexture);
-SAMPLER(sampler_MainDepthTexture);
+TEXTURE2D(_CameraDepthTexture);
+SAMPLER(sampler_CameraDepthTexture);
 
 // Main lightmap
 TEXTURE2D(unity_Lightmap);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/OpaqueAtmosphericScattering.shader

 
             float4 Frag(Varyings input) : SV_Target
             {
-                float depth = LOAD_TEXTURE2D(_MainDepthTexture, input.positionCS.xy).x;
+                float depth = LOAD_TEXTURE2D(_CameraDepthTexture, input.positionCS.xy).x;
                 PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw, depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_V);
 
                 if (depth == UNITY_RAW_FAR_CLIP_VALUE)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightUtilities.hlsl

-#ifndef UNITY_LIGHT_UTILITIES_INCLUDED
-#define UNITY_LIGHT_UTILITIES_INCLUDED
-
-#include "LightDefinition.cs.hlsl"
-
-// The EnvLightData of the sky light contains a bunch of compile-time constants.
-// This function sets them directly to allow the compiler to propagate them and optimize the code.
-EnvLightData InitSkyEnvLightData(int envIndex)
-{
-    EnvLightData output;
-    ZERO_INITIALIZE(EnvLightData, output);
-    output.influenceShapeType = ENVSHAPETYPE_SKY;
-    output.envIndex = envIndex;
-
-    output.influenceForward = float3(0.0, 0.0, 1.0);
-    output.influenceUp = float3(0.0, 1.0, 0.0);
-    output.influenceRight = float3(1.0, 0.0, 0.0);
-    output.influencePositionWS = float3(0.0, 0.0, 0.0);
-
-    output.weight = 1.0;
-    output.multiplier = 1.0;
-
-    // proxy
-    output.proxyForward = float3(0.0, 0.0, 1.0);
-    output.proxyUp = float3(0.0, 1.0, 0.0);
-    output.proxyRight = float3(1.0, 0.0, 0.0);
-    output.minProjectionDistance = 65504.0f;
-
-    return output;
-}
-
-#endif // UNITY_LIGHT_UTILITIES_INCLUDED

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightUtilities.hlsl.meta

-fileFormatVersion: 2
-guid: be2a44d9e57c5b943ab80fa5fc334d99
-timeCreated: 1480423337
-licenseType: Pro
-ShaderImporter:
-  defaultTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: