Uniform Buffers.

Blaze/Source/Blaze.cpp

@@ -74,7 +74,7 @@ SDL_AppResult SDL_AppInit( void** appstate, int, char** )
 
   app_state.miscData->lightData.pointLightCount = _countof( point_light );
 
-  app_state.renderDevice->bufferManager->WriteToBuffer( app_state.miscData->pointLights, point_light );
+  app_state.renderDevice->bufferManager->WriteRangeToBuffer( app_state.miscData->pointLights, point_light );
 
   Blaze::MiscData::DirectionalLight dir_light[] = {
     {
@@ -85,12 +85,10 @@ SDL_AppResult SDL_AppInit( void** appstate, int, char** )
 
   app_state.miscData->lightData.dirLightCount = _countof( dir_light );
 
-  app_state.renderDevice->bufferManager->WriteToBuffer( app_state.miscData->directionalLights, dir_light );
+  app_state.renderDevice->bufferManager->WriteRangeToBuffer( app_state.miscData->directionalLights, dir_light );
 
-  memcpy(
+  app_state.renderDevice->bufferManager->WriteObjectToBuffer(
-    app_state.miscData->cameraUniformBufferPtr + sizeof( Blaze::MiscData::CameraData ),
+    app_state.miscData->uniformBuffer, sizeof( Blaze::MiscData::CameraData ), app_state.miscData->lightData );
-    &app_state.miscData->lightData,
-    sizeof app_state.miscData->lightData );
 
   return SDL_APP_CONTINUE;
 }

Blaze/Source/BufferManager.cpp

@@ -40,7 +40,7 @@ Blaze::Buffer& BufferManager::FetchBufferUnchecked( BufferID const& rid )
   return m_buffers[inner_index];
 }
 
-void BufferManager::WriteToBufferImpl( BufferID const& rid, void const* data, size_t const size )
+void BufferManager::WriteToBuffer( BufferID const& rid, void const* data, size_t const size, size_t const offset )
 {
   ASSERT( IsValidID( rid ) );
 
@@ -48,7 +48,7 @@ void BufferManager::WriteToBufferImpl( BufferID const& rid, void const* data, si
 
   ASSERT( size <= buffer.size );
 
-  memcpy( buffer.mappedData, data, size );
+  memcpy( buffer.mappedData + offset, data, size );
 }
 
 bool BufferManager::IsValidID( BufferID const& rid ) const
@@ -248,6 +248,73 @@ Blaze::BufferID BufferManager::CreateStorageBuffer( size_t const size )
   return *reinterpret_cast<BufferID*>( &index );
 }
 
+Blaze::BufferID BufferManager::CreateUniformBuffer( size_t const size )
+{
+  ASSERT( not m_freeList.Empty() );
+
+  Buffer* buffer_slot = reinterpret_cast<Buffer*>( m_freeList.PopFront() );
+  ++m_count;
+
+  ASSERT( m_renderDevice );
+  RenderDevice const&      render_device      = *m_renderDevice;
+
+  VkBufferCreateInfo const buffer_create_info = {
+    .sType                 = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+    .pNext                 = nullptr,
+    .flags                 = 0,
+    .size                  = size,
+    .usage                 = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
+    .sharingMode           = VK_SHARING_MODE_EXCLUSIVE,
+    .queueFamilyIndexCount = 0,
+    .pQueueFamilyIndices   = nullptr,
+  };
+
+  VmaAllocationCreateInfo constexpr allocation_create_info = {
+    .flags          = VMA_ALLOCATION_CREATE_MAPPED_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT,
+    .usage          = VMA_MEMORY_USAGE_AUTO,
+    .requiredFlags  = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
+    .preferredFlags = 0,
+    .memoryTypeBits = 0,
+    .pool           = nullptr,
+    .pUserData      = nullptr,
+    .priority       = 1.0f,
+  };
+
+  VmaAllocationInfo allocation_info;
+  VkBuffer          storage_buffer;
+  VmaAllocation     storage_buffer_allocation;
+
+  VK_CHECK( vmaCreateBuffer(
+    render_device.gpuAllocator,
+    &buffer_create_info,
+    &allocation_create_info,
+    &storage_buffer,
+    &storage_buffer_allocation,
+    &allocation_info ) );
+
+  VkBufferDeviceAddressInfo const device_address_info = {
+    .sType  = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
+    .pNext  = nullptr,
+    .buffer = storage_buffer,
+  };
+
+  VkDeviceAddress const device_address = vkGetBufferDeviceAddress( render_device.device, &device_address_info );
+
+  // NOTE: bufferSlot preserves index between uses.
+  uint32_t index = buffer_slot->index;
+  new ( buffer_slot ) Buffer{
+    .buffer        = storage_buffer,
+    .allocation    = storage_buffer_allocation,
+    .mappedData    = static_cast<std::byte*>( allocation_info.pMappedData ),
+    .deviceAddress = device_address,
+    .size          = size,
+    .index         = index,
+  };
+
+  // NOTE: Memory hackery to create BufferID;
+  return *reinterpret_cast<BufferID*>( &index );
+}
+
 void BufferManager::FreeBuffer( BufferID* rid )
 {
   if ( not IsValidID( *rid ) ) return;

Blaze/Source/BufferManager.h

@@ -52,7 +52,6 @@ private:
   void           DestroyBuffer( Buffer& buf );
 
   Buffer&        FetchBufferUnchecked( BufferID const& rid );
-  void           WriteToBufferImpl( BufferID const& rid, void const* data, size_t size );
 
 public:
   [[nodiscard]] bool IsValidID( BufferID const& rid ) const;
@@ -60,6 +59,7 @@ public:
   BufferID           CreateVertexBuffer( size_t size );
   BufferID           CreateIndexBuffer( size_t size );
   BufferID           CreateStorageBuffer( size_t size );
+  BufferID           CreateUniformBuffer( size_t size );
 
   void               FreeBuffer( BufferID* rid );
 
@@ -67,13 +67,23 @@ public:
   std::optional<VkBuffer>        FetchBuffer( BufferID const& rid );
   std::optional<VkDeviceAddress> FetchDeviceAddress( BufferID const& rid );
 
+  void                           WriteToBuffer( BufferID const& rid, void const* data, size_t size, size_t offset );
+
   // Utility to directly muck the data
-  void WriteToBuffer( BufferID const& rid, std::ranges::contiguous_range auto const& data )
+  void WriteRangeToBuffer( BufferID const& rid, std::ranges::contiguous_range auto const& data )
   {
-    WriteToBufferImpl(
+    WriteToBuffer(
       rid,
       std::ranges::data( data ),
-      std::ranges::size( data ) * sizeof( std::ranges::range_value_t<decltype( data )> ) );
+      std::ranges::size( data ) * sizeof( std::ranges::range_value_t<decltype( data )> ),
+      0 );
+  }
+
+  // Utility to directly muck the data
+  void WriteObjectToBuffer( BufferID const& rid, size_t const offset, auto const& data )
+    requires not std::ranges::range<decltype( data )>
+  {
+    WriteToBuffer( rid, &data, sizeof data, offset );
   }
 
   static BufferManager* Create( GlobalMemory* mem, RenderDevice* render_device, uint32_t max_count );

Blaze/Source/MiscData.cpp

@@ -274,8 +274,6 @@ bool MiscData::Init( RenderDevice const& render_device )
     cameraData.viewMatrix     = DirectX::XMMatrixLookAtRH( cameraData.cameraPosition, cameraTarget, cameraUp );
     cameraData.projectionMatrix =
       DirectX::XMMatrixPerspectiveFovRH( DirectX::XMConvertToRadians( 70.0f ), 16.0f / 9.0f, 0.1f, 1000.0f );
-
-    cameraUniformBufferSize = sizeof( CameraData ) + sizeof( LightData );
   }
 
 
@@ -295,45 +293,10 @@ bool MiscData::Init( RenderDevice const& render_device )
 
   // Uniform Buffer
   {
+    uniformBuffer = render_device.bufferManager->CreateUniformBuffer( sizeof( CameraData ) + sizeof( LightData ) );
 
-    VkBufferCreateInfo const buffer_create_info = {
+    render_device.bufferManager->WriteObjectToBuffer( uniformBuffer, 0, cameraData );
-      .sType                 = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+    render_device.bufferManager->WriteObjectToBuffer( uniformBuffer, sizeof CameraData, lightData );
-      .pNext                 = nullptr,
-      .flags                 = 0,
-      .size                  = cameraUniformBufferSize,
-      .usage                 = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
-      .sharingMode           = VK_SHARING_MODE_EXCLUSIVE,
-      .queueFamilyIndexCount = 0,
-      .pQueueFamilyIndices   = nullptr,
-    };
-
-    VmaAllocationCreateInfo constexpr allocation_create_info = {
-      .flags          = VMA_ALLOCATION_CREATE_MAPPED_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT,
-      .usage          = VMA_MEMORY_USAGE_AUTO,
-      .requiredFlags  = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-      .preferredFlags = 0,
-      .memoryTypeBits = 0,
-      .pool           = nullptr,
-      .pUserData      = nullptr,
-      .priority       = 1.0f,
-    };
-
-    VmaAllocationInfo allocation_info;
-
-    VK_CHECK( vmaCreateBuffer(
-      render_device.gpuAllocator,
-      &buffer_create_info,
-      &allocation_create_info,
-      &cameraUniformBuffer,
-      &cameraUniformBufferAllocation,
-      &allocation_info ) );
-
-    if ( allocation_info.pMappedData )
-    {
-      cameraUniformBufferPtr = static_cast<uint8_t*>( allocation_info.pMappedData );
-      memcpy( cameraUniformBufferPtr, &cameraData, sizeof cameraData );
-      memcpy( cameraUniformBufferPtr + sizeof cameraData, &lightData, sizeof lightData );
-    }
   }
 
   // Descriptors
@@ -364,9 +327,9 @@ bool MiscData::Init( RenderDevice const& render_device )
     VK_CHECK( vkAllocateDescriptorSets( device, &descriptor_set_allocate_info, &descriptorSet ) );
 
     VkDescriptorBufferInfo const descriptor_buffer_info = {
-      .buffer = cameraUniformBuffer,
+      .buffer = render_device.bufferManager->FetchBuffer( uniformBuffer ).value(),
       .offset = 0,
-      .range  = cameraUniformBufferSize,
+      .range  = sizeof( CameraData ) + sizeof( LightData ),
     };
 
     VkWriteDescriptorSet write_descriptor_sets[] = {
@@ -464,7 +427,8 @@ void MiscData::Destroy( Blaze::RenderDevice const& render_device )
   VkDevice const device = render_device.device;
 
   vkDestroyDescriptorPool( device, Take( descriptorPool ), nullptr );
-  vmaDestroyBuffer( render_device.gpuAllocator, Take( cameraUniformBuffer ), Take( cameraUniformBufferAllocation ) );
+
+  render_device.bufferManager->FreeBuffer( &uniformBuffer );
 
   render_device.bufferManager->FreeBuffer( &pointLights );
   render_device.bufferManager->FreeBuffer( &directionalLights );

Blaze/Source/MiscData.h

@@ -58,10 +58,7 @@ struct MiscData
   BufferID              directionalLights;
   LightData             lightData;
 
-  VkBuffer              cameraUniformBuffer;
+  BufferID              uniformBuffer;
-  VmaAllocation         cameraUniformBufferAllocation;
-  size_t                cameraUniformBufferSize;
-  uint8_t*              cameraUniformBufferPtr;
   VkDescriptorPool      descriptorPool;
   VkDescriptorSet       descriptorSet;
 

Blaze/Source/ModelLoader.cpp

@@ -793,12 +793,12 @@ Entity* LoadModel( Blaze::RenderDevice* render_device, EntityManager* entity_man
   entity->model.vertexBuffer = render_device->bufferManager->CreateVertexBuffer( vertices.size() * sizeof vertices[0] );
   if ( not entity->model.vertexBuffer ) return nullptr;
 
-  render_device->bufferManager->WriteToBuffer( entity->model.vertexBuffer, vertices );
+  render_device->bufferManager->WriteRangeToBuffer( entity->model.vertexBuffer, vertices );
 
   entity->model.indexBuffer = render_device->bufferManager->CreateIndexBuffer( indices.size() * sizeof indices[0] );
   if ( not entity->model.indexBuffer ) return nullptr;
 
-  render_device->bufferManager->WriteToBuffer( entity->model.indexBuffer, std::span{ indices } );
+  render_device->bufferManager->WriteRangeToBuffer( entity->model.indexBuffer, indices );
 
   cgltf_free( gltf_model );
   return entity;