Refactor framebuffer handling to use dedicated cache system with RenderTarget structures

Author: hypernewbie

src/vrhi_backend.cpp

@@ -319,50 +319,41 @@ void vhCmdBackendState::BE_UpdateBuffer( vhBackendBuffer& bbuf, uint64_t offset,
     }
 }
 
-nvrhi::FramebufferHandle vhCmdBackendState::BE_GetFrameBuffer( const std::vector< vhTexture >& colours, vhTexture depth, int mip, int layer )
+nvrhi::FramebufferHandle vhCmdBackendState::BE_GetFrameBuffer( const std::vector< vhState::RenderTarget >& colourAttachment, const vhState::RenderTarget& depthAttachment )
 {
-    // TODO: ################ Finish implementation ################
-    // TODO: THIS IS UNTESTED!! Use this at graphics render time in future.
-
-    // Combine all inputs into a hash key
-    uint64_t hashInput[32]; // Enough for color attachments + depth + mip/layer
-    int i = 0;
-    for ( auto c : colours ) hashInput[i++] = ( uint64_t ) c;
-    hashInput[i++] = ( uint64_t ) depth;
-    hashInput[i++] = ( uint32_t ) mip | ( ( uint32_t ) layer << 16 );
-
-    uint64_t key = komihash( hashInput, i * sizeof( uint64_t ), 0 );
-
-    if ( backendFramebuffers.find( key ) == backendFramebuffers.end() )
+    nvrhi::FramebufferDesc desc;
+    for ( const auto& rt : colourAttachment )
     {
-        nvrhi::FramebufferDesc desc;
-        for ( auto texture : colours )
+        if ( rt.texture == VRHI_INVALID_HANDLE ) continue;
+        auto it = backendTextures.find( rt.texture );
+        if ( it != backendTextures.end() && it->second->handle )
         {
-            auto it = backendTextures.find( texture );
-            if ( it != backendTextures.end() && it->second->handle )
-            {
-                desc.addColorAttachment( nvrhi::FramebufferAttachment( it->second->handle )
-                    .setArraySlice( layer )
-                    .setMipLevel( mip ) );
-            }
+            nvrhi::FramebufferAttachment att;
+            att.setTexture( it->second->handle );
+            att.setArraySlice( rt.arrayLayer );
+            att.setMipLevel( rt.mipLevel );
+            att.setFormat( rt.formatOverride );
+            att.setReadOnly( rt.readOnly );
+            desc.addColorAttachment( att );
         }
+    }
 
-        if ( depth != VRHI_INVALID_HANDLE )
+    if ( depthAttachment.texture != VRHI_INVALID_HANDLE )
+    {
+        auto it = backendTextures.find( depthAttachment.texture );
+        if ( it != backendTextures.end() && it->second->handle )
         {
-            auto it = backendTextures.find( depth );
-            if ( it != backendTextures.end() && it->second->handle )
-            {
-                desc.setDepthAttachment( nvrhi::FramebufferAttachment( it->second->handle )
-                    .setArraySlice( layer )
-                    .setMipLevel( mip ) );
-            }
+            nvrhi::FramebufferAttachment att;
+            att.setTexture( it->second->handle );
+            att.setArraySlice( depthAttachment.arrayLayer );
+            att.setMipLevel( depthAttachment.mipLevel );
+            att.setFormat( depthAttachment.formatOverride );
+            att.setReadOnly( depthAttachment.readOnly );
+            desc.setDepthAttachment( att );
         }
-
-        std::lock_guard< std::mutex > lock( g_nvRHIStateMutex );
-        backendFramebuffers[key] = g_vhDevice->createFramebuffer( desc );
     }
 
-    return backendFramebuffers[key];
+    return vhFBOCacheGet( desc );
 }
 
 bool vhCmdBackendState::BE_PresubmitCommon_PipelineDesc(
@@ -1172,7 +1163,6 @@ void vhCmdBackendState::shutdown()
     backendTextures.clear();
     backendBuffers.clear();
     backendShaders.clear();
-    backendFramebuffers.clear();
 
     // Clear static caches
     s_layoutToShader.clear();
@@ -1209,8 +1199,7 @@ void vhCmdBackendState::Handle_vhResetTexture( VIDL_vhResetTexture* cmd )
 void vhCmdBackendState::Handle_vhResizeCleanup( VIDL_vhResizeCleanup* cmd )
 {
     BE_CmdRAII cmdRAII( cmd );
-    std::lock_guard< std::mutex > lock( g_nvRHIStateMutex );
-    backendFramebuffers.clear();
+    vhFBOCacheReset();
 }
 
 void vhCmdBackendState::Handle_vhDestroyTexture( VIDL_vhDestroyTexture* cmd )

src/vrhi_backend.h

@@ -130,7 +130,6 @@ class vhCmdBackendState : public VIDLHandler
     std::map< vhBuffer, std::unique_ptr< vhBackendBuffer > > backendBuffers;
     std::map< vhShader, std::unique_ptr< vhBackendShader > > backendShaders;
     std::map< vhStateId, vhState > backendStates;
-    std::unordered_map< uint64_t, nvrhi::FramebufferHandle > backendFramebuffers;
     vhTransientBuffer m_globalUniformBuffer;
     uint64_t m_globalUniformBufferLastHash = 0;
     vhTransientBuffer m_worldUniformBuffer;
@@ -196,7 +195,7 @@ class vhCmdBackendState : public VIDLHandler
 
     void BE_UpdateBuffer( vhBackendBuffer& bbuf, uint64_t offset, const vhMem* data );
 
-    nvrhi::FramebufferHandle BE_GetFrameBuffer( const std::vector< vhTexture >& colours, vhTexture depth, int mip = 0, int layer = 0 );
+    nvrhi::FramebufferHandle BE_GetFrameBuffer( const std::vector< vhState::RenderTarget >& colourAttachment, const vhState::RenderTarget& depthAttachment );
 
     int64_t BE_Util_WriteGlobalUniform( const vhState& state, vhTransientBuffer& tbuf, uint64_t& lastHash );
     int64_t BE_Util_WriteWorldUniform( const vhState& state, vhTransientBuffer& tbuf, uint64_t& lastHash );

src/vrhi_device.cpp

@@ -355,6 +355,7 @@ void vhShutdown( bool quiet )
     vhPSOCacheShutdown();
     vhSamplerCacheShutdown();
     vhBindingSetCacheClear();
+    vhFBOCacheReset();
 
     if ( !quiet ) VRHI_LOG( "    Destroying NVRHI Device...\n" );
     g_vhDevice = nullptr; // RefCountPtr handles the release()
@@ -1002,4 +1003,48 @@ uint64_t vhHashGlobalUniform( const vhGlobalUniform& u )
 uint64_t vhHashWorldUniform( const vhWorldUniform& u )
 {
     return komihash( &u, sizeof( u ), 0 );
-}
+}
+
+uint64_t vhHashFrameBuffer( const nvrhi::FramebufferDesc& desc )
+{
+    uint64_t h = 0;
+    for ( const auto& at : desc.colorAttachments )
+    {
+        h = komihash( &at.texture, sizeof( at.texture ), h );
+        h = komihash( &at.subresources, sizeof( at.subresources ), h );
+        h = komihash( &at.format, sizeof( at.format ), h );
+        h = komihash( &at.isReadOnly, sizeof( at.isReadOnly ), h );
+    }
+    h = komihash( &desc.depthAttachment.texture, sizeof( desc.depthAttachment.texture ), h );
+    h = komihash( &desc.depthAttachment.subresources, sizeof( desc.depthAttachment.subresources ), h );
+    h = komihash( &desc.depthAttachment.format, sizeof( desc.depthAttachment.format ), h );
+    h = komihash( &desc.depthAttachment.isReadOnly, sizeof( desc.depthAttachment.isReadOnly ), h );
+    
+    // Also hash shading rate if needed, though not explicitly requested, good practice to match struct
+    h = komihash( &desc.shadingRateAttachment.texture, sizeof( desc.shadingRateAttachment.texture ), h );
+    
+    return h;
+}
+
+static std::unordered_map< uint64_t, nvrhi::FramebufferHandle > s_FBOCache;
+
+void vhFBOCacheReset()
+{
+    std::lock_guard<std::mutex> lock( g_nvRHIStateMutex );
+    s_FBOCache.clear();
+}
+
+nvrhi::FramebufferHandle vhFBOCacheGet( const nvrhi::FramebufferDesc& desc )
+{
+    uint64_t hash = vhHashFrameBuffer( desc );
+    
+    std::lock_guard<std::mutex> lock( g_nvRHIStateMutex );
+    auto it = s_FBOCache.find( hash );
+    if ( it != s_FBOCache.end() )
+        return it->second;
+        
+    nvrhi::FramebufferHandle fb = g_vhDevice->createFramebuffer( desc );
+    if ( fb ) s_FBOCache[hash] = fb;
+    return fb;
+}
+

src/vrhi_internal.h

@@ -201,6 +201,8 @@ nvrhi::ComputePipelineHandle vhPSOCacheGet( const nvrhi::ComputePipelineDesc& de
 nvrhi::GraphicsPipelineHandle vhPSOCacheGet( const nvrhi::GraphicsPipelineDesc& desc, const nvrhi::FramebufferInfo& fbInfo );
 void vhBindingSetCacheClear();
 nvrhi::BindingSetHandle vhGetBindingSet( const nvrhi::BindingSetDesc& desc, nvrhi::BindingLayoutHandle layout );
+nvrhi::FramebufferHandle vhFBOCacheGet( const nvrhi::FramebufferDesc& desc );
+void vhFBOCacheReset();
 
 struct vhTransientBuffer
 {
@@ -267,10 +269,13 @@ uint64_t vhHashInputLayout( nvrhi::InputLayoutHandle layout );
 uint64_t vhHashSamplerDesc( const nvrhi::SamplerDesc& desc );
 uint64_t vhHashGlobalUniform( const vhGlobalUniform& u );
 uint64_t vhHashWorldUniform( const vhWorldUniform& u );
+uint64_t vhHashFrameBuffer( const nvrhi::FramebufferDesc& desc );
 void vhWriteStateToGlobalUniform( const vhState& state, vhGlobalUniform& out );
 void vhWriteStateToWorldUniform( const vhState& state, vhWorldUniform& out );
 nvrhi::PrimitiveType vhTranslatePrimitiveType( uint64_t stateFlags );
 nvrhi::BlendState vhTranslateBlendState( uint64_t stateFlags );
 nvrhi::DepthStencilState vhTranslateDepthStencilState( uint64_t stateFlags, uint32_t frontStencil, uint32_t backStencil );
 nvrhi::RasterState vhTranslateRasterState( uint64_t stateFlags );
 
+
+

test/test_backend.cpp

@@ -92,8 +92,19 @@ class vhCmdBackendStateTest
 
     static bool GetFrameBuffer( const std::vector< vhTexture >& colors, vhTexture depth )
     {
-        auto fb1 = Get().BE_GetFrameBuffer( colors, depth, 0, 0 );
-        auto fb2 = Get().BE_GetFrameBuffer( colors, depth, 0, 0 );
+        std::vector< vhState::RenderTarget > rtColors;
+        for ( auto c : colors )
+        {
+            vhState::RenderTarget rt;
+            rt.texture = c;
+            rtColors.push_back( rt );
+        }
+        
+        vhState::RenderTarget rtDepth;
+        rtDepth.texture = depth;
+        
+        auto fb1 = Get().BE_GetFrameBuffer( rtColors, rtDepth );
+        auto fb2 = Get().BE_GetFrameBuffer( rtColors, rtDepth );
 
         if ( !fb1 || !fb2 ) return false;
         return fb1.Get() == fb2.Get();