Inital work on vulkan descriptor heap implementation

1 files changed, 93 insertions, 57 deletions

diff --git a/src/vk-command-buffer.cpp b/src/vk-command-buffer.cpp
index 26c2d03..e16e384 100644
--- a/src/vk-command-buffer.cpp
+++ b/src/vk-command-buffer.cpp
@@ -12,16 +12,20 @@ void command_buffer::start() const {
 
     VKCHECK(vkBeginCommandBuffer(vk_command_buffer, &begin_info));
 
-    const bindless_model& bindless   = vkdevice::get().get_bindingmodel();
-    const device_buffer& global_uniforms = bindless.get_uniform_buffer(UniformTypes::GLOBAL);
-    constants[UniformTypes::GLOBAL] = global_uniforms.device_address + global_uniforms.offset;
+    // TODO: Bind heaps
+    VkBindHeapInfoEXT image_bind_heap_info = {
+        .sType = VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT,
+        .pNext = nullptr,
+    };
 
-    if (queue_type == QueueType::GRAPHICS) {
-        vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, bindless.global_layout, 0, 1U, &bindless.global_set, 0U, nullptr);
-        vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, bindless.global_layout, 0, 1U, &bindless.global_set, 0U, nullptr);
-    } else if (queue_type == QueueType::ASYNC_COMPUTE) {
-        vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, bindless.global_layout, 0, 1U, &bindless.global_set, 0U, nullptr);
-    }
+    vkCmdBindResourceHeapEXT(vk_command_buffer, &image_bind_heap_info);
+
+    VkBindHeapInfoEXT sampler_bind_heap_info = {
+        .sType = VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT,
+        .pNext = nullptr,
+    };
+
+    vkCmdBindSamplerHeapEXT(vk_command_buffer, &sampler_bind_heap_info);
 }
 
 void command_buffer::stop() const {
@@ -29,10 +33,10 @@ void command_buffer::stop() const {
 }
 
 void command_buffer::barrier(handle<device_texture> texture_handle, VkPipelineStageFlags2 stage, VkAccessFlags2 access, VkImageLayout layout) const {
-    auto&                   texture     = vkdevice::get().get_texture(texture_handle);
+    device_texture* texture = vkdevice::get().get_texture(texture_handle);
 
     VkImageSubresourceRange subresource_range{
-        .aspectMask     = texture.aspects,
+        .aspectMask     = texture->aspects,
         .baseMipLevel   = 0U,
         .levelCount     = 1U,
         .baseArrayLayer = 0U,
@@ -42,15 +46,15 @@ void command_buffer::barrier(handle<device_texture> texture_handle, VkPipelineSt
     VkImageMemoryBarrier2 image_barrier{
         .sType               = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
         .pNext               = nullptr,
-        .srcStageMask        = texture.stage,
-        .srcAccessMask       = texture.access,
+        .srcStageMask        = texture->stage,
+        .srcAccessMask       = texture->access,
         .dstStageMask        = stage,
         .dstAccessMask       = access,
-        .oldLayout           = texture.layout,
+        .oldLayout           = texture->layout,
         .newLayout           = layout,
         .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
         .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-        .image               = texture.vk_image,
+        .image               = texture->vk_image,
         .subresourceRange    = subresource_range,
     };
 
@@ -67,18 +71,18 @@ void command_buffer::barrier(handle<device_texture> texture_handle, VkPipelineSt
     };
     vkCmdPipelineBarrier2(vk_command_buffer, &dependency_info);
 
-    texture.layout = layout;
-    texture.stage  = stage;
-    texture.access = access;
+    texture->layout = layout;
+    texture->stage  = stage;
+    texture->access = access;
 }
 
 void command_buffer::copy(handle<device_buffer> buffer_handle, ::handle<device_texture> texture_handle, uint64_t offset) const {
-    auto&                    device      = vkdevice::get();
-    const auto&              buffer      = device.get_buffer(buffer_handle);
-    const auto&              texture     = device.get_texture(texture_handle);
+    auto&                   device      = vkdevice::get();
+    const device_buffer*    buffer      = device.get_buffer(buffer_handle);
+    const device_texture*   texture     = device.get_texture(texture_handle);
 
     VkImageSubresourceLayers image_subresource_layers{
-        .aspectMask     = texture.aspects,
+        .aspectMask     = texture->aspects,
         .mipLevel       = 0,
         .baseArrayLayer = 0,
         .layerCount     = 1,
@@ -91,24 +95,34 @@ void command_buffer::copy(handle<device_buffer> buffer_handle, ::handle<device_t
         .imageSubresource  = image_subresource_layers,
         .imageOffset       = { .x = 0, .y = 0, .z = 0 },
         .imageExtent       = {
-                  .width  = texture.width,
-                  .height = texture.height,
-                  .depth  = texture.depth,
+                  .width  = texture->width,
+                  .height = texture->height,
+                  .depth  = texture->depth,
         },
     };
 
-    vkCmdCopyBufferToImage(vk_command_buffer, buffer.vk_buffer, texture.vk_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &buffer_to_image_copy);
+    vkCmdCopyBufferToImage(vk_command_buffer, buffer->vk_buffer, texture->vk_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &buffer_to_image_copy);
 }
 
-void graphics_command_buffer::dispatch(const dispatch_params& params) const {
-    const device_pipeline& pipeline = vkdevice::get().get_pipeline(params.pipeline);
-    const bindless_model& bindless = vkdevice::get().get_bindingmodel();
+void graphics_command_buffer::dispatch(const dispatch_params& params, const void* data, size_t size) const {
+    const device_pipeline* pipeline = vkdevice::get().get_pipeline(params.pipeline);
+    // const bindless_model& bindless = vkdevice::get().get_bindingmodel();
 
-    vkCmdBindPipeline(vk_command_buffer, pipeline.bind_point, pipeline.vk_pipeline);
+    vkCmdBindPipeline(vk_command_buffer, pipeline->bind_point, pipeline->vk_pipeline);
 
-    const device_buffer& draw_uniforms = bindless.get_uniform_buffer(UniformTypes::DRAW);
-    constants[UniformTypes::DRAW] = draw_uniforms.device_address + draw_uniforms.offset;
-    vkCmdPushConstants(vk_command_buffer, bindless.global_layout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT, 0U, sizeof(constants), &constants);
+    // const device_buffer* draw_uniforms = bindless.get_uniform_buffer(UniformTypes::DRAW);
+    // constants[UniformTypes::DRAW] = draw_uniforms->device_address + draw_uniforms->offset;
+    // vkCmdPushConstants(vk_command_buffer, bindless.global_layout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT, 0U, sizeof(constants), &constants);
+    VkPushDataInfoEXT push_data {
+        .sType  = VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT,
+        .pNext  = nullptr,
+        .offset = 0,
+        .data   = {
+            .address    = data,
+            .size       = size,
+        }
+    };
+    vkCmdPushDataEXT(vk_command_buffer, &push_data);
 
     auto x = params.group_size.vec.x / params.local_group_size.vec.x;
     auto y = params.group_size.vec.y / params.local_group_size.vec.y;
@@ -117,16 +131,16 @@ void graphics_command_buffer::dispatch(const dispatch_params& params) const {
 }
 
 void graphics_command_buffer::begin_renderpass(const renderpass_params& params) const {
-    std::vector<VkRenderingAttachmentInfo> attachments_info(params.color_attachments.size());
+    std::vector<VkRenderingAttachmentInfo> attachments_info(params.color_attachments_count);
 
-    for (auto index{ 0U }; index < params.color_attachments.size(); index++) {
+    for (auto index{ 0U }; index < params.color_attachments_count; index++) {
         auto& attachment_info              = attachments_info[index];
-        auto& attachment                   = vkdevice::get().get_texture(params.color_attachments[index]);
+        device_texture* attachment         = vkdevice::get().get_texture(params.color_attachments[index]);
 
         attachment_info.sType              = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
         attachment_info.pNext              = nullptr;
-        attachment_info.imageView          = attachment.whole_view;
-        attachment_info.imageLayout        = attachment.layout;
+        attachment_info.imageView          = attachment->whole_view;
+        attachment_info.imageLayout        = attachment->layout;
         attachment_info.resolveMode        = VK_RESOLVE_MODE_NONE;
         attachment_info.resolveImageView   = nullptr;
         attachment_info.resolveImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
@@ -171,43 +185,65 @@ void graphics_command_buffer::begin_renderpass(const renderpass_params& params)
     };
     vkCmdBeginRendering(vk_command_buffer, &rendering_info);
 
-    const bindless_model& bindless   = vkdevice::get().get_bindingmodel();
-    const device_buffer& pass_uniforms = bindless.get_uniform_buffer(UniformTypes::PASS);
-    constants[UniformTypes::PASS] = pass_uniforms.device_address + pass_uniforms.offset;
+    // const bindless_model& bindless   = vkdevice::get().get_bindingmodel();
+    // const device_buffer* pass_uniforms = bindless.get_uniform_buffer(UniformTypes::PASS);
+    // constants[UniformTypes::PASS] = pass_uniforms->device_address + pass_uniforms->offset;
 
     vkCmdSetScissor(vk_command_buffer, 0U, 1U, &scissor);
     vkCmdSetViewport(vk_command_buffer, 0U, 1U, &viewport);
 }
 
-void graphics_command_buffer::draw(const draw_params& params) const {
+void graphics_command_buffer::draw(const draw_params& params, const void* data, size_t size) const {
     auto&       device   = vkdevice::get();
-    const auto& pipeline = device.get_pipeline(params.pipeline);
+    const device_pipeline* pipeline = device.get_pipeline(params.pipeline);
+
+    // const auto& bindless = device.get_bindingmodel();
 
-    const auto& bindless = device.get_bindingmodel();
+    vkCmdBindPipeline(vk_command_buffer, pipeline->bind_point, pipeline->vk_pipeline);
 
-    vkCmdBindPipeline(vk_command_buffer, pipeline.bind_point, pipeline.vk_pipeline);
+    // const device_buffer* draw_uniforms = bindless.get_uniform_buffer(UniformTypes::DRAW);
+    // constants[UniformTypes::DRAW] = draw_uniforms->device_address + draw_uniforms->offset;
+    // vkCmdPushConstants(vk_command_buffer, bindless.global_layout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT, 0U, sizeof(constants), &constants);
 
-    const device_buffer& draw_uniforms = bindless.get_uniform_buffer(UniformTypes::DRAW);
-    constants[UniformTypes::DRAW] = draw_uniforms.device_address + draw_uniforms.offset;
-    vkCmdPushConstants(vk_command_buffer, bindless.global_layout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT, 0U, sizeof(constants), &constants);
+    VkPushDataInfoEXT push_data {
+        .sType  = VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT,
+        .pNext  = nullptr,
+        .offset = 0,
+        .data   = {
+            .address    = data,
+            .size       = size,
+        }
+    };
+    vkCmdPushDataEXT(vk_command_buffer, &push_data);
 
     vkCmdDraw(vk_command_buffer, params.vertex_count, params.instance_count, params.vertex_offset, 0U);
 }
 
-void graphics_command_buffer::draw_indexed(const draw_indexed_params& params) const {
+void graphics_command_buffer::draw_indexed(const draw_indexed_params& params, const void* data, size_t size) const {
     auto&       device   = vkdevice::get();
-    const auto& pipeline = device.get_pipeline(params.pipeline);
+    const device_pipeline* pipeline = device.get_pipeline(params.pipeline);
 
-    const auto& bindless = device.get_bindingmodel();
+    // const auto& bindless = device.get_bindingmodel();
 
-    vkCmdBindPipeline(vk_command_buffer, pipeline.bind_point, pipeline.vk_pipeline);
+    vkCmdBindPipeline(vk_command_buffer, pipeline->bind_point, pipeline->vk_pipeline);
 
-    const device_buffer& draw_uniforms = bindless.get_uniform_buffer(UniformTypes::DRAW);
-    constants[UniformTypes::DRAW] = draw_uniforms.device_address + draw_uniforms.offset;
-    vkCmdPushConstants(vk_command_buffer, bindless.global_layout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT, 0U, sizeof(constants), &constants);
+    // const device_buffer* draw_uniforms = bindless.get_uniform_buffer(UniformTypes::DRAW);
+    // constants[UniformTypes::DRAW] = draw_uniforms->device_address + draw_uniforms->offset;
+    // vkCmdPushConstants(vk_command_buffer, bindless.global_layout, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT, 0U, sizeof(constants), &constants);
+
+    VkPushDataInfoEXT push_data {
+        .sType  = VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT,
+        .pNext  = nullptr,
+        .offset = 0,
+        .data   = {
+            .address    = data,
+            .size       = size,
+        }
+    };
+    vkCmdPushDataEXT(vk_command_buffer, &push_data);
 
-    const auto& index_buffer = device.get_buffer(params.index_buffer);
-    vkCmdBindIndexBuffer(vk_command_buffer, index_buffer.vk_buffer, 0U, VK_INDEX_TYPE_UINT16);
+    const device_buffer* index_buffer = device.get_buffer(params.index_buffer);
+    vkCmdBindIndexBuffer(vk_command_buffer, index_buffer->vk_buffer, 0U, VK_INDEX_TYPE_UINT16);
     vkCmdDrawIndexed(vk_command_buffer, params.vertex_count, params.instance_count, params.index_offset, static_cast<int32_t>(params.vertex_offset), 0U);
 }