Finished descriptor heaps implementation

5 files changed, 260 insertions, 499 deletions

diff --git a/src/main.cpp b/src/main.cpp
index 3cb56dc..a046c0a 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -48,7 +48,6 @@
 #include "vulkan-loader.cpp"
 #include "vk-utils.cpp"
 #include "vk-device.cpp"
-#include "vk-bindless.cpp"
 #include "vk-command-buffer.cpp"
 #endif
 
@@ -190,15 +189,15 @@ int main() {
     const float focus_distance = 10.f;
 
 #if VK
-    auto& device = vkdevice::get();
+    auto& render_device = vkdevice::get();
 #else
-    auto& device = dx12::device::get();
+    auto& render_device = dx12::device::get();
 #endif
-    device.init();
+    render_device.init();
 
     scene main_scene = scene(camera(position, target, v_fov, aspect_ratio, aperture, focus_distance), window_width, window_height);
 
-    handle<device_surface> surface_handle = device.create_surface({
+    handle<device_surface> surface_handle = render_device.create_surface({
         .window_handle = wnd.handle,
 #if VK
         .surface_format = {
@@ -214,13 +213,13 @@ int main() {
 #endif
         .image_count = 2U,
     });
-    const device_surface* surface = device.get_surface(surface_handle);
+    const device_surface* surface = render_device.get_surface(surface_handle);
 
 
     // ==============
     // create buffers
     // ==============
-    const handle<device_buffer> staging_buffer_handle = device.create_buffer({
+    const handle<device_buffer> staging_buffer_handle = render_device.create_buffer({
         .size = 128 * MB,
 #if VK
         .usages = VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT,
@@ -233,9 +232,9 @@ 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 = render_device.get_buffer(staging_buffer_handle);
 
-    const handle<device_buffer> vertex_buffer_handle = device.create_buffer({
+    const handle<device_buffer> vertex_buffer_handle = render_device.create_buffer({
         .size = MB * sizeof(uint32_t),
 #if VK
         .usages = VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT,
@@ -245,7 +244,7 @@ int main() {
         #endif
     });
 
-    const handle<device_buffer> index_buffer_handle = device.create_buffer({
+    const handle<device_buffer> index_buffer_handle = render_device.create_buffer({
         .size = MB * sizeof(uint32_t),
 #if VK
         .usages = VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT,
@@ -255,8 +254,8 @@ int main() {
 #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 = render_device.get_buffer(vertex_buffer_handle);
+    device_buffer* index_buffer = render_device.get_buffer(index_buffer_handle);
 
 
     // ================
@@ -265,20 +264,20 @@ int main() {
 #if VK
     size_t code_size = 0U;
     uint8_t* code = read_file("shaders/test.comp.spv", &code_size);
-    handle<device_pipeline> compute = device.create_compute_pipeline({
+    handle<device_pipeline> compute = render_device.create_compute_pipeline({
         .cs_code = code,
         .cs_code_size = code_size,
     });
 
     size_t rt_code_size = 0U;
     uint8_t* rt_code = read_file("shaders/compute.comp.spv", &rt_code_size);
-    handle<device_pipeline> raytracing = device.create_compute_pipeline({
+    handle<device_pipeline> raytracing = render_device.create_compute_pipeline({
         .cs_code = rt_code,
         .cs_code_size = rt_code_size,
     });
     size_t tonemapping_code_size = 0U;
     uint8_t* tonemapping_code = read_file("shaders/tonemapping.comp.spv", &tonemapping_code_size);
-    handle<device_pipeline> tonemapping = device.create_compute_pipeline({
+    handle<device_pipeline> tonemapping = render_device.create_compute_pipeline({
         .cs_code = tonemapping_code,
         .cs_code_size = tonemapping_code_size,
     });
@@ -288,7 +287,7 @@ int main() {
     uint8_t* vertex_code = read_file("shaders/api-test-ui.vert.spv", &vertex_code_size);
     size_t fragment_code_size = 0U;
     uint8_t* fragment_code = read_file("shaders/api-test-ui.frag.spv", &fragment_code_size);
-    handle<device_pipeline> graphics = device.create_graphics_pipeline({
+    handle<device_pipeline> graphics = render_device.create_graphics_pipeline({
         .vs_code = vertex_code,
         .vs_code_size = vertex_code_size,
         .fs_code = fragment_code,
@@ -299,7 +298,7 @@ int main() {
 
     size_t transmittance_lut_code_size = 0U;
     u8* transmittance_lut_code = read_file("shaders/transmittance_lut.comp.spv", &transmittance_lut_code_size);
-    handle<device_pipeline> transmittance_lut_compute = device.create_compute_pipeline({
+    handle<device_pipeline> transmittance_lut_compute = render_device.create_compute_pipeline({
         .cs_code = transmittance_lut_code,
         .cs_code_size = transmittance_lut_code_size,
         .name = "transmittance_lut_comp",
@@ -336,7 +335,7 @@ int main() {
     // ==============
     // create texures
     // ==============
-    const handle<device_texture> gpu_texture_handle = device.create_texture({
+    const handle<device_texture> gpu_texture_handle = render_device.create_texture({
         .width  = static_cast<uint32_t>(image_width),
         .height = static_cast<uint32_t>(image_height),
 #if VK
@@ -351,7 +350,7 @@ int main() {
 #endif
     });
 
-    const handle<device_texture> second_texture = device.create_texture({
+    const handle<device_texture> second_texture = render_device.create_texture({
         .width  = static_cast<uint32_t>(image_width),
         .height = static_cast<uint32_t>(image_height),
 #if VK
@@ -366,7 +365,7 @@ int main() {
 #endif
     });
 
-    const handle<device_texture> output_texture_handle = device.create_texture({
+    const handle<device_texture> output_texture_handle = render_device.create_texture({
         .width  = static_cast<uint32_t>(image_width),
         .height = static_cast<uint32_t>(image_height),
 #if VK
@@ -380,7 +379,7 @@ int main() {
 #endif
     });
 
-    const handle<device_texture> ui_texture_handle = device.create_texture({
+    const handle<device_texture> ui_texture_handle = render_device.create_texture({
         .width = static_cast<uint32_t>(atlas_width),
         .height = static_cast<uint32_t>(atlas_height),
 #if VK
@@ -396,7 +395,7 @@ int main() {
         .name = "glyph atlas"
     });
 
-    const handle<device_texture> acc_handle = device.create_texture({
+    const handle<device_texture> acc_handle = render_device.create_texture({
         .width = static_cast<uint32_t>(window_width),
         .height = static_cast<uint32_t>(window_height),
 #if VK
@@ -412,7 +411,7 @@ int main() {
         .name = "accumulation texture"
     });
 
-    const handle<device_texture> result_handle = device.create_texture({
+    const handle<device_texture> result_handle = render_device.create_texture({
         .width = static_cast<uint32_t>(window_width),
         .height = static_cast<uint32_t>(window_height),
 #if VK
@@ -428,7 +427,7 @@ int main() {
         .name = "output texture"
     });
 
-    const handle<device_texture> transmittance_lut_handle = device.create_texture({
+    const handle<device_texture> transmittance_lut_handle = render_device.create_texture({
         .width  = static_cast<uint32_t>(1024),
         .height = static_cast<uint32_t>(1024),
 #if VK
@@ -444,12 +443,12 @@ 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 = 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 = device.get_texture(ui_texture_handle);
-    const device_texture* transmittance_lut = device.get_texture(transmittance_lut_handle);
+    const device_texture* ui_texture = render_device.get_texture(ui_texture_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())));
@@ -457,10 +456,10 @@ int main() {
 
 #if VK
     std::array<graphics_command_buffer, 4U> graphics_command_buffers;
-    device.allocate_command_buffers(graphics_command_buffers.data(), graphics_command_buffers.size(), QueueType::GRAPHICS, "graphics_cmd_buf");
+    render_device.allocate_command_buffers(graphics_command_buffers.data(), graphics_command_buffers.size(), QueueType::GRAPHICS, "graphics_cmd_buf");
 #else
     std::array<dx12::graphics_command_buffer, 4U> graphics_command_buffers;
-    device.allocate_command_buffers(graphics_command_buffers.data(), graphics_command_buffers.size(), dx12::QueueType::GRAPHICS);
+    render_device.allocate_command_buffers(graphics_command_buffers.data(), graphics_command_buffers.size(), dx12::QueueType::GRAPHICS);
 #endif
 
 
@@ -485,21 +484,17 @@ int main() {
 
 
     {
-        // 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;
-             // 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();
+            } 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,
@@ -515,14 +510,11 @@ int main() {
                 u32 width;
                 u32 height;
                 u32 pad;
-            // } *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;
+            } 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,
@@ -538,8 +530,8 @@ int main() {
 
     graphics_command_buffers[0].stop();
 
-    device.submit(graphics_command_buffers.data(), 1);
-    device.wait();
+    render_device.submit(graphics_command_buffers.data(), 1);
+    render_device.wait();
 
     RD_END_CAPTURE;
 
@@ -665,16 +657,8 @@ 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));
-        }
-
         // TODO: Refactor backbuffer acquisition
-        auto backbuffer = surface->swapchain_images[device.acquire_image_index(surface_handle)];
+        auto backbuffer = surface->swapchain_images[render_device.acquire_image_index(surface_handle)];
         color_attachment[0] = backbuffer;
 
         // RD_START_CAPTURE;
@@ -692,7 +676,9 @@ int main() {
             }
 
             {
+                // TODO: Pack this fields
                 struct params {
+                    struct metadata meta;
                     uintptr_t bvh_buffer;
                     uintptr_t indices_buffer;
                     uintptr_t positions_buffer;
@@ -701,25 +687,17 @@ int main() {
                     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* 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,
@@ -730,15 +708,15 @@ int main() {
 
             {
                 struct params {
+                    s32 downscale_factor;
                     u32 output_id;
                     u32 accumulation_id;
-                // } *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 = {
+                    // 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,
@@ -761,7 +739,6 @@ int main() {
             .color_attachments_count = color_attachment.size(),
         });
 
-        // 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++) {
@@ -775,10 +752,7 @@ int main() {
                     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{
+                } ui_param = {
                     .vertex_buffer = vertex_buffer->device_address,
                     .scale {
                         2.f / draw_data->DisplaySize.x,
@@ -809,9 +783,8 @@ int main() {
 
         command_buffer.stop();
 
-        device.submit_before_present(surface_handle, &command_buffer, 1U);
-        device.present(surface_handle);
-        // device.wait();
+        render_device.submit_before_present(surface_handle, &command_buffer, 1U);
+        render_device.present(surface_handle);
 
         LARGE_INTEGER end_qpc;
         QueryPerformanceCounter(&end_qpc);
@@ -822,31 +795,31 @@ int main() {
         // RD_END_CAPTURE;
     }
 
-    device.wait();
+    render_device.wait();
 
     main_scene.deinit();
 
-    device.destroy_surface(surface_handle);
+    render_device.destroy_surface(surface_handle);
 
-    device.destroy_pipeline(compute);
-    device.destroy_pipeline(graphics);
-    device.destroy_pipeline(raytracing);
-    device.destroy_pipeline(tonemapping);
+    render_device.destroy_pipeline(compute);
+    render_device.destroy_pipeline(graphics);
+    render_device.destroy_pipeline(raytracing);
+    render_device.destroy_pipeline(tonemapping);
 
-    device.destroy_pipeline(transmittance_lut_compute);
-    device.destroy_texture(transmittance_lut_handle);
+    render_device.destroy_pipeline(transmittance_lut_compute);
+    render_device.destroy_texture(transmittance_lut_handle);
 
-    device.destroy_texture(gpu_texture_handle);
-    device.destroy_texture(second_texture);
-    device.destroy_texture(output_texture_handle);
-    device.destroy_texture(ui_texture_handle);
-    device.destroy_texture(acc_handle);
-    device.destroy_texture(result_handle);
+    render_device.destroy_texture(gpu_texture_handle);
+    render_device.destroy_texture(second_texture);
+    render_device.destroy_texture(output_texture_handle);
+    render_device.destroy_texture(ui_texture_handle);
+    render_device.destroy_texture(acc_handle);
+    render_device.destroy_texture(result_handle);
 
-    device.destroy_buffer(staging_buffer_handle);
-    device.destroy_buffer(vertex_buffer_handle);
-    device.destroy_buffer(index_buffer_handle);
-    device.deinit();
+    render_device.destroy_buffer(staging_buffer_handle);
+    render_device.destroy_buffer(vertex_buffer_handle);
+    render_device.destroy_buffer(index_buffer_handle);
+    render_device.deinit();
 
     ImGui::DestroyContext();
 #endif // VK
diff --git a/src/scene.cpp b/src/scene.cpp
index d8533f9..ae009e7 100644
--- a/src/scene.cpp
+++ b/src/scene.cpp
@@ -55,15 +55,12 @@ metadata::metadata(const camera &cam, uint32_t width, uint32_t height)
     : cam(cam), width(width), height(height) {}

 

 scene::scene(const camera& cam, uint32_t width, uint32_t height)

-    :model("../models/sponza/Sponza.gltf"), meta(cam, width, height) {

+    // :model("../models/sponza/Sponza.gltf"), meta(cam, width, height) {

     // :model("../models/BistroInterior/BistroInterior.gltf"), meta(cam, width, height) {

     // :model("../models/BistroExterior/BistroExterior.gltf"), meta(cam, width, height) {

-    // :model("../models/sponza-avif-hi.glb"), meta(cam, width, height) {

     // :model("../models/main_sponza/NewSponza_Main_glTF_003.gltf"), meta(cam, width, height) {

     // :model("../models/pkg_a_curtains/NewSponza_Curtains_glTF.gltf"), meta(cam, width, height) {

-    // :model("../models/sponza.glb", true), meta(cam, width, height) {

-

-    auto& device = vkdevice::get();

+    :model("../models/sponza.glb", true), meta(cam, width, height) {

 

     // Geometry & BVH

     std::vector<uint32_t>       indices;

@@ -151,12 +148,12 @@ scene::scene(const camera& cam, uint32_t width, uint32_t height)
                 });

 

                 if (material.base_color_texture.id != handle<device_texture>::invalid_id) {

-                    mat.albedo_texture_id = device.get_texture(material.base_color_texture).get_sampled_index();

+                    mat.albedo_texture_id = vkdevice::get().get_texture(material.base_color_texture)->get_sampled_index();

                     // mat.albedo_texture_sampler_id = device.get_sampler(0);

                 }

 

                 if (material.metallic_roughness_texture.id != handle<device_texture>::invalid_id) {

-                    mat.metallic_roughness_texture_id = device.get_texture(material.metallic_roughness_texture).get_sampled_index();

+                    mat.metallic_roughness_texture_id = vkdevice::get().get_texture(material.metallic_roughness_texture)->get_sampled_index();

                     // mat.metallic_roughness_texture_sampler_id = device.get_sampler(0);

                 }

             }

@@ -179,80 +176,80 @@ scene::scene(const camera& cam, uint32_t width, uint32_t height)
     // bvh builder(spheres, packed_nodes);

 

     {

-        indices_buffer_handle = device.create_buffer({

+        indices_buffer_handle = vkdevice::get().create_buffer({

             .size = indices.size() * sizeof(indices[0]),

-            .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,

             .name = "indices",

         });

-        const auto& indices_buffer = device.get_buffer(indices_buffer_handle);

-        void* ptr = indices_buffer.mapped_ptr;

+        const auto& indices_buffer = vkdevice::get().get_buffer(indices_buffer_handle);

+        void* ptr = indices_buffer->mapped_ptr;

         memcpy(ptr, indices.data(), indices.size() * sizeof(indices[0]));

     }

 

     {

-        positions_buffer_handle = device.create_buffer({

+        positions_buffer_handle = vkdevice::get().create_buffer({

             .size = positions.size() * sizeof(positions[0]),

-            .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,

             .name = "positions",

         });

-        const auto& positions_buffer = device.get_buffer(positions_buffer_handle);

-        void* ptr = positions_buffer.mapped_ptr;

+        const auto& positions_buffer = vkdevice::get().get_buffer(positions_buffer_handle);

+        void* ptr = positions_buffer->mapped_ptr;

         memcpy(ptr, positions.data(), positions.size() * sizeof(positions[0]));

     }

 

     {

-        normals_buffer_handle = device.create_buffer({

+        normals_buffer_handle = vkdevice::get().create_buffer({

             .size = normals.size() * sizeof(normals[0]),

-            .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,

             .name = "normals",

         });

-        const auto& normals_buffer = device.get_buffer(normals_buffer_handle);

-        void* ptr = normals_buffer.mapped_ptr;

+        const auto& normals_buffer = vkdevice::get().get_buffer(normals_buffer_handle);

+        void* ptr = normals_buffer->mapped_ptr;

         memcpy(ptr, normals.data(), normals.size() * sizeof(normals[0]));

     }

 

     {

-        uvs_buffer_handle = device.create_buffer({

+        uvs_buffer_handle = vkdevice::get().create_buffer({

             .size = uvs.size() * sizeof(uvs[0]),

-            .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,

             .name = "uvs",

         });

-        const auto& uvs_buffer = device.get_buffer(uvs_buffer_handle);

-        void* ptr = uvs_buffer.mapped_ptr;

+        const auto& uvs_buffer = vkdevice::get().get_buffer(uvs_buffer_handle);

+        void* ptr = uvs_buffer->mapped_ptr;

         memcpy(ptr, uvs.data(), uvs.size() * sizeof(uvs[0]));

     }

 

     {

-        bvh_buffer_handle = device.create_buffer({

+        bvh_buffer_handle = vkdevice::get().create_buffer({

             .size = packed_nodes.size() * sizeof(packed_nodes[0]),

-            .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,

             .name = "bvh",

         });

-        const auto& bvh_buffer = device.get_buffer(bvh_buffer_handle);

-        void* ptr = bvh_buffer.mapped_ptr;

+        const auto& bvh_buffer = vkdevice::get().get_buffer(bvh_buffer_handle);

+        void* ptr = bvh_buffer->mapped_ptr;

         memcpy(ptr, packed_nodes.data(), packed_nodes.size() * sizeof(packed_nodes[0]));

     }

 

     {

-        materials_buffer_handle = device.create_buffer({

+        materials_buffer_handle = vkdevice::get().create_buffer({

             .size = materials.size() * sizeof(materials[0]),

-            .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,

             .name = "materials",

         });

-        const auto& materials_buffer = device.get_buffer(materials_buffer_handle);

-        void* ptr = materials_buffer.mapped_ptr;

+        const auto& materials_buffer = vkdevice::get().get_buffer(materials_buffer_handle);

+        void* ptr = materials_buffer->mapped_ptr;

         memcpy(ptr, materials.data(), materials.size() * sizeof(materials[0]));

     }

 }

diff --git a/src/vk-bindless.cpp b/src/vk-bindless.cpp
deleted file mode 100644
index 8f29834..0000000
--- a/src/vk-bindless.cpp
+++ /dev/null
@@ -1,238 +0,0 @@
-#include "vk-bindless.hpp"
-
-#include "vk-device.hpp"
-#include "vk-utils.hpp"
-
-device_buffer* bindless_model::get_uniform_buffer(enum UniformTypes type) const {
-    return vkdevice::get().get_buffer(uniform_buffers[type]);
-}
-
-void bindless_model::init() {
-    vkdevice& render_device = vkdevice::get();
-    VkDevice device = render_device.get_device();
-
-    // -------------------------
-    // create immutable samplers
-    // -------------------------
-    {
-        VkSamplerCreateInfo create_info{
-            .sType                   = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
-            .pNext                   = VK_NULL_HANDLE,
-            .flags                   = 0,
-            .mipmapMode              = VK_SAMPLER_MIPMAP_MODE_NEAREST,
-            .mipLodBias              = 0.f,
-            .anisotropyEnable        = VK_FALSE,
-            .compareEnable           = VK_FALSE,
-            .compareOp               = VK_COMPARE_OP_NEVER,
-            .minLod                  = 0.f,
-            .maxLod                  = 0.f,
-            .borderColor             = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
-            .unnormalizedCoordinates = VK_FALSE,
-        };
-
-        // Nearest sampler
-        {
-            VkFilter             filter       = VK_FILTER_NEAREST;
-            VkSamplerAddressMode address_mode = VK_SAMPLER_ADDRESS_MODE_REPEAT;
-
-            create_info.magFilter             = filter,
-            create_info.minFilter             = filter,
-            create_info.addressModeU          = address_mode,
-            create_info.addressModeV          = address_mode,
-            create_info.addressModeW          = address_mode,
-
-            VKCHECK(vkCreateSampler(device, &create_info, VK_NULL_HANDLE, &samplers[SamplerType::NEAREST]));
-        }
-
-        // Linear sampler
-        {
-            VkFilter             filter       = VK_FILTER_LINEAR;
-            VkSamplerAddressMode address_mode = VK_SAMPLER_ADDRESS_MODE_REPEAT;
-
-            create_info.magFilter             = filter,
-            create_info.minFilter             = filter,
-            create_info.addressModeU          = address_mode,
-            create_info.addressModeV          = address_mode,
-            create_info.addressModeW          = address_mode,
-
-            VKCHECK(vkCreateSampler(device, &create_info, VK_NULL_HANDLE, &samplers[SamplerType::LINEAR]));
-        }
-    }
-
-    // Set 0 global resources
-    //  Binding 0 Storage images
-    //  Binding 1 Sampled images
-    //  Binding 2 Samplers
-    {
-        VkDescriptorSetLayoutBinding set_layout_bindings[]{
-            {
-                .binding            = 0U,
-                .descriptorType     = VK_DESCRIPTOR_TYPE_SAMPLER,
-                .descriptorCount    = SamplerType::MAX_SAMPLER,
-                .stageFlags         = VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
-                .pImmutableSamplers = samplers,
-            },
-            {
-                .binding            = 1U,
-                .descriptorType     = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
-                .descriptorCount    = set_descriptors_count,
-                .stageFlags         = VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
-                .pImmutableSamplers = nullptr,
-            },
-            {
-                .binding            = 2U,
-                .descriptorType     = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
-                .descriptorCount    = set_descriptors_count,
-                .stageFlags         = VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
-                .pImmutableSamplers = nullptr,
-            },
-        };
-
-        VkDescriptorBindingFlags flags[]{
-            VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT | VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT,
-            VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT | VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT,
-            VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT | VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT,
-        };
-
-        VkDescriptorSetLayoutBindingFlagsCreateInfo layout_binding_flags{
-            .sType         = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
-            .pNext         = VK_NULL_HANDLE,
-            .bindingCount  = sizeof(flags) / sizeof(VkDescriptorBindingFlags),
-            .pBindingFlags = flags,
-        };
-
-        VkDescriptorSetLayoutCreateInfo create_info{
-            .sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
-            .pNext        = &layout_binding_flags,
-            .flags        = 0U,
-            .bindingCount = sizeof(set_layout_bindings) / sizeof(VkDescriptorSetLayoutBinding),
-            .pBindings    = set_layout_bindings,
-        };
-
-        VKCHECK(vkCreateDescriptorSetLayout(device, &create_info, nullptr, &global_set_layout));
-    }
-
-    // ----------------------
-    // create layout
-    // ----------------------
-    {
-        VkPushConstantRange push_constant {
-            .stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT,
-            .offset = 0U,
-            .size = push_constant_slot_size * push_constant_slots,
-        };
-
-        VkPipelineLayoutCreateInfo create_info{
-            .sType                  = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
-            .pNext                  = nullptr,
-            .flags                  = 0U,
-            .setLayoutCount         = 1U,
-            .pSetLayouts            = &global_set_layout,
-            .pushConstantRangeCount = 1U,
-            .pPushConstantRanges    = &push_constant,
-        };
-
-        VKCHECK(vkCreatePipelineLayout(device, &create_info, nullptr, &global_layout));
-    }
-
-    // ----------------------
-    // create descriptor pool
-    // ----------------------
-    {
-        VkDescriptorPoolSize pool_sizes[]{
-            {
-                .type            = VK_DESCRIPTOR_TYPE_SAMPLER,
-                .descriptorCount = set_descriptors_count,
-            },
-            {
-                .type            = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
-                .descriptorCount = set_descriptors_count,
-            },
-            {
-                .type            = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
-                .descriptorCount = set_descriptors_count,
-            },
-        };
-
-        VkDescriptorPoolCreateInfo descriptor_pool_create_info{
-            .sType         = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
-            .pNext         = nullptr,
-            .flags         = 0U,
-            .maxSets       = descriptor_pool_allocable_sets_count,
-            .poolSizeCount = sizeof(pool_sizes) / sizeof(VkDescriptorPoolSize),
-            .pPoolSizes    = pool_sizes,
-        };
-        VKCHECK(vkCreateDescriptorPool(device, &descriptor_pool_create_info, nullptr, &descriptor_pool));
-    }
-
-    // -----------------------
-    // create descriptors sets
-    // -----------------------
-    {
-        VkDescriptorSetAllocateInfo allocate_info{
-            .sType              = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
-            .pNext              = nullptr,
-            .descriptorPool     = descriptor_pool,
-            .descriptorSetCount = 1U,
-            .pSetLayouts        = &global_set_layout,
-        };
-        VKCHECK(vkAllocateDescriptorSets(device, &allocate_info, &global_set));
-    }
-
-    // ---------------------
-    // global uniform buffer
-    // ---------------------
-    {
-        uniform_buffers[UniformTypes::GLOBAL] = render_device.create_buffer({
-            .size = globals_uniform_buffer_size,
-            .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",
-        });
-    }
-
-    // ---------------------
-    // passes uniform buffer
-    // ---------------------
-    {
-        uniform_buffers[UniformTypes::PASS] = render_device.create_buffer({
-            .size = passes_uniform_buffer_size,
-            .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"
-        });
-    }
-
-    // --------------------
-    // draws uniform buffer
-    // --------------------
-    {
-        uniform_buffers[UniformTypes::DRAW] = render_device.create_buffer({
-            .size = draws_uniform_buffer_size,
-            .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",
-        });
-    }
-}
-
-void bindless_model::deinit() {
-    vkdevice& render_device = vkdevice::get();
-    VkDevice device = render_device.get_device();
-
-    vkDestroyDescriptorPool(device, descriptor_pool, nullptr);
-
-    vkDestroyDescriptorSetLayout(device, global_set_layout, nullptr);
-    vkDestroyPipelineLayout(device, global_layout, nullptr);
-
-    render_device.destroy_buffer(uniform_buffers[UniformTypes::GLOBAL]);
-    render_device.destroy_buffer(uniform_buffers[UniformTypes::PASS]);
-    render_device.destroy_buffer(uniform_buffers[UniformTypes::DRAW]);
-
-    for (VkSampler sampler : samplers) {
-        vkDestroySampler(device, sampler, nullptr);
-    }
-}
diff --git a/src/vk-command-buffer.cpp b/src/vk-command-buffer.cpp
index e16e384..00d60a1 100644
--- a/src/vk-command-buffer.cpp
+++ b/src/vk-command-buffer.cpp
@@ -1,7 +1,5 @@
 #include "vk-command-buffer.hpp"
 
-uintptr_t constants[3U] = { 0U };
-
 void command_buffer::start() const {
     VkCommandBufferBeginInfo begin_info{
         .sType            = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
@@ -12,20 +10,42 @@ void command_buffer::start() const {
 
     VKCHECK(vkBeginCommandBuffer(vk_command_buffer, &begin_info));
 
-    // TODO: Bind heaps
-    VkBindHeapInfoEXT image_bind_heap_info = {
-        .sType = VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT,
-        .pNext = nullptr,
-    };
+    {
+        device_buffer* image_heap_buffer = vkdevice::get().get_buffer(image_heap);
 
-    vkCmdBindResourceHeapEXT(vk_command_buffer, &image_bind_heap_info);
+        VkDeviceAddressRangeEXT heap_range {
+            .address = image_heap_buffer->device_address,
+            .size = image_heap_buffer->size,
+        };
+        VkBindHeapInfoEXT bind_heap_info = {
+            .sType               = VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT,
+            .pNext               = nullptr,
+            .heapRange           = heap_range,
+            .reservedRangeOffset = 0U,
+            .reservedRangeSize   = descriptor_heap_props.minResourceHeapReservedRange,
+        };
 
-    VkBindHeapInfoEXT sampler_bind_heap_info = {
-        .sType = VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT,
-        .pNext = nullptr,
-    };
+        vkCmdBindResourceHeapEXT(vk_command_buffer, &bind_heap_info);
+    }
+
+    {
+        device_buffer* sampler_heap_buffer = vkdevice::get().get_buffer(sampler_heap);
+
+        VkDeviceAddressRangeEXT heap_range {
+            .address = sampler_heap_buffer->device_address,
+            .size = sampler_heap_buffer->size,
+        };
+
+        VkBindHeapInfoEXT sampler_bind_heap_info = {
+            .sType               = VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT,
+            .pNext               = nullptr,
+            .heapRange           = heap_range,
+            .reservedRangeOffset = 0U,
+            .reservedRangeSize   = descriptor_heap_props.minSamplerHeapReservedRange,
+        };
 
-    vkCmdBindSamplerHeapEXT(vk_command_buffer, &sampler_bind_heap_info);
+        vkCmdBindSamplerHeapEXT(vk_command_buffer, &sampler_bind_heap_info);
+    }
 }
 
 void command_buffer::stop() const {
@@ -77,9 +97,8 @@ void command_buffer::barrier(handle<device_texture> texture_handle, VkPipelineSt
 }
 
 void command_buffer::copy(handle<device_buffer> buffer_handle, ::handle<device_texture> texture_handle, uint64_t offset) const {
-    auto&                   device      = vkdevice::get();
-    const device_buffer*    buffer      = device.get_buffer(buffer_handle);
-    const device_texture*   texture     = device.get_texture(texture_handle);
+    const device_buffer*    buffer      = vkdevice::get().get_buffer(buffer_handle);
+    const device_texture*   texture     = vkdevice::get().get_texture(texture_handle);
 
     VkImageSubresourceLayers image_subresource_layers{
         .aspectMask     = texture->aspects,
@@ -106,13 +125,8 @@ void command_buffer::copy(handle<device_buffer> buffer_handle, ::handle<device_t
 
 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);
 
-    // 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,
@@ -124,9 +138,9 @@ void graphics_command_buffer::dispatch(const dispatch_params& params, const void
     };
     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;
-    auto z = params.group_size.vec.z / params.local_group_size.vec.z;
+    u32 x = params.group_size.vec.x / params.local_group_size.vec.x;
+    u32 y = params.group_size.vec.y / params.local_group_size.vec.y;
+    u32 z = params.group_size.vec.z / params.local_group_size.vec.z;
     vkCmdDispatch(vk_command_buffer, x, y, z);
 }
 
@@ -185,26 +199,14 @@ 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;
-
     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* data, size_t size) const {
-    auto&       device   = vkdevice::get();
-    const device_pipeline* pipeline = device.get_pipeline(params.pipeline);
-
-    // const auto& bindless = device.get_bindingmodel();
-
+    const device_pipeline* pipeline = vkdevice::get().get_pipeline(params.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);
-
     VkPushDataInfoEXT push_data {
         .sType  = VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT,
         .pNext  = nullptr,
@@ -220,17 +222,9 @@ void graphics_command_buffer::draw(const draw_params& params, const void* data,
 }
 
 void graphics_command_buffer::draw_indexed(const draw_indexed_params& params, const void* data, size_t size) const {
-    auto&       device   = vkdevice::get();
-    const device_pipeline* pipeline = device.get_pipeline(params.pipeline);
-
-    // const auto& bindless = device.get_bindingmodel();
-
+    const device_pipeline* pipeline = vkdevice::get().get_pipeline(params.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);
-
     VkPushDataInfoEXT push_data {
         .sType  = VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT,
         .pNext  = nullptr,
@@ -242,7 +236,7 @@ void graphics_command_buffer::draw_indexed(const draw_indexed_params& params, co
     };
     vkCmdPushDataEXT(vk_command_buffer, &push_data);
 
-    const device_buffer* index_buffer = device.get_buffer(params.index_buffer);
+    const device_buffer* index_buffer = vkdevice::get().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 988d344..bf18610 100644
--- a/src/vk-device.cpp
+++ b/src/vk-device.cpp
@@ -4,7 +4,58 @@
 
 #include <vk_mem_alloc.h>
 
-device_semaphore create_semaphore(VkDevice device, const semaphore_desc& desc, const char* name) {
+
+static VkInstance                  instance;
+static VkPhysicalDevice            physical_device;
+static VkPhysicalDeviceProperties2 physical_device_props;
+static VkDevice                    device;
+
+static constexpr size_t     max_images_count = 10000U;
+static constexpr size_t     max_samplers_count = 16U;
+static constexpr size_t     storage_images_offset = 0U;
+static constexpr size_t     sampled_images_offset = max_images_count / 2U;
+
+// TODO: Dont use handle for internally used resources
+handle<device_buffer> image_heap;
+handle<device_buffer> sampler_heap;
+
+static VmaAllocator                gpu_allocator;
+
+VkPhysicalDeviceDescriptorHeapPropertiesEXT descriptor_heap_props {
+    .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT,
+};
+
+void create_heaps(size_t max_images, size_t max_samplers) {
+    // create image heap
+    {
+        image_heap = vkdevice::get().create_buffer({
+            .size = descriptor_heap_props.minResourceHeapReservedRange + max_images * 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_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
+            .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,
+            // .memory_usage = VMA_MEMORY_USAGE_GPU_ONLY,
+            .name = "image descriptor_heap",
+        });
+    }
+
+    // create sampler heap
+    {
+        sampler_heap = vkdevice::get().create_buffer({
+            .size = descriptor_heap_props.minSamplerHeapReservedRange + max_samplers * 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_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
+            .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,
+            // .memory_usage = VMA_MEMORY_USAGE_GPU_ONLY,
+            .name = "sampler descriptor_heap",
+        });
+    }
+}
+
+device_semaphore create_semaphore(const semaphore_desc& desc, const char* name) {
     device_semaphore semaphore {
         .value = desc.initial_value,
     };
@@ -37,7 +88,7 @@ device_semaphore create_semaphore(VkDevice device, const semaphore_desc& desc, c
 }
 
 
-static VkShaderModule create_shader_module(VkDevice device, uint8_t* code, size_t code_size) {
+static VkShaderModule create_shader_module(uint8_t* code, size_t code_size) {
     VkShaderModule shader_module;
     VkShaderModuleCreateInfo create_info{
         .sType    = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
@@ -94,7 +145,6 @@ void vkdevice::init() {
     create_device();
 
     fence = create_semaphore(
-        device,
         {
             .type = VK_SEMAPHORE_TYPE_TIMELINE,
         }, "timeline_semaphore"
@@ -193,7 +243,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);
+    vmaSetAllocationName(gpu_allocator, device_buffer.alloc, desc.name);
 
     if ((desc.usages & VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT) != 0U) {
         VkBufferDeviceAddressInfo address_info {
@@ -218,7 +268,7 @@ handle<device_pipeline> vkdevice::create_graphics_pipeline(const graphics_pipeli
             .pNext               = nullptr,
             .flags               = 0U,
             .stage               = VK_SHADER_STAGE_VERTEX_BIT,
-            .module              = create_shader_module(device, desc.vs_code, desc.vs_code_size),
+            .module              = create_shader_module(desc.vs_code, desc.vs_code_size),
             .pName               = "main",
             .pSpecializationInfo = nullptr,
         },
@@ -227,7 +277,7 @@ handle<device_pipeline> vkdevice::create_graphics_pipeline(const graphics_pipeli
             .pNext               = nullptr,
             .flags               = 0U,
             .stage               = VK_SHADER_STAGE_FRAGMENT_BIT,
-            .module              = create_shader_module(device, desc.fs_code, desc.fs_code_size),
+            .module              = create_shader_module(desc.fs_code, desc.fs_code_size),
             .pName               = "main",
             .pSpecializationInfo = nullptr,
         },
@@ -320,9 +370,15 @@ handle<device_pipeline> vkdevice::create_graphics_pipeline(const graphics_pipeli
         .stencilAttachmentFormat = VK_FORMAT_UNDEFINED,
     };
 
+    VkPipelineCreateFlags2CreateInfo create_flags2 {
+        .sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO,
+        .pNext = &pipeline_rendering_create_info,
+        .flags = VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT,
+    };
+
     VkGraphicsPipelineCreateInfo create_info{
         .sType               = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
-        .pNext               = &pipeline_rendering_create_info,
+        .pNext               = &create_flags2,
         .flags               = 0U,
         .stageCount          = sizeof(shader_stages_create_info) / sizeof(VkPipelineShaderStageCreateInfo),
         .pStages             = shader_stages_create_info,
@@ -372,14 +428,20 @@ handle<device_pipeline> vkdevice::create_compute_pipeline(const compute_pipeline
         .pNext               = nullptr,
         .flags               = 0U,
         .stage               = VK_SHADER_STAGE_COMPUTE_BIT,
-        .module              = create_shader_module(device, desc.cs_code, desc.cs_code_size),
+        .module              = create_shader_module(desc.cs_code, desc.cs_code_size),
         .pName               = "main",
         .pSpecializationInfo = nullptr,
     };
 
+    VkPipelineCreateFlags2CreateInfo create_flags2 {
+        .sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT,
+    };
+
     VkComputePipelineCreateInfo create_info{
         .sType              = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
-        .pNext              = nullptr,
+        .pNext              = &create_flags2,
         .flags              = 0U,
         .stage              = stage_create_info,
         // .layout             = bindless.global_layout,
@@ -428,13 +490,11 @@ handle<device_surface> vkdevice::create_surface(const surface_desc& desc) {
 
     for (uint32_t index = 0u; index < device_surface.image_count; index++) {
         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"
@@ -802,9 +862,6 @@ void vkdevice::create_instance() {
 void vkdevice::create_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);
@@ -822,6 +879,7 @@ void vkdevice::create_device() {
             VkPhysicalDevice physical_dev = physical_devices[physical_device_index];
             if (device_support_features(physical_dev)) {
                 physical_device = physical_dev;
+
                 break;
             }
         }
@@ -863,6 +921,7 @@ void vkdevice::create_device() {
         VK_KHR_SWAPCHAIN_EXTENSION_NAME,
         VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME,
         VK_KHR_MAINTENANCE_5_EXTENSION_NAME,
+        VK_KHR_SHADER_UNTYPED_POINTERS_EXTENSION_NAME,
     };
 
     VkPhysicalDeviceVulkan12Features physical_device_12_features{
@@ -884,9 +943,22 @@ void vkdevice::create_device() {
         .dynamicRendering = VK_TRUE,
     };
 
+    VkPhysicalDeviceDescriptorHeapFeaturesEXT descriptor_heap_features {
+        .sType                       = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT,
+        .pNext                       = &physical_device_13_features,
+        .descriptorHeap              = VK_TRUE,
+        .descriptorHeapCaptureReplay = VK_TRUE,
+    };
+
+    VkPhysicalDeviceShaderUntypedPointersFeaturesKHR shader_untyped_pointers_features {
+        .sType                 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR,
+        .pNext                 = &descriptor_heap_features,
+        .shaderUntypedPointers = VK_TRUE,
+    };
+
     VkDeviceCreateInfo create_info{
         .sType                   = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
-        .pNext                   = &physical_device_13_features,
+        .pNext                   = &shader_untyped_pointers_features,
         .flags                   = 0U,
         .queueCreateInfoCount    = static_cast<uint32_t>(QueueType::MAX),
         .pQueueCreateInfos       = queue_create_infos,
@@ -938,33 +1010,7 @@ void vkdevice::create_device() {
         VKCHECK(vmaCreateAllocator(&allocator_create_info, &gpu_allocator));
     }
 
-    create_heaps(descriptor_heap_props);
-}
-
-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",
-        });
-    }
-
-    // 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",
-        });
-    }
+    create_heaps(max_images_count, max_samplers_count);
 }
 
 
@@ -1026,7 +1072,6 @@ idlist<> device_sampler::sampler_indices = {};
 
 void device_texture::init(const texture_desc& desc) {
     auto& render_device = vkdevice::get();
-    auto* device = render_device.get_device();
 
     vk_image = desc.vk_image;
     format = desc.format;
@@ -1073,8 +1118,8 @@ void device_texture::init(const texture_desc& desc) {
             .pUserData      = nullptr,
         };
 
-        VKCHECK(vmaCreateImage(render_device.get_allocator(), &create_info, &alloc_create_info, &vk_image, &alloc, nullptr));
-        vmaSetAllocationName(render_device.get_allocator(), alloc, desc.name);
+        VKCHECK(vmaCreateImage(gpu_allocator, &create_info, &alloc_create_info, &vk_image, &alloc, nullptr));
+        vmaSetAllocationName(gpu_allocator, alloc, desc.name);
     }
 
     if (desc.name) {
@@ -1129,6 +1174,7 @@ void device_texture::init(const texture_desc& desc) {
         .layout = VK_IMAGE_LAYOUT_GENERAL,
     };
 
+    device_buffer* image_heap_buffer = render_device.get_buffer(image_heap);
     u32 descriptors_count = 0U;
     VkResourceDescriptorInfoEXT resource_descriptor_infos[2U];
     VkHostAddressRangeEXT resources_address[2U];
@@ -1142,10 +1188,11 @@ void device_texture::init(const texture_desc& desc) {
             },
         };
 
-        // resource_address[descriptors_count] = {
-        //     .address = storage_indices.add(),
-        //     .size    = ,
-        // }
+        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),
+            .size    = descriptor_heap_props.imageDescriptorSize,
+        };
 
         descriptors_count++;
     }
@@ -1159,10 +1206,11 @@ void device_texture::init(const texture_desc& desc) {
             },
         };
 
-        // resource_address[descriptors_count] = {
-        //     .address = sampled_indices.add(),
-        //     .size    = ,
-        // }
+        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),
+            .size    = descriptor_heap_props.imageDescriptorSize,
+        };
 
         descriptors_count++;
     }
@@ -1171,10 +1219,6 @@ void device_texture::init(const texture_desc& desc) {
 }
 
 void device_texture::release() {
-    vkdevice& render_device = vkdevice::get();
-    VkDevice device = render_device.get_device();
-    auto* gpu_allocator = render_device.get_allocator();
-
     if (alloc != nullptr) {
         vmaDestroyImage(gpu_allocator, vk_image, alloc);
     }
@@ -1200,8 +1244,7 @@ void device_texture::create_views() {
 
 
 void device_sampler::init(const sampler_desc& desc) {
-    auto& render_device = vkdevice::get();
-    auto* device = render_device.get_device();
+    vkdevice& render_device = vkdevice::get();
 
     VkSamplerCreateInfo sampler_create_info{
         .sType                      = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
@@ -1228,22 +1271,14 @@ void device_sampler::init(const sampler_desc& desc) {
 
     sampler_index = sampler_indices.add();
 
-    // VkWriteDescriptorSet write_descriptor_set{
-    //     .sType            = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
-    //     .pNext            = nullptr,
-    //     .dstSet           = bindless.sets[BindlessSetType::GLOBAL],
-    //     .dstBinding       = 1U,
-    //     .dstArrayElement  = sampler_index.id,
-    //     .descriptorCount  = 1U,
-    //     .descriptorType   = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
-    //     .pImageInfo       = images_info,
-    //     .pBufferInfo      = nullptr,
-    //     .pTexelBufferView = nullptr,
-    // });
-
-    // TODO: Write samplers to heap
     // TODO: Create previously immutable samplers
-    VKCHECK(vkWriteSamplerDescriptorsEXT());
+    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));
 }