Merge branch 'master'

ScriptableRenderPipeline/Core/ShaderLibrary/Common.hlsl

 }
 
 // ----------------------------------------------------------------------------
-// World position reconstruction / transformation
+// Depth encoding/decoding
 // ----------------------------------------------------------------------------
 
 // Z buffer to linear 0..1 depth (0 at near plane, 1 at far plane).
     return -viewSpaceZ;
 }
 
-// The view-space Z position 'z' is assumed to lie between near and far planes.
+// 'z' is the view-space Z position. It is assumed to lie between the near and the far planes.
+// For (z <= n), the function returns 0. For (z >= f), the function returns 1.
-    return saturate(log2(z * encodingParams.z) * encodingParams.w);
+    return saturate(log2(max(1, z * encodingParams.z)) * encodingParams.w);
-    return encodingParams.x * exp2(d * encodingParams.y);
+    return encodingParams.x * exp2(saturate(d) * encodingParams.y);
+}
+
+// ----------------------------------------------------------------------------
+// Space transformations
+// ----------------------------------------------------------------------------
+
+// Use case examples:
+// (position = positionCS) => (clipSpaceTransform = use default)
+// (position = positionVS) => (clipSpaceTransform = UNITY_MATRIX_P)
+// (position = positionWS) => (clipSpaceTransform = UNITY_MATRIX_VP)
+float2 ComputeScreenSpacePosition(float3 position, float4x4 clipSpaceTransform = k_identity4x4)
+{
+    float4 positionCS = mul(clipSpaceTransform, float4(position, 1.0));
+    float2 positionSS = positionCS.xy * (rcp(positionCS.w) * 0.5) + 0.5;
+#if UNITY_UV_STARTS_AT_TOP
+    positionSS.y = 1.0 - positionSS.y;
+#endif
+    return positionSS;
+}
+
+float4 ComputeClipSpacePosition(float2 positionSS, float depthRaw)
+{
+#if UNITY_UV_STARTS_AT_TOP
+    positionSS.y = 1.0 - positionSS.y;
+#endif
+    return float4(positionSS * 2.0 - 1.0, depthRaw, 1.0);
+}
+
+float3 ComputeViewSpacePosition(float2 positionSS, float depthRaw, float4x4 invProjMatrix)
+{
+    float4 positionCS = ComputeClipSpacePosition(positionSS, depthRaw);
+    float4 positionVS = mul(invProjMatrix, positionCS);
+    // The view space uses a right-handed coordinate system.
+    positionVS.z = -positionVS.z;
+    return positionVS.xyz / positionVS.w;
+float3 ComputeWorldSpacePosition(float2 positionSS, float depthRaw, float4x4 invViewProjMatrix)
+{
+    float4 positionCS  = ComputeClipSpacePosition(positionSS, depthRaw);
+    float4 hpositionWS = mul(invViewProjMatrix, positionCS);
+    return hpositionWS.xyz / hpositionWS.w;
+}
+
+// ----------------------------------------------------------------------------
+// PositionInputs
+// ----------------------------------------------------------------------------
+
 struct PositionInputs
 {
     // Normalize screen position (offset by 0.5)
     posInput.depthRaw   = depthRaw;
     posInput.depthVS    = depthVS;
     posInput.positionWS = positionWS;
-}
-
-float4 ComputeClipSpacePosition(float2 positionSS, float depthRaw)
-{
-#if UNITY_UV_STARTS_AT_TOP
-    positionSS.y = 1.0 - positionSS.y;
-#endif
-    return float4(positionSS * 2.0 - 1.0, depthRaw, 1.0);
-}
-
-float2 ComputeScreenSpacePosition(float4 positionCS)
-{
-    float2 positionSS = positionCS.xy * (rcp(positionCS.w) * 0.5) + 0.5;
-#if UNITY_UV_STARTS_AT_TOP
-    positionSS.y = 1.0 - positionSS.y;
-#endif
-    return positionSS;
-}
-
-float2 ComputeScreenSpacePosition(float3 positionWS, float4x4 viewProjectionMatrix)
-{
-    float4 positionCS = mul(viewProjectionMatrix, float4(positionWS, 1.0));
-    return ComputeScreenSpacePosition(positionCS);
-}
-
-float3 ComputeViewSpacePosition(float2 positionSS, float depthRaw, float4x4 invProjMatrix)
-{
-    float4 positionCS = ComputeClipSpacePosition(positionSS, depthRaw);
-    float4 positionVS = mul(invProjMatrix, positionCS);
-    // The view space uses a right-handed coordinate system.
-    positionVS.z = -positionVS.z;
-    return positionVS.xyz / positionVS.w;
-}
-
-float3 ComputeWorldSpacePosition(float2 positionSS, float depthRaw, float4x4 invViewProjMatrix)
-{
-    float4 positionCS  = ComputeClipSpacePosition(positionSS, depthRaw);
-    float4 hpositionWS = mul(invViewProjMatrix, positionCS);
-    return hpositionWS.xyz / hpositionWS.w;
 }
 
 // From deferred or compute shader

ScriptableRenderPipeline/Core/ShaderLibrary/Tessellation.hlsl

 float3 GetScreenSpaceTessFactor(float3 p0, float3 p1, float3 p2, float4x4 viewProjectionMatrix, float4 screenSize, float triangleSize)
 {
     // Get screen space adaptive scale factor
-    float2 edgeScreenPosition0 = ComputeScreenSpacePosition(p0, viewProjectionMatrix) * screenSize;
-    float2 edgeScreenPosition1 = ComputeScreenSpacePosition(p1, viewProjectionMatrix) * screenSize;
-    float2 edgeScreenPosition2 = ComputeScreenSpacePosition(p2, viewProjectionMatrix) * screenSize;
+    float2 edgeScreenPosition0 = ComputeScreenSpacePosition(p0, viewProjectionMatrix) * screenSize.xy;
+    float2 edgeScreenPosition1 = ComputeScreenSpacePosition(p1, viewProjectionMatrix) * screenSize.xy;
+    float2 edgeScreenPosition2 = ComputeScreenSpacePosition(p2, viewProjectionMatrix) * screenSize.xy;
 
     float EdgeScale = 1.0 / triangleSize; // Edge size in reality, but name is simpler
     float3 tessFactor;

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugViewMaterialGBuffer.shader

                 // input.positionCS is SV_Position
                 PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw);
                 float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
-                UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
+                UpdatePositionInput(depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_VP, posInput);
 
                 FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
                 BSDFData bsdfData;

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugViewTiles.shader

                 // positionCS is SV_Position
                 PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw, uint2(input.positionCS.xy) / GetTileSize());
                 float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
-                UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
+                UpdatePositionInput(depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_VP, posInput);
 
                 int2 pixelCoord = posInput.unPositionSS.xy;
                 int2 tileCoord = (float2)pixelCoord / GetTileSize();
                 {
                     PositionInputs mousePosInput = GetPositionInput(_MousePixelCoord, _ScreenSize.zw, mouseTileCoord);
                     float depthMouse = LOAD_TEXTURE2D(_MainDepthTexture, mousePosInput.unPositionSS).x;
-                    UpdatePositionInput(depthMouse, _InvViewProjMatrix, _ViewProjMatrix, mousePosInput);
+                    UpdatePositionInput(depthMouse, UNITY_MATRIX_I_VP, UNITY_MATRIX_VP, mousePosInput);
 
                     uint category = (LIGHTCATEGORY_COUNT - 1) - tileCoord.y;
                     uint start;

ScriptableRenderPipeline/HDRenderPipeline/Lighting/Deferred.shader

                 // input.positionCS is SV_Position
                 PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw, uint2(input.positionCS.xy) / GetTileSize());
                 float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
-                UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
+                UpdatePositionInput(depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_VP, posInput);
                 float3 V = GetWorldSpaceNormalizeViewDir(posInput.positionWS);
 
                 FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/Deferred.compute

         return;
     }
 
-    UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
+    UpdatePositionInput(depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_VP, posInput);
     float3 V = GetWorldSpaceNormalizeViewDir(posInput.positionWS);
 
     FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/DeferredDirectionalShadow.compute

     PositionInputs posInput = GetPositionInput(pixelCoord.xy, _ScreenSize.zw, tileCoord);
 
     float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
-    UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
+    UpdatePositionInput(depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_VP, posInput);
 
     ShadowContext shadowContext = InitShadowContext();
     float shadow = GetDirectionalShadowAttenuation(shadowContext, posInput.positionWS, float3(0.0, 0.0, 0.0), (uint)_DirectionalShadowIndex, float3(0.0, 0.0, 0.0));

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

             #include "../../ShaderVariables.hlsl"
             #include "../../Debug/DebugDisplay.hlsl"
             #include "../../Lighting/Forward.hlsl"
-            // TEMP until pragma work in include
-            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
-
             #include "../../Lighting/Lighting.hlsl"
             #include "../Lit/ShaderPass/LitSharePass.hlsl"
             #include "LayeredLitData.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLitDataDisplacement.hlsl

     height3 += height0 * _InheritBaseHeight3 * influenceMask;
 #endif
 
-    float heightResult = BlendLayeredScalar(height0, height1, height2, height3, weights).xxx;
+    float heightResult = BlendLayeredScalar(height0, height1, height2, height3, weights);
 
    // Applying scaling of the object if requested
     #ifdef _VERTEX_DISPLACEMENT_LOCK_OBJECT_SCALE

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

     float3 refractedBackPointWS = EstimateRaycast(V, posInput, preLightData.transmissionPositionWS, preLightData.transmissionRefractV);
 
     // Calculate screen space coordinates of refracted point in back plane
-    float4 refractedBackPointCS = mul(_ViewProjMatrix, float4(refractedBackPointWS, 1.0));
+    float4 refractedBackPointCS = mul(UNITY_MATRIX_VP, float4(refractedBackPointWS, 1.0));
     float2 refractedBackPointSS = ComputeScreenSpacePosition(refractedBackPointCS);
     uint2 depthSize = uint2(_PyramidDepthMipSize.xy);
     float refractedBackPointDepth = LinearEyeDepth(LOAD_TEXTURE2D_LOD(_PyramidDepthTexture, refractedBackPointSS * depthSize, 0).r, _ZBufferParams);

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitDataMeshModification.hlsl

     // For tessellation we want to process tessellation factor always from the point of view of the camera (to be consistent and avoid Z-fight).
     // For the culling part however we want to use the current view (shadow view).
     // Thus the following code play with both.
-
+    
+    // TODO: the only reason I test the near plane here is that I am not sure that the product of other tessellation factors
+    // (such as screen-space/distance-based) results in the tessellation factor of 1 for the geometry behind the near plane.
+    // If that is the case (and, IMHO, it should be), we shouldn't have to test the near plane here.
     bool3 frustumCullEdgesMainView = CullTriangleEdgesFrustum(p0, p1, p2, frustumEps, _FrustumPlanes, 5); // Do not test the far plane
 
 #if defined(SHADERPASS) && (SHADERPASS != SHADERPASS_SHADOWS)
     if (_TessellationFactorTriangleSize > 0.0)
     {
         // return a value between 0 and 1
+        // Warning: '_ViewProjMatrix' is not the same as UNITY_MATRIX_VP for shadow views!
         edgeTessFactors *= GetScreenSpaceTessFactor( p0, p1, p2, _ViewProjMatrix, _ScreenSize, _TessellationFactorTriangleSize); // Use primary camera view
     }
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Resources/SubsurfaceScattering.compute

     #if SSS_USE_TANGENT_PLANE
         float3 relPosVS   = vec.x * tangentX + vec.y * tangentY;
         float3 positionVS = centerPosVS + relPosVS;
-        float4 positionCS = mul(projMatrix, float4(positionVS, 1));
-        float2 positionSS = ComputeScreenSpacePosition(positionCS);
+        float2 positionSS = ComputeScreenSpacePosition(positionCS, projMatrix);
 
         position = (int2)(positionSS * _ScreenSize.xy);
         xy2      = dot(relPosVS.xy, relPosVS.xy);
     // Reconstruct the view-space position corresponding to the central sample.
     float2 centerPosSS = posInput.positionSS;
     float2 cornerPosSS = centerPosSS + 0.5 * _ScreenSize.zw;
-    float3 centerPosVS = ComputeViewSpacePosition(centerPosSS, centerDepth, _InvProjMatrix);
-    float3 cornerPosVS = ComputeViewSpacePosition(cornerPosSS, centerDepth, _InvProjMatrix);
+    float3 centerPosVS = ComputeViewSpacePosition(centerPosSS, centerDepth, UNITY_MATRIX_I_P);
+    float3 cornerPosVS = ComputeViewSpacePosition(cornerPosSS, centerDepth, UNITY_MATRIX_I_P);
 
     // Rescaling the filter is equivalent to inversely scaling the world.
     float mmPerUnit  = MILLIMETERS_PER_METER * (_WorldScales[profileID].x / distScale);

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Resources/SubsurfaceScattering.shader

                 float2 centerPosSS = posInput.positionSS;
                 float2 cornerPosSS = centerPosSS + 0.5 * _ScreenSize.zw;
                 float  centerDepth = LOAD_TEXTURE2D(_MainDepthTexture, centerPosition).r;
-                float3 centerPosVS = ComputeViewSpacePosition(centerPosSS, centerDepth, _InvProjMatrix);
-                float3 cornerPosVS = ComputeViewSpacePosition(cornerPosSS, centerDepth, _InvProjMatrix);
+                float3 centerPosVS = ComputeViewSpacePosition(centerPosSS, centerDepth, UNITY_MATRIX_I_P);
+                float3 cornerPosVS = ComputeViewSpacePosition(cornerPosSS, centerDepth, UNITY_MATRIX_I_P);
 
                 // Rescaling the filter is equivalent to inversely scaling the world.
                 float  metersPerUnit = _WorldScales[profileID].x / distScale * SSS_BASIC_DISTANCE_SCALE;

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/SubsurfaceScatteringSettings.cs

 
         public string name;
 
-        [ColorUsage(false, true, 0f, 8f, 0.125f, 3f)]
+        [ColorUsage(false, true)]
         public Color            scatteringDistance;         // Per color channel (no meaningful units)
         [ColorUsage(false)]
         public Color            transmissionTint;           // Color, 0 to 1
         public float            worldScale;                 // Size of the world unit in meters
 
         // Old SSS Model >>>
-        [ColorUsage(false, true, 0f, 8f, 0.125f, 3f)]
+        [ColorUsage(false, true)]
-        [ColorUsage(false, true, 0f, 8f, 0.125f, 3f)]
+        [ColorUsage(false, true)]
         public Color            scatterDistance2;
         [Range(0f, 1f)]
         public float            lerpWeight;

ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/CameraMotionVectors.shader

         {
             PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw);
             float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
-            UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
+            UpdatePositionInput(depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_VP, posInput);
             float4 worldPos = float4(posInput.positionWS, 1.0);
             float4 prevPos = worldPos;
 

ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPassLightTransport.hlsl

     output.vmesh.positionWS = positionWS;
 #endif
 
+    // Not required for meta pass but to silent the shader compiler warning in case it is declare
+#ifdef VARYINGS_NEED_TANGENT_TO_WORLD
+    output.vmesh.normalWS = float3(0.0, 0.0, 0.0);
+    output.vmesh.tangentWS = float4(0.0, 0.0, 0.0, 0.0);
+#endif
+
 #ifdef VARYINGS_NEED_TEXCOORD0
     output.vmesh.texCoord0 = inputMesh.uv0;
 #endif

ScriptableRenderPipeline/HDRenderPipeline/ShaderVariables.hlsl

 // ----------------------------------------------------------------------------
 
 // TODO: all affine matrices should be 3x4.
+// TODO: sort these vars by the frequency of use (descending), and put commonly used vars together.
+// Note: please use UNITY_MATRIX_X macros instead referencing matrix variables directly.
 CBUFFER_START(UnityPerPass)
 float4x4 _PrevViewProjMatrix;
 float4x4 _ViewProjMatrix;

ScriptableRenderPipeline/HDRenderPipeline/ShaderVariablesMatrixDefsHDCamera.hlsl

 #define UNITY_MATRIX_P     OptimizeProjectionMatrix(_ProjMatrix)
 #define UNITY_MATRIX_I_P   _InvProjMatrix
 #define UNITY_MATRIX_VP    _ViewProjMatrix
-#define UNITY_MATRIX_MVP   mul(UNITY_MATRIX_VP, UNITY_MATRIX_M)
+#define UNITY_MATRIX_I_VP  _InvViewProjMatrix
+#define UNITY_MATRIX_MVP   mul(UNITY_MATRIX_VP, UNITY_MATRIX_M)
 
 #endif // UNITY_SHADER_VARIABLES_MATRIX_DEFS_HDCAMERA_INCLUDED

ScriptableRenderPipeline/HDRenderPipeline/ShaderVariablesMatrixDefsLegacyUnity.hlsl

 #define UNITY_MATRIX_V     unity_MatrixV
 #define UNITY_MATRIX_I_V   unity_MatrixInvV
 #define UNITY_MATRIX_P     OptimizeProjectionMatrix(glstate_matrix_projection)
-#define UNITY_MATRIX_I_P   inverse_glstate_matrix_projection_is_not_defined
+#define UNITY_MATRIX_I_P   ERROR_UNITY_MATRIX_I_P_IS_NOT_DEFINED
-#define UNITY_MATRIX_MVP   mul(UNITY_MATRIX_VP, UNITY_MATRIX_M)
+#define UNITY_MATRIX_I_VP  ERROR_UNITY_MATRIX_I_VP_IS_NOT_DEFINED
+#define UNITY_MATRIX_MVP   mul(UNITY_MATRIX_VP, UNITY_MATRIX_M)
 
 #endif // UNITY_SHADER_VARIABLES_MATRIX_DEFS_LEGACY_UNITY_INCLUDED

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

                 }
 
                 // Since we only need the world space position, so we don't pass the view-projection matrix.
-                UpdatePositionInput(depthRaw, _InvViewProjMatrix, k_identity4x4, posInput);
+                UpdatePositionInput(depthRaw, UNITY_MATRIX_I_VP, k_identity4x4, posInput);
 
                 float4 c1, c2, c3;
                 VolundTransferScatter(GetAbsolutePositionWS(posInput.positionWS), c1, c2, c3);

ScriptableRenderPipeline/HDRenderPipeline/Sky/OpaqueAtmosphericScattering.shader

             {
                 PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw);
                 float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
-                UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
+                UpdatePositionInput(depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_VP, posInput);
 
                 return EvaluateAtmosphericScattering(posInput);
             }