HDRenderPipeline: Try to connect depth offset

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitData.hlsl

 
 #include "ShaderLibrary/PerPixelDisplacement.hlsl"
 
-void ApplyPerPixelDisplacement(FragInputs input, float3 V, inout LayerTexCoord layerTexCoord)
+float ApplyPerPixelDisplacement(FragInputs input, float3 V, inout LayerTexCoord layerTexCoord)
 {
     bool ppdEnable = false;
     bool isPlanar = false;
         float lod = ComputeTextureLOD(minUvSize);
 
         PerPixelHeightDisplacementParam ppdParam;
+
+        float height; // final height processed
 
         // We need to calculate the texture space direction. It depends on the mapping.
         if (isTriplanar)
             // TODO: do we support object triplanar ? See ComputeLayerTexCoord
             float3 viewDirTS = isPlanar ? float3(-V.xz, V.y) : TransformWorldToTangent(V, input.tangentToWorld);
             int numSteps = (int)lerp(_PPDMaxSamples, _PPDMinSamples, viewDirTS.z);
-            float2 offset = ParallaxOcclusionMapping(lod, _PPDLodThreshold, numSteps, viewDirTS, maxHeight, ppdParam);
+            float2 offset;
+            ParallaxOcclusionMapping(lod, _PPDLodThreshold, numSteps, viewDirTS, maxHeight, ppdParam, offset, height);
+
+        return height * maxHeight;
+
+    return 0.0;
 }
 
 // Calculate displacement for per vertex displacement mapping
                      input.positionWS, input.tangentToWorld[2].xyz, layerTexCoord);
 
 
-    ApplyPerPixelDisplacement(input, V, layerTexCoord);
-    float depthOffset = 0.0;
+    float depthOffset = ApplyPerPixelDisplacement(input, V, layerTexCoord);
+
+    // TEMP
+    depthOffset = -depthOffset * 20.0;
 
 #ifdef _DEPTHOFFSET_ON
     ApplyDepthOffsetPositionInput(V, depthOffset, posInput);
 // - Blend Mask use same mapping as main layer (UVO, Planar, Triplanar)
 // From these rules it mean that PPD is enable only if the user 1) ask for it, 2) if there is one heightmap enabled on active layer, 3) if mapping is the same for all layer respecting 2), 4) if mapping is UV0, planar or triplanar mapping
 // Most contraint are handled by the inspector (i.e the UI) like the mapping constraint and is assumed in the shader.
-void ApplyPerPixelDisplacement(FragInputs input, float3 V, inout LayerTexCoord layerTexCoord)
+float ApplyPerPixelDisplacement(FragInputs input, float3 V, inout LayerTexCoord layerTexCoord)
 {
     bool ppdEnable = false;
     bool isPlanar = false;
         ppdParam.mainHeightInfluence = 0.0;
 #endif
 
+        float height;
+
         // We need to calculate the texture space direction. It depends on the mapping.
         if (isTriplanar)
         {
             // TODO: do we support object triplanar ? See ComputeLayerTexCoord
             float3 viewDirTS = isPlanar ? float3(-V.xz, V.y) : TransformWorldToTangent(V, input.tangentToWorld);
             int numSteps = (int)lerp(_PPDMaxSamples, _PPDMinSamples, viewDirTS.z);
-            float2 offset = ParallaxOcclusionMapping(lod, _PPDLodThreshold, numSteps, viewDirTS, maxHeight, ppdParam);
+            float2 offset;
+            ParallaxOcclusionMapping(lod, _PPDLodThreshold, numSteps, viewDirTS, maxHeight, ppdParam, offset, height);
 
             // Apply offset to all planar uvset
             // _UVMappingPlanar0 will be 1.0 is planar is used - _UVMappingMask0.x will be 1.0 is UVSet0 is used;
             layerTexCoord.details2.uv += offsetWeights.z * offset;
             layerTexCoord.details3.uv += offsetWeights.w * offset;
         }
+
+        return height * maxHeight;
+
+    return 0.0;
 }
 
 // Calculate displacement for per vertex displacement mapping

Assets/ScriptableRenderPipeline/ShaderLibrary/PerPixelDisplacement.hlsl

 // it return the offset to apply to the UVSet provide in PerPixelHeightDisplacementParam
 // viewDirTS is view vector in texture space matching the UVSet
 // ref: https://www.gamedev.net/resources/_/technical/graphics-programming-and-theory/a-closer-look-at-parallax-occlusion-mapping-r3262
-float2 ParallaxOcclusionMapping(float lod, float lodThreshold, int numSteps, float3 viewDirTS, float maxHeight, PerPixelHeightDisplacementParam ppdParam)
+void ParallaxOcclusionMapping(float lod, float lodThreshold, int numSteps, float3 viewDirTS, float maxHeight, PerPixelHeightDisplacementParam ppdParam, out float2 outOffset, out float outHeight)
 {
     // Convention: 1.0 is top, 0.0 is bottom - POM is always inward, no extrusion
     float stepSize = 1.0 / (float)numSteps;
     float ratio = delta0 / (delta0 + delta1);
     float2 offset = texOffsetCurrent - ratio * texOffsetPerStep;
 
+    currHeight = ComputePerPixelHeightDisplacement(offset, lod, ppdParam);
+
-    return offset;
+    outOffset = offset;
+    outHeight = currHeight;
 }