Inital work on vulkan descriptor heap implementation

4 files changed, 500 insertions, 507 deletions

diff --git a/src/main.cpp b/src/main.cpp
index 74bb655..3cb56dc 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -2,7 +2,7 @@
 // windows.h stuff
 // ===============
 #if defined(_WIN32)
-    #if defined(_M_AMD64)
+    #if defined(_M_AMD64) || defined(_M_X64)
         #define _AMD64_
     #endif
     #include <basetsd.h>
@@ -21,24 +21,17 @@
 // -------------------
 // thirdparties
 // -------------------
-#define IMGUI_DISABLE_WIN32_FUNCTIONS
-#include "imgui.cpp"
-#include "imgui_draw.cpp"
-#include "imgui_tables.cpp"
-#include "imgui_widgets.cpp"
+#include "imgui.h"
 
-#define STB_IMAGE_IMPLEMENTATION
 #include <stb_image.h>
 
 #include <simdjson.h>
-#include "simdjson.cpp"
 
 #define ENABLE_RENDERDOC 1
 #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
@@ -120,10 +113,10 @@ void ui(scene* scene, float frame_time) {
 
     if (ImGui::CollapsingHeader("Images")) {
         for (const handle<device_texture>& handle : debug_texture_list) {
-            const device_texture& tex = vkdevice::get().get_texture(handle);
-            const char* name = tex.name;
+            const device_texture* tex = vkdevice::get().get_texture(handle);
+            const char* name = tex->name;
             ImGui::Text(name ? name : DUMMY_NAME);
-            ImGui::Image(tex.get_sampled_index(), ImVec2(128, 128));
+            ImGui::Image(tex->get_sampled_index(), ImVec2(128, 128));
         }
     }
 
@@ -221,7 +214,7 @@ int main() {
 #endif
         .image_count = 2U,
     });
-    const device_surface& surface = device.get_surface(surface_handle);
+    const device_surface* surface = device.get_surface(surface_handle);
 
 
     // ==============
@@ -230,7 +223,7 @@ int main() {
     const handle<device_buffer> staging_buffer_handle = device.create_buffer({
         .size = 128 * MB,
 #if VK
-        .usages = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+        .usages = VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT,
         .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
         .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,
 #else
@@ -240,12 +233,12 @@ int main() {
         .heap_type  = D3D12_HEAP_TYPE_UPLOAD,
 #endif
     });
-    const device_buffer& staging_buffer = device.get_buffer(staging_buffer_handle);
+    const device_buffer* staging_buffer = device.get_buffer(staging_buffer_handle);
 
     const handle<device_buffer> vertex_buffer_handle = device.create_buffer({
         .size = MB * sizeof(uint32_t),
 #if VK
-        .usages = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
+        .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,
 #else
@@ -255,15 +248,15 @@ int main() {
     const handle<device_buffer> index_buffer_handle = device.create_buffer({
         .size = MB * sizeof(uint32_t),
 #if VK
-        .usages = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
+        .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,
 #else
 #endif
     });
 
-    device_buffer vertex_buffer = device.get_buffer(vertex_buffer_handle);
-    device_buffer index_buffer = device.get_buffer(index_buffer_handle);
+    device_buffer* vertex_buffer = device.get_buffer(vertex_buffer_handle);
+    device_buffer* index_buffer = device.get_buffer(index_buffer_handle);
 
 
     // ================
@@ -290,7 +283,7 @@ int main() {
         .cs_code_size = tonemapping_code_size,
     });
 
-    std::array<VkFormat, 1U> formats { surface.surface_format.format };
+    std::array<VkFormat, 1U> formats { surface->surface_format.format };
     size_t vertex_code_size = 0U;
     uint8_t* vertex_code = read_file("shaders/api-test-ui.vert.spv", &vertex_code_size);
     size_t fragment_code_size = 0U;
@@ -300,7 +293,8 @@ int main() {
         .vs_code_size = vertex_code_size,
         .fs_code = fragment_code,
         .fs_code_size = fragment_code_size,
-        .color_attachments_format = formats
+        .color_attachments_format = formats.data(),
+        .color_attachments_format_count = formats.size()
     });
 
     size_t transmittance_lut_code_size = 0U;
@@ -320,12 +314,12 @@ int main() {
     int channels;
     uint8_t* data = stbi_load("../models/sponza/466164707995436622.jpg", &image_width, &image_height, &channels, 4);
     size_t size = static_cast<size_t>(image_width) * image_height * 4U;
-    memcpy(staging_buffer.mapped_ptr, data, size);
+    memcpy(staging_buffer->mapped_ptr, data, size);
 
     off_t buffer_offset = image_width * image_height * 4;
     data = stbi_load("../models/sponza/715093869573992647.jpg", &image_width, &image_height, &channels, 4);
     size = static_cast<size_t>(image_width) * image_height * 4U;
-    auto* addr = static_cast<void*>(static_cast<uint8_t*>(staging_buffer.mapped_ptr) + buffer_offset);
+    auto* addr = static_cast<void*>(static_cast<uint8_t*>(staging_buffer->mapped_ptr) + buffer_offset);
     memcpy(addr, data, size);
 
     u8 *pixels = nullptr;
@@ -335,7 +329,7 @@ int main() {
 
     off_t ui_offset = 2L * buffer_offset;
     size = static_cast<size_t>(atlas_width) * atlas_height * 4U;
-    addr = static_cast<void*>(static_cast<uint8_t*>(staging_buffer.mapped_ptr) + ui_offset);
+    addr = static_cast<void*>(static_cast<uint8_t*>(staging_buffer->mapped_ptr) + ui_offset);
     memcpy(addr, pixels, size);
 
 
@@ -450,15 +444,15 @@ int main() {
     });
 
 #if VK
-    u32 acc_storage_index = device.get_texture(acc_handle).get_storage_index();
-    u32 result_storage_index = device.get_texture(result_handle).get_storage_index();
+    u32 acc_storage_index = device.get_texture(acc_handle)->get_storage_index();
+    u32 result_storage_index = device.get_texture(result_handle)->get_storage_index();
 #endif
 
-    const device_texture& ui_texture = device.get_texture(ui_texture_handle);
-    const device_texture& transmittance_lut = device.get_texture(transmittance_lut_handle);
+    const device_texture* ui_texture = device.get_texture(ui_texture_handle);
+    const device_texture* transmittance_lut = 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())));
+    io.Fonts->SetTexID(reinterpret_cast<void*>(static_cast<uintptr_t>(ui_texture->get_sampled_index())));
 
 
 #if VK
@@ -491,23 +485,28 @@ int main() {
 
 
     {
-        device_buffer& draws_uniform_buffer = device.get_bindingmodel().get_uniform_buffer(UniformTypes::DRAW);
+        // device_buffer* draws_uniform_buffer = device.get_bindingmodel().get_uniform_buffer(UniformTypes::DRAW);
         {
             struct params {
                 u32 input1;
                 u32 input2;
                 u32 output;
                 u32 pad;
-            } *params = draws_uniform_buffer.allocate<struct params>();
-             params->input1 = device.get_texture(second_texture).get_storage_index();
-             params->input2 = device.get_texture(gpu_texture_handle).get_storage_index();
-             params->output = device.get_texture(output_texture_handle).get_storage_index();
+            // } *params = draws_uniform_buffer->allocate<struct params>();
+            } params;
+             // params->input1 = device.get_texture(second_texture)->get_storage_index();
+             // params->input2 = device.get_texture(gpu_texture_handle)->get_storage_index();
+             // params->output = device.get_texture(output_texture_handle)->get_storage_index();
+             params.input1 = device.get_texture(second_texture)->get_storage_index();
+             params.input2 = device.get_texture(gpu_texture_handle)->get_storage_index();
+             params.output = 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));
         }
 
         {
@@ -516,16 +515,21 @@ int main() {
                 u32 width;
                 u32 height;
                 u32 pad;
-            } *params = draws_uniform_buffer.allocate<struct params>();
-             params->lut_id = transmittance_lut.get_storage_index();
-             params->width = transmittance_lut.width;
-             params->height = transmittance_lut.height;
+            // } *params = draws_uniform_buffer->allocate<struct params>();
+            } params;
+             // params->lut_id = transmittance_lut->get_storage_index();
+             // params->width = transmittance_lut->width;
+             // params->height = transmittance_lut->height;
+             params.lut_id = transmittance_lut->get_storage_index();
+             params.width = transmittance_lut->width;
+             params.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));
         }
     }
 
@@ -651,12 +655,12 @@ int main() {
                 ImDrawList* cmd_list = draw_data->CmdLists[index];
 
                 size_t vertex_bytes_size = sizeof(ImDrawVert) * cmd_list->VtxBuffer.size();
-                u8* vtx_ptr = static_cast<uint8_t*>(vertex_buffer.mapped_ptr) + vertex_offset;
+                u8* vtx_ptr = static_cast<uint8_t*>(vertex_buffer->mapped_ptr) + vertex_offset;
                 memcpy(vtx_ptr, cmd_list->VtxBuffer.Data, vertex_bytes_size);
                 vertex_offset += static_cast<off_t>(vertex_bytes_size);
 
                 size_t index_bytes_size = sizeof(ImDrawIdx) * cmd_list->IdxBuffer.size();
-                memcpy(static_cast<uint8_t*>(index_buffer.mapped_ptr) + index_offset, cmd_list->IdxBuffer.Data, index_bytes_size);
+                memcpy(static_cast<uint8_t*>(index_buffer->mapped_ptr) + index_offset, cmd_list->IdxBuffer.Data, index_bytes_size);
                 index_offset += static_cast<off_t>(index_bytes_size);
             }
         }
@@ -665,12 +669,12 @@ int main() {
         // global uniforms update
         // ======================
         {
-            metadata * const globals = vkdevice::get().get_bindingmodel().get_uniform_buffer(UniformTypes::GLOBAL).allocate<metadata>();
-            memcpy(static_cast<void*>(globals), &main_scene.meta, sizeof(main_scene.meta));
+            // metadata* const globals = vkdevice::get().get_bindingmodel().get_uniform_buffer(UniformTypes::GLOBAL)->allocate<metadata>();
+            // memcpy(static_cast<void*>(globals), &main_scene.meta, sizeof(main_scene.meta));
         }
 
         // TODO: Refactor backbuffer acquisition
-        auto backbuffer = surface.swapchain_images[device.acquire_image_index(surface_handle)];
+        auto backbuffer = surface->swapchain_images[device.acquire_image_index(surface_handle)];
         color_attachment[0] = backbuffer;
 
         // RD_START_CAPTURE;
@@ -698,37 +702,49 @@ int main() {
                     u32 output_id;
                     u32 accumulation_id;
                 };
-                struct params* uniforms = device.get_bindingmodel().get_uniform_buffer(UniformTypes::DRAW).allocate<params>();
-                uniforms->bvh_buffer = main_scene.bvh_buffer_address();
-                uniforms->indices_buffer = main_scene.indices_buffer_address();
-                uniforms->positions_buffer = main_scene.positions_buffer_address();
-                uniforms->normals_buffer = main_scene.normals_buffer_address();
-                uniforms->uvs_buffer = main_scene.uvs_buffer_address();
-                uniforms->materials_buffer = main_scene.materials_buffer_address();
-                uniforms->output_id = (virtual_frame_index == 0U) ? result_storage_index : acc_storage_index;
-                uniforms->accumulation_id = (virtual_frame_index == 0U) ? acc_storage_index : result_storage_index;
+                // struct params* uniforms = device.get_bindingmodel().get_uniform_buffer(UniformTypes::DRAW)->allocate<params>();
+                // uniforms->bvh_buffer = main_scene.bvh_buffer_address();
+                // uniforms->indices_buffer = main_scene.indices_buffer_address();
+                // uniforms->positions_buffer = main_scene.positions_buffer_address();
+                // uniforms->normals_buffer = main_scene.normals_buffer_address();
+                // uniforms->uvs_buffer = main_scene.uvs_buffer_address();
+                // uniforms->materials_buffer = main_scene.materials_buffer_address();
+                // uniforms->output_id = (virtual_frame_index == 0U) ? result_storage_index : acc_storage_index;
+                // uniforms->accumulation_id = (virtual_frame_index == 0U) ? acc_storage_index : result_storage_index;
+                struct params uniforms = {};
+                uniforms.bvh_buffer = main_scene.bvh_buffer_address();
+                uniforms.indices_buffer = main_scene.indices_buffer_address();
+                uniforms.positions_buffer = main_scene.positions_buffer_address();
+                uniforms.normals_buffer = main_scene.normals_buffer_address();
+                uniforms.uvs_buffer = main_scene.uvs_buffer_address();
+                uniforms.materials_buffer = main_scene.materials_buffer_address();
+                uniforms.output_id = (virtual_frame_index == 0U) ? result_storage_index : acc_storage_index;
+                uniforms.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));
             }
 
             {
                 struct params {
                     u32 output_id;
                     u32 accumulation_id;
-                } *uniforms = device.get_bindingmodel().get_uniform_buffer(UniformTypes::DRAW).allocate<params>();
+                // } *uniforms = device.get_bindingmodel().get_uniform_buffer(UniformTypes::DRAW)->allocate<params>();
+                } uniforms;
                 // TODO: Refactor backbuffer acquisition
-                uniforms->output_id = device.get_texture(backbuffer).get_storage_index();
-                uniforms->accumulation_id = (virtual_frame_index == 0U) ? result_storage_index : acc_storage_index;
+                // uniforms->output_id = device.get_texture(backbuffer)->get_storage_index();
+                // uniforms->accumulation_id = (virtual_frame_index == 0U) ? result_storage_index : acc_storage_index;
+                uniforms.output_id = device.get_texture(backbuffer)->get_storage_index();
+                uniforms.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));
             }
         }
 
@@ -741,10 +757,11 @@ int main() {
                 .width = static_cast<uint32_t>(draw_data->DisplaySize.x),
                 .height = static_cast<uint32_t>(draw_data->DisplaySize.y),
             },
-            .color_attachments = color_attachment,
+            .color_attachments = color_attachment.data(),
+            .color_attachments_count = color_attachment.size(),
         });
 
-        auto& draws_uniform_buffer = device.get_bindingmodel().get_uniform_buffer(UniformTypes::DRAW);
+        // device_buffer* draws_uniform_buffer = device.get_bindingmodel().get_uniform_buffer(UniformTypes::DRAW);
         uint32_t vertex_offset = 0;
         uint32_t index_offset = 0;
         for (s32 index = 0U ; index < draw_data->CmdListsCount; index++) {
@@ -752,28 +769,27 @@ int main() {
 
             for (auto& draw_command : cmd_list->CmdBuffer) {
                 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;
-                    };
-                    struct ui_params* ui_param = draws_uniform_buffer.allocate<ui_params>();
-                    *ui_param = ui_params{
-                        .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),
-                    };
-                }
+                struct ui_params {
+                    u64 vertex_buffer;
+                    float scale[2U];
+                    float translate[2U];
+                    uint32_t texture_index;
+                    u32 padding;
+                };
+                // struct ui_params* ui_param = draws_uniform_buffer->allocate<ui_params>();
+                // *ui_param = ui_params{
+                struct ui_params ui_param = ui_params{
+                    .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),
+                };
 
                 command_buffer.draw_indexed({
                     .pipeline = graphics,
@@ -782,7 +798,7 @@ int main() {
                     .vertex_offset = draw_command.VtxOffset + vertex_offset,
                     .index_offset = draw_command.IdxOffset + index_offset,
                     .instance_count = 1U,
-                });
+                }, &ui_param, sizeof(ui_param));
             }
             vertex_offset += cmd_list->VtxBuffer.size();
             index_offset += cmd_list->IdxBuffer.size();
diff --git a/src/vk-bindless.cpp b/src/vk-bindless.cpp
index 9e517df..8f29834 100644
--- a/src/vk-bindless.cpp
+++ b/src/vk-bindless.cpp
@@ -3,7 +3,7 @@
 #include "vk-device.hpp"
 #include "vk-utils.hpp"
 
-device_buffer& bindless_model::get_uniform_buffer(enum UniformTypes type) const {
+device_buffer* bindless_model::get_uniform_buffer(enum UniformTypes type) const {
     return vkdevice::get().get_buffer(uniform_buffers[type]);
 }
 
@@ -185,7 +185,7 @@ void bindless_model::init() {
     {
         uniform_buffers[UniformTypes::GLOBAL] = render_device.create_buffer({
             .size = globals_uniform_buffer_size,
-            .usages = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
+            .usages = 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 = "global uniform buffer",
@@ -198,7 +198,7 @@ void bindless_model::init() {
     {
         uniform_buffers[UniformTypes::PASS] = render_device.create_buffer({
             .size = passes_uniform_buffer_size,
-            .usages = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
+            .usages = 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 = "passes uniform buffer"
@@ -211,7 +211,7 @@ void bindless_model::init() {
     {
         uniform_buffers[UniformTypes::DRAW] = render_device.create_buffer({
             .size = draws_uniform_buffer_size,
-            .usages = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
+            .usages = 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 = "draws uniform buffer",
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);
 }
 
diff --git a/src/vk-device.cpp b/src/vk-device.cpp
index 9c1b7a4..988d344 100644
--- a/src/vk-device.cpp
+++ b/src/vk-device.cpp
@@ -1,8 +1,42 @@
 #include "vk-device.hpp"
+#include "vk-device-types.hpp"
+#include "vulkan-loader.hpp"
 
-#define VMA_IMPLEMENTATION
 #include <vk_mem_alloc.h>
 
+device_semaphore create_semaphore(VkDevice device, const semaphore_desc& desc, const char* name) {
+    device_semaphore semaphore {
+        .value = desc.initial_value,
+    };
+    VkSemaphoreTypeCreateInfo semaphore_type_create_info{
+        .sType         = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
+        .pNext         = nullptr,
+        .semaphoreType = desc.type,
+        .initialValue  = desc.initial_value,
+    };
+
+    VkSemaphoreCreateInfo create_info{
+        .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
+        .pNext = &semaphore_type_create_info,
+        .flags = 0U,
+    };
+
+    VKCHECK(vkCreateSemaphore(device, &create_info, nullptr, &semaphore.vk_semaphore));
+
+    if (name) {
+        VkDebugUtilsObjectNameInfoEXT object_name{
+            .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
+            .pNext = nullptr,
+            .objectType = VK_OBJECT_TYPE_SEMAPHORE,
+            .objectHandle = reinterpret_cast<uint64_t>(semaphore.vk_semaphore),
+            .pObjectName = name,
+        };
+        vkSetDebugUtilsObjectNameEXT(device, &object_name);
+    }
+    return semaphore;
+}
+
+
 static VkShaderModule create_shader_module(VkDevice device, uint8_t* code, size_t code_size) {
     VkShaderModule shader_module;
     VkShaderModuleCreateInfo create_info{
@@ -37,34 +71,46 @@ void vkdevice::init() {
 
     create_instance();
 
+    // create debug layer callback
 #ifdef _DEBUG
-    create_debug_layer_callback();
+    {
+    VkDebugUtilsMessengerCreateInfoEXT create_info{
+        .sType           = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
+        .pNext           = nullptr,
+        .flags           = 0U,
+        .messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT |
+                           VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT,
+        .messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
+                       VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT |
+                       VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT,
+        .pfnUserCallback = debug_callback,
+        .pUserData       = nullptr,
+    };
+
+    VKCHECK(vkCreateDebugUtilsMessengerEXT(instance, &create_info, nullptr, &debug_messenger));
+    }
 #endif // _DEBUG
 
     create_device();
 
-    create_memory_allocator();
-
-    bindless.init();
-
-    auto semaphore = create_semaphore({
-        .type = VK_SEMAPHORE_TYPE_TIMELINE,
-    }, "timeline_semaphore");
-    timeline_semaphore = get_semaphore(semaphore);
+    fence = create_semaphore(
+        device,
+        {
+            .type = VK_SEMAPHORE_TYPE_TIMELINE,
+        }, "timeline_semaphore"
+    );
 }
 
 void vkdevice::deinit() {
     vkDeviceWaitIdle(device);
 
-    bindless.deinit();
-
     vmaDestroyAllocator(gpu_allocator);
 
     for (auto& queue : queues) {
         vkDestroyCommandPool(device, queue.command_pool, nullptr);
     }
 
-    vkDestroySemaphore(device, timeline_semaphore.vk_semaphore, nullptr);
+    vkDestroySemaphore(device, fence.vk_semaphore, nullptr);
 
     vkDestroyDevice(device, nullptr);
 
@@ -81,19 +127,20 @@ void vkdevice::wait() {
 };
 
 void vkdevice::wait_for_fence(u64 value) {
-    VkSemaphoreWaitInfoKHR semaphore_wait_info {
-        .type = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR,
+    VkSemaphoreWaitInfo semaphore_wait_info {
+        .sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
+        .pNext = nullptr,
+        .flags = 0U,
+        .semaphoreCount = 1U,
+        .pSemaphores    = &fence.vk_semaphore,
+        .pValues        = &value,
     };
-    semaphore_wait_info.pSemaphores    = &semaphore;
-    semaphore_wait_info.semaphoreCount = 1;
-    semaphore_wait_info.pValues        = &value;
-    VK_CHECK(vkWaitSemaphoresKHR(device->get_handle(), &semaphore_wait_info, UINT64_MAX));
+
+    VKCHECK(vkWaitSemaphores(device, &semaphore_wait_info, UINT64_MAX));
 }
 
 handle<device_texture> vkdevice::create_texture(const texture_desc& desc) {
     device_texture device_texture;
-    // TODO: This must always be present since we want to display images in ImGui
-    const_cast<texture_desc&>(desc).usages |= VK_IMAGE_USAGE_SAMPLED_BIT;
     device_texture.init(desc);
 
     return textures.add(device_texture);
@@ -113,12 +160,16 @@ handle<device_buffer> vkdevice::create_buffer(const buffer_desc& desc) {
         .name   = desc.name,
     };
 
+    VkBufferUsageFlags2CreateInfo usage_flags2 {
+        .sType = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR,
+        .usage = desc.usages,
+    };
     VkBufferCreateInfo create_info{
         .sType                 = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-        .pNext                 = nullptr,
+        .pNext                 = &usage_flags2,
         .flags                 = 0U,
         .size                  = desc.size,
-        .usage                 = desc.usages,
+        .usage                 = 0U,
         .sharingMode           = VK_SHARING_MODE_EXCLUSIVE,
         .queueFamilyIndexCount = 0,
         .pQueueFamilyIndices   = nullptr,
@@ -144,7 +195,7 @@ handle<device_buffer> vkdevice::create_buffer(const buffer_desc& desc) {
     VKCHECK(vmaCreateBuffer(gpu_allocator, &create_info, &alloc_create_info, &device_buffer.vk_buffer, &device_buffer.alloc, &alloc_info));
     vmaSetAllocationName(render_device.get_allocator(), device_buffer.alloc, desc.name);
 
-    if ((desc.usages & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) != 0U) {
+    if ((desc.usages & VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT) != 0U) {
         VkBufferDeviceAddressInfo address_info {
             .sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
             .pNext = nullptr,
@@ -263,8 +314,8 @@ handle<device_pipeline> vkdevice::create_graphics_pipeline(const graphics_pipeli
         .sType                   = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,
         .pNext                   = nullptr,
         .viewMask                = 0U,
-        .colorAttachmentCount    = static_cast<uint32_t>(desc.color_attachments_format.size()),
-        .pColorAttachmentFormats = desc.color_attachments_format.data(),
+        .colorAttachmentCount    = static_cast<uint32_t>(desc.color_attachments_format_count),
+        .pColorAttachmentFormats = desc.color_attachments_format,
         .depthAttachmentFormat   = VK_FORMAT_UNDEFINED,
         .stencilAttachmentFormat = VK_FORMAT_UNDEFINED,
     };
@@ -284,7 +335,7 @@ handle<device_pipeline> vkdevice::create_graphics_pipeline(const graphics_pipeli
         .pDepthStencilState  = nullptr,
         .pColorBlendState    = &color_blend_state_create_info,
         .pDynamicState       = &dynamic_state_create_info,
-        .layout              = bindless.global_layout,
+        // .layout              = bindless.global_layout,
         .renderPass          = nullptr,
         .subpass             = 0U,
         .basePipelineHandle  = nullptr,
@@ -331,7 +382,7 @@ handle<device_pipeline> vkdevice::create_compute_pipeline(const compute_pipeline
         .pNext              = nullptr,
         .flags              = 0U,
         .stage              = stage_create_info,
-        .layout             = bindless.global_layout,
+        // .layout             = bindless.global_layout,
         .basePipelineHandle = nullptr,
         .basePipelineIndex  = 0,
     };
@@ -376,172 +427,59 @@ handle<device_surface> vkdevice::create_surface(const surface_desc& desc) {
     assert(surface_desc::max_image_count >= device_surface.image_count);
 
     for (uint32_t index = 0u; index < device_surface.image_count; index++) {
-        device_surface.acquire_semaphores[index] = create_semaphore({
-            .type = VK_SEMAPHORE_TYPE_BINARY,
-        }, "acquire_semaphore");
-        device_surface.submit_semaphores[index]  = create_semaphore({
-            .type = VK_SEMAPHORE_TYPE_BINARY,
-        }, "submit_semaphore");
+        device_surface.acquire_semaphores[index] = create_semaphore(
+            device,
+            {
+                .type = VK_SEMAPHORE_TYPE_BINARY,
+            }, "acquire_semaphore"
+        );
+        device_surface.submit_semaphores[index]  = create_semaphore(
+            device,
+            {
+                .type = VK_SEMAPHORE_TYPE_BINARY,
+            }, "submit_semaphore"
+        );
     }
 
     return surfaces.add(device_surface);
 }
 
-handle<device_semaphore> vkdevice::create_semaphore(const semaphore_desc& desc, const char* name) {
-    device_semaphore semaphore {
-        .value = desc.initial_value,
-    };
-    VkSemaphoreTypeCreateInfo semaphore_type_create_info{
-        .sType         = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
-        .pNext         = nullptr,
-        .semaphoreType = desc.type,
-        .initialValue  = desc.initial_value,
-    };
-
-    VkSemaphoreCreateInfo create_info{
-        .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
-        .pNext = &semaphore_type_create_info,
-        .flags = 0U,
-    };
-
-    VKCHECK(vkCreateSemaphore(device, &create_info, nullptr, &semaphore.vk_semaphore));
-
-    if (name) {
-        VkDebugUtilsObjectNameInfoEXT object_name{
-            .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
-            .pNext = nullptr,
-            .objectType = VK_OBJECT_TYPE_SEMAPHORE,
-            .objectHandle = reinterpret_cast<uint64_t>(semaphore.vk_semaphore),
-            .pObjectName = name,
-        };
-        vkSetDebugUtilsObjectNameEXT(device, &object_name);
-    }
-    return semaphores.add(semaphore);
-}
-
 void vkdevice::destroy_texture(handle<device_texture> handle) {
-    auto& texture = get_texture(handle);
+    device_texture* texture = get_texture(handle);
 
-    texture.release();
+    texture->release();
     textures.remove(handle);
 }
 
 void vkdevice::destroy_buffer(handle<device_buffer> handle) {
-    const auto& buffer = get_buffer(handle);
+    device_buffer* buffer = get_buffer(handle);
 
-    vmaDestroyBuffer(gpu_allocator, buffer.vk_buffer, buffer.alloc);
+    vmaDestroyBuffer(gpu_allocator, buffer->vk_buffer, buffer->alloc);
     buffers.remove(handle);
 }
 
 void vkdevice::destroy_pipeline(handle<device_pipeline> handle) {
-    const auto& pipeline = vkdevice::get_pipeline(handle);
+    const device_pipeline* pipeline = get_pipeline(handle);
 
-    vkDestroyPipeline(device, pipeline.vk_pipeline, nullptr);
+    vkDestroyPipeline(device, pipeline->vk_pipeline, nullptr);
     pipelines.remove(handle);
 }
 
-void vkdevice::destroy_semaphore(handle<device_semaphore> handle) {
-    auto& semaphore = vkdevice::get_semaphore(handle);
-
-    vkDestroySemaphore(device, semaphore.vk_semaphore, nullptr);
-    semaphores.remove(handle);
-}
-
 void vkdevice::destroy_surface(handle<device_surface> handle) {
-    auto& surface = vkdevice::get_surface(handle);
+    device_surface* surface = get_surface(handle);
 
-    for (auto texture_index{0U}; texture_index < surface.image_count; texture_index++) {
-        auto texture_handle = surface.swapchain_images[texture_index];
-        destroy_texture(texture_handle);
-    }
+    for (u32 index = 0U; index < surface->image_count; index++) {
+        destroy_texture(surface->swapchain_images[index]);
 
-    for (uint32_t index = 0u; index < surface.image_count; index++) {
-        destroy_semaphore(surface.acquire_semaphores[index]);
-        destroy_semaphore(surface.submit_semaphores[index]);
+        vkDestroySemaphore(device, surface->acquire_semaphores[index].vk_semaphore, nullptr);
+        vkDestroySemaphore(device, surface->submit_semaphores[index].vk_semaphore, nullptr);
     }
 
-    vkDestroySwapchainKHR(device, surface.vk_swapchain, nullptr);
+    vkDestroySwapchainKHR(device, surface->vk_swapchain, nullptr);
 
-    vkDestroySurfaceKHR(instance, surface.vk_surface, nullptr);
+    vkDestroySurfaceKHR(instance, surface->vk_surface, nullptr);
 }
 
-// uint64_t vkdevice::submit(std::span<command_buffer> buffers, handle<device_semaphore> wait_handle, handle<device_semaphore> signal_handle, handle<device_semaphore> fence_handle) {
-//     assert((max_submitable_command_buffers - buffers.size()) >= 0);
-//     const auto queue_type = buffers[0].queue_type;
-// 
-//     VkCommandBufferSubmitInfo command_buffers_info[buffers.size()];
-// 
-//     for (auto index{ 0U }; index < buffers.size(); index++) {
-//         assert(queue_type == buffers[index].queue_type);
-// 
-//         auto& command_buffer_info         = command_buffers_info[index];
-//         command_buffer_info.sType         = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO;
-//         command_buffer_info.pNext         = nullptr;
-//         command_buffer_info.commandBuffer = buffers[index].vk_command_buffer;
-//         command_buffer_info.deviceMask    = 0U;
-//     }
-// 
-//     VkSemaphoreSubmitInfo wait_semaphore_info{
-//         .sType       = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
-//         .pNext       = nullptr,
-//         .stageMask   = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT,
-//         .deviceIndex = 0U,
-//     };
-// 
-//     VkSemaphoreSubmitInfo signal_semaphore_infos[2U];
-// 
-//     VkSubmitInfo2 submit_info{
-//         .sType                    = VK_STRUCTURE_TYPE_SUBMIT_INFO_2,
-//         .pNext                    = nullptr,
-//         .flags                    = 0U,
-//         .waitSemaphoreInfoCount   = 0U,
-//         .commandBufferInfoCount   = static_cast<uint32_t>(buffers.size()),
-//         .pCommandBufferInfos      = command_buffers_info,
-//         .pSignalSemaphoreInfos    = signal_semaphore_infos,
-//     };
-// 
-//     if (wait_handle.is_valid()) {
-//         const auto& wait = vkdevice::get_render_device().get_semaphore(wait_handle);
-//         wait_semaphore_info.semaphore      = wait.vk_semaphore;
-//         wait_semaphore_info.value          = wait.value;
-//         submit_info.waitSemaphoreInfoCount++;
-//         submit_info.pWaitSemaphoreInfos    = &wait_semaphore_info;
-//     }
-// 
-//     if (signal_handle.is_valid()) {
-//         auto& signal = vkdevice::get_render_device().get_semaphore(signal_handle);
-//         signal_semaphore_infos[0U] = {
-//             .sType          = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
-//             .pNext          = nullptr,
-//             .semaphore      = signal.vk_semaphore,
-//             .value          = signal.value,
-//             .stageMask      = VK_PIPELINE_STAGE_2_NONE,
-//             .deviceIndex    = 0U,
-//         };
-//         submit_info.signalSemaphoreInfoCount++;
-//     }
-// 
-//     uint64_t ret = -1;
-// 
-//     if (fence_handle.is_valid()) {
-//         auto& fence = vkdevice::get_render_device().get_semaphore(fence_handle);
-//         auto fence_index = submit_info.signalSemaphoreInfoCount;
-//         signal_semaphore_infos[fence_index] = {
-//             .sType          = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
-//             .pNext          = nullptr,
-//             .semaphore      = fence.vk_semaphore,
-//             .value          = ++fence.value,
-//             .stageMask      = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
-//             .deviceIndex    = 0U,
-//         };
-//         ret = fence.value;
-//     }
-// 
-//     VKCHECK(vkQueueSubmit2(queues[static_cast<uint32_t>(queue_type)].vk_queue, 1, &submit_info, nullptr));
-// 
-//     return ret;
-// }
-
 uint64_t vkdevice::submit(command_buffer* cmd_buffers, uint32_t count) {
     assert((max_submitable_command_buffers - count) >= 0);
     const auto queue_type = cmd_buffers[0].queue_type;
@@ -569,7 +507,6 @@ uint64_t vkdevice::submit(command_buffer* cmd_buffers, uint32_t count) {
         .pCommandBufferInfos      = command_buffers_info,
     };
 
-    auto& fence = timeline_semaphore;
     VkSemaphoreSubmitInfo signal_semaphore_infos[] = {
         {
             .sType       = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
@@ -605,8 +542,8 @@ uint64_t vkdevice::submit_before_present(handle<device_surface> surface_handle,
         command_buffer_info.deviceMask    = 0U;
     }
 
-    const device_surface& surface = get_surface(surface_handle);
-    device_semaphore& wait = get_semaphore(surface.acquire_semaphores[surface.frame_index]);
+    const device_surface* surface = get_surface(surface_handle);
+    const device_semaphore& wait = surface->acquire_semaphores[surface->frame_index];
     VkSemaphoreSubmitInfo wait_semaphore_info = {
             .sType       = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
             .pNext       = nullptr,
@@ -626,8 +563,7 @@ uint64_t vkdevice::submit_before_present(handle<device_surface> surface_handle,
         .pCommandBufferInfos      = command_buffers_info,
     };
 
-    auto& fence = timeline_semaphore;
-    auto& signal = get_semaphore(surface.submit_semaphores[surface.frame_index]);
+    const device_semaphore& signal = surface->submit_semaphores[surface->frame_index];
     VkSemaphoreSubmitInfo signal_semaphore_infos[] = {
         {
             .sType       = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
@@ -655,25 +591,25 @@ uint64_t vkdevice::submit_before_present(handle<device_surface> surface_handle,
 }
 
 void vkdevice::present(handle<device_surface> surface_handle) {
-    auto& surface = render_device.get_surface(surface_handle);
+    device_surface* surface = render_device.get_surface(surface_handle);
     VkResult result;
     VkPresentInfoKHR present_info{
         .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
         .pNext = nullptr,
         .swapchainCount = 1U,
-        .pSwapchains = &surface.vk_swapchain,
-        .pImageIndices = &surface.image_index,
+        .pSwapchains = &surface->vk_swapchain,
+        .pImageIndices = &surface->image_index,
         .pResults = &result,
     };
 
-    const auto& semaphore = get_semaphore(surface.submit_semaphores[surface.frame_index]);
+    const device_semaphore& semaphore = surface->submit_semaphores[surface->frame_index];
     present_info.waitSemaphoreCount = 1U;
     present_info.pWaitSemaphores = &semaphore.vk_semaphore;
 
     VKCHECK(vkQueuePresentKHR(queues[static_cast<uint32_t>(QueueType::GRAPHICS)].vk_queue, &present_info));
 
     VKCHECK(result);
-    surface.frame_index = (surface.frame_index + 1) % surface.image_count;
+    surface->frame_index = (surface->frame_index + 1) % surface->image_count;
 }
 
 // private
@@ -738,14 +674,15 @@ void vkdevice::create_swapchain(const surface_desc& desc, device_surface& surfac
     }
 
     {
-        auto supported = false;
-        auto supported_formats_count = 0U;
+        bool supported = false;
+        u32 supported_formats_count = 0U;
         VKCHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, vk_surface, &supported_formats_count, nullptr));
 
-        std::vector<VkSurfaceFormatKHR> supported_formats{ supported_formats_count };
-        VKCHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, vk_surface, &supported_formats_count, supported_formats.data()));
+        VkSurfaceFormatKHR* supported_formats = static_cast<VkSurfaceFormatKHR*>(_malloca(supported_formats_count * sizeof(VkSurfaceFormatKHR)));
+        VKCHECK(vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, vk_surface, &supported_formats_count, supported_formats));
 
-        for (auto& surface_format : supported_formats) {
+        for (u32 format_index = 0U; format_index < supported_formats_count; format_index++) {
+            VkSurfaceFormatKHR surface_format = supported_formats[format_index];
             if (surface_format.format == desc.surface_format.format &&
                 surface_format.colorSpace == desc.surface_format.colorSpace) {
                 supported = true;
@@ -757,14 +694,15 @@ void vkdevice::create_swapchain(const surface_desc& desc, device_surface& surfac
     }
 
     {
-        auto supported = false;
-        auto supported_present_modes_count = 0U;
+        bool supported = false;
+        u32 supported_present_modes_count = 0U;
         VKCHECK(vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device, vk_surface, &supported_present_modes_count, nullptr));
 
-        std::vector<VkPresentModeKHR> supported_present_modes{ supported_present_modes_count };
-        VKCHECK(vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device, vk_surface, &supported_present_modes_count, supported_present_modes.data()));
+        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));
 
-        for (auto& present_mode : 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];
             if (present_mode == desc.present_mode) {
                 supported = true;
                 break;
@@ -805,10 +743,10 @@ void vkdevice::create_swapchain(const surface_desc& desc, device_surface& surfac
     vkGetSwapchainImagesKHR(device, surface.vk_swapchain, &surface.image_count, nullptr);
     assert(surface.image_count <= surface_desc::max_image_count);
 
-    std::vector<VkImage> images {surface.image_count};
-    vkGetSwapchainImagesKHR(device, surface.vk_swapchain, &surface.image_count, images.data());
+    VkImage* images = static_cast<VkImage*>(_malloca(surface.image_count * sizeof(VkImage)));
+    vkGetSwapchainImagesKHR(device, surface.vk_swapchain, &surface.image_count, images);
 
-    for (auto index {0U}; index < surface.image_count; index++) {
+    for (u32 index = 0U; index < surface.image_count; index++) {
         surface.swapchain_images[index] = create_texture({
             .width = extent.width,
             .height = extent.height,
@@ -835,14 +773,14 @@ void vkdevice::create_instance() {
         .apiVersion         = VK_API_VERSION_1_3,
     };
 
-    constexpr const char* instance_layers[]{
+    const char* instance_layers[]{
         "VK_LAYER_KHRONOS_validation",
     };
 
-    constexpr const char* instance_extensions[]{
+    const char* instance_extensions[]{
         VK_EXT_DEBUG_UTILS_EXTENSION_NAME,
-        "VK_KHR_surface",
-        "VK_KHR_win32_surface"
+        VK_KHR_SURFACE_EXTENSION_NAME,
+        VK_KHR_WIN32_SURFACE_EXTENSION_NAME
     };
 
     VkInstanceCreateInfo create_info{
@@ -862,7 +800,34 @@ void vkdevice::create_instance() {
 }
 
 void vkdevice::create_device() {
-    pick_physical_device();
+    // pick physical device
+    // TODO: change put this in another scope
+    VkPhysicalDeviceDescriptorHeapPropertiesEXT descriptor_heap_props {
+        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT,
+    };
+    {
+        u32 physical_devices_count = 0U;
+        vkEnumeratePhysicalDevices(instance, &physical_devices_count, nullptr);
+        assert(physical_devices_count > 0);
+
+        VkPhysicalDevice* physical_devices = static_cast<VkPhysicalDevice*>(_malloca(physical_devices_count * sizeof(VkPhysicalDevice)));
+        vkEnumeratePhysicalDevices(instance, &physical_devices_count, physical_devices);
+
+        physical_device_props = VkPhysicalDeviceProperties2 {
+            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
+            .pNext = &descriptor_heap_props,
+        };
+
+        for (u32 physical_device_index = 0U; physical_device_index < physical_devices_count; physical_device_index++) {
+            VkPhysicalDevice physical_dev = physical_devices[physical_device_index];
+            if (device_support_features(physical_dev)) {
+                physical_device = physical_dev;
+                break;
+            }
+        }
+
+        assert(true);
+    }
 
     float                   queue_priority = 1.f;
     VkDeviceQueueCreateInfo queue_create_infos[static_cast<uint32_t>(QueueType::MAX)];
@@ -875,17 +840,17 @@ void vkdevice::create_device() {
         queue_create_info.pQueuePriorities = &queue_priority;
     }
 
-    auto queue_properties_count = 0U;
+    u32 queue_properties_count = 0U;
     vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_properties_count, nullptr);
 
-    std::vector<VkQueueFamilyProperties> queue_properties{ queue_properties_count };
-    vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_properties_count, queue_properties.data());
+    VkQueueFamilyProperties* queue_properties = static_cast<VkQueueFamilyProperties*>(_malloca(queue_properties_count * sizeof(VkQueueFamilyProperties)));
+    vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_properties_count, queue_properties);
 
-    for (auto index{ 0U }; index < static_cast<uint32_t>(QueueType::MAX); index++) {
-        auto& queue = queues[index];
+    for (u32 index = 0U; index < static_cast<uint32_t>(QueueType::MAX); index++) {
+        queue& queue = queues[index];
 
-        for (auto properties_index{ 0U }; properties_index < queue_properties_count; properties_index++) {
-            auto& queue_property = queue_properties[properties_index];
+        for (u32 properties_index = 0U; properties_index < queue_properties_count; properties_index++) {
+            VkQueueFamilyProperties queue_property = queue_properties[properties_index];
 
             if ((queue_property.queueFlags & queue.usages) == queue.usages) {
                 queue_create_infos[index].queueFamilyIndex = queue.index = properties_index;
@@ -894,9 +859,10 @@ void vkdevice::create_device() {
         }
     }
 
-    constexpr const char* device_extensions[] = {
+    const char* device_extensions[] = {
         VK_KHR_SWAPCHAIN_EXTENSION_NAME,
-        // VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME
+        VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME,
+        VK_KHR_MAINTENANCE_5_EXTENSION_NAME,
     };
 
     VkPhysicalDeviceVulkan12Features physical_device_12_features{
@@ -939,78 +905,72 @@ void vkdevice::create_device() {
         vkGetDeviceQueue(device, queue.index, 0, &queue.vk_queue);
     }
 
-    create_command_pools();
-}
-
-void vkdevice::create_memory_allocator() {
-    VmaVulkanFunctions functions = {
-        .vkGetInstanceProcAddr = vkGetInstanceProcAddr,
-        .vkGetDeviceProcAddr = vkGetDeviceProcAddr,
-    };
-    VmaAllocatorCreateInfo create_info{
-        .flags            = VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT,
-        .physicalDevice   = physical_device,
-        .device           = device,
-        .pVulkanFunctions = &functions,
-        .instance         = instance,
-        .vulkanApiVersion = VK_API_VERSION_1_2,
-    };
-
-    VKCHECK(vmaCreateAllocator(&create_info, &gpu_allocator));
-}
-
-void vkdevice::create_command_pools() {
-    VkCommandPoolCreateInfo create_info{
-        .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
-    };
+    // create command pool
+    {
+        VkCommandPoolCreateInfo command_pool_create_info{
+            .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
+            .pNext = nullptr,
+            .flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
+        };
 
-    for (auto& queue : queues) {
-        create_info.queueFamilyIndex = queue.index;
+        for (queue& queue : queues) {
+            command_pool_create_info.queueFamilyIndex = queue.index;
 
-        VKCHECK(vkCreateCommandPool(device, &create_info, nullptr, &queue.command_pool));
+            VKCHECK(vkCreateCommandPool(device, &command_pool_create_info, nullptr, &queue.command_pool));
+        }
     }
-}
 
-void vkdevice::pick_physical_device() {
-    auto physical_devices_count = 0U;
-    vkEnumeratePhysicalDevices(instance, &physical_devices_count, nullptr);
-
-    assert(physical_devices_count > 0);
-
-    std::vector<VkPhysicalDevice> physical_devices{ physical_devices_count };
-    vkEnumeratePhysicalDevices(instance, &physical_devices_count, physical_devices.data());
+    // create memory allocator
+    {
+        VmaVulkanFunctions functions = {
+            .vkGetInstanceProcAddr = vkGetInstanceProcAddr,
+            .vkGetDeviceProcAddr = vkGetDeviceProcAddr,
+        };
+        VmaAllocatorCreateInfo allocator_create_info{
+            .flags            = VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT,
+            .physicalDevice   = physical_device,
+            .device           = device,
+            .pVulkanFunctions = &functions,
+            .instance         = instance,
+            .vulkanApiVersion = VK_API_VERSION_1_2,
+        };
 
-    physical_device_props = VkPhysicalDeviceProperties2 {
-        .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
-        .pNext = nullptr,
-    };
+        VKCHECK(vmaCreateAllocator(&allocator_create_info, &gpu_allocator));
+    }
 
-    for (auto& physical_dev : physical_devices) {
-        if (device_support_features(physical_dev)) {
-            physical_device = physical_dev;
+    create_heaps(descriptor_heap_props);
+}
 
-            return;
-        }
+void vkdevice::create_heaps(VkPhysicalDeviceDescriptorHeapPropertiesEXT& descriptor_heap_props) {
+    // create image heap
+    {
+        sampler_heap = create_buffer({
+            .size = descriptor_heap_props.minResourceHeapReservedRange + max_images_count * descriptor_heap_props.imageDescriptorSize,
+            .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_usage = VMA_MEMORY_USAGE_GPU_ONLY,
+            .name = "image descriptor_heap",
+        });
     }
 
-    assert(true);
+    // create sampler heap
+    {
+        sampler_heap = create_buffer({
+            .size = descriptor_heap_props.minSamplerHeapReservedRange + max_samplers_count * descriptor_heap_props.samplerDescriptorSize,
+            .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_usage = VMA_MEMORY_USAGE_GPU_ONLY,
+            .name = "sampler descriptor_heap",
+        });
+    }
 }
 
+
 bool vkdevice::device_support_features(VkPhysicalDevice physical_dev) {
     // limits
-    {
-        vkGetPhysicalDeviceProperties2(physical_dev, &physical_device_props);
-
-        VkPhysicalDeviceLimits* limits = &physical_device_props.properties.limits;
-        if (limits->maxPerStageDescriptorSampledImages < 0x10000 ||
-            limits->maxPerStageDescriptorStorageImages < 0x10000 ||
-            limits->maxDescriptorSetSampledImages      < 0x10000 ||
-            limits->maxDescriptorSetStorageImages      < 0x10000) {
-            return false;
-        }
-    }
+    vkGetPhysicalDeviceProperties2(physical_dev, &physical_device_props);
 
     // Vulkan 1.2 physical device features support
     {
@@ -1025,7 +985,6 @@ bool vkdevice::device_support_features(VkPhysicalDevice physical_dev) {
 
         vkGetPhysicalDeviceFeatures2(physical_dev, &physical_device_features);
 
-        // clang-format off
         if (vulkan_12_features.bufferDeviceAddress                          == VK_FALSE ||
             vulkan_12_features.runtimeDescriptorArray                       == VK_FALSE ||
             vulkan_12_features.shaderStorageImageArrayNonUniformIndexing    == VK_FALSE ||
@@ -1035,7 +994,6 @@ bool vkdevice::device_support_features(VkPhysicalDevice physical_dev) {
             vulkan_12_features.imagelessFramebuffer                         == VK_FALSE) {
             return false;
         }
-        // clang-format on
     }
 
     // Vulkan 1.3 physical device features support
@@ -1061,25 +1019,6 @@ bool vkdevice::device_support_features(VkPhysicalDevice physical_dev) {
     return true;
 }
 
-void vkdevice::create_debug_layer_callback() {
-#ifdef _DEBUG
-    VkDebugUtilsMessengerCreateInfoEXT create_info{
-        .sType           = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
-        .pNext           = nullptr,
-        .flags           = 0U,
-        .messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT |
-                           VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT,
-        .messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
-                       VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT |
-                       VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT,
-        .pfnUserCallback = debug_callback,
-        .pUserData       = nullptr,
-    };
-
-    VKCHECK(vkCreateDebugUtilsMessengerEXT(instance, &create_info, nullptr, &debug_messenger));
-#endif // _DEBUG
-}
-
 
 idlist<> device_texture::sampled_indices = {};
 idlist<> device_texture::storage_indices = {};
@@ -1087,7 +1026,6 @@ idlist<> device_sampler::sampler_indices = {};
 
 void device_texture::init(const texture_desc& desc) {
     auto& render_device = vkdevice::get();
-    const auto& bindless = render_device.get_bindingmodel();
     auto* device = render_device.get_device();
 
     vk_image = desc.vk_image;
@@ -1150,59 +1088,91 @@ void device_texture::init(const texture_desc& desc) {
         vkSetDebugUtilsObjectNameEXT(device, &object_name);
     }
 
-    create_views();
+    VkImageViewCreateInfo image_view_create_info{
+        .sType      = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+        .pNext      = nullptr,
+        .flags      = 0U,
+        .image      = vk_image,
+        .viewType   = VK_IMAGE_VIEW_TYPE_2D,
+        .format     = format,
+        .components = {
+            .r = VK_COMPONENT_SWIZZLE_R,
+            .g = VK_COMPONENT_SWIZZLE_G,
+            .b = VK_COMPONENT_SWIZZLE_B,
+            .a = VK_COMPONENT_SWIZZLE_A,
+        },
+        .subresourceRange = {
+            .aspectMask     = aspects,
+            .baseMipLevel   = 0,
+            .levelCount     = 1,
+            .baseArrayLayer = 0,
+            .layerCount     = 1,
+        },
+    };
+    // create views
+    {
+        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]));
+        }
+
+        image_view_create_info.subresourceRange.baseMipLevel = 0;
+        image_view_create_info.subresourceRange.levelCount   = mips;
+        VKCHECK(vkCreateImageView(device, &image_view_create_info, nullptr, &whole_view));
+    }
 
     // TODO: Handle mips views
-    VkDescriptorImageInfo images_info[]{
-        {
-            nullptr,
-            whole_view,
-            VK_IMAGE_LAYOUT_GENERAL,
-        },
+    VkImageDescriptorInfoEXT image_info = {
+        .sType  = VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT,
+        .pNext  = nullptr,
+        .pView  = &image_view_create_info,
+        .layout = VK_IMAGE_LAYOUT_GENERAL,
     };
 
-    std::vector<VkWriteDescriptorSet> write_descriptor_sets;
+    u32 descriptors_count = 0U;
+    VkResourceDescriptorInfoEXT resource_descriptor_infos[2U];
+    VkHostAddressRangeEXT resources_address[2U];
     if ((desc.usages & VK_IMAGE_USAGE_STORAGE_BIT) != 0) {
-        storage_index = storage_indices.add();
+        resource_descriptor_infos[descriptors_count] = VkResourceDescriptorInfoEXT{
+            .sType = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT,
+            .pNext = nullptr,
+            .type  = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
+            .data  = {
+                .pImage = &image_info,
+            },
+        };
 
-        write_descriptor_sets.push_back({
-            .sType            = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
-            .pNext            = nullptr,
-            // .dstSet           = bindless.sets[BindlessSetType::GLOBAL],
-            .dstSet           = bindless.global_set,
-            .dstBinding       = 2U,
-            .dstArrayElement  = storage_index.id,
-            .descriptorCount  = sizeof(images_info) / sizeof(VkDescriptorImageInfo),
-            .descriptorType   = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
-            .pImageInfo       = images_info,
-            .pBufferInfo      = nullptr,
-            .pTexelBufferView = nullptr,
-        });
+        // resource_address[descriptors_count] = {
+        //     .address = storage_indices.add(),
+        //     .size    = ,
+        // }
+
+        descriptors_count++;
     }
     if ((desc.usages & VK_IMAGE_USAGE_SAMPLED_BIT) != 0) {
-        sampled_index = sampled_indices.add();
+        resource_descriptor_infos[descriptors_count] = VkResourceDescriptorInfoEXT{
+            .sType = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT,
+            .pNext = nullptr,
+            .type  = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
+            .data  = {
+                .pImage = &image_info,
+            },
+        };
 
-        write_descriptor_sets.push_back({
-            .sType            = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
-            .pNext            = nullptr,
-            // .dstSet           = bindless.sets[BindlessSetType::GLOBAL],
-            .dstSet           = bindless.global_set,
-            .dstBinding       = 1U,
-            .dstArrayElement  = sampled_index.id,
-            .descriptorCount  = sizeof(images_info) / sizeof(VkDescriptorImageInfo),
-            .descriptorType   = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
-            .pImageInfo       = images_info,
-            .pBufferInfo      = nullptr,
-            .pTexelBufferView = nullptr,
-        });
+        // resource_address[descriptors_count] = {
+        //     .address = sampled_indices.add(),
+        //     .size    = ,
+        // }
+
+        descriptors_count++;
     }
 
-    vkUpdateDescriptorSets(device, static_cast<uint32_t>(write_descriptor_sets.size()), write_descriptor_sets.data(), 0U, nullptr);
+    VKCHECK(vkWriteResourceDescriptorsEXT(device, static_cast<uint32_t>(descriptors_count), resource_descriptor_infos, resources_address));
 }
 
 void device_texture::release() {
-    auto& render_device = vkdevice::get();
-    auto* device = render_device.get_device();
+    vkdevice& render_device = vkdevice::get();
+    VkDevice device = render_device.get_device();
     auto* gpu_allocator = render_device.get_allocator();
 
     if (alloc != nullptr) {
@@ -1226,44 +1196,11 @@ void device_texture::release() {
 }
 
 void device_texture::create_views() {
-    auto* device = vkdevice::get().get_device();
-
-    VkImageViewCreateInfo create_info{
-        .sType      = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
-        .pNext      = nullptr,
-        .flags      = 0U,
-        .image      = vk_image,
-        .viewType   = VK_IMAGE_VIEW_TYPE_2D,
-        .format     = format,
-        .components = {
-            .r = VK_COMPONENT_SWIZZLE_R,
-            .g = VK_COMPONENT_SWIZZLE_G,
-            .b = VK_COMPONENT_SWIZZLE_B,
-            .a = VK_COMPONENT_SWIZZLE_A,
-        },
-        .subresourceRange = {
-            .aspectMask     = aspects,
-            .baseMipLevel   = 0,
-            .levelCount     = 1,
-            .baseArrayLayer = 0,
-            .layerCount     = 1,
-        },
-    };
-
-    for (auto mip_index{ 0U }; mip_index < mips; mip_index++) {
-        create_info.subresourceRange.baseMipLevel = mip_index;
-        VKCHECK(vkCreateImageView(device, &create_info, nullptr, &mips_views[mip_index]));
-    }
-
-    create_info.subresourceRange.baseMipLevel = 0;
-    create_info.subresourceRange.levelCount   = mips;
-    VKCHECK(vkCreateImageView(device, &create_info, nullptr, &whole_view));
 }
 
 
 void device_sampler::init(const sampler_desc& desc) {
     auto& render_device = vkdevice::get();
-    // const auto& bindless = render_device.get_bindingmodel();
     auto* device = render_device.get_device();
 
     VkSamplerCreateInfo sampler_create_info{
@@ -1303,23 +1240,27 @@ void device_sampler::init(const sampler_desc& desc) {
     //     .pBufferInfo      = nullptr,
     //     .pTexelBufferView = nullptr,
     // });
+
+    // TODO: Write samplers to heap
+    // TODO: Create previously immutable samplers
+    VKCHECK(vkWriteSamplerDescriptorsEXT());
 }
 
 
 uint32_t vkdevice::acquire_image_index(handle<device_surface> surface_handle) {
-    auto& surface = get_surface(surface_handle);
-    const auto& signal = get_semaphore(surface.acquire_semaphores[surface.frame_index]);
+    device_surface* surface = get_surface(surface_handle);
+    const device_semaphore& signal = surface->acquire_semaphores[surface->frame_index];
 
     VkSemaphoreWaitInfo wait_info {
         .sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
         .pNext = nullptr,
         .flags = 0U,
         .semaphoreCount = 1U,
-        .pSemaphores = &timeline_semaphore.vk_semaphore,
-        .pValues = &timeline_semaphore.value,
+        .pSemaphores = &fence.vk_semaphore,
+        .pValues = &fence.value,
     };
     vkWaitSemaphores(device, &wait_info, UINT64_MAX);
-    VKCHECK(vkAcquireNextImageKHR(device, surface.vk_swapchain, UINT64_MAX, signal.vk_semaphore, nullptr, &surface.image_index));
+    VKCHECK(vkAcquireNextImageKHR(device, surface->vk_swapchain, UINT64_MAX, signal.vk_semaphore, nullptr, &surface->image_index));
 
-    return surface.image_index;
+    return surface->image_index;
 }