Hydrogent: render MeshID of translucent materials in a separate pass

Author: TheMostDiligent

Hydrogent/interface/HnRenderPass.hpp

@@ -65,6 +65,10 @@ struct HnRenderPassParams
     USD_Renderer::RenderPassType Type        = USD_Renderer::RenderPassType::Main;
     USD_Renderer::USD_PSO_FLAGS  UsdPsoFlags = USD_Renderer::USD_PSO_FLAG_NONE;
 
+    // If not USD_Renderer::ALPHA_MODE_NUM_MODES, the alpha mode to use for the render pass.
+    // Otherwise, the alpha mode is determined by the material tag.
+    USD_Renderer::ALPHA_MODE AlphaMode = USD_Renderer::ALPHA_MODE_NUM_MODES;
+
     constexpr bool operator==(const HnRenderPassParams& rhs) const
     {
         return (Selection == rhs.Selection &&

Hydrogent/interface/Tasks/HnTaskManager.hpp

@@ -66,6 +66,7 @@ class HnTaskManager
     static constexpr TaskUID TaskUID_EndOITPass                      = 0xa4a829379e28420c;
     static constexpr TaskUID TaskUID_RenderRprimsAdditive            = 0x37d45531106c4c52;
     static constexpr TaskUID TaskUID_RenderRprimsTranslucent         = 0xa015c7e45941407e;
+    static constexpr TaskUID TaskUID_RenderRprimsTranslucentMeshId   = 0xb94c6316ea7f480c;
     static constexpr TaskUID TaskUID_RenderRprimsAdditiveSelected    = 0x2cb8a35254ec46da;
     static constexpr TaskUID TaskUID_RenderRprimsTranslucentSelected = 0x50a786394d834b4f;
     static constexpr TaskUID TaskUID_RenderEnvMap                    = 0xf646122e1dc74bab;
@@ -113,6 +114,8 @@ class HnTaskManager
     ///                             * Renders all Rprims with additive material tag
     ///                         - RenderRprimsTranslucent
     ///                             * Renders all Rprims with translucent material tag
+    ///                         - TaskUID_RenderRprimsTranslucentMeshId
+    ///                             * Renders all Rprims with translucent material tag (Mesh ID, Motion Vectors, Depth)
     ///                         - RenderRprimsAdditiveSelected
     ///                             * Renders only selected Rprims with the additive material tag (depth only)
     ///                         - RenderRprimsTranslucentSelected
@@ -139,6 +142,7 @@ class HnTaskManager
     ///     | RenderRprimsOITLayers           |                  |                   |        |           |          |                  |            |
     ///	    | EndOITPass                      |                  |                   |        |           |          |                  |            |
     ///     | RenderRprimsTranslucent         |       V          |         V         |   V    |     V     |    V     |                  |     V      |
+    ///     | RenderRprimsTranslucentMeshId   |       V          |         V         |        |     V     |          |                  |     V      |
     ///     | RenderRprimsAdditiveSelected    |       V          |                   |        |           |          |        V         |            |
     ///     | RenderRprimsTranslucentSelected |       V          |                   |        |           |          |        V         |            |
     ///     | ReadRprimId                     |                  |                   |        |           |          |                  |            |

Hydrogent/shaders/HnPostProcess.psh

@@ -53,8 +53,8 @@ void main(in  FullScreenTriangleVSOutput VSOut,
         float4 BaseColor   = g_BaseColor.Load(int3(Pos.xy, 0));
         float4 Material    = g_MaterialData.Load(int3(Pos.xy, 0));
 
-        float Roughness = Material.x;
-        float Metallic  = Material.y;
+        float Roughness = saturate(Material.x);
+        float Metallic  = saturate(Material.y);
         SurfaceReflectanceInfo SrfInfo = GetSurfaceReflectanceMR(BaseColor.rgb, Metallic, Roughness);
 
         float4 WorldPos = mul(float4(VSOut.f2NormalizedXY, DepthToNormalizedDeviceZ(0.5), 1.0), g_Frame.Camera.mViewProjInv);

Hydrogent/src/HnRenderPass.cpp

@@ -131,7 +131,11 @@ struct HnRenderPass::RenderState
         RendererSettings{USDRenderer.GetSettings()},
         pCtx{RenderDelegate.GetDeviceContext()},
         Type{RenderPass.m_Params.Type},
-        AlphaMode{MaterialTagToPbrAlphaMode(RenderPass.m_MaterialTag)},
+        AlphaMode{
+            RenderPass.m_Params.AlphaMode != USD_Renderer::ALPHA_MODE_NUM_MODES ?
+                RenderPass.m_Params.AlphaMode :
+                MaterialTagToPbrAlphaMode(RenderPass.m_MaterialTag),
+        },
         ConstantBufferOffsetAlignment{RenderDelegate.GetDevice()->GetAdapterInfo().Buffer.ConstantBufferOffsetAlignment},
         NativeMultiDrawSupported{RenderDelegate.GetDevice()->GetDeviceInfo().Features.NativeMultiDraw == DEVICE_FEATURE_STATE_ENABLED}
     {
@@ -391,10 +395,15 @@ HnRenderPass::EXECUTE_RESULT HnRenderPass::Execute(HnRenderPassState& RPState, c
 
     RenderState State{*this, RPState};
 
-    const std::string DebugGroupName = std::string{"Render Pass - "} +
+    std::string DebugGroupName = std::string{"Render Pass - "} +
         USD_Renderer::GetRenderPassTypeString(m_Params.Type) + " - " +
         m_MaterialTag.GetString() + " - " +
         HnRenderPassParams::GetSelectionTypeString(m_Params.Selection);
+    if (m_Params.AlphaMode != USD_Renderer::ALPHA_MODE_NUM_MODES)
+    {
+        DebugGroupName += " - ";
+        DebugGroupName += USD_Renderer::GetAlphaModeString(m_Params.AlphaMode);
+    }
     ScopedDebugGroup DebugGroup{State.pCtx, DebugGroupName.c_str()};
 
     RPState.Commit(State.pCtx);
@@ -1337,7 +1346,8 @@ void HnRenderPass::UpdateDrawListItemGPUResources(DrawListItem& ListItem, Render
                     PSOFlags |= (MaterialPSOFlags & (PBR_Renderer::PSO_FLAG_USE_COLOR_MAP & PBR_Renderer::PSO_FLAG_ENABLE_TEXCOORD_TRANSFORM));
                 }
 
-                VERIFY(pMaterial->GetMaterialData().Attribs.AlphaMode == State.AlphaMode || pMaterial->GetId().IsEmpty(),
+                VERIFY(((m_Params.AlphaMode != USD_Renderer::ALPHA_MODE_NUM_MODES ? m_Params.AlphaMode : pMaterial->GetMaterialData().Attribs.AlphaMode) == State.AlphaMode ||
+                        pMaterial->GetId().IsEmpty()),
                        "Alpha mode derived from the material tag is not consistent with the alpha mode in the shader attributes. "
                        "This may indicate an issue in how alpha mode is determined in the material, or (less likely) an issue in Rprim sorting by Hydra.");
             }

Hydrogent/src/Tasks/HnTaskManager.cpp

@@ -221,8 +221,9 @@ HnTaskManager::HnTaskManager(pxr::HdRenderIndex& RenderIndex,
                                    USD_Renderer::USD_PSO_FLAG_ENABLE_ALL_OUTPUTS,
                                });
         CreateEndOITPassTask();
-        // We will write mesh ID and depth in a separate pass
-        TranslucentPassOutputs &= ~USD_Renderer::USD_PSO_FLAG_ENABLE_MESH_ID_OUTPUT;
+        // We will write mesh ID, motion vectors and depth in a separate pass
+        TranslucentPassOutputs &= ~(USD_Renderer::USD_PSO_FLAG_ENABLE_MESH_ID_OUTPUT |
+                                    USD_Renderer::USD_PSO_FLAG_ENABLE_MOTION_VECTORS_OUTPUT);
     }
 
     CreateRenderRprimsTask(HnMaterialTagTokens->translucent,
@@ -234,6 +235,20 @@ HnTaskManager::HnTaskManager(pxr::HdRenderIndex& RenderIndex,
                                TranslucentPassOutputs,
                            });
 
+    if (OITEnabled)
+    {
+        // When OIT is enabled, we do not render mesh ID, motion vectors and depth in translucent pass.
+        CreateRenderRprimsTask(HnMaterialTagTokens->translucent,
+                               TaskUID_RenderRprimsTranslucentMeshId,
+                               {
+                                   HnRenderResourceTokens->renderPass_TransparentAll,
+                                   HnRenderPassParams::SelectionType::All,
+                                   USD_Renderer::RenderPassType::Main,
+                                   USD_Renderer::USD_PSO_FLAG_ENABLE_MESH_ID_OUTPUT | USD_Renderer::USD_PSO_FLAG_ENABLE_MOTION_VECTORS_OUTPUT,
+                                   USD_Renderer::ALPHA_MODE_OPAQUE, // Override alpha mode
+                               });
+    }
+
     // Transparent selected RPrims  -> {0 + SelectionDepth}
     CreateRenderRprimsTask(HnMaterialTagTokens->additive,
                            TaskUID_RenderRprimsAdditiveSelected,
@@ -250,6 +265,7 @@ HnTaskManager::HnTaskManager(pxr::HdRenderIndex& RenderIndex,
                                HnRenderPassParams::SelectionType::Selected,
                                USD_Renderer::RenderPassType::Main,
                                USD_Renderer::USD_PSO_FLAG_NONE,
+                               USD_Renderer::ALPHA_MODE_OPAQUE, // Override alpha mode
                            });
 
     CreateReadRprimIdTask();
@@ -357,6 +373,11 @@ pxr::SdfPath HnTaskManager::GetTaskId(const pxr::TfToken& TaskName) const
 pxr::SdfPath HnTaskManager::GetRenderRprimsTaskId(const pxr::TfToken& MaterialTag, const HnRenderPassParams& RenderPassParams) const
 {
     std::string Id = std::string{"RenderRprimsTask_"} + PBR_Renderer::GetRenderPassTypeString(RenderPassParams.Type) + "_" + MaterialTag.GetString();
+    if (RenderPassParams.AlphaMode != USD_Renderer::ALPHA_MODE_NUM_MODES)
+    {
+        Id += "_";
+        Id += USD_Renderer::GetAlphaModeString(RenderPassParams.AlphaMode);
+    }
     for (char& c : Id)
     {
         if (c == ':' || c == ' ')

PBR/src/USD_Renderer.cpp

@@ -119,7 +119,10 @@ USD_Renderer::CreateInfo::PSMainSourceInfo USD_Renderer::GetUsdPbrPSMainSource(U
         MaterialData = lerp(MaterialData, float2(1.0, 0.0), g_Frame.Renderer.LoadingAnimation.Factor);
 #   endif
 #endif
-    
+
+    Normal       *= Transmittance;
+    MaterialData *= Transmittance;
+    IBL          *= Transmittance;
 )";
 
     if (PSOFlags & USD_PSO_FLAG_ENABLE_ALL_OUTPUTS)

Shaders/PBR/private/RenderPBR.psh

@@ -536,6 +536,7 @@ PSOutput main(in VSOutput VSOut,
     }
 #endif
 
+    float Transmittance = 1.0;
     if (BasicAttribs.AlphaMode == PBR_ALPHA_MODE_BLEND)
     {
         OutColor.rgb *= BaseColor.a;
@@ -547,8 +548,8 @@ PSOutput main(in VSOutput VSOut,
             {
                 D = 1.0 - D;
             }
-            float T = GetOITTransmittance(D, uint2(VSOut.ClipPos.xy));
-            OutColor.rgb *= T;
+            Transmittance = GetOITTransmittance(D, uint2(VSOut.ClipPos.xy));
+            OutColor.rgb *= Transmittance;
         }
 #endif
     }