Reached working state (still things to be double-checked)

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/PathTracing.cs

@@ -570,10 +570,7 @@ void RenderPathTracingFrame(RenderGraph renderGraph, HDCamera hdCamera, in Camer
                         }
 
                         // Run the computation
-                        ctx.cmd.DispatchRays(data.shader, "TracePath", (uint)data.width, (uint)data.height, 1);
-
-                        // FIXME AOV SUPPORT
-                        //ctx.cmd.DispatchRays(data.shader, data.enableAOVs ? "RayGenAOV" : "RayGen", (uint)data.width, (uint)data.height, 1);
+                        ctx.cmd.DispatchRays(data.shader, data.enableAOVs ? "RayGenAOV" : "RayGen", (uint)data.width, (uint)data.height, 1);
                     });
             }
         }

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/Shaders/PathTracingAOV.hlsl

@@ -1,65 +1,28 @@
 #ifndef UNITY_PATH_TRACING_AOV_INCLUDED
 #define UNITY_PATH_TRACING_AOV_INCLUDED
 
-#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/Shaders/PathTracingIntersection.hlsl"
+#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/Shaders/PathTracingPayload.hlsl"
 
 struct AOVData
 {
     float3 albedo;
     float3 normal;
 };
 
-// Helper functions to read and write AOV values in the payload, hijacking other existing member variables
-void SetAlbedo(inout PathIntersection payload, float3 albedo)
+void WriteAOVData(AOVData aovData, float3 positionWS, inout PathPayload payload)
 {
-    payload.cone.width = albedo.x;
-    payload.cone.spreadAngle = albedo.y;
-    payload.remainingDepth = asint(albedo.z);
-}
-
-float3 GetAlbedo(in PathIntersection payload)
-{
-    return float3(payload.cone.width, payload.cone.spreadAngle, asfloat(payload.remainingDepth));
-}
-
-void SetNormal(inout PathIntersection payload, float3 normal)
-{
-    payload.pixelCoord.x = asint(normal.x);
-    payload.pixelCoord.y = asint(normal.y);
-    payload.maxRoughness = normal.z;
-}
-
-float3 GetNormal(inout PathIntersection payload)
-{
-    return float3(asfloat(payload.pixelCoord.x), asfloat(payload.pixelCoord.y), payload.maxRoughness);
-}
-
-void ClearAOVData(inout PathIntersection payload)
-{
-    SetAlbedo(payload, 0.0);
-    SetNormal(payload, 0.0);
-    payload.motionVector = 0;
-}
-
-void WriteAOVData(inout PathIntersection pathIntersection, AOVData aovData, float3 positionWS)
-{
-    SetAlbedo(pathIntersection, aovData.albedo);
-    SetNormal(pathIntersection, aovData.normal);
-
-    float2 jitteredPixelCoord = pathIntersection.motionVector;
-
-    // Compute motion vector
+    // Compute motion vector (from pixel coordinates and world position passed as inputs)
     float3 prevPosWS = mul(unity_MatrixPreviousM, float4(positionWS, 1.0)).xyz;
     float4 prevClipPos = mul(UNITY_MATRIX_PREV_VP, prevPosWS);
     prevClipPos.xy /= prevClipPos.w;
     prevClipPos.y = -prevClipPos.y;
-
     float2 viewportSize = _ScreenSize.xy *_RTHandleScale.xy;
-    float2 prevFramePos = (prevClipPos.xy * 0.5 + 0.5) * viewportSize;
-    if (prevFramePos.x > 0 && prevFramePos.y > 0 && prevFramePos.x < viewportSize.x && prevFramePos.y < viewportSize.y)
-        pathIntersection.motionVector = prevFramePos - jitteredPixelCoord;
-    else
-        pathIntersection.motionVector = 0;
+    float2 prevPixelCoord = (prevClipPos.xy * 0.5 + 0.5) * viewportSize;
+
+    // Write final AOV values to the payload
+    payload.aovMotionVector = prevPixelCoord - payload.aovMotionVector;
+    payload.aovAlbedo = aovData.albedo;
+    payload.aovNormal = aovData.normal;
 }
 
 #endif //UNITY_PATH_TRACING_AOV_INCLUDED

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/Shaders/PathTracingIntegrator.hlsl

@@ -8,6 +8,7 @@
 // Path tracing includes
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/Shaders/PathTracingPayload.hlsl"
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/Shaders/PathTracingSkySampling.hlsl"
+#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/Shaders/PathTracingAOV.hlsl"
 #ifdef HAS_LIGHTLOOP
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/Shaders/PathTracingLight.hlsl"
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/Shaders/PathTracingVolume.hlsl"
@@ -123,6 +124,12 @@ void ComputeSurfaceScattering(inout PathPayload payload : SV_RayPayload, Attribu
     // Check if we want to compute direct and emissive lighting for current depth
     bool computeDirect = payload.segmentID >= _RaytracingMinRecursion - 1;
 
+    // Get our world space shading position
+    float3 shadingPosition = fragInput.positionRWS;
+
+    // We will write our AOV data in there
+    AOVData aovData;
+
 #ifndef SHADER_UNLIT
 
     // Compute the bsdf data
@@ -132,9 +139,6 @@ void ComputeSurfaceScattering(inout PathPayload payload : SV_RayPayload, Attribu
     // Also make sure that it is in the same hemisphere as the shading normal (which may have been flipped)
     bsdfData.geomNormalWS = dot(bsdfData.normalWS, geomNormal) > 0.0 ? geomNormal : -geomNormal;
 
-    // Get our world space shading position
-    float3 shadingPosition = fragInput.positionRWS;
-
     // And reset the payload value, which will store our final radiance result for this path depth
     payload.value = computeDirect ? builtinData.emissiveColor : 0.0;
 
@@ -258,6 +262,9 @@ void ComputeSurfaceScattering(inout PathPayload payload : SV_RayPayload, Attribu
         }
     }
 
+    // Grab AOV data
+    GetAOVData(mtlData, aovData);
+
 #else // SHADER_UNLIT
 
     if (computeDirect)
@@ -272,6 +279,9 @@ void ComputeSurfaceScattering(inout PathPayload payload : SV_RayPayload, Attribu
     #endif
     }
 
+    // Get the closest thing we have to a shading normal in the Unlit model
+    float3 shadingNormal = fragInput.tangentToWorld[2];
+
     #ifdef _SURFACE_TYPE_TRANSPARENT
     if (builtinData.opacity < 1.0)
     {
@@ -280,10 +290,10 @@ void ComputeSurfaceScattering(inout PathPayload payload : SV_RayPayload, Attribu
         shadowPayload.segmentID = SEGMENT_ID_NEAREST_HIT;
         shadowPayload.rayTHit = FLT_INF;
 
-        float bias = dot(WorldRayDirection(), fragInput.tangentToWorld[2]) > 0.0 ? _RaytracingRayBias : -_RaytracingRayBias;
+        float bias = dot(WorldRayDirection(), shadingNormal) > 0.0 ? _RaytracingRayBias : -_RaytracingRayBias;
 
         RayDesc ray;
-        ray.Origin = fragInput.positionRWS + bias * fragInput.tangentToWorld[2];
+        ray.Origin = shadingPosition + bias * shadingNormal;
         ray.Direction = WorldRayDirection();
         ray.TMin = 0.0;
         ray.TMax = FLT_INF;
@@ -312,7 +322,15 @@ void ComputeSurfaceScattering(inout PathPayload payload : SV_RayPayload, Attribu
     }
     #endif
 
+    // Grab AOV data for Unlit
+    aovData.albedo = surfaceData.color;
+    aovData.normal = shadingNormal;
+
 #endif // SHADER_UNLIT
+
+    // Write AOV data to the payload (if needed)
+    if (payload.segmentID == 0 && any(payload.aovMotionVector))
+        WriteAOVData(aovData, shadingPosition, payload);
 }
 
 // Generic function that handles one scattering event (a vertex along the full path), can be either:
@@ -324,7 +342,7 @@ void ClosestHit(inout PathPayload payload : SV_RayPayload, AttributeData attribu
     // Always set the new t value
     payload.rayTHit = RayTCurrent();
 
-    if (payload.segmentID == SEGMENT_ID_NEAREST_HIT)
+    if (payload.segmentID == SEGMENT_ID_NEAREST_HIT )
         return;
 
     bool computeDirect = payload.segmentID >= _RaytracingMinRecursion - 1;

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/Shaders/PathTracingMain.raytrace

@@ -21,6 +21,7 @@
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/Shaders/PathTracingSampling.hlsl"
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/Shaders/PathTracingSkySampling.hlsl"
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/Shaders/PathTracingVolume.hlsl"
+#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/Shaders/PathTracingAOV.hlsl"
 
 // Input(s)
 float4x4    _PixelCoordToViewDirWS;
@@ -32,6 +33,11 @@ float4      _PathTracingTilingParameters; // xy: tile count, zw: current tile in
 // Output(s)
 RW_TEXTURE2D_X(float4, _FrameTexture);
 
+// AOVs
+RW_TEXTURE2D_X(float4, _AlbedoAOV);
+RW_TEXTURE2D_X(float4, _NormalAOV);
+RW_TEXTURE2D_X(float4, _MotionVectorAOV);
+
 [shader("miss")]
 void CameraMiss(inout PathPayload payload : SV_RayPayload)
 {
@@ -79,6 +85,9 @@ void CameraMiss(inout PathPayload payload : SV_RayPayload)
         // Reinject the environment value
         payload.value += envValue;
     }
+
+    // Override AOV motion vector information
+    payload.aovMotionVector = 0.0;
 }
 
 [shader("miss")]
@@ -108,7 +117,7 @@ void ApplyDepthOfField(uint2 pixelCoord, float dotDirection, inout float3 origin
     direction = normalize(focusPoint - origin);
 }
 
-void GenerateCameraRay(uint2 pixelCoord, out PathPayload payload, out RayDesc ray)
+void GenerateCameraRay(uint2 pixelCoord, out PathPayload payload, out RayDesc ray, bool withAOV = false)
 {
     // Get the current tile coordinates (for interleaved tiling) and update pixel coordinates accordingly
     uint2 tileCount = uint2(_PathTracingTilingParameters.xy);
@@ -130,6 +139,11 @@ void GenerateCameraRay(uint2 pixelCoord, out PathPayload payload, out RayDesc ra
     payload.cone.spreadAngle = _RaytracingPixelSpreadAngle / min(tileCount.x, tileCount.y);
     payload.cone.width = 0.0;
 
+    // The motion vector AOV value will also serve as a on/off indicator for AOV computations
+    payload.aovMotionVector = withAOV ? jitteredPixelCoord.xy : 0.0;
+    payload.aovAlbedo = 0.0;
+    payload.aovNormal = 0.0;
+
     // Generate the ray descriptor for this pixel
     ray.TMin = _RaytracingCameraNearPlane;
     ray.TMax = FLT_INF;
@@ -167,16 +181,12 @@ float3 ClampValue(float3 value, float maxIntensity = _RaytracingIntensityClamp)
     return intensity > maxIntensity ? value * maxIntensity / intensity : value;
 }
 
-[shader("raygeneration")]
-void TracePath()
+void TracePath(uint2 pixelCoord, bool withAOV = false)
 {
-    // Get the current integer pixel coordinates
-    uint2 pixelCoord = DispatchRaysIndex().xy;
-
     // Generate the camera segment of our path
     PathPayload payload;
     RayDesc ray;
-    GenerateCameraRay(pixelCoord, payload, ray);
+    GenerateCameraRay(pixelCoord, payload, ray, withAOV);
 
     // Trace our camera ray
     TraceRay(_RaytracingAccelerationStructure, RAY_FLAG_CULL_BACK_FACING_TRIANGLES, RAYTRACINGRENDERERFLAG_PATH_TRACING, 0, 1, 0, ray, payload);
@@ -204,7 +214,7 @@ void TracePath()
             payload.value = 0.0;
             payload.rayDirection = 0.0;
             payload.pixelCoord = pixelCoord;
-            payload.segmentID = segmentID;    
+            payload.segmentID = segmentID;
 
             // Trace our continuation ray
             TraceRay(_RaytracingAccelerationStructure, RAY_FLAG_CULL_BACK_FACING_TRIANGLES | RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH,
@@ -222,4 +232,24 @@ void TracePath()
 
     // Copy the full path radiance value (and alpha/presence) to our output buffer
     _FrameTexture[COORD_TEXTURE2D_X(pixelCoord)] = float4(value, alpha);
+
+    if (withAOV)
+    {
+        // If we computed AOVs, copy relevant values to our output buffers
+        _AlbedoAOV[COORD_TEXTURE2D_X(pixelCoord)] = float4(payload.aovAlbedo, 1.0);
+        _NormalAOV[COORD_TEXTURE2D_X(pixelCoord)] = float4(payload.aovNormal, 1.0);
+        _MotionVectorAOV[COORD_TEXTURE2D_X(pixelCoord)] = float4(payload.aovMotionVector, 0.0, 1.0);
+    }
+}
+
+[shader("raygeneration")]
+void RayGen()
+{
+    TracePath(DispatchRaysIndex().xy);
+}
+
+[shader("raygeneration")]
+void RayGenAOV()
+{
+    TracePath(DispatchRaysIndex().xy, true);
 }

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/Shaders/PathTracingPayload.hlsl

@@ -24,22 +24,33 @@ struct PathPayload
     //
     // Input
     //
-    uint2   pixelCoord;   // Pixel coordinates from which the path emanates
-    uint    segmentID;    // Identifier for path segment (see above)
+    uint2   pixelCoord;      // Pixel coordinates from which the path emanates
+    uint    segmentID;       // Identifier for path segment (see above)
 
     //
     // Input/output
     //
-    float3  throughput;   // Current path throughput
-    float   maxRoughness; // Current maximum roughness encountered along the path
-    RayCone cone;         // Ray differential information (not used currently)
+    float3  throughput;      // Current path throughput
+    float   maxRoughness;    // Current maximum roughness encountered along the path
+    RayCone cone;            // Ray differential information (not used currently)
 
     //
     // Output
     //
-    float3  value;        // Main value (radiance, or normal for random walk)
-    float3  rayDirection; // Continuation ray direction, null means no continuation
-    float   rayTHit;      // Ray parameter, used either for current or next hit
+    float3  value;           // Main value (radiance, or normal for random walk)
+    float3  rayDirection;    // Continuation ray direction, null means no continuation
+    float   rayTHit;         // Ray parameter, used either for current or next hit
+
+    //
+    // AOV Input/output
+    //
+    float2  aovMotionVector; // Motion vector (also serve as on/off AOV switch)
+
+    //
+    // AOV Output
+    //
+    float3  aovAlbedo;       // Diffuse reflectance
+    float3  aovNormal;       // Shading normal
 };
 
 void SetContinuationRayOrigin(float3 origin, out PathPayload payload)

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/PathTracing/Shaders/PathTracingVolume.hlsl

@@ -110,7 +110,7 @@ void ComputeVolumeScattering(inout PathPayload payload : SV_RayPayload, float3 i
     {
         if (SampleLights(lightList, inputSample, scatteringPosition, 0.0, true, ray.Direction, value, pdf, ray.TMax, shadowOpacity))
         {
-            // FIXME: Apply phase function and divide by pdf (only isotropic for now, and not sure about sigmaS value)
+            // Apply phase function and divide by PDF
             value *= _HeightFogBaseScattering.xyz * ComputeHeightFogMultiplier(scatteringPosition.y) * INV_FOUR_PI / pdf;
 
             if (Luminance(value) > 0.001)
@@ -129,6 +129,8 @@ void ComputeVolumeScattering(inout PathPayload payload : SV_RayPayload, float3 i
         }
     }
 
+    // Override AOV motion vector information
+    payload.aovMotionVector = 0.0;
 }
 
 #endif // UNITY_PATH_TRACING_VOLUME_INCLUDED