Merge pull request #1308 from Unity-Technologies/Rename-_MainDepthTexture-to-_CameraDepthTexture

Rename maindepthtexture to cameradepthtexture

ScriptableRenderPipeline/HDRenderPipeline/CHANGELOG.md

 ### Changed, Removals and deprecations
 - Remove Resource folder of PreIntegratedFGD and add the resource to RenderPipeline Asset
 - Default number of planar reflection change from 4 to 2
+- Rename _MainDepthTexture to _CameraDepthTexture
 
 ### Bug fixes
 - Fix ConvertPhysicalLightIntensityToLightIntensity() function used when creating light from script to match HDLightEditor behavior

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