Bindless graphics pipeline

8 files changed, 232 insertions, 224 deletions

diff --git a/include/vk-api.hpp b/include/vk-api.hpp
index 8e4b342..8612e00 100644
--- a/include/vk-api.hpp
+++ b/include/vk-api.hpp
@@ -15,14 +15,11 @@ struct Buffer {
 
 struct Pipeline {
     std::vector<VkShaderModule> shader_modules;
-    // TODO: Remove once all pipelines use bindless layout
-    VkDescriptorSetLayout       descriptor_set_layout;
-    VkPipelineLayout            layout;
     VkPipeline                  handle;
     VkPipelineBindPoint         bind_point;
 };
 
-struct Image {
+struct image {
     VkImage                 handle;
     VkImageView             view;
     VmaAllocation           alloc;
@@ -30,27 +27,62 @@ struct Image {
     VkImageSubresourceRange subresource_range;
     VkFormat                format;
     VkExtent3D              size;
-    uint32_t                 bindless_index;
+    uint32_t                bindless_storage_index;
+    uint32_t                bindless_sampled_index;
 };
 
 struct Swapchain {
     size_t                  image_count;
-    std::vector<Image>      images;
+    std::vector<image>      images;
     VkSwapchainKHR          handle;
     VkSurfaceFormatKHR      surface_format;
     VkExtent2D              extent;
 };
 
+struct sampler {
+    VkSampler               handle;
+    uint32_t                bindless_index;
+};
+
 struct global_descriptor {
     VkDescriptorSetLayout   set_layout;
     VkPipelineLayout        pipeline_layout;
     VkDescriptorSet         set;
 
-    std::vector<uint32_t>   indices;
+    // TODO: Use constant here
+    std::vector<uint32_t>   index_pool[3];
 
     global_descriptor() {
-        for (size_t index = 0; index < 1024; index++) {
-            indices.push_back(index);
+        for (int32_t index = 1024; index >= 0; index--) {
+            index_pool[0].push_back((uint32_t)index);
+            index_pool[1].push_back((uint32_t)index);
+            index_pool[2].push_back((uint32_t)index);
+        }
+    }
+
+    uint32_t allocate(VkDescriptorType type) {
+        auto &pool = index_pool[descriptor_type_binding(type)];
+        auto index = pool.back();
+        pool.pop_back();
+
+        return index;
+    }
+
+    void free(uint32_t index, VkDescriptorType type) {
+        index_pool[descriptor_type_binding(type)].push_back(index);
+    }
+
+    int32_t descriptor_type_binding(VkDescriptorType type) {
+        switch(type) {
+            case VK_DESCRIPTOR_TYPE_SAMPLER:
+                 return 0;
+            case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+                 return 1;
+            case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+                return 2;
+            default:
+                std::cerr << "descriptor type not supported" << std::endl;
+                return -1;
         }
     }
 };
@@ -65,14 +97,14 @@ class vkapi {
 
         Buffer create_buffer(size_t data_size, VkBufferUsageFlags buffer_usage, VmaMemoryUsage mem_usage);
         void copy_buffer(VkCommandBuffer cmd_buf, Buffer src, Buffer dst, size_t size);
-        void copy_buffer(VkCommandBuffer cmd_buf, Buffer src, Image dst);
+        void copy_buffer(VkCommandBuffer cmd_buf, Buffer src, image dst);
         void destroy_buffer(Buffer& buffer);
 
 
-        Image create_image(VkExtent3D size, VkFormat format, VkImageUsageFlags usages);
-        void destroy_image(Image &image);
-        std::vector<Image> create_images(VkExtent3D size, VkFormat format, VkImageUsageFlags usages, size_t image_count);
-        void destroy_images(std::vector<Image> &images);
+        image create_image(VkExtent3D size, VkFormat format, VkImageUsageFlags usages);
+        void destroy_image(image &image);
+        std::vector<image> create_images(VkExtent3D size, VkFormat format, VkImageUsageFlags usages, size_t image_count);
+        void destroy_images(std::vector<image> &images);
 
 
         VkFence create_fence();
@@ -86,8 +118,8 @@ class vkapi {
         std::vector<VkSemaphore> create_semaphores(size_t semaphores_count);
         void destroy_semaphores(std::vector<VkSemaphore> &semaphores);
 
-        VkSampler create_sampler(VkFilter filter, VkSamplerAddressMode address_mode);
-        void destroy_sampler(VkSampler sampler);
+        sampler create_sampler(VkFilter filter, VkSamplerAddressMode address_mode);
+        void destroy_sampler(sampler sampler);
 
 
         std::vector<VkCommandBuffer> create_command_buffers(size_t command_buffers_count);
@@ -99,14 +131,14 @@ class vkapi {
         void destroy_render_pass(VkRenderPass render_pass);
 
 
-        VkFramebuffer create_framebuffer(VkRenderPass render_pass, std::vector<Image>& images, VkExtent2D size);
-        std::vector<VkFramebuffer> create_framebuffers(VkRenderPass render_pass, std::vector<Image>& images, VkExtent2D size, uint32_t framebuffer_count);
+        VkFramebuffer create_framebuffer(VkRenderPass render_pass, std::vector<image>& images, VkExtent2D size);
+        std::vector<VkFramebuffer> create_framebuffers(VkRenderPass render_pass, std::vector<image>& images, VkExtent2D size, uint32_t framebuffer_count);
         void destroy_framebuffer(VkFramebuffer framebuffer);
         void destroy_framebuffers(std::vector<VkFramebuffer>& framebuffers);
 
 
         Pipeline create_compute_pipeline(const char* shader_name);
-        Pipeline create_graphics_pipeline(const char* shader_name, std::vector<VkDescriptorSetLayoutBinding>& bindings, VkShaderStageFlagBits shader_stages, VkRenderPass render_pass, std::vector<VkDynamicState> dynamic_states);
+        Pipeline create_graphics_pipeline(const char* shader_name, VkShaderStageFlagBits shader_stages, VkRenderPass render_pass, std::vector<VkDynamicState> dynamic_states);
         void destroy_pipeline(Pipeline &pipeline);
 
 
@@ -121,25 +153,23 @@ class vkapi {
         Swapchain create_swapchain(VkSurfaceKHR surface, size_t min_image_count, VkImageUsageFlags usages, VkSwapchainKHR old_swapchain);
         void destroy_swapchain(Swapchain& swapchain);
 
-        void update_descriptor_set_buffer(VkDescriptorSet set, VkDescriptorSetLayoutBinding binding, Buffer& buffer);
-        void update_descriptor_set_buffer(VkDescriptorSet set, VkDescriptorSetLayoutBinding binding, Buffer& buffer, VkDeviceSize offset, VkDeviceSize range);
-        void update_descriptor_set_image(VkDescriptorSet set, VkDescriptorSetLayoutBinding binding, VkImageView view, VkSampler sampler);
-        void update_bindless_descriptor_set_images(std::vector<Image> &images, std::vector<VkSampler> &samplers);
+        void update_descriptor_images(std::vector<image> &images, VkDescriptorType type);
+        void update_descriptor_samplers(std::vector<sampler> &samplers);
 
 
         void start_record(VkCommandBuffer command_buffer);
 
-        void image_barrier(VkCommandBuffer command_buffer, VkImageLayout src_layout, VkImageLayout dst_layout, VkPipelineStageFlagBits src_stage, VkPipelineStageFlagBits dst_stage, VkAccessFlags src_access, VkAccessFlags dst_access, Image image);
+        void image_barrier(VkCommandBuffer command_buffer, VkImageLayout src_layout, VkImageLayout dst_layout, VkPipelineStageFlagBits src_stage, VkPipelineStageFlagBits dst_stage, VkAccessFlags src_access, VkAccessFlags dst_access, image image);
 
         void begin_render_pass(VkCommandBuffer command_buffer, VkRenderPass render_pass, VkFramebuffer framebuffer, VkExtent2D size, Pipeline pipeline);
         void end_render_pass(VkCommandBuffer command_buffer);
 
         void run_compute_pipeline(VkCommandBuffer command_buffer, Pipeline pipeline, size_t group_count_x, size_t group_count_y, size_t group_count_z);
 
-        void draw(VkCommandBuffer command_buffer, Pipeline pipeline, VkDescriptorSet set, uint32_t vertex_count, uint32_t vertex_offset);
-        void draw(VkCommandBuffer command_buffer, Pipeline pipeline, VkDescriptorSet set, Buffer index_buffer, uint32_t primitive_count, uint32_t indices_offset, uint32_t vertices_offset);
+        void draw(VkCommandBuffer command_buffer, Pipeline pipeline, uint32_t vertex_count, uint32_t vertex_offset);
+        void draw(VkCommandBuffer command_buffer, Pipeline pipeline, Buffer index_buffer, uint32_t primitive_count, uint32_t indices_offset, uint32_t vertices_offset);
 
-        void blit_full(VkCommandBuffer command_buffer, Image src_image, Image dst_image);
+        void blit_full(VkCommandBuffer command_buffer, image src_image, image dst_image);
 
         void end_record(VkCommandBuffer command_buffer);
 
diff --git a/include/vk-renderer.hpp b/include/vk-renderer.hpp
index 6b256d3..7024fd7 100644
--- a/include/vk-renderer.hpp
+++ b/include/vk-renderer.hpp
@@ -44,9 +44,9 @@ class vkrenderer {
         uint32_t                        virtual_frame_index = 0;
         uint32_t                        swapchain_image_index = 0;
 
-        std::vector<Image>              accumulation_images;
-        VkSampler                       ui_texture_sampler;
-        Image                           ui_texture;
+        std::vector<image>              accumulation_images;
+        sampler                         ui_texture_sampler;
+        image                           ui_texture;
 
         std::vector<VkCommandBuffer>    command_buffers;
 
@@ -59,11 +59,8 @@ class vkrenderer {
 
         Pipeline                        tonemapping_pipeline;
 
-        std::vector<VkDescriptorSetLayoutBinding> ui_sets_bindings;
-        std::vector<Buffer>             ui_transforms_buffers;
         std::vector<Buffer>             ui_vertex_buffers;
         std::vector<Buffer>             ui_index_buffers;
-        std::vector<VkDescriptorSet>    ui_sets;
         Pipeline                        ui_pipeline;
         VkRenderPass                    render_pass;
         std::vector<VkFramebuffer>      framebuffers;
diff --git a/shaders/compute.comp b/shaders/compute.comp
index db5756c..0696f6d 100644
--- a/shaders/compute.comp
+++ b/shaders/compute.comp
@@ -94,7 +94,7 @@ layout(buffer_reference) readonly buffer nodes_array {
     bvh_node[] nodes;
 };
 
-layout(set = 0, binding = 0, rgba32f) uniform image2D images[];
+layout(set = 0, binding = 2, rgba32f) uniform image2D images[];
 
 layout(push_constant) uniform buffers {
     scene_metadata scene;
diff --git a/shaders/tonemapping.comp b/shaders/tonemapping.comp
index 5613d55..94c7479 100644
--- a/shaders/tonemapping.comp
+++ b/shaders/tonemapping.comp
@@ -8,7 +8,7 @@ layout(buffer_reference) readonly buffer scene_metadata {
     uint downscale_factor;

 };

 

-layout(set = 0, binding = 0, rgba32f) uniform image2D images[];

+layout(set = 0, binding = 2, rgba32f) uniform image2D images[];

 

 layout(push_constant) uniform constants {

     scene_metadata scene;

diff --git a/shaders/ui.frag b/shaders/ui.frag
index 78833d1..c4e0150 100644
--- a/shaders/ui.frag
+++ b/shaders/ui.frag
@@ -1,3 +1,5 @@
+#extension GL_EXT_nonuniform_qualifier : require

+

 layout(location = 0) out vec4 o_Color;

 

 layout(location = 0) in struct {

@@ -5,8 +7,14 @@ layout(location = 0) in struct {
     vec4 color;

 } In;

 

-layout(set = 0, binding = 2) uniform sampler2D atlas;

+layout(set = 0, binding = 0) uniform sampler samplers[];

+layout(set = 0, binding = 1) uniform texture2D textures[];

+

+layout(push_constant) uniform constants {

+    layout(offset = 56) uint texture_index;

+    uint sampler_index;

+} consts;

 

 void main() {

-    o_Color = In.color * texture(atlas, In.uv.xy);

+    o_Color = In.color * texture(sampler2D(textures[consts.texture_index], samplers[consts.sampler_index]), In.uv.xy);

 }

diff --git a/shaders/ui.vert b/shaders/ui.vert
index c935357..dd71ef6 100644
--- a/shaders/ui.vert
+++ b/shaders/ui.vert
@@ -1,17 +1,21 @@
-struct Vertex {

+#extension GL_EXT_buffer_reference : require

+

+struct vertex {

     vec2    pos;

     vec2    uv;

     uint    color;

+    uint[3] padding;

 };

 

-layout(set = 0, binding = 0) uniform Vertices {

-    Vertex vertices[158];

+layout(buffer_reference) readonly buffer vertices {

+    vertex vertices[];

 };

 

-layout(set = 0, binding = 1) uniform UiTransforms {

+layout(push_constant) uniform constants {

+    layout(offset = 32) vertices vertex_buffer;

     vec2 scale;

     vec2 translate;

-};

+} consts;

 

 out gl_PerVertex {

     vec4 gl_Position;

@@ -24,10 +28,10 @@ layout(location = 0) out struct {
 

 

 void main() {

-    Vertex v = vertices[gl_VertexIndex];

+    vertex v = consts.vertex_buffer.vertices[gl_VertexIndex];

 

     Out.color = unpackUnorm4x8(v.color);

     Out.uv = v.uv;

 

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

+    gl_Position = vec4(v.pos * consts.scale + consts.translate, 0.0, 1.0);

 }

diff --git a/src/vk-api.cpp b/src/vk-api.cpp
index 33b32ee..795fa42 100644
--- a/src/vk-api.cpp
+++ b/src/vk-api.cpp
@@ -24,15 +24,15 @@ vkapi::vkapi() {
             .descriptorCount                    = (uint32_t)1024,
         },
         {
-            .type                               = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+            .type                               = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
             .descriptorCount                    = (uint32_t)1024,
         },
         {
-            .type                               = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
+            .type                               = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
             .descriptorCount                    = (uint32_t)1024,
         },
         {
-            .type                               = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+            .type                               = VK_DESCRIPTOR_TYPE_SAMPLER,
             .descriptorCount                    = (uint32_t)1024,
         }
     };
@@ -51,18 +51,34 @@ vkapi::vkapi() {
      VkDescriptorSetLayoutBinding bindless_layout_bindings[] = {
             {
                 .binding = 0,
+                .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER,
+                .descriptorCount = 1024,
+                .stageFlags = VK_SHADER_STAGE_ALL,
+            },
+            {
+                .binding = 1,
+                .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
+                .descriptorCount = 1024,
+                .stageFlags = VK_SHADER_STAGE_ALL,
+            },
+            {
+                .binding = 2,
                 .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
                 .descriptorCount = 1024,
                 .stageFlags = VK_SHADER_STAGE_ALL,
             },
     };
 
-    VkDescriptorBindingFlags flag = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT | VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT;
+    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 descriptor_set_layout_binding_flags = {};
     descriptor_set_layout_binding_flags.sType           = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
     descriptor_set_layout_binding_flags.pNext           = VK_NULL_HANDLE;
-    descriptor_set_layout_binding_flags.bindingCount    = 1;
-    descriptor_set_layout_binding_flags.pBindingFlags   = &flag;
+    descriptor_set_layout_binding_flags.bindingCount    = sizeof(flags) / sizeof(VkDescriptorBindingFlags);
+    descriptor_set_layout_binding_flags.pBindingFlags   = flags;
 
     VkDescriptorSetLayoutCreateInfo descriptor_set_layout_create_info = {};
     descriptor_set_layout_create_info.sType         = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
@@ -74,10 +90,23 @@ vkapi::vkapi() {
     VKRESULT(vkCreateDescriptorSetLayout(context.device, &descriptor_set_layout_create_info, nullptr, &bindless_descriptor.set_layout))
 
 
-    VkPushConstantRange push_constant               = {};
-    push_constant.stageFlags                        = VK_SHADER_STAGE_COMPUTE_BIT;
-    push_constant.offset                            = 0;
-    push_constant.size                              = 64;
+    VkPushConstantRange push_constants[] = {
+        {
+            .stageFlags                        = VK_SHADER_STAGE_COMPUTE_BIT,
+            .offset                            = 0,
+            .size                              = 32,
+        },
+        {
+            .stageFlags                        = VK_SHADER_STAGE_VERTEX_BIT,
+            .offset                            = 32,
+            .size                              = 24,
+        },
+        {
+            .stageFlags                        = VK_SHADER_STAGE_FRAGMENT_BIT,
+            .offset                            = 56,
+            .size                              = 8,
+        },
+    };
 
     VkPipelineLayoutCreateInfo layout_create_info   = {};
     layout_create_info.sType                        = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
@@ -85,8 +114,8 @@ vkapi::vkapi() {
     layout_create_info.flags                        = 0;
     layout_create_info.setLayoutCount               = 1;
     layout_create_info.pSetLayouts                  = &bindless_descriptor.set_layout;
-    layout_create_info.pushConstantRangeCount       = 1;
-    layout_create_info.pPushConstantRanges          = &push_constant;
+    layout_create_info.pushConstantRangeCount       = sizeof(push_constants) / sizeof(VkPushConstantRange);
+    layout_create_info.pPushConstantRanges          = push_constants;
 
     VKRESULT(vkCreatePipelineLayout(context.device, &layout_create_info, nullptr, &bindless_descriptor.pipeline_layout))
 
@@ -147,7 +176,7 @@ void vkapi::copy_buffer(VkCommandBuffer cmd_buf, Buffer src, Buffer dst, size_t
     vkCmdCopyBuffer(cmd_buf, src.handle, dst.handle, 1, &buffer_copy);
 }
 
-void vkapi::copy_buffer(VkCommandBuffer cmd_buf, Buffer src, Image dst) {
+void vkapi::copy_buffer(VkCommandBuffer cmd_buf, Buffer src, image dst) {
     VkImageSubresourceLayers image_subresource_layers   = {};
     image_subresource_layers.aspectMask                 = dst.subresource_range.aspectMask;
     image_subresource_layers.mipLevel                   = 0;
@@ -170,8 +199,8 @@ void vkapi::destroy_buffer(Buffer& buffer) {
 }
 
 
-Image vkapi::create_image(VkExtent3D size, VkFormat format, VkImageUsageFlags usages) {
-    Image image;
+image vkapi::create_image(VkExtent3D size, VkFormat format, VkImageUsageFlags usages) {
+    image image;
 
     image.size = size;
 
@@ -220,20 +249,21 @@ Image vkapi::create_image(VkExtent3D size, VkFormat format, VkImageUsageFlags us
 
     VKRESULT(vkCreateImageView(context.device, &image_view_create_info, VK_NULL_HANDLE, &image.view))
 
-    image.bindless_index = bindless_descriptor.indices.back();
-    bindless_descriptor.indices.pop_back();
+    image.bindless_storage_index = bindless_descriptor.allocate(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE);
+    image.bindless_sampled_index = bindless_descriptor.allocate(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
 
     return std::move(image);
 }
-void vkapi::destroy_image(Image &image) {
-    bindless_descriptor.indices.push_back(image.bindless_index);
+void vkapi::destroy_image(image &image) {
+    bindless_descriptor.free(image.bindless_storage_index, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE);
+    bindless_descriptor.free(image.bindless_sampled_index, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
 
     vmaDestroyImage(context.allocator, image.handle, image.alloc);
     vkDestroyImageView(context.device, image.view, nullptr);
 }
 
-std::vector<Image> vkapi::create_images(VkExtent3D size, VkFormat format, VkImageUsageFlags usages, size_t image_count) {
-    std::vector<Image> images { image_count };
+std::vector<image> vkapi::create_images(VkExtent3D size, VkFormat format, VkImageUsageFlags usages, size_t image_count) {
+    std::vector<image> images { image_count };
 
     for (size_t image_index = 0; image_index < image_count; image_index++) {
         images[image_index] = create_image(size, format, usages);
@@ -242,7 +272,7 @@ std::vector<Image> vkapi::create_images(VkExtent3D size, VkFormat format, VkImag
     return std::move(images);
 }
 
-void vkapi::destroy_images(std::vector<Image> &images) {
+void vkapi::destroy_images(std::vector<image> &images) {
     for (auto &image: images) {
         destroy_image(image);
     }
@@ -315,7 +345,7 @@ void vkapi::destroy_semaphores(std::vector<VkSemaphore> &semaphores) {
 }
 
 
-VkSampler vkapi::create_sampler(VkFilter filter, VkSamplerAddressMode address_mode) {
+sampler vkapi::create_sampler(VkFilter filter, VkSamplerAddressMode address_mode) {
     VkSamplerCreateInfo sampler_create_info     = {};
     sampler_create_info.sType                   = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
     sampler_create_info.pNext                   = VK_NULL_HANDLE;
@@ -335,14 +365,18 @@ VkSampler vkapi::create_sampler(VkFilter filter, VkSamplerAddressMode address_mo
     sampler_create_info.borderColor             = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
     sampler_create_info.unnormalizedCoordinates = VK_FALSE;
 
-    VkSampler sampler;
-    VKRESULT(vkCreateSampler(context.device, &sampler_create_info, VK_NULL_HANDLE, &sampler))
+    sampler sampler;
+    VKRESULT(vkCreateSampler(context.device, &sampler_create_info, VK_NULL_HANDLE, &sampler.handle))
+
+    sampler.bindless_index = bindless_descriptor.allocate(VK_DESCRIPTOR_TYPE_SAMPLER);
 
-    return sampler;
+    return std::move(sampler);
 }
 
-void vkapi::destroy_sampler(VkSampler sampler) {
-    vkDestroySampler(context.device, sampler, VK_NULL_HANDLE);
+void vkapi::destroy_sampler(sampler sampler) {
+    bindless_descriptor.free(sampler.bindless_index, VK_DESCRIPTOR_TYPE_SAMPLER);
+
+    vkDestroySampler(context.device, sampler.handle, VK_NULL_HANDLE);
 }
 
 
@@ -422,7 +456,7 @@ void vkapi::destroy_render_pass(VkRenderPass render_pass) {
 }
 
 
-VkFramebuffer vkapi::create_framebuffer(VkRenderPass render_pass, std::vector<Image>& images, VkExtent2D size) {
+VkFramebuffer vkapi::create_framebuffer(VkRenderPass render_pass, std::vector<image>& images, VkExtent2D size) {
     VkFramebuffer framebuffer;
     std::vector<VkImageView> attachements;
     for (auto& image: images) {
@@ -445,7 +479,7 @@ VkFramebuffer vkapi::create_framebuffer(VkRenderPass render_pass, std::vector<Im
     return framebuffer;
 }
 
-std::vector<VkFramebuffer> vkapi::create_framebuffers(VkRenderPass render_pass, std::vector<Image>& images, VkExtent2D size, uint32_t framebuffer_count) {
+std::vector<VkFramebuffer> vkapi::create_framebuffers(VkRenderPass render_pass, std::vector<image>& images, VkExtent2D size, uint32_t framebuffer_count) {
     std::vector<VkFramebuffer> framebuffers { framebuffer_count };
 
     for (auto& framebuffer: framebuffers) {
@@ -518,7 +552,7 @@ Pipeline vkapi::create_compute_pipeline(const char* shader_name) {
     return std::move(pipeline);
 }
 
-Pipeline vkapi::create_graphics_pipeline(const char* shader_name, std::vector<VkDescriptorSetLayoutBinding>& bindings, VkShaderStageFlagBits shader_stages, VkRenderPass render_pass, std::vector<VkDynamicState> dynamic_states) {
+Pipeline vkapi::create_graphics_pipeline(const char* shader_name, VkShaderStageFlagBits shader_stages, VkRenderPass render_pass, std::vector<VkDynamicState> dynamic_states) {
     Pipeline pipeline {
         .bind_point = VK_PIPELINE_BIND_POINT_GRAPHICS
     };
@@ -561,28 +595,6 @@ Pipeline vkapi::create_graphics_pipeline(const char* shader_name, std::vector<Vk
     }
 
 
-    VkDescriptorSetLayoutCreateInfo descriptor_set_layout_create_info = {};
-    descriptor_set_layout_create_info.sType         = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
-    descriptor_set_layout_create_info.pNext         = nullptr;
-    descriptor_set_layout_create_info.flags         = 0;
-    descriptor_set_layout_create_info.bindingCount  = bindings.size();
-    descriptor_set_layout_create_info.pBindings     = bindings.data();
-
-    VKRESULT(vkCreateDescriptorSetLayout(context.device, &descriptor_set_layout_create_info, nullptr, &pipeline.descriptor_set_layout))
-
-
-    VkPipelineLayoutCreateInfo layout_create_info   = {};
-    layout_create_info.sType                        = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
-    layout_create_info.pNext                        = nullptr;
-    layout_create_info.flags                        = 0;
-    layout_create_info.setLayoutCount               = 1;
-    layout_create_info.pSetLayouts                  = &pipeline.descriptor_set_layout;
-    layout_create_info.pushConstantRangeCount       = 0;
-    layout_create_info.pPushConstantRanges          = nullptr;
-
-    VKRESULT(vkCreatePipelineLayout(context.device, &layout_create_info, nullptr, &pipeline.layout))
-
-
     VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info     = {};
     vertex_input_state_create_info.sType                                    = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
 
@@ -659,7 +671,7 @@ Pipeline vkapi::create_graphics_pipeline(const char* shader_name, std::vector<Vk
     pipeline_create_info.pMultisampleState                                  = &multisample_state_create_info;
     pipeline_create_info.pColorBlendState                                   = &color_blend_state_create_info;
     pipeline_create_info.pDynamicState                                      = &dynamic_state_create_info;
-    pipeline_create_info.layout                                             = pipeline.layout;
+    pipeline_create_info.layout                                             = bindless_descriptor.pipeline_layout;
     pipeline_create_info.renderPass                                         = render_pass;
     pipeline_create_info.subpass                                            = 0;
 
@@ -673,8 +685,6 @@ void vkapi::destroy_pipeline(Pipeline &pipeline) {
         vkDestroyShaderModule(context.device, shader_module, nullptr);
     }
 
-    vkDestroyDescriptorSetLayout(context.device, pipeline.descriptor_set_layout, nullptr);
-    vkDestroyPipelineLayout(context.device, pipeline.layout, nullptr);
     vkDestroyPipeline(context.device, pipeline.handle, nullptr);
 }
 
@@ -802,7 +812,7 @@ Swapchain vkapi::create_swapchain(VkSurfaceKHR surface, size_t min_image_count,
     VKRESULT(vkGetSwapchainImagesKHR(context.device, swapchain.handle, &image_count, VK_NULL_HANDLE))
 
     swapchain.image_count = image_count;
-    swapchain.images = std::vector<Image>{ swapchain.image_count };
+    swapchain.images = std::vector<image>{ swapchain.image_count };
     auto images = std::vector<VkImage>{ swapchain.image_count };
     auto views = std::vector<VkImageView>{ swapchain.image_count };
 
@@ -822,8 +832,8 @@ Swapchain vkapi::create_swapchain(VkSurfaceKHR surface, size_t min_image_count,
     };
 
     for (size_t image_index = 0; image_index < swapchain.image_count; image_index++) {
-        swapchain.images[image_index].bindless_index = bindless_descriptor.indices.back();
-        bindless_descriptor.indices.pop_back();
+        swapchain.images[image_index].bindless_storage_index = bindless_descriptor.allocate(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE);
+        swapchain.images[image_index].bindless_sampled_index = bindless_descriptor.allocate(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
 
         swapchain.images[image_index].handle = images[image_index];
         swapchain.images[image_index].size = image_size;
@@ -852,7 +862,8 @@ Swapchain vkapi::create_swapchain(VkSurfaceKHR surface, size_t min_image_count,
 
 void vkapi::destroy_swapchain(Swapchain& swapchain) {
     for(auto &image: swapchain.images) {
-        bindless_descriptor.indices.push_back(image.bindless_index);
+        bindless_descriptor.free(image.bindless_storage_index, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE);
+        bindless_descriptor.free(image.bindless_sampled_index, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
 
         vkDestroyImageView(context.device, image.view, nullptr);
     }
@@ -860,68 +871,23 @@ void vkapi::destroy_swapchain(Swapchain& swapchain) {
 }
 
 
-void vkapi::update_descriptor_set_buffer(VkDescriptorSet set, VkDescriptorSetLayoutBinding binding, Buffer& buffer) {
-    update_descriptor_set_buffer(set, binding, buffer, 0, VK_WHOLE_SIZE);
-}
-
-void vkapi::update_descriptor_set_buffer(VkDescriptorSet set, VkDescriptorSetLayoutBinding binding, Buffer& buffer, VkDeviceSize offset, VkDeviceSize range) {
-    VkDescriptorBufferInfo descriptor_buffer_info = {};
-    descriptor_buffer_info.buffer           = buffer.handle;
-    descriptor_buffer_info.offset           = 0;
-    descriptor_buffer_info.range            = VK_WHOLE_SIZE;
-
-    VkWriteDescriptorSet write_descriptor   = {};
-    write_descriptor.sType                  = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-    write_descriptor.pNext                  = nullptr;
-    write_descriptor.dstSet                 = set;
-    write_descriptor.dstBinding             = binding.binding;
-    write_descriptor.dstArrayElement        = 0;
-    write_descriptor.descriptorCount        = binding.descriptorCount;
-    write_descriptor.descriptorType         = binding.descriptorType;
-    write_descriptor.pImageInfo             = VK_NULL_HANDLE;
-    write_descriptor.pBufferInfo            = &descriptor_buffer_info;
-    write_descriptor.pTexelBufferView       = VK_NULL_HANDLE;
-
-    vkUpdateDescriptorSets(context.device, 1, &write_descriptor, 0, nullptr);
-}
-
-void vkapi::update_descriptor_set_image(VkDescriptorSet set, VkDescriptorSetLayoutBinding binding, VkImageView view, VkSampler sampler) {
-    VkDescriptorImageInfo descriptor_image_info = {};
-    descriptor_image_info.sampler               = sampler;
-    descriptor_image_info.imageView             = view;
-    descriptor_image_info.imageLayout           = VK_IMAGE_LAYOUT_GENERAL;
-
-    VkWriteDescriptorSet write_descriptor       = {};
-    write_descriptor.sType                      = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-    write_descriptor.pNext                      = nullptr;
-    write_descriptor.dstSet                     = set;
-    write_descriptor.dstBinding                 = binding.binding;
-    write_descriptor.dstArrayElement            = 0;
-    write_descriptor.descriptorCount            = binding.descriptorCount;
-    write_descriptor.descriptorType             = binding.descriptorType;
-    write_descriptor.pImageInfo                 = &descriptor_image_info;
-    write_descriptor.pBufferInfo                = VK_NULL_HANDLE;
-    write_descriptor.pTexelBufferView           = VK_NULL_HANDLE;
-
-    vkUpdateDescriptorSets(context.device, 1, &write_descriptor, 0, nullptr);
-}
-
-void vkapi::update_bindless_descriptor_set_images(std::vector<Image> &images, std::vector<VkSampler> &samplers) {
+void vkapi::update_descriptor_images(std::vector<image> &images, VkDescriptorType type) {
     std::vector<VkDescriptorImageInfo> descriptor_images_info   { images.size() };
     std::vector<VkWriteDescriptorSet> writes_descriptor         { images.size() };
 
     for (size_t image_index = 0; image_index < images.size(); image_index++) {
-        descriptor_images_info[image_index].sampler         = samplers[image_index];
-        descriptor_images_info[image_index].imageView       = images[image_index].view;
+        auto &image = images[image_index];
+        descriptor_images_info[image_index].sampler         = VK_NULL_HANDLE;
+        descriptor_images_info[image_index].imageView       = image.view;
         descriptor_images_info[image_index].imageLayout     = VK_IMAGE_LAYOUT_GENERAL;
 
         writes_descriptor[image_index].sType                = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
         writes_descriptor[image_index].pNext                = nullptr;
         writes_descriptor[image_index].dstSet               = bindless_descriptor.set;
-        writes_descriptor[image_index].dstBinding           = 0;
-        writes_descriptor[image_index].dstArrayElement      = images[image_index].bindless_index;
+        writes_descriptor[image_index].dstBinding           = type == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE ? 2 : 1;
+        writes_descriptor[image_index].dstArrayElement      = type == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE ? image.bindless_storage_index : image.bindless_sampled_index;
         writes_descriptor[image_index].descriptorCount      = 1;
-        writes_descriptor[image_index].descriptorType       = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
+        writes_descriptor[image_index].descriptorType       = type;
         writes_descriptor[image_index].pImageInfo           = &descriptor_images_info[image_index];
         writes_descriptor[image_index].pBufferInfo          = VK_NULL_HANDLE;
         writes_descriptor[image_index].pTexelBufferView     = VK_NULL_HANDLE;
@@ -930,6 +896,30 @@ void vkapi::update_bindless_descriptor_set_images(std::vector<Image> &images, st
     vkUpdateDescriptorSets(context.device, writes_descriptor.size(), writes_descriptor.data(), 0, nullptr);
 }
 
+void vkapi::update_descriptor_samplers(std::vector<sampler> &samplers) {
+    std::vector<VkDescriptorImageInfo> descriptor_images_info   { samplers.size() };
+    std::vector<VkWriteDescriptorSet> writes_descriptor         { samplers.size() };
+
+    for (size_t sampler_index = 0; sampler_index < samplers.size(); sampler_index++) {
+        descriptor_images_info[sampler_index].sampler         = samplers[sampler_index].handle;
+        descriptor_images_info[sampler_index].imageView       = VK_NULL_HANDLE;
+        descriptor_images_info[sampler_index].imageLayout     = VK_IMAGE_LAYOUT_GENERAL;
+
+        writes_descriptor[sampler_index].sType                = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+        writes_descriptor[sampler_index].pNext                = nullptr;
+        writes_descriptor[sampler_index].dstSet               = bindless_descriptor.set;
+        writes_descriptor[sampler_index].dstBinding           = 0;
+        writes_descriptor[sampler_index].dstArrayElement      = samplers[sampler_index].bindless_index;
+        writes_descriptor[sampler_index].descriptorCount      = 1;
+        writes_descriptor[sampler_index].descriptorType       = VK_DESCRIPTOR_TYPE_SAMPLER;
+        writes_descriptor[sampler_index].pImageInfo           = &descriptor_images_info[sampler_index];
+        writes_descriptor[sampler_index].pBufferInfo          = VK_NULL_HANDLE;
+        writes_descriptor[sampler_index].pTexelBufferView     = VK_NULL_HANDLE;
+    }
+
+    vkUpdateDescriptorSets(context.device, writes_descriptor.size(), writes_descriptor.data(), 0, nullptr);
+}
+
 
 void vkapi::start_record(VkCommandBuffer command_buffer) {
     VkCommandBufferBeginInfo cmd_buf_begin_info = {};
@@ -941,7 +931,7 @@ void vkapi::start_record(VkCommandBuffer command_buffer) {
     vkBeginCommandBuffer(command_buffer, &cmd_buf_begin_info);
 }
 
-void vkapi::image_barrier(VkCommandBuffer command_buffer, VkImageLayout src_layout, VkImageLayout dst_layout, VkPipelineStageFlagBits src_stage, VkPipelineStageFlagBits dst_stage, VkAccessFlags src_access, VkAccessFlags dst_access, Image image) {
+void vkapi::image_barrier(VkCommandBuffer command_buffer, VkImageLayout src_layout, VkImageLayout dst_layout, VkPipelineStageFlagBits src_stage, VkPipelineStageFlagBits dst_stage, VkAccessFlags src_access, VkAccessFlags dst_access, image image) {
     VkImageMemoryBarrier undefined_to_general_barrier   = {};
     undefined_to_general_barrier.sType                  = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
     undefined_to_general_barrier.pNext                  = nullptr;
@@ -1005,21 +995,21 @@ void vkapi::run_compute_pipeline(VkCommandBuffer command_buffer, Pipeline pipeli
     vkCmdDispatch(command_buffer, group_count_x, group_count_y, group_count_z);
 }
 
-void vkapi::draw(VkCommandBuffer command_buffer, Pipeline pipeline, VkDescriptorSet set, uint32_t vertex_count, uint32_t vertex_offset) {
-    vkCmdBindDescriptorSets(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.layout, 0, 1, &set, 0, nullptr);
+void vkapi::draw(VkCommandBuffer command_buffer, Pipeline pipeline, uint32_t vertex_count, uint32_t vertex_offset) {
+    vkCmdBindDescriptorSets(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, bindless_descriptor.pipeline_layout, 0, 1, &bindless_descriptor.set, 0, nullptr);
     vkCmdBindPipeline(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.handle);
 
     vkCmdDraw(command_buffer, vertex_count, 1, vertex_offset, 0);
 }
 
-void vkapi::draw(VkCommandBuffer command_buffer, Pipeline pipeline, VkDescriptorSet set, Buffer index_buffer, uint32_t index_count, uint32_t index_offset, uint32_t vertex_offset) {
+void vkapi::draw(VkCommandBuffer command_buffer, Pipeline pipeline, Buffer index_buffer, uint32_t index_count, uint32_t index_offset, uint32_t vertex_offset) {
     vkCmdBindIndexBuffer(command_buffer, index_buffer.handle, 0, VK_INDEX_TYPE_UINT16);
-    vkCmdBindDescriptorSets(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.layout, 0, 1, &set, 0, nullptr);
+    vkCmdBindDescriptorSets(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, bindless_descriptor.pipeline_layout, 0, 1, &bindless_descriptor.set, 0, nullptr);
 
     vkCmdDrawIndexed(command_buffer, index_count, 1, index_offset, vertex_offset, 0);
 }
 
-void vkapi::blit_full(VkCommandBuffer command_buffer, Image src_image, Image dst_image) {
+void vkapi::blit_full(VkCommandBuffer command_buffer, image src_image, image dst_image) {
     VkImageSubresourceLayers images_subres_layers {
         .aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT,
         .mipLevel       = 0,
diff --git a/src/vk-renderer.cpp b/src/vk-renderer.cpp
index 4d7646a..54a0008 100644
--- a/src/vk-renderer.cpp
+++ b/src/vk-renderer.cpp
@@ -55,44 +55,21 @@ vkrenderer::vkrenderer(window& wnd, size_t scene_buffer_size, size_t geometry_bu
     geometry_buffer = api.create_buffer(geometry_buffer_size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VMA_MEMORY_USAGE_GPU_ONLY);
     bvh_buffer = api.create_buffer(bvh_buffer_size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VMA_MEMORY_USAGE_GPU_ONLY);
 
+
     std::vector<VkFormat> attachments_format { swapchain.surface_format.format };
     render_pass = api.create_render_pass(attachments_format, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
 
-    for (auto& image : swapchain.images) {
-        std::vector<Image> attachments { image };
+    for (auto& current_image : swapchain.images) {
+        std::vector<image> attachments { current_image };
         framebuffers.push_back(api.create_framebuffer(render_pass, attachments, swapchain.extent));
     }
 
-    ui_sets_bindings = {
-        {
-            .binding = 0,
-            .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-            .descriptorCount = 1,
-            .stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
-            .pImmutableSamplers = VK_NULL_HANDLE,
-        },
-        {
-            .binding = 1,
-            .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-            .descriptorCount = 1,
-            .stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
-            .pImmutableSamplers = VK_NULL_HANDLE,
-        },
-        {
-            .binding = 2,
-            .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
-            .descriptorCount = 1,
-            .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
-            .pImmutableSamplers = VK_NULL_HANDLE,
-        },
-    };
 
     std::vector<VkDynamicState> dynamic_states {
         VK_DYNAMIC_STATE_VIEWPORT,
         VK_DYNAMIC_STATE_SCISSOR
     };
-    ui_pipeline = api.create_graphics_pipeline("ui", ui_sets_bindings, (VkShaderStageFlagBits)(VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT), render_pass, dynamic_states);
-    ui_sets = api.create_descriptor_sets(ui_pipeline.descriptor_set_layout, virtual_frames_count);
+    ui_pipeline = api.create_graphics_pipeline("ui", (VkShaderStageFlagBits)(VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT), render_pass, dynamic_states);
 
     ImGui::CreateContext();
     auto io = ImGui::GetIO();
@@ -136,7 +113,7 @@ vkrenderer::vkrenderer(window& wnd, size_t scene_buffer_size, size_t geometry_bu
 
     api.destroy_buffer(staging_buffer);
 
-    std::vector<Image> images = {
+    std::vector<image> images = {
         accumulation_images[0],
         accumulation_images[1],
 
@@ -144,25 +121,25 @@ vkrenderer::vkrenderer(window& wnd, size_t scene_buffer_size, size_t geometry_bu
         swapchain.images[1],
         swapchain.images[2]
     };
-    std::vector<VkSampler> samplers { images.size(), VK_NULL_HANDLE };
 
-    api.update_bindless_descriptor_set_images(images, samplers);
+    api.update_descriptor_images(images, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE);
 
-    virtual_frame_index++;
+    std::vector<image> sampled_images = {
+        ui_texture
+    };
+    api.update_descriptor_images(sampled_images, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
 
     ui_texture_sampler = api.create_sampler(VK_FILTER_LINEAR, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE);
 
-    for (size_t index = 0; index < virtual_frames_count; index++) {
-        api.update_descriptor_set_image(ui_sets[index], ui_sets_bindings[2], ui_texture.view, ui_texture_sampler);
-    }
+    std::vector<sampler> samplers = {
+        ui_texture_sampler,
+    };
+    api.update_descriptor_samplers(samplers);
+
+    virtual_frame_index++;
 
     ui_vertex_buffers.resize(virtual_frames_count);
     ui_index_buffers.resize(virtual_frames_count);
-
-    for (size_t index = 0; index < virtual_frames_count; index++) {
-        ui_transforms_buffers.push_back(api.create_buffer(sizeof(UiTransforms), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU));
-        api.update_descriptor_set_buffer(ui_sets[index], ui_sets_bindings[1], ui_transforms_buffers[index]);
-    }
 }
 
 vkrenderer::~vkrenderer() {
@@ -187,10 +164,6 @@ vkrenderer::~vkrenderer() {
         api.destroy_framebuffer(framebuffer);
     }
 
-    for (auto& transforms_buffer: ui_transforms_buffers) {
-        api.destroy_buffer(transforms_buffer);
-    }
-
     for (auto& vertex_buffer: ui_vertex_buffers) {
         api.destroy_buffer(vertex_buffer);
     }
@@ -205,8 +178,6 @@ vkrenderer::~vkrenderer() {
     api.destroy_pipeline(tonemapping_pipeline);
     api.destroy_pipeline(ui_pipeline);
 
-    api.destroy_descriptor_sets(ui_sets);
-
     api.destroy_swapchain(swapchain);
     api.destroy_surface(platform_surface);
 }
@@ -215,19 +186,13 @@ void vkrenderer::begin_frame() {
     ImGui::Render();
     ImDrawData* draw_data = ImGui::GetDrawData();
 
-    ((UiTransforms*)ui_transforms_buffers[virtual_frame_index].alloc_info.pMappedData)->scale_x = 2.f / draw_data->DisplaySize.x;
-    ((UiTransforms*)ui_transforms_buffers[virtual_frame_index].alloc_info.pMappedData)->scale_y = 2.f / draw_data->DisplaySize.y;
-    ((UiTransforms*)ui_transforms_buffers[virtual_frame_index].alloc_info.pMappedData)->translate_x = -1.f - draw_data->DisplayPos.x * (2.f / draw_data->DisplaySize.x);
-    ((UiTransforms*)ui_transforms_buffers[virtual_frame_index].alloc_info.pMappedData)->translate_y = -1.f - draw_data->DisplayPos.y * (2.f / draw_data->DisplaySize.y);
-
     VKRESULT(vkWaitForFences(api.context.device, 1, &submission_fences[virtual_frame_index], VK_TRUE, UINT64_MAX))
     VKRESULT(vkResetFences(api.context.device, 1, &submission_fences[virtual_frame_index]))
 
     if (ui_vertex_buffers[virtual_frame_index].size < draw_data->TotalVtxCount * sizeof(VkVertex)) {
         api.destroy_buffer(ui_vertex_buffers[virtual_frame_index]);
 
-        ui_vertex_buffers[virtual_frame_index] = api.create_buffer(draw_data->TotalVtxCount * sizeof(VkVertex), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU);
-        api.update_descriptor_set_buffer(ui_sets[virtual_frame_index], ui_sets_bindings[0], ui_vertex_buffers[virtual_frame_index]);
+        ui_vertex_buffers[virtual_frame_index] = api.create_buffer(draw_data->TotalVtxCount * sizeof(VkVertex), VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU);
     }
     if (ui_index_buffers[virtual_frame_index].size < draw_data->TotalIdxCount * sizeof(ImDrawIdx)) {
         api.destroy_buffer(ui_index_buffers[virtual_frame_index]);
@@ -295,6 +260,21 @@ void vkrenderer::ui() {
 
     vkCmdSetViewport(cmd_buf, 0, 1, &viewport);
 
+    float scale[] {
+        2.f / draw_data->DisplaySize.x,
+        2.f / draw_data->DisplaySize.y,
+    };
+    float 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),
+    };
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_VERTEX_BIT, 32, 8, (void*)&ui_vertex_buffers[virtual_frame_index].device_address);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_VERTEX_BIT, 40, 8, (void*)&scale);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_VERTEX_BIT, 48, 8, (void*)&translate);
+
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_FRAGMENT_BIT, 56, 4, (void*)&ui_texture.bindless_sampled_index);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_FRAGMENT_BIT, 60, 4, (void*)&ui_texture_sampler.bindless_index);
+
     off_t vertex_buffer_offset = 0;
     off_t index_buffer_offset = 0;
     for (size_t cmd_index = 0; cmd_index < draw_data->CmdListsCount; cmd_index++) {
@@ -312,7 +292,7 @@ void vkrenderer::ui() {
             };
             vkCmdSetScissor(cmd_buf, 0, 1, &rect);
 
-            api.draw(cmd_buf, ui_pipeline, ui_sets[virtual_frame_index], ui_index_buffers[virtual_frame_index], draw_cmd.ElemCount, index_buffer_offset + draw_cmd.IdxOffset, vertex_buffer_offset + draw_cmd.VtxOffset);
+            api.draw(cmd_buf, ui_pipeline, ui_index_buffers[virtual_frame_index], draw_cmd.ElemCount, index_buffer_offset + draw_cmd.IdxOffset, vertex_buffer_offset + draw_cmd.VtxOffset);
         }
 
         vertex_buffer_offset += draw_list->VtxBuffer.Size;
@@ -328,16 +308,16 @@ void vkrenderer::compute(uint32_t width, uint32_t height) {
     vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, 8, (void*)&scene_buffer.device_address);
     vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 8, 8, (void*)&geometry_buffer.device_address);
     vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 16, 8, (void*)&bvh_buffer.device_address);
-    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 24, 4, (void*)&accumulation_images[0].bindless_index);
-    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 28, 4, (void*)&accumulation_images[1].bindless_index);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 24, 4, (void*)&accumulation_images[0].bindless_storage_index);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 28, 4, (void*)&accumulation_images[1].bindless_storage_index);
     api.run_compute_pipeline(cmd_buf, compute_pipeline, (width / 8) + 1, (height / 8) + 1, 1);
 
 
     api.image_barrier(cmd_buf, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, 0, swapchain.images[swapchain_image_index]);
 
     vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, 8, (void*)&scene_buffer.device_address);
-    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 8, 4, (void*)&swapchain.images[swapchain_image_index].bindless_index);
-    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 12, 4, (void*)&accumulation_images[0].bindless_index);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 8, 4, (void*)&swapchain.images[swapchain_image_index].bindless_storage_index);
+    vkCmdPushConstants(cmd_buf, api.bindless_descriptor.pipeline_layout, VK_SHADER_STAGE_COMPUTE_BIT, 12, 4, (void*)&accumulation_images[0].bindless_storage_index);
 
     api.run_compute_pipeline(cmd_buf, tonemapping_pipeline, (width / 8) + 1, (height / 8) + 1, 1);
 }
@@ -393,7 +373,7 @@ void vkrenderer::recreate_swapchain() {
 
     VKRESULT(vkWaitForFences(api.context.device, 1, &submission_fences[0], VK_TRUE, UINT64_MAX))
 
-    std::vector<Image> images = {
+    std::vector<image> images = {
         accumulation_images[0],
         accumulation_images[1],
 
@@ -401,17 +381,16 @@ void vkrenderer::recreate_swapchain() {
         swapchain.images[1],
         swapchain.images[2]
     };
-    std::vector<VkSampler> samplers { images.size(), VK_NULL_HANDLE };
 
-    api.update_bindless_descriptor_set_images(images, samplers);
+    api.update_descriptor_images(images, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE);
 
     for (auto& framebuffer: framebuffers) {
         api.destroy_framebuffer(framebuffer);
     }
     framebuffers.clear();
 
-    for (auto& image : swapchain.images) {
-        std::vector<Image> attachments { image };
+    for (auto& current_image : swapchain.images) {
+        std::vector<image> attachments { current_image };
         framebuffers.push_back(api.create_framebuffer(render_pass, attachments, swapchain.extent));
     }
 }