Fix some descriptor heap usage errors

Change VKCHECK macro

7 files changed, 219 insertions, 218 deletions

diff --git a/include/vk-command-buffer.hpp b/include/vk-command-buffer.hpp
index f82e52f..96bc7be 100644
--- a/include/vk-command-buffer.hpp
+++ b/include/vk-command-buffer.hpp
@@ -56,8 +56,6 @@ struct command_buffer {
 
     VkCommandBuffer vk_command_buffer;
     QueueType       queue_type;
-
-    // TODO: Add relevant fields in order to bind heaps
 };
 
 // General purpose queue
diff --git a/include/vk-utils.hpp b/include/vk-utils.hpp
index c67cf31..094c5db 100644
--- a/include/vk-utils.hpp
+++ b/include/vk-utils.hpp
@@ -1,9 +1,17 @@
 #pragma once
 
 #ifdef DEBUG
-#define VKCHECK(result) assert((result) == VK_SUCCESS)
+#define VK_CHECK(expr)                                              \
+    do {                                                            \
+    VkResult res = expr;                                            \
+        if (res < VK_SUCCESS) {                                     \
+            printf("%s returned error code : %d", #expr, res);      \
+            __debugbreak();                                         \
+        }                                                           \
+    }                                                               \
+    while(0);
 #else
-#define VKCHECK(result) (void)result
+#define VK_CHECK(expr) (void)expr
 #endif
 
 VKAPI_ATTR VkBool32 VKAPI_CALL debug_callback(VkDebugUtilsMessageSeverityFlagBitsEXT      severity,
diff --git a/shaders/api-test-ui.frag b/shaders/api-test-ui.frag
index ad2ea21..5c56479 100644
--- a/shaders/api-test-ui.frag
+++ b/shaders/api-test-ui.frag
@@ -27,11 +27,13 @@ layout(buffer_reference) readonly buffer vertices {
 

 layout(push_constant) uniform registers {

     vertices vertex_buffer;

-    vec2 scale;

-    vec2 translate;

-    uint texture_index;

-} regs;

+    // vec2 scale;

+    // vec2 translate;

+    // uint texture_index;

+    // uint padding;

+};

 

 void main() {

-    o_Color = In.color * texture(sampler2D(textures[nonuniformEXT(regs.texture_index)], samplers[nonuniformEXT(0U)]), In.uv.xy);

+    // o_Color = In.color * texture(sampler2D(textures[nonuniformEXT(texture_index)], samplers[nonuniformEXT(0U)]), In.uv.xy);

+    o_Color = vec4(1.f, 0.f, 0.f, 1.f);

 }

diff --git a/shaders/api-test-ui.vert b/shaders/api-test-ui.vert
index f4d5fee..29e8842 100644
--- a/shaders/api-test-ui.vert
+++ b/shaders/api-test-ui.vert
@@ -8,56 +8,18 @@ struct vertex {
     uint    color;

 };

 

-struct camera {

-    vec4 position;

-

-    vec4 forward;

-    vec4 up;

-    vec4 right;

-

-    vec4 horizontal;

-    vec4 vertical;

-    vec4 first_pixel;

-

-    float lens_radius;

-};

-

-layout(buffer_reference) readonly buffer global_params {

-    camera cam;

-

-    uint max_bounce;

-    uint min_bounce;

-    uint width;

-    uint height;

-    uint sample_index;

-

-    uint enable_dof;

-    uint debug_bvh;

-    int downscale_factor;

-};

-

-layout(buffer_reference) readonly buffer pass_params {

-    uint padding;

-};

-

 layout(buffer_reference) readonly buffer vertices {

     vertex vertices[];

 };

 

-layout(buffer_reference) readonly buffer params {

+layout(push_constant) uniform registers {

     vertices vertex_buffer;

-    vec2 scale;

-    vec2 translate;

-    uint texture_index;

-    uint padding;

+    // vec2 scale;

+    // vec2 translate;

+    // uint texture_index;

+    // uint padding;

 };

 

-layout(push_constant) uniform registers {

-    global_params globals;

-    pass_params pass;

-    params ui_params;

-} regs;

-

 out gl_PerVertex {

     vec4 gl_Position;

 };

@@ -69,11 +31,12 @@ layout(location = 0) out struct {
 

 

 void main() {

-    vertex v = regs.ui_params.vertex_buffer.vertices[gl_VertexIndex];

+    vertex v = vertex_buffer.vertices[gl_VertexIndex];

 

     Out.color = unpackUnorm4x8(v.color);

     Out.uv = vec2(v.uv_x, v.uv_y);

 

     vec2 pos = vec2(v.pos_x, v.pos_y);

-    gl_Position = vec4(pos * regs.ui_params.scale + regs.ui_params.translate, 0.0, 1.0);

+    gl_Position = vec4(pos * (vec2(1280.f, 720.f) / 2.f) + vec2(-1.f, -1.f), 0.0, 1.0);

+    // gl_Position = vec4(pos * scale + translate, -1.f), 0.0, 1.0);

 }

diff --git a/src/main.cpp b/src/main.cpp
index 34cc894..d0e50c5 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -27,11 +27,10 @@
 
 #include <simdjson.h>
 
-#define ENABLE_RENDERDOC 1
+#define ENABLE_RENDERDOC 0
 #if ENABLE_RENDERDOC
 #include <renderdoc_app.h>
 
-
 #define RD_START_CAPTURE if(rdoc_api != nullptr) rdoc_api->StartFrameCapture(nullptr, nullptr)
 #define RD_END_CAPTURE if(rdoc_api != nullptr) rdoc_api->EndFrameCapture(nullptr, nullptr)
 #else
@@ -254,6 +253,7 @@ int main() {
         .usages = VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT,
         .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
         .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,
+        .name = "ImGui vertex buffer",
 #else
         #endif
     });
@@ -264,6 +264,7 @@ int main() {
         .usages = VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT,
         .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
         .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,
+        .name = "ImGui index buffer",
 #else
 #endif
     });
@@ -457,16 +458,24 @@ int main() {
     });
 
 #if VK
-    u32 acc_storage_index = render_device.get_texture(acc_handle)->get_storage_index();
-    u32 result_storage_index = render_device.get_texture(result_handle)->get_storage_index();
+    // u32 acc_storage_index = render_device.get_texture(acc_handle)->get_storage_index();
+    // u32 result_storage_index = render_device.get_texture(result_handle)->get_storage_index();
 #endif
 
     const device_texture* ui_texture = render_device.get_texture(ui_texture_handle);
-    const device_texture* transmittance_lut = render_device.get_texture(transmittance_lut_handle);
+    // const device_texture* transmittance_lut = render_device.get_texture(transmittance_lut_handle);
     debug_texture_list.push_back(transmittance_lut_handle);
 
     io.Fonts->SetTexID(reinterpret_cast<void*>(static_cast<uintptr_t>(ui_texture->get_sampled_index())));
 
+    handle<device_sampler> default_sampler = vkdevice::get().create_sampler(sampler_desc{
+        .mag_filter          = VK_FILTER_LINEAR,
+        .min_filter          = VK_FILTER_LINEAR,
+        .address_mode_u      = VK_SAMPLER_ADDRESS_MODE_REPEAT,
+        .address_mode_v      = VK_SAMPLER_ADDRESS_MODE_REPEAT,
+        .address_mode_w      = VK_SAMPLER_ADDRESS_MODE_REPEAT,
+    });
+
 
 #if VK
     std::array<graphics_command_buffer, 4U> graphics_command_buffers;
@@ -481,71 +490,71 @@ int main() {
     // API test code
     // =============
     RD_START_CAPTURE;
-    graphics_command_buffers[0].start();
+    // graphics_command_buffers[0].start();
 
 #if VK
-    graphics_command_buffers[0].barrier(gpu_texture_handle, VK_PIPELINE_STAGE_2_TRANSFER_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
-    graphics_command_buffers[0].barrier(second_texture, VK_PIPELINE_STAGE_2_TRANSFER_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
-    graphics_command_buffers[0].barrier(ui_texture_handle, VK_PIPELINE_STAGE_2_TRANSFER_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+    // graphics_command_buffers[0].barrier(gpu_texture_handle, VK_PIPELINE_STAGE_2_TRANSFER_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+    // graphics_command_buffers[0].barrier(second_texture, VK_PIPELINE_STAGE_2_TRANSFER_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+    // graphics_command_buffers[0].barrier(ui_texture_handle, VK_PIPELINE_STAGE_2_TRANSFER_BIT, VK_ACCESS_2_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
 #endif
 
-    graphics_command_buffers[0].copy(staging_buffer_handle, gpu_texture_handle);
-    graphics_command_buffers[0].copy(staging_buffer_handle, second_texture, buffer_offset);
-    graphics_command_buffers[0].copy(staging_buffer_handle, ui_texture_handle, ui_offset);
+    // graphics_command_buffers[0].copy(staging_buffer_handle, gpu_texture_handle);
+    // graphics_command_buffers[0].copy(staging_buffer_handle, second_texture, buffer_offset);
+    // graphics_command_buffers[0].copy(staging_buffer_handle, ui_texture_handle, ui_offset);
 #if VK
-    graphics_command_buffers[0].barrier(gpu_texture_handle, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL);
-    graphics_command_buffers[0].barrier(second_texture, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_READ_BIT, VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL);
+    // graphics_command_buffers[0].barrier(gpu_texture_handle, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL);
+    // graphics_command_buffers[0].barrier(second_texture, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_READ_BIT, VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL);
 
 
-    {
-        {
-            struct params {
-                u32 input1;
-                u32 input2;
-                u32 output;
-                u32 pad;
-            } params = {
-                .input1 = render_device.get_texture(second_texture)->get_storage_index(),
-                .input2 = render_device.get_texture(gpu_texture_handle)->get_storage_index(),
-                .output = render_device.get_texture(output_texture_handle)->get_storage_index(),
-            };
+    // {
+    //     {
+    //         struct params {
+    //             u32 input1;
+    //             u32 input2;
+    //             u32 output;
+    //             u32 pad;
+    //         } params = {
+    //             .input1 = render_device.get_texture(second_texture)->get_storage_index(),
+    //             .input2 = render_device.get_texture(gpu_texture_handle)->get_storage_index(),
+    //             .output = render_device.get_texture(output_texture_handle)->get_storage_index(),
+    //         };
 
-            graphics_command_buffers[0].dispatch({
-                .pipeline = compute,
-                .group_size = { .vec = { static_cast<u32>(image_width), static_cast<u32>(image_height), 1U }},
-                .local_group_size = { .vec = { 8U, 8U, 1U }},
-            },
-            &params, sizeof(struct params));
-        }
+    //         graphics_command_buffers[0].dispatch({
+    //             .pipeline = compute,
+    //             .group_size = { .vec = { static_cast<u32>(image_width), static_cast<u32>(image_height), 1U }},
+    //             .local_group_size = { .vec = { 8U, 8U, 1U }},
+    //         },
+    //         &params, sizeof(struct params));
+    //     }
 
-        {
-            struct params {
-                u32 lut_id;
-                u32 width;
-                u32 height;
-                u32 pad;
-            } params = {
-                .lut_id = transmittance_lut->get_storage_index(),
-                .width = transmittance_lut->width,
-                .height = transmittance_lut->height,
-            };
+    //     {
+    //         struct params {
+    //             u32 lut_id;
+    //             u32 width;
+    //             u32 height;
+    //             u32 pad;
+    //         } params = {
+    //             .lut_id = transmittance_lut->get_storage_index(),
+    //             .width = transmittance_lut->width,
+    //             .height = transmittance_lut->height,
+    //         };
 
-            graphics_command_buffers[0].dispatch({
-                .pipeline = transmittance_lut_compute,
-                .group_size = { .vec = { 1024U, 1024U, 1U }},
-                .local_group_size = { .vec { 8U, 8U, 1U }},
-            },
-            &params, sizeof(struct params));
-        }
-    }
+    //         graphics_command_buffers[0].dispatch({
+    //             .pipeline = transmittance_lut_compute,
+    //             .group_size = { .vec = { 1024U, 1024U, 1U }},
+    //             .local_group_size = { .vec { 8U, 8U, 1U }},
+    //         },
+    //         &params, sizeof(struct params));
+    //     }
+    // }
 
-    graphics_command_buffers[0].barrier(gpu_texture_handle, VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
+    // graphics_command_buffers[0].barrier(gpu_texture_handle, VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
 #endif
 
-    graphics_command_buffers[0].stop();
+    // graphics_command_buffers[0].stop();
 
-    render_device.submit(graphics_command_buffers.data(), 1);
-    render_device.wait();
+    // render_device.submit(graphics_command_buffers.data(), 1);
+    // render_device.wait();
 
     RD_END_CAPTURE;
 
@@ -690,53 +699,53 @@ int main() {
             }
 
             {
-                struct params {
-                    struct metadata meta;
-                    uintptr_t bvh_buffer;
-                    uintptr_t indices_buffer;
-                    uintptr_t positions_buffer;
-                    uintptr_t normals_buffer;
-                    uintptr_t uvs_buffer;
-                    uintptr_t materials_buffer;
-                    u32 output_id;
-                    u32 accumulation_id;
-                } uniforms = {
-                    .meta             = main_scene.meta,
-                    .bvh_buffer       = main_scene.bvh_buffer_address(),
-                    .indices_buffer   = main_scene.indices_buffer_address(),
-                    .positions_buffer = main_scene.positions_buffer_address(),
-                    .normals_buffer   = main_scene.normals_buffer_address(),
-                    .uvs_buffer       = main_scene.uvs_buffer_address(),
-                    .materials_buffer = main_scene.materials_buffer_address(),
-                    .output_id        = (virtual_frame_index == 0U) ? result_storage_index : acc_storage_index,
-                    .accumulation_id  = (virtual_frame_index == 0U) ? acc_storage_index : result_storage_index,
-                };
+                // struct params {
+                //     struct metadata meta;
+                //     uintptr_t bvh_buffer;
+                //     uintptr_t indices_buffer;
+                //     uintptr_t positions_buffer;
+                //     uintptr_t normals_buffer;
+                //     uintptr_t uvs_buffer;
+                //     uintptr_t materials_buffer;
+                //     u32 output_id;
+                //     u32 accumulation_id;
+                // } uniforms = {
+                //     .meta             = main_scene.meta,
+                //     .bvh_buffer       = main_scene.bvh_buffer_address(),
+                //     .indices_buffer   = main_scene.indices_buffer_address(),
+                //     .positions_buffer = main_scene.positions_buffer_address(),
+                //     .normals_buffer   = main_scene.normals_buffer_address(),
+                //     .uvs_buffer       = main_scene.uvs_buffer_address(),
+                //     .materials_buffer = main_scene.materials_buffer_address(),
+                //     .output_id        = (virtual_frame_index == 0U) ? result_storage_index : acc_storage_index,
+                //     .accumulation_id  = (virtual_frame_index == 0U) ? acc_storage_index : result_storage_index,
+                // };
 
-                command_buffer.dispatch({
-                    .pipeline = raytracing,
-                    .group_size = { .vec { window_width / main_scene.meta.downscale_factor, window_height / main_scene.meta.downscale_factor, 1U, } },
-                    .local_group_size = { .vec { 8U, 8U, 1U, } },
-                }, (const void*)&uniforms, sizeof(struct params));
+                // command_buffer.dispatch({
+                //     .pipeline = raytracing,
+                //     .group_size = { .vec { window_width / main_scene.meta.downscale_factor, window_height / main_scene.meta.downscale_factor, 1U, } },
+                //     .local_group_size = { .vec { 8U, 8U, 1U, } },
+                // }, (const void*)&uniforms, sizeof(struct params));
             }
 
-            {
-                struct params {
-                    s32 downscale_factor;
-                    u32 output_id;
-                    u32 accumulation_id;
-                } uniforms = {
-                    // TODO: Refactor backbuffer acquisition
-                    .downscale_factor = main_scene.meta.downscale_factor,
-                    .output_id = render_device.get_texture(backbuffer)->get_storage_index(),
-                    .accumulation_id = (virtual_frame_index == 0U) ? result_storage_index : acc_storage_index,
-                };
+            // {
+            //     struct params {
+            //         s32 downscale_factor;
+            //         u32 output_id;
+            //         u32 accumulation_id;
+            //     } uniforms = {
+            //         // TODO: Refactor backbuffer acquisition
+            //         .downscale_factor = main_scene.meta.downscale_factor,
+            //         .output_id = render_device.get_texture(backbuffer)->get_storage_index(),
+            //         .accumulation_id = (virtual_frame_index == 0U) ? result_storage_index : acc_storage_index,
+            //     };
 
-                command_buffer.dispatch({
-                    .pipeline = tonemapping,
-                    .group_size = { .vec { window_width / main_scene.meta.downscale_factor, window_height / main_scene.meta.downscale_factor, 1U, } },
-                    .local_group_size = { .vec { 8U, 8U, 1U, } },
-                }, &uniforms, sizeof(struct params));
-            }
+            //     command_buffer.dispatch({
+            //         .pipeline = tonemapping,
+            //         .group_size = { .vec { window_width / main_scene.meta.downscale_factor, window_height / main_scene.meta.downscale_factor, 1U, } },
+            //         .local_group_size = { .vec { 8U, 8U, 1U, } },
+            //     }, &uniforms, sizeof(struct params));
+            // }
         }
 
         command_buffer.barrier(backbuffer, VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
@@ -758,24 +767,24 @@ int main() {
             auto* cmd_list = draw_data->CmdLists[index];
 
             for (auto& draw_command : cmd_list->CmdBuffer) {
-                ImTextureID texture_id = draw_command.TexRef.GetTexID();
+                // ImTextureID texture_id = draw_command.TexRef.GetTexID();
                 struct ui_params {
                     u64 vertex_buffer;
-                    float scale[2U];
-                    float translate[2U];
-                    uint32_t texture_index;
-                    u32 padding;
+                    // float scale[2U];
+                    // float translate[2U];
+                    // u32 texture_index;
+                    // u32 padding;
                 } ui_param = {
                     .vertex_buffer = vertex_buffer->device_address,
-                    .scale {
-                        2.f / draw_data->DisplaySize.x,
-                        2.f / draw_data->DisplaySize.y,
-                    },
-                    .translate {
-                        -1.f - draw_data->DisplayPos.x * (2.f / draw_data->DisplaySize.x),
-                        -1.f - draw_data->DisplayPos.y * (2.f / draw_data->DisplaySize.y),
-                    },
-                    .texture_index = *reinterpret_cast<uint32_t*>(&texture_id),
+                    // .scale {
+                    //     2.f / draw_data->DisplaySize.x,
+                    //     2.f / draw_data->DisplaySize.y,
+                    // },
+                    // .translate {
+                    //     -1.f - draw_data->DisplayPos.x * (2.f / draw_data->DisplaySize.x),
+                    //     -1.f - draw_data->DisplayPos.y * (2.f / draw_data->DisplaySize.y),
+                    // },
+                    // .texture_index = *reinterpret_cast<uint32_t*>(&texture_id),
                 };
 
                 command_buffer.draw_indexed({
diff --git a/src/vk-command-buffer.cpp b/src/vk-command-buffer.cpp
index aa87265..6b1f271 100644
--- a/src/vk-command-buffer.cpp
+++ b/src/vk-command-buffer.cpp
@@ -8,7 +8,7 @@ void command_buffer::start() const {
         .pInheritanceInfo = nullptr
     };
 
-    VKCHECK(vkBeginCommandBuffer(vk_command_buffer, &begin_info));
+    VK_CHECK(vkBeginCommandBuffer(vk_command_buffer, &begin_info));
 
     {
         device_buffer* image_heap_buffer = vkdevice::get().get_buffer(image_heap);
@@ -21,7 +21,7 @@ void command_buffer::start() const {
             .sType               = VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT,
             .pNext               = nullptr,
             .heapRange           = heap_range,
-            .reservedRangeOffset = 0U,
+            .reservedRangeOffset = image_heap_buffer->size - descriptor_heap_props.minResourceHeapReservedRange,
             .reservedRangeSize   = descriptor_heap_props.minResourceHeapReservedRange,
         };
 
@@ -40,7 +40,7 @@ void command_buffer::start() const {
             .sType               = VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT,
             .pNext               = nullptr,
             .heapRange           = heap_range,
-            .reservedRangeOffset = 0U,
+            .reservedRangeOffset = sampler_heap_buffer->size - descriptor_heap_props.minSamplerHeapReservedRange,
             .reservedRangeSize   = descriptor_heap_props.minSamplerHeapReservedRange,
         };
 
@@ -49,7 +49,7 @@ void command_buffer::start() const {
 }
 
 void command_buffer::stop() const {
-    VKCHECK(vkEndCommandBuffer(vk_command_buffer));
+    VK_CHECK(vkEndCommandBuffer(vk_command_buffer));
 }
 
 void command_buffer::barrier(handle<device_texture> texture_handle, VkPipelineStageFlags2 stage, VkAccessFlags2 access, VkImageLayout layout) const {
@@ -147,10 +147,10 @@ void graphics_command_buffer::dispatch(const dispatch_params& params, const void
 }
 
 void graphics_command_buffer::begin_renderpass(const renderpass_params& params) const {
-    std::vector<VkRenderingAttachmentInfo> attachments_info(params.color_attachments_count);
+    VkRenderingAttachmentInfo* attachments_info = static_cast<VkRenderingAttachmentInfo*>(_malloca(sizeof(VkRenderingAttachmentInfo) * params.color_attachments_count));
 
-    for (auto index{ 0U }; index < params.color_attachments_count; index++) {
-        auto& attachment_info              = attachments_info[index];
+    for (u32 index = 0U; index < params.color_attachments_count; index++) {
+        VkRenderingAttachmentInfo& attachment_info  = attachments_info[index];
         device_texture* attachment         = vkdevice::get().get_texture(params.color_attachments[index]);
 
         attachment_info.sType              = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
@@ -194,8 +194,8 @@ void graphics_command_buffer::begin_renderpass(const renderpass_params& params)
         .renderArea           = scissor,
         .layerCount           = 1U,
         .viewMask             = 0U,
-        .colorAttachmentCount = static_cast<uint32_t>(attachments_info.size()),
-        .pColorAttachments    = attachments_info.data(),
+        .colorAttachmentCount = static_cast<uint32_t>(params.color_attachments_count),
+        .pColorAttachments    = attachments_info,
         .pDepthAttachment     = nullptr,
         .pStencilAttachment   = nullptr,
     };
diff --git a/src/vk-device.cpp b/src/vk-device.cpp
index 7be2d22..c35ea05 100644
--- a/src/vk-device.cpp
+++ b/src/vk-device.cpp
@@ -37,14 +37,18 @@ struct physical_device_features {
 static void create_heaps(size_t max_images, size_t max_samplers) {
     // create image heap
     {
+        u64 alignment = descriptor_heap_props.imageDescriptorAlignment < descriptor_heap_props.bufferDescriptorAlignment ?
+            descriptor_heap_props.bufferDescriptorAlignment :
+            descriptor_heap_props.imageDescriptorAlignment;
+
         image_heap = vkdevice::get().create_buffer({
-            .size = descriptor_heap_props.minResourceHeapReservedRange + max_images * descriptor_heap_props.imageDescriptorSize,
+            .size = descriptor_heap_props.minResourceHeapReservedRange + ALIGN(max_images * descriptor_heap_props.imageDescriptorSize, alignment),
             .usages = VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT |
                       VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT |
                       VK_BUFFER_USAGE_2_TRANSFER_DST_BIT,
             .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-            .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,
-            // .memory_usage = VMA_MEMORY_USAGE_GPU_ONLY,
+            .memory_usage = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
+                            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
             .name = "image descriptor_heap",
         });
     }
@@ -52,13 +56,13 @@ static void create_heaps(size_t max_images, size_t max_samplers) {
     // create sampler heap
     {
         sampler_heap = vkdevice::get().create_buffer({
-            .size = descriptor_heap_props.minSamplerHeapReservedRange + max_samplers * descriptor_heap_props.samplerDescriptorSize,
+            .size = descriptor_heap_props.minSamplerHeapReservedRange + ALIGN(max_samplers * descriptor_heap_props.samplerDescriptorSize, descriptor_heap_props.samplerDescriptorAlignment),
             .usages = VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT |
                       VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT |
                       VK_BUFFER_USAGE_2_TRANSFER_DST_BIT,
             .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-            .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,
-            // .memory_usage = VMA_MEMORY_USAGE_GPU_ONLY,
+            .memory_usage = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
+                            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
             .name = "sampler descriptor_heap",
         });
     }
@@ -81,7 +85,7 @@ static device_semaphore create_semaphore(const semaphore_desc& desc, const char*
         .flags = 0U,
     };
 
-    VKCHECK(vkCreateSemaphore(device, &create_info, nullptr, &semaphore.vk_semaphore));
+    VK_CHECK(vkCreateSemaphore(device, &create_info, nullptr, &semaphore.vk_semaphore));
 
     if (name) {
         VkDebugUtilsObjectNameInfoEXT object_name{
@@ -107,7 +111,7 @@ static VkShaderModule create_shader_module(uint8_t* code, size_t code_size) {
         .pCode    = reinterpret_cast<uint32_t*>(code),
     };
 
-    VKCHECK(vkCreateShaderModule(device, &create_info, nullptr, &shader_module));
+    VK_CHECK(vkCreateShaderModule(device, &create_info, nullptr, &shader_module));
     return shader_module;
 }
 
@@ -163,6 +167,9 @@ void vkdevice::init() {
 void vkdevice::deinit() {
     vkDeviceWaitIdle(device);
 
+    destroy_buffer(image_heap);
+    destroy_buffer(sampler_heap);
+
     vmaDestroyAllocator(gpu_allocator);
 
     for (auto& queue : queues) {
@@ -195,7 +202,7 @@ void vkdevice::wait_for_fence(u64 value) {
         .pValues        = &value,
     };
 
-    VKCHECK(vkWaitSemaphores(device, &semaphore_wait_info, UINT64_MAX));
+    VK_CHECK(vkWaitSemaphores(device, &semaphore_wait_info, UINT64_MAX));
 }
 
 handle<device_texture> vkdevice::create_texture(const texture_desc& desc) {
@@ -251,8 +258,18 @@ handle<device_buffer> vkdevice::create_buffer(const buffer_desc& desc) {
         .pName = desc.name,
     };
 
-    VKCHECK(vmaCreateBuffer(gpu_allocator, &create_info, &alloc_create_info, &device_buffer.vk_buffer, &device_buffer.alloc, &alloc_info));
-    vmaSetAllocationName(gpu_allocator, device_buffer.alloc, desc.name);
+    VK_CHECK(vmaCreateBuffer(gpu_allocator, &create_info, &alloc_create_info, &device_buffer.vk_buffer, &device_buffer.alloc, &alloc_info));
+
+    if (desc.name) {
+        VkDebugUtilsObjectNameInfoEXT object_name{
+            .sType          = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
+            .pNext          = nullptr,
+            .objectType     = VK_OBJECT_TYPE_BUFFER,
+            .objectHandle   = reinterpret_cast<uint64_t>(device_buffer.vk_buffer),
+            .pObjectName    = desc.name,
+        };
+        vkSetDebugUtilsObjectNameEXT(device, &object_name);
+    }
 
     if ((desc.usages & VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT) != 0U) {
         VkBufferDeviceAddressInfo address_info {
@@ -408,7 +425,7 @@ handle<device_pipeline> vkdevice::create_graphics_pipeline(const graphics_pipeli
     };
 
     device_pipeline.bind_point = VK_PIPELINE_BIND_POINT_GRAPHICS;
-    VKCHECK(vkCreateGraphicsPipelines(device, nullptr, 1U, &create_info, nullptr, &device_pipeline.vk_pipeline));
+    VK_CHECK(vkCreateGraphicsPipelines(device, nullptr, 1U, &create_info, nullptr, &device_pipeline.vk_pipeline));
 
     for(auto& stage_create_info : shader_stages_create_info) {
         vkDestroyShaderModule(device, stage_create_info.module, nullptr);
@@ -459,7 +476,7 @@ handle<device_pipeline> vkdevice::create_compute_pipeline(const compute_pipeline
     };
 
     device_pipeline.bind_point = VK_PIPELINE_BIND_POINT_COMPUTE;
-    VKCHECK(vkCreateComputePipelines(device, nullptr, 1U, &create_info, nullptr, &device_pipeline.vk_pipeline));
+    VK_CHECK(vkCreateComputePipelines(device, nullptr, 1U, &create_info, nullptr, &device_pipeline.vk_pipeline));
 
     vkDestroyShaderModule(device, stage_create_info.module, nullptr);
 
@@ -490,7 +507,7 @@ handle<device_surface> vkdevice::create_surface(const surface_desc& desc) {
             .hwnd      = desc.window_handle,
         };
 
-        VKCHECK(vkCreateWin32SurfaceKHR(instance, &create_info, nullptr, &device_surface.vk_surface));
+        VK_CHECK(vkCreateWin32SurfaceKHR(instance, &create_info, nullptr, &device_surface.vk_surface));
     }
 
     create_swapchain(desc, device_surface);
@@ -589,7 +606,7 @@ uint64_t vkdevice::submit(command_buffer* cmd_buffers, uint32_t count) {
     submit_info.signalSemaphoreInfoCount = sizeof(signal_semaphore_infos) / sizeof(signal_semaphore_infos[0U]);
     submit_info.pSignalSemaphoreInfos = signal_semaphore_infos;
 
-    VKCHECK(vkQueueSubmit2(queues[static_cast<uint32_t>(queue_type)].vk_queue, 1, &submit_info, nullptr));
+    VK_CHECK(vkQueueSubmit2(queues[static_cast<uint32_t>(queue_type)].vk_queue, 1, &submit_info, nullptr));
 
     return fence.value;
 }
@@ -598,7 +615,6 @@ uint64_t vkdevice::submit_before_present(handle<device_surface> surface_handle,
     assert((max_submitable_command_buffers - count) >= 0);
     const QueueType queue_type = cmd_buffers[0].queue_type;
 
-    // VkCommandBufferSubmitInfo command_buffers_info[count];
     VkCommandBufferSubmitInfo command_buffers_info[max_submitable_command_buffers];
 
     for (uint32_t index{ 0U }; index < count; index++) {
@@ -654,7 +670,7 @@ uint64_t vkdevice::submit_before_present(handle<device_surface> surface_handle,
     submit_info.signalSemaphoreInfoCount = sizeof(signal_semaphore_infos) / sizeof(signal_semaphore_infos[0U]);
     submit_info.pSignalSemaphoreInfos = signal_semaphore_infos;
 
-    VKCHECK(vkQueueSubmit2(queues[static_cast<uint32_t>(queue_type)].vk_queue, 1, &submit_info, nullptr));
+    VK_CHECK(vkQueueSubmit2(queues[static_cast<uint32_t>(queue_type)].vk_queue, 1, &submit_info, nullptr));
 
     return fence.value;
 }
@@ -675,9 +691,9 @@ void vkdevice::present(handle<device_surface> surface_handle) {
     present_info.waitSemaphoreCount = 1U;
     present_info.pWaitSemaphores = &semaphore.vk_semaphore;
 
-    VKCHECK(vkQueuePresentKHR(queues[static_cast<uint32_t>(QueueType::GRAPHICS)].vk_queue, &present_info));
+    VK_CHECK(vkQueuePresentKHR(queues[static_cast<uint32_t>(QueueType::GRAPHICS)].vk_queue, &present_info));
 
-    VKCHECK(result);
+    VK_CHECK(result);
     surface->frame_index = (surface->frame_index + 1) % surface->image_count;
 }
 
@@ -695,7 +711,7 @@ void vkdevice::allocate_command_buffers(command_buffer* cmd_buffers, size_t coun
         .commandBufferCount = static_cast<uint32_t>(count),
     };
 
-    VKCHECK(vkAllocateCommandBuffers(device, &allocate_info, command_buffers));
+    VK_CHECK(vkAllocateCommandBuffers(device, &allocate_info, command_buffers));
 
     for (uint32_t index{ 0U }; index < count; index++) {
         cmd_buffers[index].vk_command_buffer = command_buffers[index];
@@ -721,13 +737,13 @@ void vkdevice::create_swapchain(const surface_desc& desc, device_surface& surfac
 
     {
         VkBool32 supported = VK_FALSE;
-        VKCHECK(vkGetPhysicalDeviceSurfaceSupportKHR(physical_device, queue.index, vk_surface, &supported));
+        VK_CHECK(vkGetPhysicalDeviceSurfaceSupportKHR(physical_device, queue.index, vk_surface, &supported));
 
         assert(supported);
     }
 
     VkSurfaceCapabilitiesKHR surface_capabilities;
-    VKCHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical_device, vk_surface, &surface_capabilities));
+    VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical_device, vk_surface, &surface_capabilities));
 
     VkExtent2D extent = surface_capabilities.currentExtent;
     if (extent.width < surface_capabilities.minImageExtent.width) {
@@ -745,10 +761,10 @@ void vkdevice::create_swapchain(const surface_desc& desc, device_surface& surfac
     {
         bool supported = false;
         u32 supported_formats_count = 0U;
-        VKCHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, vk_surface, &supported_formats_count, nullptr));
+        VK_CHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, vk_surface, &supported_formats_count, nullptr));
 
         VkSurfaceFormatKHR* supported_formats = static_cast<VkSurfaceFormatKHR*>(_malloca(supported_formats_count * sizeof(VkSurfaceFormatKHR)));
-        VKCHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, vk_surface, &supported_formats_count, supported_formats));
+        VK_CHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, vk_surface, &supported_formats_count, supported_formats));
 
         for (u32 format_index = 0U; format_index < supported_formats_count; format_index++) {
             VkSurfaceFormatKHR surface_format = supported_formats[format_index];
@@ -765,10 +781,10 @@ void vkdevice::create_swapchain(const surface_desc& desc, device_surface& surfac
     {
         bool supported = false;
         u32 supported_present_modes_count = 0U;
-        VKCHECK(vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device, vk_surface, &supported_present_modes_count, nullptr));
+        VK_CHECK(vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device, vk_surface, &supported_present_modes_count, nullptr));
 
         VkPresentModeKHR* supported_present_modes = static_cast<VkPresentModeKHR*>(_malloca(supported_present_modes_count * sizeof(VkPresentModeKHR)));
-        VKCHECK(vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device, vk_surface, &supported_present_modes_count, supported_present_modes));
+        VK_CHECK(vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device, vk_surface, &supported_present_modes_count, supported_present_modes));
 
         for (u32 present_mode_index = 0U; present_mode_index < supported_present_modes_count; present_mode_index++) {
             VkPresentModeKHR present_mode = supported_present_modes[present_mode_index];
@@ -805,7 +821,7 @@ void vkdevice::create_swapchain(const surface_desc& desc, device_surface& surfac
             .oldSwapchain          = nullptr,
     };
 
-    VKCHECK(vkCreateSwapchainKHR(device, &create_info, nullptr, &surface.vk_swapchain));
+    VK_CHECK(vkCreateSwapchainKHR(device, &create_info, nullptr, &surface.vk_swapchain));
 
     surface.surface_format = desc.surface_format;
 
@@ -863,7 +879,7 @@ void vkdevice::create_instance() {
         .ppEnabledExtensionNames = instance_extensions,
     };
 
-    VKCHECK(vkCreateInstance(&create_info, nullptr, &instance));
+    VK_CHECK(vkCreateInstance(&create_info, nullptr, &instance));
 
     load_instance_functions(instance);
 }
@@ -897,6 +913,7 @@ void vkdevice::create_device() {
         },
     };
 
+    // select physical device
     {
         u32 physical_devices_count = 0U;
         vkEnumeratePhysicalDevices(instance, &physical_devices_count, nullptr);
@@ -927,6 +944,7 @@ void vkdevice::create_device() {
                 features.physical_device_13_features.dynamicRendering                             == VK_TRUE &&
                 features.physical_device_14_features.maintenance5                                 == VK_TRUE &&
                 features.descriptor_heap_features.descriptorHeap                                  == VK_TRUE &&
+                features.descriptor_heap_features.descriptorHeapCaptureReplay                     == VK_TRUE &&
                 features.shader_untyped_pointers_features.shaderUntypedPointers                   == VK_TRUE) {
 
                 physical_device = physical_dev;
@@ -987,11 +1005,11 @@ void vkdevice::create_device() {
         .pEnabledFeatures        = nullptr,
     };
 
-    VKCHECK(vkCreateDevice(physical_device, &create_info, nullptr, &device));
+    VK_CHECK(vkCreateDevice(physical_device, &create_info, nullptr, &device));
 
     load_device_functions(device);
 
-    for (auto& queue : queues) {
+    for (struct queue& queue : queues) {
         vkGetDeviceQueue(device, queue.index, 0, &queue.vk_queue);
     }
 
@@ -1006,7 +1024,7 @@ void vkdevice::create_device() {
         for (queue& queue : queues) {
             command_pool_create_info.queueFamilyIndex = queue.index;
 
-            VKCHECK(vkCreateCommandPool(device, &command_pool_create_info, nullptr, &queue.command_pool));
+            VK_CHECK(vkCreateCommandPool(device, &command_pool_create_info, nullptr, &queue.command_pool));
         }
     }
 
@@ -1025,7 +1043,7 @@ void vkdevice::create_device() {
             .vulkanApiVersion = VK_API_VERSION_1_2,
         };
 
-        VKCHECK(vmaCreateAllocator(&allocator_create_info, &gpu_allocator));
+        VK_CHECK(vmaCreateAllocator(&allocator_create_info, &gpu_allocator));
     }
 
     create_heaps(max_images_count, max_samplers_count);
@@ -1084,7 +1102,7 @@ void device_texture::init(const texture_desc& desc) {
             .pUserData      = nullptr,
         };
 
-        VKCHECK(vmaCreateImage(gpu_allocator, &create_info, &alloc_create_info, &vk_image, &alloc, nullptr));
+        VK_CHECK(vmaCreateImage(gpu_allocator, &create_info, &alloc_create_info, &vk_image, &alloc, nullptr));
         vmaSetAllocationName(gpu_allocator, alloc, desc.name);
     }
 
@@ -1124,12 +1142,12 @@ void device_texture::init(const texture_desc& desc) {
     {
         for (u32 mip_index = 0U; mip_index < mips; mip_index++) {
             image_view_create_info.subresourceRange.baseMipLevel = mip_index;
-            VKCHECK(vkCreateImageView(device, &image_view_create_info, nullptr, &mips_views[mip_index]));
+            VK_CHECK(vkCreateImageView(device, &image_view_create_info, nullptr, &mips_views[mip_index]));
         }
 
         image_view_create_info.subresourceRange.baseMipLevel = 0;
         image_view_create_info.subresourceRange.levelCount   = mips;
-        VKCHECK(vkCreateImageView(device, &image_view_create_info, nullptr, &whole_view));
+        VK_CHECK(vkCreateImageView(device, &image_view_create_info, nullptr, &whole_view));
     }
 
     // TODO: Handle mips views
@@ -1154,9 +1172,11 @@ void device_texture::init(const texture_desc& desc) {
             },
         };
 
+        static u32 strg_index = 0U;
+        strg_index++;
         storage_index = storage_indices.add();
         resources_address[descriptors_count] = {
-            .address = ((u8*)image_heap_buffer->mapped_ptr) + descriptor_heap_props.imageDescriptorSize * (storage_index.id + storage_images_offset),
+            .address = ((u8*)image_heap_buffer->mapped_ptr) + descriptor_heap_props.imageDescriptorSize * (strg_index + storage_images_offset),
             .size    = descriptor_heap_props.imageDescriptorSize,
         };
 
@@ -1172,16 +1192,18 @@ void device_texture::init(const texture_desc& desc) {
             },
         };
 
+        static u32 smpl_index = 0U;
+        smpl_index++;
         sampled_index = sampled_indices.add();
         resources_address[descriptors_count] = {
-            .address = ((u8*)image_heap_buffer->mapped_ptr) + descriptor_heap_props.imageDescriptorSize * (sampled_index.id + sampled_images_offset),
+            .address = ((u8*)image_heap_buffer->mapped_ptr) + descriptor_heap_props.imageDescriptorSize * (smpl_index + sampled_images_offset),
             .size    = descriptor_heap_props.imageDescriptorSize,
         };
 
         descriptors_count++;
     }
 
-    VKCHECK(vkWriteResourceDescriptorsEXT(device, static_cast<uint32_t>(descriptors_count), resource_descriptor_infos, resources_address));
+    VK_CHECK(vkWriteResourceDescriptorsEXT(device, static_cast<uint32_t>(descriptors_count), resource_descriptor_infos, resources_address));
 }
 
 void device_texture::release() {
@@ -1233,18 +1255,17 @@ void device_sampler::init(const sampler_desc& desc) {
         .unnormalizedCoordinates    = desc.unnomalized_coords,
     };
 
-    VKCHECK(vkCreateSampler(device, &sampler_create_info, nullptr, &vk_sampler));
+    VK_CHECK(vkCreateSampler(device, &sampler_create_info, nullptr, &vk_sampler));
 
     sampler_index = sampler_indices.add();
 
-    // TODO: Create previously immutable samplers
     device_buffer* sampler_heap_buffer = render_device.get_buffer(sampler_heap);
 
     VkHostAddressRangeEXT destination_address {
         .address = ((u8*)sampler_heap_buffer->mapped_ptr) + descriptor_heap_props.samplerDescriptorSize * sampler_index.id,
         .size    = descriptor_heap_props.samplerDescriptorSize,
     };
-    VKCHECK(vkWriteSamplerDescriptorsEXT(device, 1U, &sampler_create_info, &destination_address));
+    VK_CHECK(vkWriteSamplerDescriptorsEXT(device, 1U, &sampler_create_info, &destination_address));
 }
 
 
@@ -1261,7 +1282,7 @@ uint32_t vkdevice::acquire_image_index(handle<device_surface> surface_handle) {
         .pValues = &fence.value,
     };
     vkWaitSemaphores(device, &wait_info, UINT64_MAX);
-    VKCHECK(vkAcquireNextImageKHR(device, surface->vk_swapchain, UINT64_MAX, signal.vk_semaphore, nullptr, &surface->image_index));
+    VK_CHECK(vkAcquireNextImageKHR(device, surface->vk_swapchain, UINT64_MAX, signal.vk_semaphore, nullptr, &surface->image_index));
 
     return surface->image_index;
 }