Hydrogent: properly update draw item buffers when cached buffers resize

Author: TheMostDiligent

Hydrogent/include/HnDrawItem.hpp

@@ -61,14 +61,14 @@ class HnDrawItem final : public pxr::HdDrawItem
 
     struct GeometryData
     {
-        RefCntAutoPtr<IBuffer> Positions;
-        RefCntAutoPtr<IBuffer> Normals;
-        RefCntAutoPtr<IBuffer> VertexColors;
-        RefCntAutoPtr<IBuffer> Joints;
+        IBuffer* Positions    = nullptr;
+        IBuffer* Normals      = nullptr;
+        IBuffer* VertexColors = nullptr;
+        IBuffer* Joints       = nullptr;
 
-        std::array<RefCntAutoPtr<IBuffer>, 2> TexCoords;
+        std::array<IBuffer*, 2> TexCoords{};
 
-        operator bool() const { return Positions; }
+        operator bool() const { return Positions != nullptr; }
     };
 
     void                SetGeometryData(GeometryData&& Data) { m_GeometryData = std::move(Data); }

Hydrogent/interface/HnMesh.hpp

@@ -129,6 +129,8 @@ class HnMesh final : public pxr::HdMesh
 
     entt::entity GetEntity() const { return m_Entity; }
 
+    static Uint32 GetCacheResourceVersion(const HnRenderDelegate& RenderDelegate);
+
 protected:
     // This callback from Rprim gives the prim an opportunity to set
     // additional dirty bits based on those already set.
@@ -273,6 +275,8 @@ class HnMesh final : public pxr::HdMesh
     std::atomic<Uint32> m_GeometryVersion{0};
     std::atomic<Uint32> m_MaterialVersion{0};
     std::atomic<Uint32> m_SkinningPrimvarsVersion{0};
+    Uint32              m_IndexPoolVersion  = ~0u;
+    Uint32              m_VertexPoolVersion = ~0u;
     std::atomic<bool>   m_DrawItemGpuTopologyDirty{false};
     std::atomic<bool>   m_DrawItemGpuGeometryDirty{false};
 

Hydrogent/interface/HnRenderPass.hpp

@@ -282,6 +282,7 @@ class HnRenderPass final : public pxr::HdRenderPass
         uint32_t MeshMaterial        = ~0u;
         uint32_t MeshCulling         = ~0u;
         uint32_t Material            = ~0u;
+        uint32_t MeshResourceCache   = ~0u;
     } m_GlobalAttribVersions;
 
     DRAW_LIST_ITEM_DIRTY_FLAGS m_DrawListItemsDirtyFlags = DRAW_LIST_ITEM_DIRTY_FLAG_ALL;

Hydrogent/src/HnMesh.cpp

@@ -1192,6 +1192,30 @@ void HnMesh::UpdateDrawItemGpuTopology(HnRenderDelegate& RenderDelegate)
 
 void HnMesh::CommitGPUResources(HnRenderDelegate& RenderDelegate)
 {
+    const GLTF::ResourceManager& ResMgr            = RenderDelegate.GetResourceManager();
+    const Uint32                 IndexPoolVersion  = ResMgr.GetIndexBufferVersion();
+    const Uint32                 VertexPoolVersion = ResMgr.GetVertexPoolsVersion();
+    if (m_VertexHandle)
+    {
+        if (m_IndexPoolVersion != IndexPoolVersion)
+        {
+            // Update index buffer
+            m_DrawItemGpuTopologyDirty.store(true);
+        }
+
+        if (m_VertexPoolVersion != VertexPoolVersion)
+        {
+            // Update vertex buffers
+            m_DrawItemGpuGeometryDirty.store(true);
+        }
+    }
+    else
+    {
+        // The mesh has not been initialized yet.
+        // m_DrawItemGpuGeometryDirty and m_DrawItemGpuTopologyDirty will be set
+        // by UpdateRepr() when the mesh is initialized.
+    }
+
     if (m_DrawItemGpuTopologyDirty.load())
     {
         UpdateDrawItemGpuTopology(RenderDelegate);
@@ -1201,13 +1225,22 @@ void HnMesh::CommitGPUResources(HnRenderDelegate& RenderDelegate)
     {
         UpdateDrawItemGpuGeometry(RenderDelegate);
     }
+
+    m_IndexPoolVersion  = IndexPoolVersion;
+    m_VertexPoolVersion = VertexPoolVersion;
 }
 
 IBuffer* HnMesh::GetVertexBuffer(const pxr::TfToken& Name) const
 {
     return m_VertexHandle ? m_VertexHandle->GetBuffer(Name) : nullptr;
 }
 
+Uint32 HnMesh::GetCacheResourceVersion(const HnRenderDelegate& RenderDelegate)
+{
+    const GLTF::ResourceManager& ResMgr = RenderDelegate.GetResourceManager();
+    return ResMgr.GetIndexBufferVersion() + ResMgr.GetVertexPoolsVersion();
+}
+
 } // namespace USD
 
 } // namespace Diligent

Hydrogent/src/HnRenderDelegate.cpp

@@ -810,7 +810,9 @@ void HnRenderDelegate::CommitResources(pxr::HdChangeTracker* tracker)
     }
 
     {
-        const auto MeshVersion = m_RenderParam->GetAttribVersion(HnRenderParam::GlobalAttrib::MeshGeometry);
+        const auto MeshVersion =
+            m_RenderParam->GetAttribVersion(HnRenderParam::GlobalAttrib::MeshGeometry) +
+            HnMesh::GetCacheResourceVersion(*this);
         if (m_MeshResourcesVersion != MeshVersion)
         {
             std::lock_guard<std::mutex> Guard{m_MeshesMtx};

Hydrogent/src/HnRenderPass.cpp

@@ -425,6 +425,13 @@ HnRenderPass::EXECUTE_RESULT HnRenderPass::Execute(HnRenderPassState& RPState, c
             m_GlobalAttribVersions.MeshCulling = MeshCullingVersion;
         }
 
+        const Uint32 MeshResourceCacheVersion = HnMesh::GetCacheResourceVersion(State.RenderDelegate);
+        if (m_GlobalAttribVersions.MeshResourceCache != MeshResourceCacheVersion)
+        {
+            m_GlobalAttribVersions.MeshResourceCache = MeshResourceCacheVersion;
+            m_DrawListItemsDirtyFlags |= DRAW_LIST_ITEM_DIRTY_FLAG_MESH_DATA;
+        }
+
         // If either mesh material or mesh geometry changes, call UpdateDrawListGPUResources(), but
         // don't set the dirty flags in the m_DrawListItemsDirtyFlags. The UpdateDrawListGPUResources()
         // method will check the version of each individual mesh and only update those that have changed.