Hydrogent: use manual depth testing in OIT layers pass on WebGPU

TheMostDiligent · TheMostDiligent · commit 24c300b71b22 · 2025-03-05T17:51:18.000-08:00
diff --git a/Hydrogent/interface/Tasks/HnBeginOITPassTask.hpp b/Hydrogent/interface/Tasks/HnBeginOITPassTask.hpp
@@ -26,6 +26,8 @@
 
 #pragma once
 
+#include <array>
+
 #include "HnTask.hpp"
 #include "../interface/HnRenderPassState.hpp"
 
@@ -80,7 +82,9 @@ class HnBeginOITPassTask final : public HnTask
     HnRenderPassState m_RenderPassState;
 
     RefCntAutoPtr<IShaderResourceBinding> m_ClearLayersSRB;
-    RefCntAutoPtr<IShaderResourceBinding> m_RWLayersSRB;
+
+    // Two SRBs for ping-ponging between depth buffers.
+    std::array<RefCntAutoPtr<IShaderResourceBinding>, 2> m_RWLayersSRBs;
 
     Uint32 m_BoundOITResourcesVersion = ~0u;
 };
diff --git a/Hydrogent/src/Tasks/HnBeginOITPassTask.cpp b/Hydrogent/src/Tasks/HnBeginOITPassTask.cpp
@@ -83,11 +83,13 @@ void HnBeginOITPassTask::Prepare(pxr::HdTaskContext* TaskCtx,
         {
             FrameTargets->OIT = {};
             m_ClearLayersSRB.Release();
-            m_RWLayersSRB.Release();
+            m_RWLayersSRBs = {};
         }
     }
 
     HnRenderDelegate* RenderDelegate = static_cast<HnRenderDelegate*>(RenderIndex->GetRenderDelegate());
+    IRenderDevice*    pDevice        = RenderDelegate->GetDevice();
+    const bool        IsWebGPUDevice = pDevice->GetDeviceInfo().IsWebGPUDevice();
 
     const USD_Renderer& Renderer = *RenderDelegate->GetUSDRenderer();
     VERIFY_EXPR(Renderer.GetSettings().OITLayerCount > 0);
@@ -103,7 +105,9 @@ void HnBeginOITPassTask::Prepare(pxr::HdTaskContext* TaskCtx,
     bool UseReverseDepth = false;
     GetTaskContextData(TaskCtx, HnRenderResourceTokens->useReverseDepth, UseReverseDepth);
 
-    const TEXTURE_FORMAT DepthFormat = FrameTargets->DepthDSV->GetTexture()->GetDesc().Format;
+    const TEXTURE_FORMAT DepthFormat = !IsWebGPUDevice ?
+        FrameTargets->DepthDSV->GetDesc().Format :
+        TEX_FORMAT_UNKNOWN;
     if (m_RenderPassState.GetDepthStencilFormat() != DepthFormat ||
         m_RenderPassState.GetUseReverseDepth() != UseReverseDepth)
     {
@@ -122,7 +126,10 @@ void HnBeginOITPassTask::Prepare(pxr::HdTaskContext* TaskCtx,
         0, // Unused
         1, // Total tail transmittance
     };
-    m_RenderPassState.Begin(_countof(OITRTVs), OITRTVs, FrameTargets->DepthDSV, &TailClearValue, 0, 0x01u);
+    // WebGPU does not support the earlydepthstencil attribute, so we have to
+    // perform depth testing manually in the shader.
+    ITextureView* pDepthDSV = !IsWebGPUDevice ? FrameTargets->DepthDSV : nullptr;
+    m_RenderPassState.Begin(_countof(OITRTVs), OITRTVs, pDepthDSV, &TailClearValue, 0, 0x01u);
 
     const HnCamera* pCamera = nullptr;
     if (GetTaskContextData(TaskCtx, HnRenderResourceTokens->camera, pCamera))
@@ -177,13 +184,16 @@ void HnBeginOITPassTask::Execute(pxr::HdTaskContext* TaskCtx)
     }
 
     HnRenderDelegate* RenderDelegate = static_cast<HnRenderDelegate*>(m_RenderIndex->GetRenderDelegate());
+    IRenderDevice*    pDevice        = RenderDelegate->GetDevice();
+    const bool        IsWebGPUDevice = pDevice->GetDeviceInfo().IsWebGPUDevice();
     IDeviceContext*   pCtx           = RenderDelegate->GetDeviceContext();
 
-    HnRenderParam* RenderParam = static_cast<HnRenderParam*>(RenderDelegate->GetRenderParam());
-    if (m_BoundOITResourcesVersion != RenderParam->GetAttribVersion(HnRenderParam::GlobalAttrib::OITResources))
+    const HnRenderParam* RenderParam         = static_cast<HnRenderParam*>(RenderDelegate->GetRenderParam());
+    const Uint32         OITResourcesVersion = RenderParam->GetAttribVersion(HnRenderParam::GlobalAttrib::OITResources);
+    if (m_BoundOITResourcesVersion != OITResourcesVersion)
     {
         BindOITResources(RenderDelegate);
-        m_BoundOITResourcesVersion = RenderParam->GetAttribVersion(HnRenderParam::GlobalAttrib::OITResources);
+        m_BoundOITResourcesVersion = OITResourcesVersion;
     }
 
     ScopedDebugGroup DebugGroup{pCtx, "Begin OIT pass"};
@@ -193,16 +203,28 @@ void HnBeginOITPassTask::Execute(pxr::HdTaskContext* TaskCtx)
     {
         Renderer.CreateClearOITLayersSRB(RenderDelegate->GetFrameAttribsCB(), m_FrameTargets->OIT.Layers, &m_ClearLayersSRB);
     }
-    if (!m_RWLayersSRB)
+
+    // For WebGPU, we need to ping-pong between two SRBs using odd/even frame depth buffers.
+    // Other APIs can use a single SRB since they support early depth testing.
+    RefCntAutoPtr<IShaderResourceBinding>& RWLayersSRB = m_RWLayersSRBs[IsWebGPUDevice ? (RenderParam->GetFrameNumber() & 0x01) : 0];
+    if (!RWLayersSRB)
     {
-        Renderer.CreateRWOITLayersSRB(m_FrameTargets->OIT.Layers, &m_RWLayersSRB);
+        ITextureView* pDepthSRV = nullptr;
+        if (IsWebGPUDevice)
+        {
+            // WebGPU does not support the earlydepthstencil attribute, so we have to
+            // perform depth testing manually in the shader.
+            pDepthSRV = m_FrameTargets->DepthDSV->GetTexture()->GetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE);
+            DEV_CHECK_ERR(pDepthSRV != nullptr, "Depth buffer shader resource view is null");
+        }
+        Renderer.CreateRWOITLayersSRB(m_FrameTargets->OIT.Layers, pDepthSRV, &RWLayersSRB);
     }
     const TextureDesc& OITTailDesc = m_FrameTargets->OIT.Tail->GetDesc();
     Renderer.ClearOITLayers(pCtx, m_ClearLayersSRB, OITTailDesc.Width, OITTailDesc.Height);
 
     IShaderResourceBinding* pFrameAttribsSRB = RenderDelegate->GetFrameAttribsSRB(HnRenderDelegate::FrameAttribsSRBType::Opaque);
     m_RenderPassState.SetFrameAttribsSRB(pFrameAttribsSRB);
-    m_RenderPassState.SetRWOITLayersSRB(m_RWLayersSRB);
+    m_RenderPassState.SetRWOITLayersSRB(RWLayersSRB);
     m_RenderPassState.Commit(pCtx);
 }
 
diff --git a/PBR/interface/PBR_Renderer.hpp b/PBR/interface/PBR_Renderer.hpp
@@ -796,7 +796,7 @@ class PBR_Renderer
     static OITResources CreateOITResources(IRenderDevice* pDevice, Uint32 Width, Uint32 Height, Uint32 LayerCount);
     OITResources        CreateOITResources(Uint32 Width, Uint32 Height) const;
     void                CreateClearOITLayersSRB(IBuffer* pFrameAttribs, IBuffer* OITLayers, IShaderResourceBinding** ppSRB) const;
-    void                CreateRWOITLayersSRB(IBuffer* OITLayers, IShaderResourceBinding** ppSRB) const;
+    void                CreateRWOITLayersSRB(IBuffer* OITLayers, ITextureView* pDepthSRV, IShaderResourceBinding** ppSRB) const;
     void                ClearOITLayers(IDeviceContext* pCtx, IShaderResourceBinding* pSRB, Uint32 Width, Uint32 Height) const;
     void                CreateApplyOITAttenuationPSO(TEXTURE_FORMAT ColorFormat, TEXTURE_FORMAT DepthFormat, IPipelineState** ppPSO) const;
     void                CreateApplyOITAttenuationSRB(IBuffer*                 pFrameAttribs,
diff --git a/PBR/src/PBR_Renderer.cpp b/PBR/src/PBR_Renderer.cpp
@@ -1254,6 +1254,11 @@ void PBR_Renderer::CreateSignature()
                 .SetBindingIndex(static_cast<Uint8>(m_ResourceSignatures.size()))
                 .SetUseCombinedTextureSamplers(true)
                 .AddResource(SHADER_TYPE_PIXEL, "g_rwOITLayers", SHADER_RESOURCE_TYPE_BUFFER_UAV, SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE);
+            if (m_Device.GetDeviceInfo().IsWebGPUDevice())
+            {
+                constexpr WebGPUResourceAttribs WGPUDepthMap{WEB_GPU_BINDING_TYPE_UNFILTERABLE_FLOAT_TEXTURE, RESOURCE_DIM_TEX_2D};
+                OITLayersSignDesc.AddResource(SHADER_TYPE_PIXEL, "g_DepthBuffer", SHADER_RESOURCE_TYPE_TEXTURE_SRV, SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE, PIPELINE_RESOURCE_FLAG_NONE, WGPUDepthMap);
+            }
             m_RWOITLayersSignature = m_Device.CreatePipelineResourceSignature(OITLayersSignDesc);
             VERIFY_EXPR(m_RWOITLayersSignature);
         }
@@ -1975,6 +1980,9 @@ void PBR_Renderer::CreatePSO(PsoHashMapType&             PsoHashMap,
         {
             SrcFile = "UpdateOITLayers.psh";
             Name    = "OIT Layers PS";
+            // WebGPU does not support the earlydepthstencil attribute, so we have to
+            // perform depth testing manually in the shader.
+            Macros.Add("USE_MANUAL_DEPTH_TEST", m_Device.GetDeviceInfo().IsWebGPUDevice());
         }
         else
         {
@@ -2294,7 +2302,7 @@ void PBR_Renderer::CreateClearOITLayersSRB(IBuffer* pFrameAttribs, IBuffer* OITL
     ShaderResourceVariableX{*ppSRB, SHADER_TYPE_COMPUTE, "g_rwOITLayers"}.Set(OITLayers->GetDefaultView(BUFFER_VIEW_UNORDERED_ACCESS));
 }
 
-void PBR_Renderer::CreateRWOITLayersSRB(IBuffer* OITLayers, IShaderResourceBinding** ppSRB) const
+void PBR_Renderer::CreateRWOITLayersSRB(IBuffer* OITLayers, ITextureView* pDepthSRV, IShaderResourceBinding** ppSRB) const
 {
     if (!m_RWOITLayersSignature)
     {
@@ -2305,6 +2313,17 @@ void PBR_Renderer::CreateRWOITLayersSRB(IBuffer* OITLayers, IShaderResourceBindi
     m_RWOITLayersSignature->CreateShaderResourceBinding(ppSRB, true);
     VERIFY_EXPR(*ppSRB);
     ShaderResourceVariableX{*ppSRB, SHADER_TYPE_PIXEL, "g_rwOITLayers"}.Set(OITLayers->GetDefaultView(BUFFER_VIEW_UNORDERED_ACCESS));
+    if (m_Device.GetDeviceInfo().IsWebGPUDevice())
+    {
+        if (pDepthSRV != nullptr)
+        {
+            ShaderResourceVariableX{*ppSRB, SHADER_TYPE_PIXEL, "g_DepthBuffer"}.Set(pDepthSRV);
+        }
+        else
+        {
+            DEV_ERROR("Depth buffer SRV is required on WebGPU to perform manual depth test");
+        }
+    }
 }
 
 void PBR_Renderer::CreateApplyOITAttenuationSRB(IBuffer*                 pFrameAttribs,
diff --git a/Shaders/PBR/private/OIT/UpdateOITLayers.psh b/Shaders/PBR/private/OIT/UpdateOITLayers.psh
@@ -52,16 +52,19 @@ PSOutput main(in VSOutput VSOut,
               in bool     IsFrontFace : SV_IsFrontFace)
 {
     float D = VSOut.ClipPos.z;
-    if (g_Frame.Camera.fNearPlaneDepth > g_Frame.Camera.fFarPlaneDepth)
-    {
-        D = 1.0 - D;
-    }
 #if USE_MANUAL_DEPTH_TEST
-    if (D >= g_DepthBuffer.Load(int3(VSOut.ClipPos.xy, 0)))
     {
-        discard;
+        float S = g_Frame.Camera.fNearPlaneDepth < g_Frame.Camera.fFarPlaneDepth ? +1.0 : -1.0;
+        if (D * S >= g_DepthBuffer.Load(int3(VSOut.ClipPos.xy, 0)) * S)
+        {
+            discard;
+        }
     }
 #endif
+    if (g_Frame.Camera.fNearPlaneDepth > g_Frame.Camera.fFarPlaneDepth)
+    {
+        D = 1.0 - D;
+    }
  
     float4 BaseColor = GetBaseColor(VSOut, g_Material, g_Frame.Renderer.MipBias, PRIMITIVE.FallbackColor);
     

Original file line number	Diff line number	Diff line change
`@@ -1254,6 +1254,11 @@ void PBR_Renderer::CreateSignature()`
`1254`	`1254`	`.SetBindingIndex(static_cast<Uint8>(m_ResourceSignatures.size()))`
`1255`	`1255`	`.SetUseCombinedTextureSamplers(true)`
`1256`	`1256`	`.AddResource(SHADER_TYPE_PIXEL, "g_rwOITLayers", SHADER_RESOURCE_TYPE_BUFFER_UAV, SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE);`
	`1257`	`+ if (m_Device.GetDeviceInfo().IsWebGPUDevice())`
	`1258`	`+ {`
	`1259`	`+ constexpr WebGPUResourceAttribs WGPUDepthMap{WEB_GPU_BINDING_TYPE_UNFILTERABLE_FLOAT_TEXTURE, RESOURCE_DIM_TEX_2D};`
	`1260`	`+ OITLayersSignDesc.AddResource(SHADER_TYPE_PIXEL, "g_DepthBuffer", SHADER_RESOURCE_TYPE_TEXTURE_SRV, SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE, PIPELINE_RESOURCE_FLAG_NONE, WGPUDepthMap);`
	`1261`	`+ }`
`1257`	`1262`	`m_RWOITLayersSignature = m_Device.CreatePipelineResourceSignature(OITLayersSignDesc);`
`1258`	`1263`	`VERIFY_EXPR(m_RWOITLayersSignature);`
`1259`	`1264`	`}`
`@@ -1975,6 +1980,9 @@ void PBR_Renderer::CreatePSO(PsoHashMapType& PsoHashMap,`
`1975`	`1980`	`{`
`1976`	`1981`	`SrcFile = "UpdateOITLayers.psh";`
`1977`	`1982`	`Name = "OIT Layers PS";`
	`1983`	`+ // WebGPU does not support the earlydepthstencil attribute, so we have to`
	`1984`	`+ // perform depth testing manually in the shader.`
	`1985`	`+ Macros.Add("USE_MANUAL_DEPTH_TEST", m_Device.GetDeviceInfo().IsWebGPUDevice());`
`1978`	`1986`	`}`
`1979`	`1987`	`else`
`1980`	`1988`	`{`
`@@ -2294,7 +2302,7 @@ void PBR_Renderer::CreateClearOITLayersSRB(IBuffer* pFrameAttribs, IBuffer* OITL`
`2294`	`2302`	`ShaderResourceVariableX{*ppSRB, SHADER_TYPE_COMPUTE, "g_rwOITLayers"}.Set(OITLayers->GetDefaultView(BUFFER_VIEW_UNORDERED_ACCESS));`
`2295`	`2303`	`}`
`2296`	`2304`
`2297`		`-void PBR_Renderer::CreateRWOITLayersSRB(IBuffer* OITLayers, IShaderResourceBinding** ppSRB) const`
	`2305`	`+void PBR_Renderer::CreateRWOITLayersSRB(IBuffer* OITLayers, ITextureView* pDepthSRV, IShaderResourceBinding** ppSRB) const`
`2298`	`2306`	`{`
`2299`	`2307`	`if (!m_RWOITLayersSignature)`
`2300`	`2308`	`{`
`@@ -2305,6 +2313,17 @@ void PBR_Renderer::CreateRWOITLayersSRB(IBuffer* OITLayers, IShaderResourceBindi`
`2305`	`2313`	`m_RWOITLayersSignature->CreateShaderResourceBinding(ppSRB, true);`
`2306`	`2314`	`VERIFY_EXPR(*ppSRB);`
`2307`	`2315`	`ShaderResourceVariableX{*ppSRB, SHADER_TYPE_PIXEL, "g_rwOITLayers"}.Set(OITLayers->GetDefaultView(BUFFER_VIEW_UNORDERED_ACCESS));`
	`2316`	`+ if (m_Device.GetDeviceInfo().IsWebGPUDevice())`
	`2317`	`+ {`
	`2318`	`+ if (pDepthSRV != nullptr)`
	`2319`	`+ {`
	`2320`	`+ ShaderResourceVariableX{*ppSRB, SHADER_TYPE_PIXEL, "g_DepthBuffer"}.Set(pDepthSRV);`
	`2321`	`+ }`
	`2322`	`+ else`
	`2323`	`+ {`
	`2324`	`+ DEV_ERROR("Depth buffer SRV is required on WebGPU to perform manual depth test");`
	`2325`	`+ }`
	`2326`	`+ }`
`2308`	`2327`	`}`
`2309`	`2328`
`2310`	`2329`	`void PBR_Renderer::CreateApplyOITAttenuationSRB(IBuffer* pFrameAttribs,`