Add support for user global constant buffers

Author: hypernewbie

src/vrhi_backend.cpp

@@ -735,6 +735,49 @@ bool vhCmdBackendState::BE_PreSubmitCommon_FindResource(
                 return true;
             }
 
+            // Check for User Globals ($Globals)
+            // These aren't explicitly bound in vhState::buffers, so we must find them via reflection.
+            // TODO: Move this to the cache, to avoid O(N^3) loop here.
+            for ( const auto* shader : scache.bshaders )
+            {
+                for ( const auto& res : shader->reflection )
+                {
+                    if ( res.slot == item.slot && res.type == nvrhi::ResourceType::ConstantBuffer && ( res.name == "$Globals" || res.name == "_Globals" || res.name == "globalParams" ) )
+                    {
+                        if ( state.debugFlags & VRHI_STATE_DEBUG_LOG_ALL_BINDINGS )
+                        {
+                             VRHI_LOG( "FindResource: Found User Globals '%s' at slot %u. Size: %u\n", res.name.c_str(), res.slot, res.sizeInBytes );
+                             for( auto& m : res.members ) VRHI_LOG( "  Member: %s ( Offset: %u )\n", m.name.c_str(), m.offset );
+                        }
+                        if ( res.sizeInBytes == 0 ) continue;
+
+                        static std::vector< uint8_t > s_globalPackBuffer;
+                        uint32_t packSize = res.sizeInBytes;
+                        if ( ( state.debugFlags & VRHI_STATE_DEBUG_LOG_ALL_BINDINGS ) && packSize > 65536 )
+                        {
+                             VRHI_LOG( "FindResource: Large Globals CB size %u\n", packSize );
+                        }
+                        
+                        uint32_t alignedSize = ( uint32_t ) VRHI_ROUND_UP( packSize, VRHI_CBUF_ALIGN );
+                        if ( s_globalPackBuffer.size() < alignedSize ) s_globalPackBuffer.resize( alignedSize, 0 );
+                        vhPackUserGlobals( state.uniforms, res.members, s_globalPackBuffer.data(), packSize );
+                        
+                        int64_t offset = m_userUniformBuffer.Write( s_globalPackBuffer.data(), alignedSize );
+                        if ( offset < 0 )
+                        {
+                             if ( state.debugFlags & VRHI_STATE_DEBUG_LOG_BINDING_MISMATCH ) VRHI_ERR( "FindResource: Failed to write UserGlobals ($Globals)\n" );
+                             return false;
+                        }
+                        
+                        nvrhi::BufferRange range( offset, alignedSize );
+                        outItem = nvrhi::BindingSetItem::ConstantBuffer( item.slot, m_userUniformBuffer.handle[ m_userUniformBuffer.frameIdx ], range );
+                        outItem.type = item.type;
+                        if ( state.debugFlags & VRHI_STATE_DEBUG_LOG_ALL_BINDINGS ) VRHI_LOG( "FindResource: UserGlobals bound to slot %d\n", item.slot );
+                        return true;
+                    }
+                }
+            }
+
             auto it = stageTable.bufferTable.find( item.slot );
             if ( it == stageTable.bufferTable.end() )
             {
@@ -1363,6 +1406,14 @@ void vhCmdBackendState::init()
         descWorld.setCpuAccess( nvrhi::CpuAccessMode::Write );
         descWorld.setDebugName( "WorldUniforms" );
         m_worldUniformBuffer.Init_DeviceStateLocked( descWorld );
+        
+        nvrhi::BufferDesc descUser;
+        descUser.setByteSize( g_vhInit.maxUserGlobals ); 
+        descUser.setIsConstantBuffer( true );
+        descUser.setCpuAccess( nvrhi::CpuAccessMode::Write );
+        descUser.setDebugName( "UserUniforms" );
+        m_userUniformBuffer.Init_DeviceStateLocked( descUser );
+        assert( g_vhInit.maxUserGlobals % VRHI_CBUF_ALIGN == 0 );
     }
 }
 
@@ -1373,6 +1424,7 @@ void vhCmdBackendState::shutdown()
 
     m_globalUniformBuffer.Shutdown_DeviceStateLocked();
     m_worldUniformBuffer.Shutdown_DeviceStateLocked();
+    m_userUniformBuffer.Shutdown_DeviceStateLocked();
 
     backendTextures.clear();
     backendBuffers.clear();
@@ -2169,6 +2221,7 @@ void vhCmdBackendState::Handle_vhFlushInternal( VIDL_vhFlushInternal* cmd )
 
     // Flush and step transient buffer maps here.
     // This needs to be done *before* we flush the command lists to GPU!!
+
     m_globalUniformBuffer.Unmap_DeviceStateLocked();
     m_globalUniformBuffer.Step();
     m_globalUniformBufferLastHash = 0;
@@ -2177,6 +2230,9 @@ void vhCmdBackendState::Handle_vhFlushInternal( VIDL_vhFlushInternal* cmd )
     m_worldUniformBuffer.Step();
     m_worldUniformBufferLastHash = 0;
 
+    m_userUniformBuffer.Unmap_DeviceStateLocked();
+    m_userUniformBuffer.Step();
+
     // Send it!!
     vhCmdListFlushAll_DeviceStateLocked();
 

src/vrhi_backend.h

@@ -135,6 +135,7 @@ class vhCmdBackendState : public VIDLHandler
     uint64_t m_globalUniformBufferLastHash = 0;
     vhTransientBuffer m_worldUniformBuffer;
     uint64_t m_worldUniformBufferLastHash = 0;
+    vhTransientBuffer m_userUniformBuffer;
 
     // RAII for vhMem, takes ownership of the pointer and auto-destructs it.
     inline std::unique_ptr< vhMem > BE_MemRAII( const vhMem* mem )

src/vrhi_device.cpp

@@ -75,21 +75,21 @@ void vhEnableRenderDoc()
 
     if ( !mod )
     {
-        VRHI_LOG( "Failed to load renderdoc.dll module.\n" );
+        VRHI_LOG( "    No renderdoc.dll module. This is OK.\n" );
         return;
     }
 
     pRENDERDOC_GetAPI RENDERDOC_GetAPI = ( pRENDERDOC_GetAPI ) GetProcAddress( mod, "RENDERDOC_GetAPI" );
     if ( !RENDERDOC_GetAPI )
     {
-        VRHI_LOG( "Failed to get RENDERDOC_GetAPI address.\n" );
+        VRHI_LOG( "    Failed to get RENDERDOC_GetAPI address.\n" );
         return;
     }
 
     int ret = RENDERDOC_GetAPI( eRENDERDOC_API_Version_1_1_2, ( void** ) &g_vhRenderDoc );
     if ( ret != 1 )
     {
-        VRHI_LOG( "Failed to initialise RenderDoc API.\n" );
+        VRHI_LOG( "    Failed to initialise RenderDoc API.\n" );
         return;
     }
     VRHI_LOG( "    RenderDoc API loaded successfully.\n" );

src/vrhi_internal.h

@@ -260,6 +260,13 @@ bool vhReflectSpirv(
     std::vector< vhVertexLayoutDef >* outInputLayout = nullptr
 );
 
+void vhPackUserGlobals(
+    const std::vector< vhState::UniformBufferValue >& uniforms,
+    const std::vector< vhReflectionMember >& members,
+    uint8_t* outData,
+    uint64_t dataSize
+);
+
 bool vhShaderValidateBinding( const vhShaderReflectionResource& reflection, const nvrhi::BindingLayoutItem& binding, bool logError );
 bool vhDebugLayoutDiffCheck( const nvrhi::BindingLayoutVector& layouts, const nvrhi::BindingSetVector& bindings );
 uint64_t vhHashGraphicsPipeline( const nvrhi::GraphicsPipelineDesc& desc, const nvrhi::FramebufferInfo& fbInfo );

src/vrhi_shader.cpp

@@ -213,6 +213,15 @@ bool vhReflectSpirv(
             res.arraySize = binding->count;
             res.sizeInBytes = binding->block.size;
 
+            if ( res.type == nvrhi::ResourceType::ConstantBuffer && ( res.name == "$Globals" || res.name == "_Globals" || res.name == "globalParams" ) )
+            {
+                for ( uint32_t j = 0; j < binding->block.member_count; ++j )
+                {
+                    const auto& m = binding->block.members[j];
+                    res.members.push_back( { m.name ? m.name : "", m.offset, m.size } );
+                }
+            }
+
             outResources.push_back( res );
         }
     }
@@ -578,3 +587,45 @@ bool vhShaderValidateBinding( const vhShaderReflectionResource& reflection, cons
 
     return true;
 }
+
+void vhPackUserGlobals(
+    const std::vector< vhState::UniformBufferValue >& uniforms,
+    const std::vector< vhReflectionMember >& members,
+    uint8_t* outData,
+    uint64_t dataSize
+)
+{
+    if ( !outData || dataSize == 0 )
+        return;
+
+    memset( outData, 0, dataSize );
+
+    for ( const auto& member : members )
+    {
+        const vhState::UniformBufferValue* match = nullptr;
+        for ( const auto& u : uniforms )
+        {
+            if ( u.name == member.name )
+            {
+                match = &u;
+                break;
+            }
+        }
+
+        if ( match )
+        {
+            if ( member.offset >= dataSize )
+                continue;
+
+            uint64_t copySize = member.size;
+            if ( member.offset + copySize > dataSize )
+            {
+                copySize = dataSize - member.offset;
+            }
+
+            uint64_t srcSizeBytes = match->data.size() * sizeof( glm::vec4 );
+            uint64_t actualCopy = std::min( copySize, srcSizeBytes );
+            memcpy( outData + member.offset, match->data.data(), actualCopy );
+        }
+    }
+}

src/vrhi_utils.h

@@ -26,6 +26,8 @@
 
 // -------------------------------------------------------- Utils --------------------------------------------------------
 
+#define VRHI_ROUND_UP( x, alignment ) ( ( ( x ) + ( alignment ) - 1 ) & ~( ( alignment ) - 1 ) )
+
 // Allocator for list of object IDs.
 // Works be using a free list.
 class vhAllocatorObjectFreeList
@@ -112,3 +114,5 @@ inline uint32_t vhNextPow2( uint32_t v )
     v--; v |= v >> 1; v |= v >> 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; v++;
     return v;
 }
+
+

test/test_buffer.cpp

@@ -759,3 +759,5 @@ UTEST_F( Buffer, SubAllocator )
     EXPECT_LE( available, 1024 * 1024 );
     EXPECT_EQ( used + available, 1024 * 1024 );
 }
+
+