Global rename: 'depthRaw' -> 'deviceDepth', 'depthVS -> linearDepth'

ScriptableRenderPipeline/Core/ShaderLibrary/Common.hlsl

 // Z buffer to linear depth.
 // Correctly handles oblique view frustums. Only valid for projection matrices!
 // Ref: An Efficient Depth Linearization Method for Oblique View Frustums, Eq. 6.
-float LinearEyeDepth(float2 positionSS, float depthRaw, float4 invProjParam)
+float LinearEyeDepth(float2 positionSS, float deviceDepth, float4 invProjParam)
-    float4 positionCS = float4(positionSS * 2.0 - 1.0, depthRaw, 1.0);
+    float4 positionCS = float4(positionSS * 2.0 - 1.0, deviceDepth, 1.0);
     float  viewSpaceZ = rcp(dot(positionCS, invProjParam));
     // The view space uses a right-handed coordinate system.
     return -viewSpaceZ;
     return positionSS;
 }
 
-float4 ComputeClipSpacePosition(float2 positionSS, float depthRaw)
+float4 ComputeClipSpacePosition(float2 positionSS, float deviceDepth)
-    return float4(positionSS * 2.0 - 1.0, depthRaw, 1.0);
+    return float4(positionSS * 2.0 - 1.0, deviceDepth, 1.0);
-float3 ComputeViewSpacePosition(float2 positionSS, float depthRaw, float4x4 invProjMatrix)
+float3 ComputeViewSpacePosition(float2 positionSS, float deviceDepth, float4x4 invProjMatrix)
-    float4 positionCS = ComputeClipSpacePosition(positionSS, depthRaw);
+    float4 positionCS = ComputeClipSpacePosition(positionSS, deviceDepth);
     float4 positionVS = mul(invProjMatrix, positionCS);
     // The view space uses a right-handed coordinate system.
     positionVS.z = -positionVS.z;
-float3 ComputeWorldSpacePosition(float2 positionSS, float depthRaw, float4x4 invViewProjMatrix)
+float3 ComputeWorldSpacePosition(float2 positionSS, float deviceDepth, float4x4 invViewProjMatrix)
-    float4 positionCS  = ComputeClipSpacePosition(positionSS, depthRaw);
+    float4 positionCS  = ComputeClipSpacePosition(positionSS, deviceDepth);
     float4 hpositionWS = mul(invViewProjMatrix, positionCS);
     return hpositionWS.xyz / hpositionWS.w;
 }
     uint2 unPositionSS;
     uint2 unTileCoord;
 
-    float depthRaw; // raw depth from depth buffer
-    float depthVS;
+    float deviceDepth; // raw depth from depth buffer
+    float linearDepth;
 
     float3 positionWS;
 };
 }
 
 // From forward
-// depthRaw and depthVS come directly form .zw of SV_Position
-void UpdatePositionInput(float depthRaw, float depthVS, float3 positionWS, inout PositionInputs posInput)
+// deviceDepth and linearDepth come directly from .zw of SV_Position
+void UpdatePositionInput(float deviceDepth, float linearDepth, float3 positionWS, inout PositionInputs posInput)
-    posInput.depthRaw   = depthRaw;
-    posInput.depthVS    = depthVS;
-    posInput.positionWS = positionWS;
+    posInput.deviceDepth = deviceDepth;
+    posInput.linearDepth = linearDepth;
+    posInput.positionWS  = positionWS;
-void UpdatePositionInput(float depthRaw, float4x4 invViewProjMatrix, float4x4 viewProjMatrix, inout PositionInputs posInput)
+void UpdatePositionInput(float deviceDepth, float4x4 invViewProjMatrix, float4x4 viewProjMatrix, inout PositionInputs posInput)
-    posInput.depthRaw = depthRaw;
-
-    posInput.positionWS = ComputeWorldSpacePosition(posInput.positionSS, depthRaw, invViewProjMatrix);
+    posInput.deviceDepth = deviceDepth;
+    posInput.positionWS  = ComputeWorldSpacePosition(posInput.positionSS, deviceDepth, invViewProjMatrix);
-    posInput.depthVS = mul(viewProjMatrix, float4(posInput.positionWS, 1.0)).w;
+    posInput.linearDepth = mul(viewProjMatrix, float4(posInput.positionWS, 1.0)).w;
 }
 
 // The view direction 'V' points towards the camera.
     posInput.positionWS += depthOffsetVS * (-V);
 
-    float4 positionCS = mul(viewProjMatrix, float4(posInput.positionWS, 1.0));
-    posInput.depthVS  = positionCS.w;
-    posInput.depthRaw = positionCS.z / positionCS.w;
+    float4 positionCS    = mul(viewProjMatrix, float4(posInput.positionWS, 1.0));
+    posInput.linearDepth = positionCS.w;
+    posInput.deviceDepth = positionCS.z / positionCS.w;
 }
 
 // ----------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugViewMaterialGBuffer.shader

 
                 if (_DebugViewMaterial == DEBUGVIEWGBUFFER_DEPTH)
                 {
-                    float linearDepth = frac(posInput.depthVS * 0.1);
+                    float linearDepth = frac(posInput.linearDepth * 0.1);
                     result = linearDepth.xxx;
                 }
                 // Caution: This value is not the same than the builtin data bakeDiffuseLighting. It also include emissive and multiply by the albedo

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePassLoop.hlsl

         logBase = g_logBaseBuffer[tileIndex.y * _NumTileClusteredX + tileIndex.x];
     }
 
-    int clustIdx = SnapToClusterIdxFlex(posInput.depthVS, logBase, g_isLogBaseBufferEnabled != 0);
+    int clustIdx = SnapToClusterIdxFlex(posInput.linearDepth, logBase, g_isLogBaseBufferEnabled != 0);
 
     int nrClusters = (1 << g_iLog2NumClusters);
     const int idx = ((lightCategory * nrClusters + clustIdx) * _NumTileClusteredY + tileIndex.y) * _NumTileClusteredX + tileIndex.x;

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

     float depth = LinearEyeDepth(pyramidDepth, _ZBufferParams);
 
     // Distance from point to the back plane
-    float depthFromPositionInput = depth - posInputs.depthVS;
+    float depthFromPositionInput = depth - posInputs.linearDepth;
 
     float offset = dot(-V, positionWS - posInputs.positionWS);
     float depthFromPosition = depthFromPositionInput - offset;
 #endif
 
 #ifdef SHADOWS_SHADOWMASK
-        float fade = saturate(posInput.depthVS * lightData.fadeDistanceScaleAndBias.x + lightData.fadeDistanceScaleAndBias.y);
+        float fade = saturate(posInput.linearDepth * lightData.fadeDistanceScaleAndBias.x + lightData.fadeDistanceScaleAndBias.y);
 
         // See comment in EvaluateBSDF_Punctual
         shadow = lightData.dynamicShadowCasterOnly ? min(shadowMask, shadow) : shadow;
 
     // Exit if texel is out of color buffer
     // Or if the texel is from an object in front of the object
-    if (refractedBackPointDepth < posInput.depthVS
+    if (refractedBackPointDepth < posInput.linearDepth
         || any(refractedBackPointSS < 0.0)
         || any(refractedBackPointSS > 1.0))
     {

ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPassDepthOnly.hlsl

     outColor = float4(0.0, 0.0, 0.0, 0.0);
 
 #ifdef _DEPTHOFFSET_ON
-    outputDepth = posInput.depthRaw;
+    outputDepth = posInput.deviceDepth;
 #endif
 }

ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPassForward.hlsl

     }
 
 #ifdef _DEPTHOFFSET_ON
-    outputDepth = posInput.depthRaw;
+    outputDepth = posInput.deviceDepth;
 #endif
 
 #ifdef DEBUG_DISPLAY

ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPassGBuffer.hlsl

     ENCODE_VELOCITY_INTO_GBUFFER(builtinData.velocity, outVelocityBuffer);
 
 #ifdef _DEPTHOFFSET_ON
-    outputDepth = posInput.depthRaw;
+    outputDepth = posInput.deviceDepth;
 #endif
 }

ScriptableRenderPipeline/HDRenderPipeline/Sky/AtmosphericScattering/AtmosphericScattering.hlsl

     else if (_FogColorMode == FOGCOLORMODE_SKY_COLOR)
     {
         // Based on Uncharted 4 "Mip Sky Fog" trick: http://advances.realtimerendering.com/other/2016/naughty_dog/NaughtyDog_TechArt_Final.pdf
-        float mipLevel = (1.0 - _MipFogMaxMip * saturate((posInput.depthVS - _MipFogNear) / (_MipFogFar - _MipFogNear))) * _SkyTextureMipCount;
+        float mipLevel = (1.0 - _MipFogMaxMip * saturate((posInput.linearDepth - _MipFogNear) / (_MipFogFar - _MipFogNear))) * _SkyTextureMipCount;
         float3 dir = normalize(posInput.positionWS - GetPrimaryCameraPosition());
         return SampleSkyTexture(dir, mipLevel).rgb;
     }
     if (_AtmosphericScatteringType == FOGTYPE_EXPONENTIAL)
     {
         float3 fogColor = GetFogColor(posInput);
-        float fogFactor = _ExpFogDensity * (1.0f - Transmittance(OpticalDepthHomogeneous(1.0f / _ExpFogDistance, posInput.depthVS)));
+        float fogFactor = _ExpFogDensity * (1.0f - Transmittance(OpticalDepthHomogeneous(1.0f / _ExpFogDistance, posInput.linearDepth)));
-        float fogFactor = _LinearFogDensity * saturate((posInput.depthVS - _LinearFogStart) * _LinearFogOneOverRange);
+        float fogFactor = _LinearFogDensity * saturate((posInput.linearDepth - _LinearFogStart) * _LinearFogOneOverRange);
         return float4(fogColor, fogFactor);
     }
     else // NONE

ScriptableRenderPipeline/HDRenderPipeline/Sky/BlacksmithlSky/Resources/SkyBlacksmith.shader

                 #ifdef PERFORM_SKY_OCCLUSION_TEST
                     // Determine whether the sky is occluded by the scene geometry.
                     // Do not perform blending with the environment map if the sky is occluded.
-                    float depthRaw     = max(_SkyDepth, LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).r);
-                    float skyTexWeight = (depthRaw > _SkyDepth) ? 0.0 : 1.0;
+                    float deviceDepth  = max(_SkyDepth, LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).r);
+                    float skyTexWeight = (deviceDepth > _SkyDepth) ? 0.0 : 1.0;
-                    float depthRaw     = _SkyDepth;
+                    float deviceDepth  = _SkyDepth;
-                    depthRaw     = _SkyDepth;
+                    deviceDepth  = _SkyDepth;
-                UpdatePositionInput(depthRaw, UNITY_MATRIX_I_VP, k_identity4x4, posInput);
+                UpdatePositionInput(deviceDepth, UNITY_MATRIX_I_VP, k_identity4x4, posInput);
 
                 float4 c1, c2, c3;
                 VolundTransferScatter(GetAbsolutePositionWS(posInput.positionWS), c1, c2, c3);