HnRenderParam: grouped global setting into the Configuration struct

TheMostDiligent · TheMostDiligent · commit 64fdb1ea5197 · 2024-12-25T13:58:26.000-08:00
diff --git a/Hydrogent/include/HnRenderParam.hpp b/Hydrogent/include/HnRenderParam.hpp
@@ -46,24 +46,21 @@ namespace USD
 class HnRenderParam final : public pxr::HdRenderParam
 {
 public:
-    HnRenderParam(bool                              UseVertexPool,
-                  bool                              UseIndexPool,
-                  bool                              AsyncShaderCompilation,
-                  bool                              UseNativeStartVertex,
-                  HN_MATERIAL_TEXTURES_BINDING_MODE TextureBindingMode,
-                  float                             MetersPerUnit,
-                  Uint64                            GeometryLoadBudget) noexcept;
-    ~HnRenderParam();
-
-    bool GetUseVertexPool() const { return m_UseVertexPool; }
-    bool GetUseIndexPool() const { return m_UseIndexPool; }
-    bool GetAsyncShaderCompilation() const { return m_AsyncShaderCompilation; }
-    bool GetUseNativeStartVertex() const { return m_UseNativeStartVertex; }
+    struct Configuration
+    {
+        bool                              UseVertexPool          = false;
+        bool                              UseIndexPool           = false;
+        bool                              AsyncShaderCompilation = false;
+        bool                              UseNativeStartVertex   = false;
+        HN_MATERIAL_TEXTURES_BINDING_MODE TextureBindingMode     = {};
+        float                             MetersPerUnit          = 1.0f;
+        Uint64                            GeometryLoadBudget     = 0;
+    };
 
-    HN_MATERIAL_TEXTURES_BINDING_MODE GetTextureBindingMode() const { return m_TextureBindingMode; }
+    HnRenderParam(const Configuration& Config) noexcept;
+    ~HnRenderParam();
 
-    float  GetMetersPerUnit() const { return m_MetersPerUnit; }
-    Uint64 GetGeometryLoadBudget() const { return m_GeometryLoadBudget; }
+    const Configuration& GetConfig() const { return m_Config; }
 
     HN_RENDER_MODE GetRenderMode() const { return m_RenderMode; }
     void           SetRenderMode(HN_RENDER_MODE Mode) { m_RenderMode = Mode; }
@@ -134,15 +131,7 @@ class HnRenderParam final : public pxr::HdRenderParam
     const auto& GetDirtyRPrims() const { return m_DirtyRPrims; }
 
 private:
-    const bool m_UseVertexPool;
-    const bool m_UseIndexPool;
-    const bool m_AsyncShaderCompilation;
-    const bool m_UseNativeStartVertex;
-
-    const HN_MATERIAL_TEXTURES_BINDING_MODE m_TextureBindingMode;
-
-    const float  m_MetersPerUnit;
-    const Uint64 m_GeometryLoadBudget;
+    const Configuration m_Config;
 
     HN_RENDER_MODE m_RenderMode = HN_RENDER_MODE_SOLID;
 
diff --git a/Hydrogent/src/HnCamera.cpp b/Hydrogent/src/HnCamera.cpp
@@ -60,7 +60,7 @@ void HnCamera::Sync(pxr::HdSceneDelegate* SceneDelegate,
     pxr::HdDirtyBits OrigDirtyBits = *DirtyBits;
     pxr::HdCamera::Sync(SceneDelegate, RenderParam, DirtyBits);
 
-    const float MetersPerUnit = RenderParam ? static_cast<const HnRenderParam*>(RenderParam)->GetMetersPerUnit() : 0.01f;
+    const float MetersPerUnit = RenderParam ? static_cast<const HnRenderParam*>(RenderParam)->GetConfig().MetersPerUnit : 0.01f;
     const float UnitsPerMeter = 1.f / MetersPerUnit;
     if (OrigDirtyBits & pxr::HdCamera::DirtyTransform)
     {
diff --git a/Hydrogent/src/HnLight.cpp b/Hydrogent/src/HnLight.cpp
@@ -510,7 +510,7 @@ void HnLight::Sync(pxr::HdSceneDelegate* SceneDelegate,
             float MetersPerUnit = 1;
             if (RenderParam != nullptr)
             {
-                MetersPerUnit = static_cast<const HnRenderParam*>(RenderParam)->GetMetersPerUnit();
+                MetersPerUnit = static_cast<const HnRenderParam*>(RenderParam)->GetConfig().MetersPerUnit;
             }
             if (ApproximateAreaLight(*SceneDelegate, MetersPerUnit))
             {
diff --git a/Hydrogent/src/HnMaterial.cpp b/Hydrogent/src/HnMaterial.cpp
@@ -977,7 +977,7 @@ Uint32 HnMaterial::GetResourceCacheVersion(HnRenderDelegate& RenderDelegate)
     RefCntAutoPtr<HnMaterialSRBCache> SRBCache{RenderDelegate.GetMaterialSRBCache(), IID_HnMaterialSRBCache};
     VERIFY_EXPR(SRBCache);
 
-    const HN_MATERIAL_TEXTURES_BINDING_MODE BindingMode = static_cast<const HnRenderParam*>(RenderDelegate.GetRenderParam())->GetTextureBindingMode();
+    const HN_MATERIAL_TEXTURES_BINDING_MODE BindingMode = static_cast<const HnRenderParam*>(RenderDelegate.GetRenderParam())->GetConfig().TextureBindingMode;
 
     Uint32 ResourceCacheVersion = SRBCache->GetMaterialAttribsBufferVersion();
     if (BindingMode == HN_MATERIAL_TEXTURES_BINDING_MODE_ATLAS)
@@ -1047,7 +1047,7 @@ bool HnMaterial::UpdateSRB(HnRenderDelegate& RenderDelegate)
 
     HnMaterialSRBCache::ResourceKey SRBKey{m_ResourceCacheVersion};
 
-    const HN_MATERIAL_TEXTURES_BINDING_MODE BindingMode = static_cast<const HnRenderParam*>(RenderDelegate.GetRenderParam())->GetTextureBindingMode();
+    const HN_MATERIAL_TEXTURES_BINDING_MODE BindingMode = static_cast<const HnRenderParam*>(RenderDelegate.GetRenderParam())->GetConfig().TextureBindingMode;
     if (BindingMode == HN_MATERIAL_TEXTURES_BINDING_MODE_LEGACY ||
         BindingMode == HN_MATERIAL_TEXTURES_BINDING_MODE_ATLAS)
     {
diff --git a/Hydrogent/src/HnMesh.cpp b/Hydrogent/src/HnMesh.cpp
@@ -202,7 +202,7 @@ void HnMesh::Sync(pxr::HdSceneDelegate* Delegate,
     HnRenderDelegate* RenderDelegate      = static_cast<HnRenderDelegate*>(Delegate->GetRenderIndex().GetRenderDelegate());
     HnGeometryPool&   GeometryPool        = RenderDelegate->GetGeometryPool();
     const Int64       PendingGeometrySize = GeometryPool.GetPendingVertexDataSize() + GeometryPool.GetPendingIndexDataSize();
-    const Uint64      GeometryLoadBudget  = static_cast<HnRenderParam*>(RenderParam)->GetGeometryLoadBudget();
+    const Uint64      GeometryLoadBudget  = static_cast<HnRenderParam*>(RenderParam)->GetConfig().GeometryLoadBudget;
     bool              ReprUpdated         = false;
     if (GeometryLoadBudget == 0 || static_cast<Uint64>(PendingGeometrySize) < GeometryLoadBudget)
     {
@@ -401,7 +401,7 @@ void HnMesh::UpdateRepr(pxr::HdSceneDelegate& SceneDelegate,
         DirtyBits &= ~pxr::HdChangeTracker::DirtyPrimvar;
     }
 
-    const bool UseNativeStartVertex = static_cast<HnRenderParam*>(RenderParam)->GetUseNativeStartVertex();
+    const bool UseNativeStartVertex = static_cast<HnRenderParam*>(RenderParam)->GetConfig().UseNativeStartVertex;
 
     // When native start vertex is not supported, start vertex needs to be baked into the index data.
     Uint32 BakedStartVertex = (!UseNativeStartVertex && m_VertexHandle) ? m_VertexHandle->GetStartVertex() : 0;
@@ -1138,7 +1138,7 @@ void HnMesh::UpdateDrawItemGpuGeometry(HnRenderDelegate& RenderDelegate)
 void HnMesh::UpdateDrawItemGpuTopology(HnRenderDelegate& RenderDelegate)
 {
     const HnRenderParam* pRenderParam = static_cast<const HnRenderParam*>(RenderDelegate.GetRenderParam());
-    const Uint32         StartVertex  = pRenderParam->GetUseNativeStartVertex() ? m_VertexHandle->GetStartVertex() : 0;
+    const Uint32         StartVertex  = pRenderParam->GetConfig().UseNativeStartVertex ? m_VertexHandle->GetStartVertex() : 0;
 
     Uint32 SubsetIdx = 0;
     ProcessDrawItems(
diff --git a/Hydrogent/src/HnRenderDelegate.cpp b/Hydrogent/src/HnRenderDelegate.cpp
@@ -462,13 +462,15 @@ HnRenderDelegate::HnRenderDelegate(const CreateInfo& CI) :
     },
     m_RenderParam{
         std::make_unique<HnRenderParam>(
-            CI.UseVertexPool,
-            CI.UseIndexPool,
-            CI.AsyncShaderCompilation,
-            !CI.pDevice->GetDeviceInfo().IsGLDevice(), // UseNativeStartVertex
-            CI.TextureBindingMode,
-            CI.MetersPerUnit,
-            CI.GeometryLoadBudget),
+            HnRenderParam::Configuration{
+                CI.UseVertexPool,
+                CI.UseIndexPool,
+                CI.AsyncShaderCompilation,
+                !CI.pDevice->GetDeviceInfo().IsGLDevice(), // UseNativeStartVertex
+                CI.TextureBindingMode,
+                CI.MetersPerUnit,
+                CI.GeometryLoadBudget,
+            }),
     },
     m_ShadowMapManager{CreateShadowMapManager(CI)}
 {
diff --git a/Hydrogent/src/HnRenderParam.cpp b/Hydrogent/src/HnRenderParam.cpp
@@ -32,20 +32,8 @@ namespace Diligent
 namespace USD
 {
 
-HnRenderParam::HnRenderParam(bool                              UseVertexPool,
-                             bool                              UseIndexPool,
-                             bool                              AsyncShaderCompilation,
-                             bool                              UseNativeStartVertex,
-                             HN_MATERIAL_TEXTURES_BINDING_MODE TextureBindingMode,
-                             float                             MetersPerUnit,
-                             Uint64                            GeometryLoadBudget) noexcept :
-    m_UseVertexPool{UseVertexPool},
-    m_UseIndexPool{UseIndexPool},
-    m_AsyncShaderCompilation{AsyncShaderCompilation},
-    m_UseNativeStartVertex{UseNativeStartVertex},
-    m_TextureBindingMode{TextureBindingMode},
-    m_MetersPerUnit{MetersPerUnit},
-    m_GeometryLoadBudget{GeometryLoadBudget}
+HnRenderParam::HnRenderParam(const Configuration& Config) noexcept :
+    m_Config{Config}
 {
     for (auto& Version : m_GlobalAttribVersions)
         Version.store(0);
diff --git a/Hydrogent/src/HnRenderPass.cpp b/Hydrogent/src/HnRenderPass.cpp
@@ -1264,7 +1264,7 @@ void HnRenderPass::UpdateDrawListItemGPUResources(DrawListItem& ListItem, Render
         const auto ShaderTextureIndexingId = pMaterial->GetStaticShaderTextureIndexingId();
 
         PBR_Renderer::PsoCacheAccessor::GET_FLAGS GetPSOFlags = PBR_Renderer::PsoCacheAccessor::GET_FLAG_CREATE_IF_NULL;
-        if (State.RenderParam.GetAsyncShaderCompilation())
+        if (State.RenderParam.GetConfig().AsyncShaderCompilation)
             GetPSOFlags |= PBR_Renderer::PsoCacheAccessor::GET_FLAG_ASYNC_COMPILE;
 
         if (Geo.Joints != nullptr)
@@ -1302,7 +1302,7 @@ void HnRenderPass::UpdateDrawListItemGPUResources(DrawListItem& ListItem, Render
                        "This may indicate an issue in how alpha mode is determined in the material, or (less likely) an issue in Rprim sorting by Hydra.");
             }
 
-            if (State.RenderParam.GetTextureBindingMode() == HN_MATERIAL_TEXTURES_BINDING_MODE_ATLAS)
+            if (State.RenderParam.GetConfig().TextureBindingMode == HN_MATERIAL_TEXTURES_BINDING_MODE_ATLAS)
                 PSOFlags |= PBR_Renderer::PSO_FLAG_USE_TEXTURE_ATLAS;
 
             if (State.USDRenderer.GetSettings().EnableShadows &&
diff --git a/Hydrogent/src/Tasks/HnBeginFrameTask.cpp b/Hydrogent/src/Tasks/HnBeginFrameTask.cpp
@@ -520,7 +520,7 @@ void HnBeginFrameTask::UpdateFrameConstants(IDeviceContext* pCtx,
             CamAttribs.f2Jitter   = Jitter;
             CamAttribs.fFStop     = m_pCamera->GetFStop();
 
-            const float MetersPerUnit = RenderParam ? RenderParam->GetMetersPerUnit() : 0.01f;
+            const float MetersPerUnit = RenderParam ? RenderParam->GetConfig().MetersPerUnit : 0.01f;
 
             // USD camera properties are measured in scene units, but Diligent camera expects them in world units.
             CamAttribs.fFocusDistance = m_pCamera->GetFocusDistance() * MetersPerUnit;
diff --git a/Hydrogent/src/Tasks/HnPostProcessTask.cpp b/Hydrogent/src/Tasks/HnPostProcessTask.cpp
@@ -482,7 +482,7 @@ void HnPostProcessTask::CreateVectorFieldRenderer(TEXTURE_FORMAT RTVFormat)
     CI.NumRenderTargets   = 1;
     CI.RTVFormats[0]      = RTVFormat;
     CI.PackMatrixRowMajor = RenderDelegate->GetUSDRenderer()->GetSettings().PackMatrixRowMajor;
-    CI.AsyncShaders       = pRenderParam->GetAsyncShaderCompilation();
+    CI.AsyncShaders       = pRenderParam->GetConfig().AsyncShaderCompilation;
 
     m_VectorFieldRenderer = std::make_unique<VectorFieldRenderer>(CI);
 }
@@ -562,7 +562,7 @@ void HnPostProcessTask::Prepare(pxr::HdTaskContext* TaskCtx,
     }
 
     const HnRenderParam* pRenderParam           = static_cast<const HnRenderParam*>(RenderDelegate->GetRenderParam());
-    const bool           AsyncShaderCompilation = pRenderParam->GetAsyncShaderCompilation();
+    const bool           AsyncShaderCompilation = pRenderParam->GetConfig().AsyncShaderCompilation;
     if (!m_PostFXContext)
     {
         PostFXContext::CreateInfo PostFXCI;
diff --git a/Hydrogent/src/Tasks/HnProcessSelectionTask.cpp b/Hydrogent/src/Tasks/HnProcessSelectionTask.cpp
@@ -99,7 +99,7 @@ void HnProcessSelectionTask::PrepareTechniques(TEXTURE_FORMAT RTVFormat)
         ShaderCI.SourceLanguage = SHADER_SOURCE_LANGUAGE_HLSL;
         if (RenderDelegate->GetUSDRenderer()->GetSettings().PackMatrixRowMajor)
             ShaderCI.CompileFlags |= SHADER_COMPILE_FLAG_PACK_MATRIX_ROW_MAJOR;
-        if (RenderParam->GetAsyncShaderCompilation())
+        if (RenderParam->GetConfig().AsyncShaderCompilation)
             ShaderCI.CompileFlags |= SHADER_COMPILE_FLAG_ASYNCHRONOUS;
 
         auto pHnFxCompoundSourceFactory     = HnShaderSourceFactory::CreateHnFxCompoundFactory();
@@ -129,7 +129,7 @@ void HnProcessSelectionTask::PrepareTechniques(TEXTURE_FORMAT RTVFormat)
             .SetRasterizerDesc(RS_SolidFillNoCull)
             .SetPrimitiveTopology(PRIMITIVE_TOPOLOGY_TRIANGLE_LIST);
 
-        if (RenderParam->GetAsyncShaderCompilation())
+        if (RenderParam->GetConfig().AsyncShaderCompilation)
             PsoCI.Flags |= PSO_CREATE_FLAG_ASYNCHRONOUS;
 
         if (!m_InitTech.PSO)
diff --git a/Hydrogent/src/Tasks/HnRenderBoundBoxTask.cpp b/Hydrogent/src/Tasks/HnRenderBoundBoxTask.cpp
@@ -173,7 +173,7 @@ void HnRenderBoundBoxTask::Prepare(pxr::HdTaskContext* TaskCtx,
             BoundBoxRenderer::CreateInfo BoundBoxRndrCI;
             BoundBoxRndrCI.pDevice            = pRenderDelegate->GetDevice();
             BoundBoxRndrCI.PackMatrixRowMajor = pRenderDelegate->GetUSDRenderer()->GetSettings().PackMatrixRowMajor;
-            BoundBoxRndrCI.AsyncShaders       = pRenderParam->GetAsyncShaderCompilation();
+            BoundBoxRndrCI.AsyncShaders       = pRenderParam->GetConfig().AsyncShaderCompilation;
             BoundBoxRndrCI.pCameraAttribsCB   = pRenderDelegate->GetFrameAttribsCB();
             BoundBoxRndrCI.NumRenderTargets   = RenderPassState->GetNumRenderTargets();
             for (Uint32 rt = 0; rt < BoundBoxRndrCI.NumRenderTargets; ++rt)

Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ void HnCamera::Sync(pxr::HdSceneDelegate* SceneDelegate,`
`60`	`60`	`pxr::HdDirtyBits OrigDirtyBits = *DirtyBits;`
`61`	`61`	`pxr::HdCamera::Sync(SceneDelegate, RenderParam, DirtyBits);`
`62`	`62`
`63`		`- const float MetersPerUnit = RenderParam ? static_cast<const HnRenderParam*>(RenderParam)->GetMetersPerUnit() : 0.01f;`
	`63`	`+ const float MetersPerUnit = RenderParam ? static_cast<const HnRenderParam*>(RenderParam)->GetConfig().MetersPerUnit : 0.01f;`
`64`	`64`	`const float UnitsPerMeter = 1.f / MetersPerUnit;`
`65`	`65`	`if (OrigDirtyBits & pxr::HdCamera::DirtyTransform)`
`66`	`66`	`{`
Original file line number	Diff line number	Diff line change
`@@ -510,7 +510,7 @@ void HnLight::Sync(pxr::HdSceneDelegate* SceneDelegate,`
`510`	`510`	`float MetersPerUnit = 1;`
`511`	`511`	`if (RenderParam != nullptr)`
`512`	`512`	`{`
`513`		`- MetersPerUnit = static_cast<const HnRenderParam*>(RenderParam)->GetMetersPerUnit();`
	`513`	`+ MetersPerUnit = static_cast<const HnRenderParam*>(RenderParam)->GetConfig().MetersPerUnit;`
`514`	`514`	`}`
`515`	`515`	`if (ApproximateAreaLight(*SceneDelegate, MetersPerUnit))`
`516`	`516`	`{`
Original file line number	Diff line number	Diff line change
`@@ -482,7 +482,7 @@ void HnPostProcessTask::CreateVectorFieldRenderer(TEXTURE_FORMAT RTVFormat)`
`482`	`482`	`CI.NumRenderTargets = 1;`
`483`	`483`	`CI.RTVFormats[0] = RTVFormat;`
`484`	`484`	`CI.PackMatrixRowMajor = RenderDelegate->GetUSDRenderer()->GetSettings().PackMatrixRowMajor;`
`485`		`- CI.AsyncShaders = pRenderParam->GetAsyncShaderCompilation();`
	`485`	`+ CI.AsyncShaders = pRenderParam->GetConfig().AsyncShaderCompilation;`
`486`	`486`
`487`	`487`	`m_VectorFieldRenderer = std::make_unique<VectorFieldRenderer>(CI);`
`488`	`488`	`}`
`@@ -562,7 +562,7 @@ void HnPostProcessTask::Prepare(pxr::HdTaskContext* TaskCtx,`
`562`	`562`	`}`
`563`	`563`
`564`	`564`	`const HnRenderParam* pRenderParam = static_cast<const HnRenderParam*>(RenderDelegate->GetRenderParam());`
`565`		`- const bool AsyncShaderCompilation = pRenderParam->GetAsyncShaderCompilation();`
	`565`	`+ const bool AsyncShaderCompilation = pRenderParam->GetConfig().AsyncShaderCompilation;`
`566`	`566`	`if (!m_PostFXContext)`
`567`	`567`	`{`
`568`	`568`	`PostFXContext::CreateInfo PostFXCI;`