WIP new rendering api

7 files changed, 589 insertions, 597 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 54a4c54..1f514f0 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -29,6 +29,7 @@ add_executable(
     primitive-renderpass.cpp
     bvh.cpp
     mesh.cpp
+    resource-manager.cpp
 )
 
 if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
@@ -58,8 +59,9 @@ target_compile_definitions(path-tracer PUBLIC ${DEFINES})
 
 target_include_directories(path-tracer SYSTEM PUBLIC ${CMAKE_SOURCE_DIR}/thirdparty)
 
+target_include_directories(path-tracer SYSTEM PUBLIC ${Vulkan_INCLUDE_DIRS})
+
 target_include_directories(path-tracer PUBLIC ${CMAKE_SOURCE_DIR}/include)
-target_include_directories(path-tracer PUBLIC ${Vulkan_INCLUDE_DIRS})
 
 if(UNIX AND NOT APPLE)
     target_include_directories(path-tracer PUBLIC ${X11_xcb_INCLUDE_PATH})
diff --git a/src/main.cpp b/src/main.cpp
index 805a0b4..1acf2fb 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -320,7 +320,7 @@ int main() {
                     main_scene.meta.cam.set_aspect_ratio((float)event.width / (float)event.height);
 
                     delete accumulation_texture;
-                    delete output_texture;
+                    delete output_texture);
                     accumulation_texture = vkrenderer::create_2d_texture(event.width, event.height, VK_FORMAT_R32G32B32A32_SFLOAT);
                     output_texture = vkrenderer::create_2d_texture(event.width, event.height, VK_FORMAT_R32G32B32A32_SFLOAT);
                     raytracing_pass->set_dispatch_size(event.width / 8 + 1, event.height / 8 + 1, 1);
diff --git a/src/resource-manager.cpp b/src/resource-manager.cpp
index e0b00aa..067107d 100644
--- a/src/resource-manager.cpp
+++ b/src/resource-manager.cpp
@@ -1,2 +1,8 @@
-#include "resourcemanager.hpp"
-static const resour
+#include "resource-manager.hpp"
+
+const auto ResourceManager::resource_manager = ResourceManager();
+
+Handle<Texture> ResourceManager::create_texture(const TextureDesc &desc) {
+    textures.add({});
+    return { 0 };
+}
diff --git a/src/scene.cpp b/src/scene.cpp
index f560d03..9980e75 100644
--- a/src/scene.cpp
+++ b/src/scene.cpp
@@ -142,24 +142,24 @@ scene::scene(const camera& cam, uint32_t width, uint32_t height)
                     indices[triangle_offset + 2]    = (submesh_level_index_3 + vertex_offset) | (0xff000000 & (materials.size() << 24));

                 }

 

-                const auto& albedo_image = vkrenderer::api.get_image(material.base_color_texture->device_image);

-                const auto& albedo_sampler = vkrenderer::api.get_sampler(material.base_color_texture->sampler->device_sampler);

+//                 const auto& albedo_image = vkrenderer::api.get_image(material.base_color_texture->device_image);

+//                 const auto& albedo_sampler = vkrenderer::api.get_sampler(material.base_color_texture->sampler->device_sampler);

 

                 materials.emplace_back(gpu_material {

                     .base_color = material.base_color,

-                    .albedo_texture_id = albedo_image.bindless_sampled_index,

-                    .albedo_texture_sampler_id = albedo_sampler.bindless_index,

+//                     .albedo_texture_id = albedo_image.bindless_sampled_index,

+//                     .albedo_texture_sampler_id = albedo_sampler.bindless_index,

                     .metalness = material.metalness,

                     .roughness = material.roughness

                 });

 

                 if (material.metallic_roughness_texture != nullptr) {

                     auto& gpu_material = materials.back();

-                    const auto& metallic_roughness_image = vkrenderer::api.get_image(material.metallic_roughness_texture->device_image);

-                    const auto& metallic_roughness_sampler = vkrenderer::api.get_sampler(material.metallic_roughness_texture->sampler->device_sampler);

+//                     const auto& metallic_roughness_image = vkrenderer::api.get_image(material.metallic_roughness_texture->device_image);

+//                     const auto& metallic_roughness_sampler = vkrenderer::api.get_sampler(material.metallic_roughness_texture->sampler->device_sampler);

 

-                    gpu_material.metallic_roughness_texture_id = metallic_roughness_image.bindless_sampled_index;

-                    gpu_material.metallic_roughness_texture_sampler_id = metallic_roughness_sampler.bindless_index;

+//                    gpu_material.metallic_roughness_texture_id = metallic_roughness_image.bindless_sampled_index;

+//                    gpu_material.metallic_roughness_texture_sampler_id = metallic_roughness_sampler.bindless_index;

                 }

 

             }

diff --git a/src/vec3.cpp b/src/vec3.cpp
index 1bd068f..0e08f16 100644
--- a/src/vec3.cpp
+++ b/src/vec3.cpp
@@ -6,38 +6,41 @@
 #include "vec3.hpp"
 
 vec3::vec3() : v(_mm_setzero_ps()) {}
+
 vec3::vec3(float x) : v(_mm_set1_ps(x)) {}
+
 vec3::vec3(float x, float y, float z) : v(_mm_set_ps(0.f, z, y, x)) {}
 
-vec3::vec3(__m128 &v) : v(v) {}
-vec3::vec3(__m128 &&v) : v(v) {}
+vec3::vec3(__m128& v) : v(v) {}
 
-vec3::vec3(const vec3 &vec) { v = _mm_load_ps((float *)&vec.v); }
+vec3::vec3(__m128&& v) : v(v) {}
 
-vec3::vec3(const vec3 &&vec) { v = _mm_load_ps((float *)&vec.v); }
+vec3::vec3(const vec3& vec) { v = _mm_load_ps((float*)&vec.v); }
+
+vec3::vec3(const vec3&& vec) noexcept { v = _mm_load_ps((float*)&vec.v); }
 
 vec3 vec3::operator-() const { return { _mm_xor_ps(v, _mm_set1_ps(-0.0f)) }; }
 
-vec3 &vec3::operator=(const vec3 &vec) {
-    v = _mm_load_ps((float *)&vec.v);
+vec3& vec3::operator=(const vec3& vec) {
+    v = _mm_load_ps((float*)&vec.v);
 
     return *this;
 }
 
-vec3 &vec3::operator+=(const vec3 &vec) {
+vec3& vec3::operator+=(const vec3& vec) {
     v = _mm_add_ps(v, vec.v);
 
     return *this;
 }
 
-vec3 &vec3::operator*=(float scale) {
+vec3& vec3::operator*=(float scale) {
     __m128 s = _mm_set1_ps(scale);
     v = _mm_mul_ps(v, s);
 
     return *this;
 }
 
-vec3 &vec3::operator/=(float numerator) {
+vec3& vec3::operator/=(float numerator) {
     __m128 s = _mm_set1_ps(numerator);
     v = _mm_div_ps(v, s);
 
@@ -45,7 +48,9 @@ vec3 &vec3::operator/=(float numerator) {
 }
 
 float vec3::operator[](const int axis) {
-    if (axis > 2) { return std::numeric_limits<float>::infinity(); }
+    if (axis > 2) {
+        return std::numeric_limits<float>::infinity();
+    }
 
     return v[axis];
 }
@@ -57,9 +62,9 @@ float vec3::length() const {
 
 float vec3::length_sq() const { return (_mm_dp_ps(v, v, 0b11110001))[0]; }
 
-float vec3::dot(const vec3 &vec) const { return (_mm_dp_ps(v, vec.v, 0b11110001))[0]; }
+float vec3::dot(const vec3& vec) const { return (_mm_dp_ps(v, vec.v, 0b11110001))[0]; }
 
-vec3 vec3::cross(const vec3 &vec) const {
+vec3 vec3::cross(const vec3& vec) const {
     __m128 tmp0 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(3, 0, 2, 1));
     __m128 tmp1 = _mm_shuffle_ps(vec.v, vec.v, _MM_SHUFFLE(3, 1, 0, 2));
     __m128 tmp2 = _mm_mul_ps(tmp0, vec.v);
@@ -68,15 +73,15 @@ vec3 vec3::cross(const vec3 &vec) const {
     return _mm_sub_ps(tmp3, tmp4);
 }
 
-vec3 vec3::min(const vec3 &vec) const {
+vec3 vec3::min(const vec3& vec) const {
     return { _mm_min_ps(v, vec.v) };
 }
 
-vec3 vec3::max(const vec3 &vec) const {
+vec3 vec3::max(const vec3& vec) const {
     return { _mm_max_ps(v, vec.v) };
 }
 
-vec3 &vec3::normalize() {
+vec3& vec3::normalize() {
     v = _mm_div_ps(v, _mm_sqrt_ps(_mm_dp_ps(v, v, 0xff)));
 
     return *this;
@@ -96,36 +101,35 @@ vec3 vec3::random() { return { randd(), randd(), randd() }; }
 
 vec3 vec3::random(float min, float max) { return { randd(min, max), randd(min, max), randd(min, max) }; }
 
-
 // TODO: Use simd instructions
-vec3 lerp(const vec3 &u, const vec3 &v, float t) { return (1.f - t) * u + t * v; }
+vec3 lerp(const vec3& u, const vec3& v, float t) { return (1.f - t) * u + t * v; }
 
-vec3 operator+(const vec3 &u, const vec3 &v) { return vec3(_mm_add_ps(u.v, v.v)); }
+vec3 operator+(const vec3& u, const vec3& v) { return vec3(_mm_add_ps(u.v, v.v)); }
 
-vec3 operator-(const vec3 &u, const vec3 &v) { return vec3(_mm_sub_ps(u.v, v.v)); }
+vec3 operator-(const vec3& u, const vec3& v) { return vec3(_mm_sub_ps(u.v, v.v)); }
 
-vec3 operator*(const vec3 &u, const vec3 &v) { return vec3(_mm_mul_ps(u.v, v.v)); }
+vec3 operator*(const vec3& u, const vec3& v) { return vec3(_mm_mul_ps(u.v, v.v)); }
 
-vec3 operator*(const vec3 &u, float scale) {
+vec3 operator*(const vec3& u, float scale) {
     __m128 s = _mm_set1_ps(scale);
     return vec3(_mm_mul_ps(u.v, s));
 }
 
-vec3 operator*(float scale, const vec3 &u) {
+vec3 operator*(float scale, const vec3& u) {
     __m128 s = _mm_set1_ps(scale);
     return vec3(_mm_mul_ps(u.v, s));
 }
 
-vec3 operator/(const vec3 &u, float scale) {
+vec3 operator/(const vec3& u, float scale) {
     __m128 s = _mm_set1_ps(scale);
     return vec3(_mm_div_ps(u.v, s));
 }
 
 // TODO: Use simd instructions
-vec3 reflect(const vec3 &v, const vec3 &n) { return v - 2 * v.dot(n) * n; }
+vec3 reflect(const vec3& v, const vec3& n) { return v - 2 * v.dot(n) * n; }
 
 // TODO: Use simd instructions
-vec3 refract(const vec3 &uv, const vec3 &n, float etai_over_etat) {
+vec3 refract(const vec3& uv, const vec3& n, float etai_over_etat) {
     auto cos_theta = fmin(n.dot(-uv), 1.f);
     vec3 r_out_perp = etai_over_etat * (uv + cos_theta * n);
     vec3 r_out_parallel = -sqrt(fabs(1.f - r_out_perp.length_sq())) * n;
diff --git a/src/vk-api.cpp b/src/vk-api.cpp
index 60ab6d4..f0d21de 100644
--- a/src/vk-api.cpp
+++ b/src/vk-api.cpp
@@ -1,13 +1,13 @@
 #include "vk-api.hpp"
 
-#include <filesystem>
 #include <cassert>
+#include <filesystem>
 
 #include <vk_mem_alloc.h>
 
-#include "window.hpp"
 #include "utils.hpp"
 #include "vk-context.hpp"
+#include "window.hpp"
 
 #include "vulkan-loader.hpp"
 
@@ -19,89 +19,88 @@
 
 
 vkapi::vkapi(vkcontext& context)
-    : context(context) {
+        : context(context) {
     VkDescriptorPoolSize descriptor_pools_sizes[] = {
         {
-            .type                               = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-            .descriptorCount                    = (uint32_t)global_descriptor::pool_size,
+            .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+            .descriptorCount = (uint32_t)global_descriptor::pool_size,
         },
         {
-            .type                               = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
-            .descriptorCount                    = (uint32_t)global_descriptor::pool_size,
+            .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
+            .descriptorCount = (uint32_t)global_descriptor::pool_size,
         },
         {
-            .type                               = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
-            .descriptorCount                    = (uint32_t)global_descriptor::pool_size,
+            .type = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
+            .descriptorCount = (uint32_t)global_descriptor::pool_size,
         },
         {
-            .type                               = VK_DESCRIPTOR_TYPE_SAMPLER,
-            .descriptorCount                    = (uint32_t)global_descriptor::pool_size,
+            .type = VK_DESCRIPTOR_TYPE_SAMPLER,
+            .descriptorCount = (uint32_t)global_descriptor::pool_size,
         }
     };
 
-    VkDescriptorPoolCreateInfo descriptor_pool_create_info  = {};
-    descriptor_pool_create_info.sType                       = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
-    descriptor_pool_create_info.pNext                       = nullptr;
-    descriptor_pool_create_info.flags                       = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
-    descriptor_pool_create_info.maxSets                     = 0xff;
-    descriptor_pool_create_info.poolSizeCount               = sizeof(descriptor_pools_sizes) / sizeof(descriptor_pools_sizes[0]);
-    descriptor_pool_create_info.pPoolSizes                  = descriptor_pools_sizes;
+    VkDescriptorPoolCreateInfo descriptor_pool_create_info = {};
+    descriptor_pool_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+    descriptor_pool_create_info.pNext = nullptr;
+    descriptor_pool_create_info.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
+    descriptor_pool_create_info.maxSets = 0xff;
+    descriptor_pool_create_info.poolSizeCount = sizeof(descriptor_pools_sizes) / sizeof(descriptor_pools_sizes[0]);
+    descriptor_pool_create_info.pPoolSizes = descriptor_pools_sizes;
 
     VKRESULT(vkCreateDescriptorPool(context.device, &descriptor_pool_create_info, nullptr, &descriptor_pool))
 
     // Global descriptor
-     VkDescriptorSetLayoutBinding bindless_layout_bindings[] = {
-            {
-                .binding = 0,
-                .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER,
-                .descriptorCount = global_descriptor::pool_size,
-                .stageFlags = VK_SHADER_STAGE_ALL,
-            },
-            {
-                .binding = 1,
-                .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
-                .descriptorCount = global_descriptor::pool_size,
-                .stageFlags = VK_SHADER_STAGE_ALL,
-            },
-            {
-                .binding = 2,
-                .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
-                .descriptorCount = global_descriptor::pool_size,
-                .stageFlags = VK_SHADER_STAGE_ALL,
-            },
+    VkDescriptorSetLayoutBinding bindless_layout_bindings[] = {
+        {
+            .binding = 0,
+            .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER,
+            .descriptorCount = global_descriptor::pool_size,
+            .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
+        },
+        {
+            .binding = 1,
+            .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
+            .descriptorCount = global_descriptor::pool_size,
+            .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
+        },
+        {
+            .binding = 2,
+            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
+            .descriptorCount = global_descriptor::pool_size,
+            .stageFlags = VK_SHADER_STAGE_FRAGMENT_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,
+    VkDescriptorBindingFlags flags[3] = {
         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    = sizeof(flags) / sizeof(VkDescriptorBindingFlags);
-    descriptor_set_layout_binding_flags.pBindingFlags   = 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 = 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;
-    descriptor_set_layout_create_info.pNext         = &descriptor_set_layout_binding_flags;
-    descriptor_set_layout_create_info.flags         = 0;
-    descriptor_set_layout_create_info.bindingCount  = sizeof(bindless_layout_bindings) / sizeof(VkDescriptorSetLayoutBinding);
-    descriptor_set_layout_create_info.pBindings     = bindless_layout_bindings;
+    descriptor_set_layout_create_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+    descriptor_set_layout_create_info.pNext = &descriptor_set_layout_binding_flags;
+    descriptor_set_layout_create_info.flags = 0;
+    descriptor_set_layout_create_info.bindingCount = sizeof(bindless_layout_bindings) / sizeof(VkDescriptorSetLayoutBinding);
+    descriptor_set_layout_create_info.pBindings = bindless_layout_bindings;
 
     VKRESULT(vkCreateDescriptorSetLayout(context.device, &descriptor_set_layout_create_info, nullptr, &bindless_descriptor.set_layout))
 
 
     VkPushConstantRange push_constants[] = {
         {
-            .stageFlags                        = VK_SHADER_STAGE_COMPUTE_BIT,
-            .offset                            = 0,
-            .size                              = 64,
+            .stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
+            .offset = 0,
+            .size = 64,
         },
         {
-            .stageFlags                        = VK_SHADER_STAGE_ALL_GRAPHICS,
-            .offset                            = 64,
-            .size                              = 64,
+            .stageFlags = VK_SHADER_STAGE_ALL_GRAPHICS,
+            .offset = 64,
+            .size = 64,
         },
         // {
         //     .stageFlags                        = VK_SHADER_STAGE_VERTEX_BIT,
@@ -115,24 +114,24 @@ vkapi::vkapi(vkcontext& context)
         // },
     };
 
-    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                  = &bindless_descriptor.set_layout;
-    layout_create_info.pushConstantRangeCount       = sizeof(push_constants) / sizeof(VkPushConstantRange);
-    layout_create_info.pPushConstantRanges          = push_constants;
+    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 = &bindless_descriptor.set_layout;
+    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))
 
 
-    VkDescriptorSetAllocateInfo descriptor_set_allocate_info    = {};
-    descriptor_set_allocate_info.sType                          = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
-    descriptor_set_allocate_info.pNext                          = VK_NULL_HANDLE;
-    descriptor_set_allocate_info.descriptorPool                 = descriptor_pool;
-    descriptor_set_allocate_info.descriptorSetCount             = 1;
-    descriptor_set_allocate_info.pSetLayouts                    = &bindless_descriptor.set_layout;
+    VkDescriptorSetAllocateInfo descriptor_set_allocate_info = {};
+    descriptor_set_allocate_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+    descriptor_set_allocate_info.pNext = VK_NULL_HANDLE;
+    descriptor_set_allocate_info.descriptorPool = descriptor_pool;
+    descriptor_set_allocate_info.descriptorSetCount = 1;
+    descriptor_set_allocate_info.pSetLayouts = &bindless_descriptor.set_layout;
 
     vkAllocateDescriptorSets(context.device, &descriptor_set_allocate_info, &bindless_descriptor.set);
 }
@@ -147,7 +146,7 @@ vkapi::~vkapi() {
         destroy_image(image_handle);
     }
 
-    for(handle sampler_handle = 0; sampler_handle < samplers.size(); sampler_handle++) {
+    for (handle sampler_handle = 0; sampler_handle < samplers.size(); sampler_handle++) {
         destroy_sampler(sampler_handle);
     }
 
@@ -159,27 +158,26 @@ vkapi::~vkapi() {
     vkDestroyDescriptorPool(context.device, descriptor_pool, nullptr);
 }
 
-
 handle vkapi::create_buffer(size_t data_size, VkBufferUsageFlags buffer_usage, uint32_t mem_usage) {
     auto* buffer = new struct buffer();
 
-    VkBufferCreateInfo buffer_info  = {};
-    buffer_info.sType               = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
-    buffer_info.size                = data_size;
-    buffer_info.usage               = buffer_usage | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR;
+    VkBufferCreateInfo buffer_info = {};
+    buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+    buffer_info.size = data_size;
+    buffer_info.usage = buffer_usage | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR;
 
     VmaAllocationCreateInfo alloc_create_info = {};
     alloc_create_info.usage = (VmaMemoryUsage)mem_usage;
     alloc_create_info.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
 
-    VmaAllocationInfo alloc_info {};
+    VmaAllocationInfo alloc_info{};
 
     VKRESULT(vmaCreateBuffer(context.allocator, &buffer_info, &alloc_create_info, &buffer->handle, &buffer->alloc, &alloc_info))
 
     VkBufferDeviceAddressInfo buffer_device_address_info = {};
-    buffer_device_address_info.sType    = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;
-    buffer_device_address_info.pNext    = VK_NULL_HANDLE;
-    buffer_device_address_info.buffer   = buffer->handle;
+    buffer_device_address_info.sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;
+    buffer_device_address_info.pNext = VK_NULL_HANDLE;
+    buffer_device_address_info.buffer = buffer->handle;
 
     buffer->size = data_size;
 
@@ -204,19 +202,19 @@ void vkapi::copy_buffer(VkCommandBuffer cmd_buf, handle src, handle dst, size_t
 void vkapi::copy_buffer(VkCommandBuffer cmd_buf, handle src, handle dst, size_t size, size_t buffer_offset) {
     auto& dst_image = images[dst];
 
-    VkImageSubresourceLayers image_subresource_layers   = {};
-    image_subresource_layers.aspectMask                 = dst_image->subresource_range.aspectMask;
-    image_subresource_layers.mipLevel                   = 0;
-    image_subresource_layers.baseArrayLayer             = 0;
-    image_subresource_layers.layerCount                 = 1;
+    VkImageSubresourceLayers image_subresource_layers = {};
+    image_subresource_layers.aspectMask = dst_image->subresource_range.aspectMask;
+    image_subresource_layers.mipLevel = 0;
+    image_subresource_layers.baseArrayLayer = 0;
+    image_subresource_layers.layerCount = 1;
 
-    VkBufferImageCopy buffer_to_image_copy  = {};
-    buffer_to_image_copy.bufferOffset       = buffer_offset;
-    buffer_to_image_copy.bufferRowLength    = 0;
-    buffer_to_image_copy.bufferImageHeight  = 0;
-    buffer_to_image_copy.imageSubresource   = image_subresource_layers;
-    buffer_to_image_copy.imageOffset        = { 0, 0, 0 };
-    buffer_to_image_copy.imageExtent        = dst_image->size;
+    VkBufferImageCopy buffer_to_image_copy = {};
+    buffer_to_image_copy.bufferOffset = buffer_offset;
+    buffer_to_image_copy.bufferRowLength = 0;
+    buffer_to_image_copy.bufferImageHeight = 0;
+    buffer_to_image_copy.imageSubresource = image_subresource_layers;
+    buffer_to_image_copy.imageOffset = { 0, 0, 0 };
+    buffer_to_image_copy.imageExtent = dst_image->size;
 
     vkCmdCopyBufferToImage(cmd_buf, buffers[src]->handle, dst_image->handle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &buffer_to_image_copy);
 }
@@ -228,62 +226,60 @@ void vkapi::destroy_buffer(handle buffer) {
     // buffers.erase(buffer.handle);
 }
 
-
 handle vkapi::create_image(VkExtent3D size, VkFormat format, VkImageUsageFlags usages) {
     auto* image = new struct image();
 
     image->size = size;
 
-    image->subresource_range.aspectMask      = VK_IMAGE_ASPECT_COLOR_BIT;
-    image->subresource_range.baseMipLevel    = 0;
-    image->subresource_range.levelCount      = 1;
-    image->subresource_range.baseArrayLayer  = 0;
-    image->subresource_range.layerCount      = 1;
+    image->subresource_range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+    image->subresource_range.baseMipLevel = 0;
+    image->subresource_range.levelCount = 1;
+    image->subresource_range.baseArrayLayer = 0;
+    image->subresource_range.layerCount = 1;
 
-    VkImageCreateInfo img_create_info       = {};
-    img_create_info.sType                   = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
-    img_create_info.pNext                   = VK_NULL_HANDLE;
-    img_create_info.flags                   = 0;
-    img_create_info.imageType               = VK_IMAGE_TYPE_2D;
-    img_create_info.format                  = format;
-    img_create_info.extent                  = size;
-    img_create_info.mipLevels               = 1;
-    img_create_info.arrayLayers             = 1;
-    img_create_info.samples                 = VK_SAMPLE_COUNT_1_BIT;
-    img_create_info.tiling                  = VK_IMAGE_TILING_OPTIMAL;
-    img_create_info.usage                   = usages;
-    img_create_info.sharingMode             = VK_SHARING_MODE_EXCLUSIVE;
-    img_create_info.queueFamilyIndexCount   = 0;
-    img_create_info.pQueueFamilyIndices     = nullptr;
-    img_create_info.initialLayout           = VK_IMAGE_LAYOUT_UNDEFINED;
+    VkImageCreateInfo img_create_info = {};
+    img_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+    img_create_info.pNext = VK_NULL_HANDLE;
+    img_create_info.flags = 0;
+    img_create_info.imageType = VK_IMAGE_TYPE_2D;
+    img_create_info.format = format;
+    img_create_info.extent = size;
+    img_create_info.mipLevels = 1;
+    img_create_info.arrayLayers = 1;
+    img_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
+    img_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
+    img_create_info.usage = usages;
+    img_create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+    img_create_info.queueFamilyIndexCount = 0;
+    img_create_info.pQueueFamilyIndices = nullptr;
+    img_create_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 
     VmaAllocationCreateInfo alloc_create_info = {};
     alloc_create_info.usage = VMA_MEMORY_USAGE_GPU_ONLY;
 
-    VmaAllocationInfo alloc_info {};
+    VmaAllocationInfo alloc_info{};
 
     VKRESULT(vmaCreateImage(context.allocator, &img_create_info, &alloc_create_info, &image->handle, &image->alloc, &alloc_info))
 
-    VkImageViewCreateInfo image_view_create_info    = {};
-    image_view_create_info.sType                    = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
-    image_view_create_info.pNext                    = nullptr;
-    image_view_create_info.flags                    = 0;
-    image_view_create_info.image                    = image->handle;
-    image_view_create_info.viewType                 = VK_IMAGE_VIEW_TYPE_2D;
-    image_view_create_info.format                   = format;
-    image_view_create_info.components               = {
+    VkImageViewCreateInfo image_view_create_info = {};
+    image_view_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+    image_view_create_info.pNext = nullptr;
+    image_view_create_info.flags = 0;
+    image_view_create_info.image = image->handle;
+    image_view_create_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
+    image_view_create_info.format = format;
+    image_view_create_info.components = {
         VK_COMPONENT_SWIZZLE_IDENTITY,
         VK_COMPONENT_SWIZZLE_IDENTITY,
         VK_COMPONENT_SWIZZLE_IDENTITY,
         VK_COMPONENT_SWIZZLE_IDENTITY
     };
-    image_view_create_info.subresourceRange        = image->subresource_range;
+    image_view_create_info.subresourceRange = image->subresource_range;
 
     VKRESULT(vkCreateImageView(context.device, &image_view_create_info, VK_NULL_HANDLE, &image->view))
 
     image->format = format;
     image->usages = usages;
-    image->device_ptr = alloc_info.pMappedData;
 
     images.push_back(image);
 
@@ -301,6 +297,7 @@ handle vkapi::create_image(VkExtent3D size, VkFormat format, VkImageUsageFlags u
 
     return image_handle;
 }
+
 void vkapi::destroy_image(handle image) {
     auto* current_image = images[image];
 
@@ -317,7 +314,6 @@ void vkapi::destroy_image(handle image) {
 
     // TODO: Free once using freelist
     // images.erase(image.handle);
-
 }
 
 std::vector<handle> vkapi::create_images(VkExtent3D size, VkFormat format, VkImageUsageFlags usages, size_t image_count) {
@@ -330,19 +326,18 @@ std::vector<handle> vkapi::create_images(VkExtent3D size, VkFormat format, VkIma
     return images_handles;
 }
 
-void vkapi::destroy_images(std::vector<handle> &imgs) {
-    for (auto handle: imgs) {
+void vkapi::destroy_images(std::vector<handle>& imgs) {
+    for (auto handle : imgs) {
         destroy_image(handle);
     }
 }
 
-
 VkFence vkapi::create_fence() const {
     VkFence fence;
-    VkFenceCreateInfo create_info   = {};
-    create_info.sType               = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
-    create_info.pNext               = nullptr;
-    create_info.flags               = VK_FENCE_CREATE_SIGNALED_BIT;
+    VkFenceCreateInfo create_info = {};
+    create_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+    create_info.pNext = nullptr;
+    create_info.flags = VK_FENCE_CREATE_SIGNALED_BIT;
 
     VKRESULT(vkCreateFence(context.device, &create_info, nullptr, &fence))
 
@@ -354,9 +349,9 @@ void vkapi::destroy_fence(VkFence fence) const {
 }
 
 std::vector<VkFence> vkapi::create_fences(size_t fences_count) const {
-    std::vector<VkFence> fences { fences_count };
+    std::vector<VkFence> fences{ fences_count };
 
-    for(size_t fence_index = 0; fence_index < fences_count; fence_index++) {
+    for (size_t fence_index = 0; fence_index < fences_count; fence_index++) {
         fences[fence_index] = create_fence();
     }
 
@@ -364,18 +359,17 @@ std::vector<VkFence> vkapi::create_fences(size_t fences_count) const {
 }
 
 void vkapi::destroy_fences(VkFence fences[], size_t fences_count) const {
-    for(size_t index { 0 }; index < fences_count; index++) {
+    for (size_t index{ 0 }; index < fences_count; index++) {
         vkDestroyFence(context.device, fences[index], nullptr);
     }
 }
 
-
 VkSemaphore vkapi::create_semaphore() const {
     VkSemaphore semaphore;
-    VkSemaphoreCreateInfo create_info   = {};
-    create_info.sType                   = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
-    create_info.pNext                   = nullptr;
-    create_info.flags                   = 0;
+    VkSemaphoreCreateInfo create_info = {};
+    create_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+    create_info.pNext = nullptr;
+    create_info.flags = 0;
 
     VKRESULT(vkCreateSemaphore(context.device, &create_info, nullptr, &semaphore))
 
@@ -387,9 +381,9 @@ void vkapi::destroy_semaphore(VkSemaphore semaphore) const {
 }
 
 std::vector<VkSemaphore> vkapi::create_semaphores(size_t semaphores_count) const {
-    std::vector<VkSemaphore> semaphores { semaphores_count };
+    std::vector<VkSemaphore> semaphores{ semaphores_count };
 
-    for (size_t semaphore_index { 0 }; semaphore_index < semaphores_count; semaphore_index++) {
+    for (size_t semaphore_index{ 0 }; semaphore_index < semaphores_count; semaphore_index++) {
         semaphores[semaphore_index] = create_semaphore();
     }
 
@@ -397,30 +391,29 @@ std::vector<VkSemaphore> vkapi::create_semaphores(size_t semaphores_count) const
 }
 
 void vkapi::destroy_semaphores(VkSemaphore semaphores[], size_t semaphores_count) const {
-    for(size_t index { 0 }; index < semaphores_count; index++) {
+    for (size_t index{ 0 }; index < semaphores_count; index++) {
         vkDestroySemaphore(context.device, semaphores[index], nullptr);
     }
 }
 
-
 handle 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;
-    sampler_create_info.flags                   = 0;
-    sampler_create_info.magFilter               = filter;
-    sampler_create_info.minFilter               = filter;
-    sampler_create_info.mipmapMode              = VK_SAMPLER_MIPMAP_MODE_NEAREST;
-    sampler_create_info.addressModeU            = address_mode;
-    sampler_create_info.addressModeV            = address_mode;
-    sampler_create_info.addressModeW            = address_mode;
-    sampler_create_info.mipLodBias              = 0.f;
-    sampler_create_info.anisotropyEnable        = VK_FALSE;
-    sampler_create_info.compareEnable           = VK_FALSE;
-    sampler_create_info.compareOp               = VK_COMPARE_OP_ALWAYS;
-    sampler_create_info.minLod                  = 0.f;
-    sampler_create_info.maxLod                  = 0.f;
-    sampler_create_info.borderColor             = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
+    VkSamplerCreateInfo sampler_create_info = {};
+    sampler_create_info.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+    sampler_create_info.pNext = VK_NULL_HANDLE;
+    sampler_create_info.flags = 0;
+    sampler_create_info.magFilter = filter;
+    sampler_create_info.minFilter = filter;
+    sampler_create_info.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
+    sampler_create_info.addressModeU = address_mode;
+    sampler_create_info.addressModeV = address_mode;
+    sampler_create_info.addressModeW = address_mode;
+    sampler_create_info.mipLodBias = 0.f;
+    sampler_create_info.anisotropyEnable = VK_FALSE;
+    sampler_create_info.compareEnable = VK_FALSE;
+    sampler_create_info.compareOp = VK_COMPARE_OP_ALWAYS;
+    sampler_create_info.minLod = 0.f;
+    sampler_create_info.maxLod = 0.f;
+    sampler_create_info.borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
     sampler_create_info.unnormalizedCoordinates = VK_FALSE;
 
     struct sampler* sampler = new struct sampler();
@@ -445,13 +438,12 @@ void vkapi::destroy_sampler(handle sampler) {
     // samplers.erase(sampler.handle);
 }
 
-
 VkCommandPool vkapi::create_command_pool() const {
-    VkCommandPoolCreateInfo cmd_pool_create_info    = {};
-    cmd_pool_create_info.sType                      = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
-    cmd_pool_create_info.pNext                      = nullptr;
-    cmd_pool_create_info.flags                      = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
-    cmd_pool_create_info.queueFamilyIndex           = context.graphics_queue.index;
+    VkCommandPoolCreateInfo cmd_pool_create_info = {};
+    cmd_pool_create_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+    cmd_pool_create_info.pNext = nullptr;
+    cmd_pool_create_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
+    cmd_pool_create_info.queueFamilyIndex = context.graphics_queue.index;
 
     VkCommandPool command_pool;
     VKRESULT(vkCreateCommandPool(context.device, &cmd_pool_create_info, nullptr, &command_pool))
@@ -459,88 +451,86 @@ VkCommandPool vkapi::create_command_pool() const {
     return command_pool;
 }
 
-
 void vkapi::allocate_command_buffers(VkCommandPool command_pool, VkCommandBuffer* command_buffers, size_t count) const {
-    VkCommandBufferAllocateInfo cmd_buf_allocate_info   = {};
-    cmd_buf_allocate_info.sType                         = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
-    cmd_buf_allocate_info.pNext                         = VK_NULL_HANDLE;
-    cmd_buf_allocate_info.commandPool                   = command_pool;
-    cmd_buf_allocate_info.level                         = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
-    cmd_buf_allocate_info.commandBufferCount            = count;
+    VkCommandBufferAllocateInfo cmd_buf_allocate_info = {};
+    cmd_buf_allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+    cmd_buf_allocate_info.pNext = VK_NULL_HANDLE;
+    cmd_buf_allocate_info.commandPool = command_pool;
+    cmd_buf_allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+    cmd_buf_allocate_info.commandBufferCount = count;
 
     vkAllocateCommandBuffers(context.device, &cmd_buf_allocate_info, command_buffers);
 }
 
 // TODO: attachment structure
 VkRenderPass vkapi::create_render_pass(std::vector<VkFormat>& color_attachments_format, VkImageLayout initial_layout, VkImageLayout final_layout) {
-    std::vector<VkAttachmentDescription> attachments_description        = {};
-    std::vector<VkAttachmentReference> attachments_reference            = {};
+    std::vector<VkAttachmentDescription> attachments_description = {};
+    std::vector<VkAttachmentReference> attachments_reference = {};
 
     for (size_t attachment_index = 0; attachment_index < color_attachments_format.size(); attachment_index++) {
         auto format = color_attachments_format[attachment_index];
-        VkAttachmentDescription attachment_description                  = {};
-        attachment_description.flags                                    = 0;
-        attachment_description.format                                   = format;
-        attachment_description.samples                                  = VK_SAMPLE_COUNT_1_BIT;
-        attachment_description.loadOp                                   = VK_ATTACHMENT_LOAD_OP_LOAD; // TODO: Set based on render pass usage
-        attachment_description.storeOp                                  = VK_ATTACHMENT_STORE_OP_STORE; // TODO: Set based on render pass usage
+        VkAttachmentDescription attachment_description = {};
+        attachment_description.flags = 0;
+        attachment_description.format = format;
+        attachment_description.samples = VK_SAMPLE_COUNT_1_BIT;
+        attachment_description.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;    // TODO: Set based on render pass usage
+        attachment_description.storeOp = VK_ATTACHMENT_STORE_OP_STORE; // TODO: Set based on render pass usage
 
-        attachment_description.stencilLoadOp                            = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
-        attachment_description.stencilStoreOp                           = VK_ATTACHMENT_STORE_OP_DONT_CARE;
-        attachment_description.initialLayout                            = initial_layout;
-        attachment_description.finalLayout                              = final_layout;
+        attachment_description.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+        attachment_description.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+        attachment_description.initialLayout = initial_layout;
+        attachment_description.finalLayout = final_layout;
 
         attachments_description.push_back(attachment_description);
 
-        VkAttachmentReference attachment_reference                      = {};
-        attachment_reference.attachment                                 = attachment_index;
-        attachment_reference.layout                                     = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+        VkAttachmentReference attachment_reference = {};
+        attachment_reference.attachment = attachment_index;
+        attachment_reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 
         attachments_reference.push_back(attachment_reference);
     }
 
-    VkSubpassDescription subpass_description                            = {};
-    subpass_description.flags                                           = 0;
-    subpass_description.pipelineBindPoint                               = VK_PIPELINE_BIND_POINT_GRAPHICS;
-    subpass_description.colorAttachmentCount                            = attachments_reference.size();
-    subpass_description.pColorAttachments                               = attachments_reference.data();
-    subpass_description.pDepthStencilAttachment                         = VK_NULL_HANDLE;
-    subpass_description.pResolveAttachments                             = VK_NULL_HANDLE;
-    subpass_description.preserveAttachmentCount                         = 0;
-    subpass_description.pPreserveAttachments                            = VK_NULL_HANDLE;
+    VkSubpassDescription subpass_description = {};
+    subpass_description.flags = 0;
+    subpass_description.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+    subpass_description.colorAttachmentCount = attachments_reference.size();
+    subpass_description.pColorAttachments = attachments_reference.data();
+    subpass_description.pDepthStencilAttachment = VK_NULL_HANDLE;
+    subpass_description.pResolveAttachments = VK_NULL_HANDLE;
+    subpass_description.preserveAttachmentCount = 0;
+    subpass_description.pPreserveAttachments = VK_NULL_HANDLE;
 
 
+    VkSubpassDependency subpass_dependency[2] = {};
+    subpass_dependency[0].srcSubpass = VK_SUBPASS_EXTERNAL;
+    subpass_dependency[0].dstSubpass = 1; // First subpass attachment is used in
+    subpass_dependency[0].srcStageMask = VK_PIPELINE_STAGE_NONE_KHR;
+    subpass_dependency[0].dstStageMask = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
+    subpass_dependency[0].srcAccessMask = 0;
+    subpass_dependency[0].dstAccessMask = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT |
+                                          VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
+                                          VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+    subpass_dependency[0].dependencyFlags = 0;
 
-    VkSubpassDependency subpass_dependency[2]   = {};
-    subpass_dependency[0].srcSubpass            = VK_SUBPASS_EXTERNAL;
-    subpass_dependency[0].dstSubpass            = 1; // First subpass attachment is used in
-    subpass_dependency[0].srcStageMask          = VK_PIPELINE_STAGE_NONE_KHR;
-    subpass_dependency[0].dstStageMask          = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
-    subpass_dependency[0].srcAccessMask         = 0;
-    subpass_dependency[0].dstAccessMask         = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT |
-                                                  VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
-                                                  VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-    subpass_dependency[0].dependencyFlags       = 0;
 
-
-    subpass_dependency[1].srcSubpass                = 1; // Last subpass attachment is used in
-    subpass_dependency[1].dstSubpass                = VK_SUBPASS_EXTERNAL;
-    subpass_dependency[1].srcStageMask              = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
-    subpass_dependency[1].dstStageMask              = VK_PIPELINE_STAGE_NONE_KHR;
-    subpass_dependency[1].srcAccessMask             = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-    subpass_dependency[1].dstAccessMask             = 0;
-    subpass_dependency[1].dependencyFlags           = 0;
+    subpass_dependency[1].srcSubpass = 1; // Last subpass attachment is used in
+    subpass_dependency[1].dstSubpass = VK_SUBPASS_EXTERNAL;
+    subpass_dependency[1].srcStageMask = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
+    subpass_dependency[1].dstStageMask = VK_PIPELINE_STAGE_NONE_KHR;
+    subpass_dependency[1].srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+    subpass_dependency[1].dstAccessMask = 0;
+    subpass_dependency[1].dependencyFlags = 0;
 
 
     VkRenderPass render_pass;
-    VkRenderPassCreateInfo create_info                                  = {};
-    create_info.sType                                                   = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
-    create_info.pNext                                                   = VK_NULL_HANDLE;
-    create_info.flags                                                   = 0;
-    create_info.attachmentCount                                         = attachments_description.size();
-    create_info.pAttachments                                            = attachments_description.data();
-    create_info.subpassCount                                            = 1;
-    create_info.pSubpasses                                              = &subpass_description;
+    VkRenderPassCreateInfo create_info = {};
+    create_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+    create_info.pNext = VK_NULL_HANDLE;
+    create_info.flags = 0;
+    create_info.attachmentCount = attachments_description.size();
+    create_info.pAttachments = attachments_description.data();
+    create_info.subpassCount = 1;
+    create_info.pSubpasses = &subpass_description;
     // create_info.dependencyCount                                         = sizeof(subpass_dependency) / sizeof(VkSubpassDependency);
     // create_info.pDependencies                                           = subpass_dependency;
 
@@ -553,42 +543,41 @@ void vkapi::destroy_render_pass(VkRenderPass render_pass) {
     vkDestroyRenderPass(context.device, render_pass, VK_NULL_HANDLE);
 }
 
-
 framebuffer vkapi::create_framebuffer(VkRenderPass render_pass, std::vector<VkFormat>& formats, VkExtent2D size) {
     VkFramebuffer framebuffer_handle;
 
     std::vector<VkFramebufferAttachmentImageInfo> attachments_image_infos(formats.size());
     for (size_t index = 0; index < formats.size(); index++) {
         VkFramebufferAttachmentImageInfo attachments_image_info = {};
-        attachments_image_info.sType            = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO;
-        attachments_image_info.pNext            = VK_NULL_HANDLE;
-        attachments_image_info.flags            = 0;
-        attachments_image_info.usage            = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
-        attachments_image_info.width            = size.width;
-        attachments_image_info.height           = size.height;
-        attachments_image_info.layerCount       = 1;
-        attachments_image_info.viewFormatCount  = 1;
-        attachments_image_info.pViewFormats     = &formats[index];
+        attachments_image_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO;
+        attachments_image_info.pNext = VK_NULL_HANDLE;
+        attachments_image_info.flags = 0;
+        attachments_image_info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+        attachments_image_info.width = size.width;
+        attachments_image_info.height = size.height;
+        attachments_image_info.layerCount = 1;
+        attachments_image_info.viewFormatCount = 1;
+        attachments_image_info.pViewFormats = &formats[index];
 
         attachments_image_infos[index] = attachments_image_info;
     }
 
     VkFramebufferAttachmentsCreateInfo attachments_create_info = {};
-    attachments_create_info.sType                       = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO;
-    attachments_create_info.pNext                       = VK_NULL_HANDLE;
-    attachments_create_info.attachmentImageInfoCount    = attachments_image_infos.size();
-    attachments_create_info.pAttachmentImageInfos       = attachments_image_infos.data();
+    attachments_create_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO;
+    attachments_create_info.pNext = VK_NULL_HANDLE;
+    attachments_create_info.attachmentImageInfoCount = attachments_image_infos.size();
+    attachments_create_info.pAttachmentImageInfos = attachments_image_infos.data();
 
     VkFramebufferCreateInfo create_info = {};
-    create_info.sType                   = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
-    create_info.pNext                   = &attachments_create_info;
-    create_info.flags                   = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT;
-    create_info.renderPass              = render_pass;
-    create_info.attachmentCount         = formats.size();
-    create_info.pAttachments            = VK_NULL_HANDLE;
-    create_info.width                   = size.width;
-    create_info.height                  = size.height;
-    create_info.layers                  = 1;
+    create_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+    create_info.pNext = &attachments_create_info;
+    create_info.flags = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT;
+    create_info.renderPass = render_pass;
+    create_info.attachmentCount = formats.size();
+    create_info.pAttachments = VK_NULL_HANDLE;
+    create_info.width = size.width;
+    create_info.height = size.height;
+    create_info.layers = 1;
 
     VKRESULT(vkCreateFramebuffer(context.device, &create_info, VK_NULL_HANDLE, &framebuffer_handle))
 
@@ -596,9 +585,9 @@ framebuffer vkapi::create_framebuffer(VkRenderPass render_pass, std::vector<VkFo
 }
 
 std::vector<framebuffer> vkapi::create_framebuffers(VkRenderPass render_pass, std::vector<VkFormat>& formats, VkExtent2D size, uint32_t framebuffer_count) {
-    std::vector<framebuffer> framebuffers { framebuffer_count };
+    std::vector<framebuffer> framebuffers{ framebuffer_count };
 
-    for (auto& framebuffer: framebuffers) {
+    for (auto& framebuffer : framebuffers) {
         framebuffer = create_framebuffer(render_pass, formats, size);
     }
 
@@ -614,14 +603,13 @@ void vkapi::destroy_framebuffer(framebuffer framebuffer) const {
 void vkapi::destroy_framebuffers(std::vector<framebuffer>& framebuffers) const {
     VKRESULT(vkDeviceWaitIdle(context.device))
 
-    for (auto& framebuffer: framebuffers) {
+    for (auto& framebuffer : framebuffers) {
         vkDestroyFramebuffer(context.device, framebuffer.handle, VK_NULL_HANDLE);
     }
 }
 
-
 pipeline vkapi::create_compute_pipeline(const char* shader_name) const {
-    pipeline pipeline {
+    pipeline pipeline{
         .bind_point = VK_PIPELINE_BIND_POINT_COMPUTE
     };
 
@@ -632,31 +620,31 @@ pipeline vkapi::create_compute_pipeline(const char* shader_name) const {
 
     pipeline.shader_modules.resize(1);
 
-    VkShaderModuleCreateInfo shader_create_info     = {};
-    shader_create_info.sType                        = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
-    shader_create_info.pNext                        = VK_NULL_HANDLE;
-    shader_create_info.flags                        = 0;
-    shader_create_info.codeSize                     = shader_code.size();
-    shader_create_info.pCode                        = reinterpret_cast<uint32_t*>(shader_code.data());
+    VkShaderModuleCreateInfo shader_create_info = {};
+    shader_create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+    shader_create_info.pNext = VK_NULL_HANDLE;
+    shader_create_info.flags = 0;
+    shader_create_info.codeSize = shader_code.size();
+    shader_create_info.pCode = reinterpret_cast<uint32_t*>(shader_code.data());
 
     VKRESULT(vkCreateShaderModule(context.device, &shader_create_info, VK_NULL_HANDLE, (pipeline.shader_modules).data()))
 
     VkPipelineShaderStageCreateInfo stage_create_info = {};
-    stage_create_info.sType                         = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
-    stage_create_info.pNext                         = VK_NULL_HANDLE;
-    stage_create_info.flags                         = 0;
-    stage_create_info.stage                         = VK_SHADER_STAGE_COMPUTE_BIT;
-    stage_create_info.module                        = pipeline.shader_modules[0];
-    stage_create_info.pName                         = "main";
-    stage_create_info.pSpecializationInfo           = VK_NULL_HANDLE;
+    stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+    stage_create_info.pNext = VK_NULL_HANDLE;
+    stage_create_info.flags = 0;
+    stage_create_info.stage = VK_SHADER_STAGE_COMPUTE_BIT;
+    stage_create_info.module = pipeline.shader_modules[0];
+    stage_create_info.pName = "main";
+    stage_create_info.pSpecializationInfo = VK_NULL_HANDLE;
 
 
-    VkComputePipelineCreateInfo create_info         = {};
-    create_info.sType                               = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
-    create_info.pNext                               = VK_NULL_HANDLE;
-    create_info.flags                               = 0;
-    create_info.stage                               = stage_create_info;
-    create_info.layout                              = bindless_descriptor.pipeline_layout;
+    VkComputePipelineCreateInfo create_info = {};
+    create_info.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
+    create_info.pNext = VK_NULL_HANDLE;
+    create_info.flags = 0;
+    create_info.stage = stage_create_info;
+    create_info.layout = bindless_descriptor.pipeline_layout;
 
     VKRESULT(vkCreateComputePipelines(
         context.device,
@@ -664,14 +652,13 @@ pipeline vkapi::create_compute_pipeline(const char* shader_name) const {
         1,
         &create_info,
         nullptr,
-        &pipeline.handle
-    ))
+        &pipeline.handle))
 
     return pipeline;
 }
 
 pipeline vkapi::create_graphics_pipeline(const char* shader_name, VkShaderStageFlagBits shader_stages, VkRenderPass render_pass, std::vector<VkDynamicState>& dynamic_states) const {
-    pipeline pipeline {
+    pipeline pipeline{
         .bind_point = VK_PIPELINE_BIND_POINT_GRAPHICS
     };
 
@@ -686,151 +673,150 @@ pipeline vkapi::create_graphics_pipeline(const char* shader_name, VkShaderStageF
             std::vector<uint8_t> shader_code = read_file(shader_path.string().c_str());
             assert(!shader_code.empty());
 
-            VkShaderModuleCreateInfo shader_create_info     = {};
-            shader_create_info.sType                        = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
-            shader_create_info.pNext                        = nullptr;
-            shader_create_info.flags                        = 0;
-            shader_create_info.codeSize                     = shader_code.size();
-            shader_create_info.pCode                        = reinterpret_cast<uint32_t*>(shader_code.data());
+            VkShaderModuleCreateInfo shader_create_info = {};
+            shader_create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+            shader_create_info.pNext = nullptr;
+            shader_create_info.flags = 0;
+            shader_create_info.codeSize = shader_code.size();
+            shader_create_info.pCode = reinterpret_cast<uint32_t*>(shader_code.data());
 
             VKRESULT(vkCreateShaderModule(context.device, &shader_create_info, nullptr, &shader_module))
 
             pipeline.shader_modules.push_back(shader_module);
 
             VkPipelineShaderStageCreateInfo stage_create_info = {};
-            stage_create_info.sType                         = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
-            stage_create_info.pNext                         = nullptr;
-            stage_create_info.flags                         = 0;
-            stage_create_info.stage                         = (VkShaderStageFlagBits)stage_flag;
-            stage_create_info.module                        = shader_module;
-            stage_create_info.pName                         = "main";
-            stage_create_info.pSpecializationInfo           = nullptr;
+            stage_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+            stage_create_info.pNext = nullptr;
+            stage_create_info.flags = 0;
+            stage_create_info.stage = (VkShaderStageFlagBits)stage_flag;
+            stage_create_info.module = shader_module;
+            stage_create_info.pName = "main";
+            stage_create_info.pSpecializationInfo = nullptr;
 
             stages_create_info.push_back(stage_create_info);
         }
     }
 
 
-    VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info     = {};
-    vertex_input_state_create_info.sType                                    = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+    VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info = {};
+    vertex_input_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
 
     VkPipelineInputAssemblyStateCreateInfo input_assembly_state_create_info = {};
-    input_assembly_state_create_info.sType                                  = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
-    input_assembly_state_create_info.pNext                                  = nullptr;
-    input_assembly_state_create_info.flags                                  = 0;
-    input_assembly_state_create_info.topology                               = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+    input_assembly_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+    input_assembly_state_create_info.pNext = nullptr;
+    input_assembly_state_create_info.flags = 0;
+    input_assembly_state_create_info.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
 
-    VkPipelineViewportStateCreateInfo viewport_state_create_info            = {};
-    viewport_state_create_info.sType                                        = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
-    viewport_state_create_info.pNext                                        = nullptr;
-    viewport_state_create_info.flags                                        = 0;
-    viewport_state_create_info.viewportCount                                = 1;
-    viewport_state_create_info.pViewports                                   = VK_NULL_HANDLE;
-    viewport_state_create_info.scissorCount                                 = 1;
-    viewport_state_create_info.pScissors                                    = VK_NULL_HANDLE;
+    VkPipelineViewportStateCreateInfo viewport_state_create_info = {};
+    viewport_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+    viewport_state_create_info.pNext = nullptr;
+    viewport_state_create_info.flags = 0;
+    viewport_state_create_info.viewportCount = 1;
+    viewport_state_create_info.pViewports = VK_NULL_HANDLE;
+    viewport_state_create_info.scissorCount = 1;
+    viewport_state_create_info.pScissors = VK_NULL_HANDLE;
 
-    VkPipelineRasterizationStateCreateInfo rasterization_state_create_info  = {};
-    rasterization_state_create_info.sType                                   = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
-    rasterization_state_create_info.pNext                                   = nullptr;
-    rasterization_state_create_info.flags                                   = 0;
-    rasterization_state_create_info.depthClampEnable                        = VK_FALSE;
-    rasterization_state_create_info.rasterizerDiscardEnable                 = VK_FALSE;
-    rasterization_state_create_info.polygonMode                             = VK_POLYGON_MODE_FILL;
-    rasterization_state_create_info.cullMode                                = VK_CULL_MODE_NONE;
-    rasterization_state_create_info.frontFace                               = VK_FRONT_FACE_COUNTER_CLOCKWISE;
-    rasterization_state_create_info.depthBiasEnable                         = VK_FALSE;
-    rasterization_state_create_info.lineWidth                               = 1.f;
+    VkPipelineRasterizationStateCreateInfo rasterization_state_create_info = {};
+    rasterization_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+    rasterization_state_create_info.pNext = nullptr;
+    rasterization_state_create_info.flags = 0;
+    rasterization_state_create_info.depthClampEnable = VK_FALSE;
+    rasterization_state_create_info.rasterizerDiscardEnable = VK_FALSE;
+    rasterization_state_create_info.polygonMode = VK_POLYGON_MODE_FILL;
+    rasterization_state_create_info.cullMode = VK_CULL_MODE_NONE;
+    rasterization_state_create_info.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
+    rasterization_state_create_info.depthBiasEnable = VK_FALSE;
+    rasterization_state_create_info.lineWidth = 1.f;
 
-    VkPipelineMultisampleStateCreateInfo multisample_state_create_info      = {};
-    multisample_state_create_info.sType                                     = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
-    multisample_state_create_info.pNext                                     = nullptr;
-    multisample_state_create_info.flags                                     = 0;
-    multisample_state_create_info.rasterizationSamples                      = VK_SAMPLE_COUNT_1_BIT;
-    multisample_state_create_info.sampleShadingEnable                       = VK_FALSE;
-    multisample_state_create_info.minSampleShading                          = 1.f;
+    VkPipelineMultisampleStateCreateInfo multisample_state_create_info = {};
+    multisample_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+    multisample_state_create_info.pNext = nullptr;
+    multisample_state_create_info.flags = 0;
+    multisample_state_create_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+    multisample_state_create_info.sampleShadingEnable = VK_FALSE;
+    multisample_state_create_info.minSampleShading = 1.f;
 
-    VkPipelineColorBlendAttachmentState color_attachment_state              = {};
-    color_attachment_state.blendEnable                                      = VK_TRUE;
-    color_attachment_state.srcColorBlendFactor                              = VK_BLEND_FACTOR_SRC_ALPHA;
-    color_attachment_state.dstColorBlendFactor                              = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
-    color_attachment_state.colorBlendOp                                     = VK_BLEND_OP_ADD;
-    color_attachment_state.srcAlphaBlendFactor                              = VK_BLEND_FACTOR_ONE;
-    color_attachment_state.dstAlphaBlendFactor                              = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
-    color_attachment_state.alphaBlendOp                                     = VK_BLEND_OP_ADD;
-    color_attachment_state.colorWriteMask                                   = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+    VkPipelineColorBlendAttachmentState color_attachment_state = {};
+    color_attachment_state.blendEnable = VK_TRUE;
+    color_attachment_state.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
+    color_attachment_state.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+    color_attachment_state.colorBlendOp = VK_BLEND_OP_ADD;
+    color_attachment_state.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
+    color_attachment_state.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+    color_attachment_state.alphaBlendOp = VK_BLEND_OP_ADD;
+    color_attachment_state.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
 
-    VkPipelineColorBlendStateCreateInfo color_blend_state_create_info       = {};
-    color_blend_state_create_info.sType                                     = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
-    color_blend_state_create_info.pNext                                     = nullptr;
-    color_blend_state_create_info.flags                                     = 0;
-    color_blend_state_create_info.logicOpEnable                             = VK_FALSE;
-    color_blend_state_create_info.attachmentCount                           = 1;
-    color_blend_state_create_info.pAttachments                              = &color_attachment_state;
+    VkPipelineColorBlendStateCreateInfo color_blend_state_create_info = {};
+    color_blend_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+    color_blend_state_create_info.pNext = nullptr;
+    color_blend_state_create_info.flags = 0;
+    color_blend_state_create_info.logicOpEnable = VK_FALSE;
+    color_blend_state_create_info.attachmentCount = 1;
+    color_blend_state_create_info.pAttachments = &color_attachment_state;
 
-    VkPipelineDynamicStateCreateInfo dynamic_state_create_info              = {};
-    dynamic_state_create_info.sType                                         = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
-    dynamic_state_create_info.pNext                                         = VK_NULL_HANDLE;
-    dynamic_state_create_info.flags                                         = 0;
-    dynamic_state_create_info.dynamicStateCount                             = dynamic_states.size();
-    dynamic_state_create_info.pDynamicStates                                = dynamic_states.data();
+    VkPipelineDynamicStateCreateInfo dynamic_state_create_info = {};
+    dynamic_state_create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
+    dynamic_state_create_info.pNext = VK_NULL_HANDLE;
+    dynamic_state_create_info.flags = 0;
+    dynamic_state_create_info.dynamicStateCount = dynamic_states.size();
+    dynamic_state_create_info.pDynamicStates = dynamic_states.data();
 
-    VkGraphicsPipelineCreateInfo pipeline_create_info                       = {};
-    pipeline_create_info.sType                                              = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
-    pipeline_create_info.pNext                                              = nullptr;
-    pipeline_create_info.flags                                              = 0;
-    pipeline_create_info.stageCount                                         = stages_create_info.size();
-    pipeline_create_info.pStages                                            = stages_create_info.data();
-    pipeline_create_info.pVertexInputState                                  = &vertex_input_state_create_info;
-    pipeline_create_info.pInputAssemblyState                                = &input_assembly_state_create_info;
-    pipeline_create_info.pViewportState                                     = &viewport_state_create_info;
-    pipeline_create_info.pRasterizationState                                = &rasterization_state_create_info;
-    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                                             = bindless_descriptor.pipeline_layout;
-    pipeline_create_info.renderPass                                         = render_pass;
-    pipeline_create_info.subpass                                            = 0;
+    VkGraphicsPipelineCreateInfo pipeline_create_info = {};
+    pipeline_create_info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+    pipeline_create_info.pNext = nullptr;
+    pipeline_create_info.flags = 0;
+    pipeline_create_info.stageCount = stages_create_info.size();
+    pipeline_create_info.pStages = stages_create_info.data();
+    pipeline_create_info.pVertexInputState = &vertex_input_state_create_info;
+    pipeline_create_info.pInputAssemblyState = &input_assembly_state_create_info;
+    pipeline_create_info.pViewportState = &viewport_state_create_info;
+    pipeline_create_info.pRasterizationState = &rasterization_state_create_info;
+    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 = bindless_descriptor.pipeline_layout;
+    pipeline_create_info.renderPass = render_pass;
+    pipeline_create_info.subpass = 0;
 
     VKRESULT(vkCreateGraphicsPipelines(context.device, VK_NULL_HANDLE, 1, &pipeline_create_info, VK_NULL_HANDLE, &pipeline.handle))
 
     return pipeline;
 }
 
-void vkapi::destroy_pipeline(pipeline &pipeline) const {
-    for (auto& shader_module: pipeline.shader_modules) {
+void vkapi::destroy_pipeline(pipeline& pipeline) const {
+    for (auto& shader_module : pipeline.shader_modules) {
         vkDestroyShaderModule(context.device, shader_module, nullptr);
     }
 
     vkDestroyPipeline(context.device, pipeline.handle, nullptr);
 }
 
-
 VkSurfaceKHR vkapi::create_surface(window& wnd) const {
     VkSurfaceKHR surface;
 
 #if defined(LINUX)
-    VkXcbSurfaceCreateInfoKHR create_info   = {};
-    create_info.sType                       = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
-    create_info.pNext                       = nullptr;
-    create_info.flags                       = 0;
-    create_info.connection                  = wnd.connection;
-    create_info.window                      = wnd.win;
+    VkXcbSurfaceCreateInfoKHR create_info = {};
+    create_info.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
+    create_info.pNext = nullptr;
+    create_info.flags = 0;
+    create_info.connection = wnd.connection;
+    create_info.window = wnd.win;
 
     VKRESULT(vkCreateXcbSurfaceKHR(context.instance, &create_info, nullptr, &surface))
 #elif defined(WINDOWS)
-    VkWin32SurfaceCreateInfoKHR create_info   = {};
-    create_info.sType                       = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
-    create_info.pNext                       = nullptr;
-    create_info.flags                       = 0;
-    create_info.hinstance                   = GetModuleHandle(nullptr);
-    create_info.hwnd                        = wnd.window_handle;
+    VkWin32SurfaceCreateInfoKHR create_info = {};
+    create_info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
+    create_info.pNext = nullptr;
+    create_info.flags = 0;
+    create_info.hinstance = GetModuleHandle(nullptr);
+    create_info.hwnd = wnd.window_handle;
 
     VKRESULT(vkCreateWin32SurfaceKHR(context.instance, &create_info, nullptr, &surface))
 #elif defined(MACOS)
     VkMetalSurfaceCreateInfoEXT create_info = {};
-    create_info.sType                       = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
-    create_info.pNext                       = nullptr;
-    create_info.flags                       = 0;
+    create_info.sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
+    create_info.pNext = nullptr;
+    create_info.flags = 0;
     // create_info.pLayer                   =   GetModuleHandle(NULL);
 
     VKRESULT(vkCreateMetalSurfaceEXT(context.instance, &create_info, nullptr, &surface))
@@ -843,7 +829,6 @@ void vkapi::destroy_surface(VkSurfaceKHR surface) {
     vkDestroySurfaceKHR(context.instance, surface, nullptr);
 }
 
-
 swapchain vkapi::create_swapchain(VkSurfaceKHR surface, size_t min_image_count, VkImageUsageFlags usages, VkSwapchainKHR old_swapchain) {
     swapchain swapchain;
 
@@ -871,38 +856,38 @@ swapchain vkapi::create_swapchain(VkSurfaceKHR surface, size_t min_image_count,
 
 
     uint32_t supported_formats_count = 0;
-    VKRESULT(vkGetPhysicalDeviceSurfaceFormatsKHR(context.physical_device, surface, &supported_formats_count,  VK_NULL_HANDLE))
+    VKRESULT(vkGetPhysicalDeviceSurfaceFormatsKHR(context.physical_device, surface, &supported_formats_count, VK_NULL_HANDLE))
 
-    std::vector<VkSurfaceFormatKHR> supported_formats { supported_formats_count };
-    VKRESULT(vkGetPhysicalDeviceSurfaceFormatsKHR(context.physical_device, surface, &supported_formats_count,  supported_formats.data()))
+    std::vector<VkSurfaceFormatKHR> supported_formats{ supported_formats_count };
+    VKRESULT(vkGetPhysicalDeviceSurfaceFormatsKHR(context.physical_device, surface, &supported_formats_count, supported_formats.data()))
 
 
     uint32_t supported_present_modes_count = 0;
     VKRESULT(vkGetPhysicalDeviceSurfacePresentModesKHR(context.physical_device, surface, &supported_present_modes_count, VK_NULL_HANDLE))
 
-    std::vector<VkPresentModeKHR> supported_present_modes { supported_present_modes_count };
+    std::vector<VkPresentModeKHR> supported_present_modes{ supported_present_modes_count };
     VKRESULT(vkGetPhysicalDeviceSurfacePresentModesKHR(context.physical_device, surface, &supported_present_modes_count, supported_present_modes.data()))
 
 
     swapchain.surface_format = supported_formats[0];
 
-    VkSwapchainCreateInfoKHR create_info    = {};
-    create_info.sType                       = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
-    create_info.pNext                       = nullptr;
-    create_info.flags                       = 0;
-    create_info.surface                     = surface;
-    create_info.minImageCount               = min_image_count;
-    create_info.imageFormat                 = swapchain.surface_format.format;
-    create_info.imageColorSpace             = swapchain.surface_format.colorSpace;
-    create_info.imageExtent                 = swapchain.extent;
-    create_info.imageArrayLayers            = 1;
-    create_info.imageUsage                  = usages;
-    create_info.imageSharingMode            = VK_SHARING_MODE_EXCLUSIVE;
-    create_info.preTransform                = caps.currentTransform;
-    create_info.compositeAlpha              = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
-    create_info.presentMode                 = supported_present_modes[0];
-    create_info.clipped                     = VK_TRUE;
-    create_info.oldSwapchain                = old_swapchain;
+    VkSwapchainCreateInfoKHR create_info = {};
+    create_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
+    create_info.pNext = nullptr;
+    create_info.flags = 0;
+    create_info.surface = surface;
+    create_info.minImageCount = min_image_count;
+    create_info.imageFormat = swapchain.surface_format.format;
+    create_info.imageColorSpace = swapchain.surface_format.colorSpace;
+    create_info.imageExtent = swapchain.extent;
+    create_info.imageArrayLayers = 1;
+    create_info.imageUsage = usages;
+    create_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+    create_info.preTransform = caps.currentTransform;
+    create_info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+    create_info.presentMode = supported_present_modes[0];
+    create_info.clipped = VK_TRUE;
+    create_info.oldSwapchain = old_swapchain;
 
     VKRESULT(vkCreateSwapchainKHR(context.device, &create_info, nullptr, &swapchain.handle))
 
@@ -916,16 +901,16 @@ swapchain vkapi::create_swapchain(VkSurfaceKHR surface, size_t min_image_count,
 
 
     VkImageSubresourceRange image_subresource_range = {};
-    image_subresource_range.aspectMask              = VK_IMAGE_ASPECT_COLOR_BIT;
-    image_subresource_range.baseMipLevel            = 0;
-    image_subresource_range.levelCount              = 1;
-    image_subresource_range.baseArrayLayer          = 0;
-    image_subresource_range.layerCount              = 1;
+    image_subresource_range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+    image_subresource_range.baseMipLevel = 0;
+    image_subresource_range.levelCount = 1;
+    image_subresource_range.baseArrayLayer = 0;
+    image_subresource_range.layerCount = 1;
 
     VkExtent3D image_size = {
-        .width   = swapchain.extent.width,
-        .height  = swapchain.extent.height,
-        .depth   = 1,
+        .width = swapchain.extent.width,
+        .height = swapchain.extent.height,
+        .depth = 1,
     };
 
     for (size_t image_index = 0; image_index < swapchain.image_count; image_index++) {
@@ -937,20 +922,20 @@ swapchain vkapi::create_swapchain(VkSurfaceKHR surface, size_t min_image_count,
         current_image->usages = usages;
 
 
-        VkImageViewCreateInfo image_view_create_info    = {};
-        image_view_create_info.sType                    = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
-        image_view_create_info.pNext                    = nullptr;
-        image_view_create_info.flags                    = 0;
-        image_view_create_info.image                    = current_image->handle;
-        image_view_create_info.viewType                 = VK_IMAGE_VIEW_TYPE_2D;
-        image_view_create_info.format                   = swapchain.surface_format.format;
-        image_view_create_info.components               = {
+        VkImageViewCreateInfo image_view_create_info = {};
+        image_view_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+        image_view_create_info.pNext = nullptr;
+        image_view_create_info.flags = 0;
+        image_view_create_info.image = current_image->handle;
+        image_view_create_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
+        image_view_create_info.format = swapchain.surface_format.format;
+        image_view_create_info.components = {
             VK_COMPONENT_SWIZZLE_IDENTITY,
             VK_COMPONENT_SWIZZLE_IDENTITY,
             VK_COMPONENT_SWIZZLE_IDENTITY,
             VK_COMPONENT_SWIZZLE_IDENTITY
         };
-        image_view_create_info.subresourceRange         = image_subresource_range;
+        image_view_create_info.subresourceRange = image_subresource_range;
 
         VKRESULT(vkCreateImageView(context.device, &image_view_create_info, nullptr, &current_image->view))
 
@@ -977,63 +962,62 @@ swapchain vkapi::create_swapchain(VkSurfaceKHR surface, size_t min_image_count,
 void vkapi::destroy_swapchain(swapchain& swapchain) {
     VKRESULT(vkDeviceWaitIdle(context.device))
 
-    for(auto &image: swapchain.images) {
+    for (auto& image : swapchain.images) {
         // TODO: Change this
         if (images[image]->bindless_storage_index != 0)
             bindless_descriptor.free(images[image]->bindless_storage_index, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE);
         if (images[image]->bindless_sampled_index != 0)
-        bindless_descriptor.free(images[image]->bindless_sampled_index, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
+            bindless_descriptor.free(images[image]->bindless_sampled_index, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
 
         vkDestroyImageView(context.device, images[image]->view, nullptr);
     }
     vkDestroySwapchainKHR(context.device, swapchain.handle, nullptr);
 }
 
-
 void vkapi::update_descriptor_image(handle img, VkDescriptorType type) {
     VkDescriptorImageInfo descriptor_image_info;
     VkWriteDescriptorSet write_descriptor;
 
     auto* current_image = images[img];
 
-    descriptor_image_info.sampler         = VK_NULL_HANDLE;
-    descriptor_image_info.imageView       = current_image->view;
-    descriptor_image_info.imageLayout     = VK_IMAGE_LAYOUT_GENERAL;
+    descriptor_image_info.sampler = VK_NULL_HANDLE;
+    descriptor_image_info.imageView = current_image->view;
+    descriptor_image_info.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
 
-    write_descriptor.sType                = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-    write_descriptor.pNext                = nullptr;
-    write_descriptor.dstSet               = bindless_descriptor.set;
-    write_descriptor.dstBinding           = type == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE ? 2 : 1;
-    write_descriptor.dstArrayElement      = type == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE ? current_image->bindless_storage_index : current_image->bindless_sampled_index;
-    write_descriptor.descriptorCount      = 1;
-    write_descriptor.descriptorType       = type;
-    write_descriptor.pImageInfo           = &descriptor_image_info;
-    write_descriptor.pBufferInfo          = VK_NULL_HANDLE;
-    write_descriptor.pTexelBufferView     = VK_NULL_HANDLE;
+    write_descriptor.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+    write_descriptor.pNext = nullptr;
+    write_descriptor.dstSet = bindless_descriptor.set;
+    write_descriptor.dstBinding = type == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE ? 2 : 1;
+    write_descriptor.dstArrayElement = type == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE ? current_image->bindless_storage_index : current_image->bindless_sampled_index;
+    write_descriptor.descriptorCount = 1;
+    write_descriptor.descriptorType = type;
+    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_descriptor_images(std::vector<handle> &handles, VkDescriptorType type) {
-    std::vector<VkDescriptorImageInfo> descriptor_images_info   { images.size() };
-    std::vector<VkWriteDescriptorSet> writes_descriptor         { images.size() };
+void vkapi::update_descriptor_images(std::vector<handle>& handles, 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++) {
         auto image = images[handles[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;
+        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           = 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       = 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;
+        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 = 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 = 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;
     }
 
     vkUpdateDescriptorSets(context.device, writes_descriptor.size(), writes_descriptor.data(), 0, nullptr);
@@ -1044,44 +1028,44 @@ void vkapi::update_descriptor_sampler(handle sampler) {
     VkWriteDescriptorSet write_descriptor;
     auto current_sampler = samplers[sampler];
 
-    descriptor_image_info.sampler         = current_sampler->handle;
-    descriptor_image_info.imageView       = VK_NULL_HANDLE;
-    descriptor_image_info.imageLayout     = VK_IMAGE_LAYOUT_GENERAL;
+    descriptor_image_info.sampler = current_sampler->handle;
+    descriptor_image_info.imageView = VK_NULL_HANDLE;
+    descriptor_image_info.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
 
-    write_descriptor.sType                = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
-    write_descriptor.pNext                = nullptr;
-    write_descriptor.dstSet               = bindless_descriptor.set;
-    write_descriptor.dstBinding           = 0;
-    write_descriptor.dstArrayElement      = current_sampler->bindless_index;
-    write_descriptor.descriptorCount      = 1;
-    write_descriptor.descriptorType       = VK_DESCRIPTOR_TYPE_SAMPLER;
-    write_descriptor.pImageInfo           = &descriptor_image_info;
-    write_descriptor.pBufferInfo          = VK_NULL_HANDLE;
-    write_descriptor.pTexelBufferView     = VK_NULL_HANDLE;
+    write_descriptor.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+    write_descriptor.pNext = nullptr;
+    write_descriptor.dstSet = bindless_descriptor.set;
+    write_descriptor.dstBinding = 0;
+    write_descriptor.dstArrayElement = current_sampler->bindless_index;
+    write_descriptor.descriptorCount = 1;
+    write_descriptor.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;
+    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_descriptor_samplers(std::vector<handle> &handles) {
-    std::vector<VkDescriptorImageInfo> descriptor_images_info   { samplers.size() };
-    std::vector<VkWriteDescriptorSet> writes_descriptor         { samplers.size() };
+void vkapi::update_descriptor_samplers(std::vector<handle>& handles) {
+    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++) {
         auto sampler = samplers[handles[sampler_index]];
-        descriptor_images_info[sampler_index].sampler         = sampler->handle;
-        descriptor_images_info[sampler_index].imageView       = VK_NULL_HANDLE;
-        descriptor_images_info[sampler_index].imageLayout     = VK_IMAGE_LAYOUT_GENERAL;
+        descriptor_images_info[sampler_index].sampler = sampler->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      = sampler->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;
+        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 = sampler->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);
@@ -1093,28 +1077,28 @@ void vkapi::update_constants(VkCommandBuffer command_buffer, VkShaderStageFlagBi
 
 void vkapi::start_record(VkCommandBuffer command_buffer) {
     VkCommandBufferBeginInfo cmd_buf_begin_info = {};
-    cmd_buf_begin_info.sType                    = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
-    cmd_buf_begin_info.pNext                    = nullptr;
-    cmd_buf_begin_info.flags                    = 0;
-    cmd_buf_begin_info.pInheritanceInfo         = nullptr;
+    cmd_buf_begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+    cmd_buf_begin_info.pNext = nullptr;
+    cmd_buf_begin_info.flags = 0;
+    cmd_buf_begin_info.pInheritanceInfo = nullptr;
 
     vkBeginCommandBuffer(command_buffer, &cmd_buf_begin_info);
 }
 
 void vkapi::image_barrier(VkCommandBuffer command_buffer, VkImageLayout dst_layout, VkPipelineStageFlagBits dst_stage, VkAccessFlags dst_access, handle image) {
-    auto *current_image = images[image];
+    auto* current_image = images[image];
 
-    VkImageMemoryBarrier image_barrier   = {};
-    image_barrier.sType                  = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
-    image_barrier.pNext                  = nullptr;
-    image_barrier.srcAccessMask          = current_image->previous_access;
-    image_barrier.dstAccessMask          = dst_access;
-    image_barrier.oldLayout              = current_image->previous_layout;
-    image_barrier.newLayout              = dst_layout;
-    image_barrier.srcQueueFamilyIndex    = VK_QUEUE_FAMILY_IGNORED;
-    image_barrier.dstQueueFamilyIndex    = VK_QUEUE_FAMILY_IGNORED;
-    image_barrier.image                  = current_image->handle;
-    image_barrier.subresourceRange       = current_image->subresource_range;
+    VkImageMemoryBarrier image_barrier = {};
+    image_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+    image_barrier.pNext = nullptr;
+    image_barrier.srcAccessMask = current_image->previous_access;
+    image_barrier.dstAccessMask = dst_access;
+    image_barrier.oldLayout = current_image->previous_layout;
+    image_barrier.newLayout = dst_layout;
+    image_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+    image_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+    image_barrier.image = current_image->handle;
+    image_barrier.subresourceRange = current_image->subresource_range;
 
     vkCmdPipelineBarrier(
         command_buffer,
@@ -1126,15 +1110,13 @@ void vkapi::image_barrier(VkCommandBuffer command_buffer, VkImageLayout dst_layo
         0,
         nullptr,
         1,
-        &image_barrier
-    );
+        &image_barrier);
 
     current_image->previous_layout = dst_layout;
     current_image->previous_access = dst_access;
     current_image->previous_stage = dst_stage;
 }
 
-
 void vkapi::begin_render_pass(VkCommandBuffer command_buffer, VkRenderPass render_pass, std::vector<VkImageView>& attachments, framebuffer framebuffer, VkExtent2D size) {
     VkRect2D render_area = {
         {
@@ -1145,20 +1127,20 @@ void vkapi::begin_render_pass(VkCommandBuffer command_buffer, VkRenderPass rende
     };
 
     VkRenderPassAttachmentBeginInfo attachment_begin_info = {};
-    attachment_begin_info.sType                     = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO;
-    attachment_begin_info.pNext                     = VK_NULL_HANDLE;
-    attachment_begin_info.attachmentCount           = attachments.size();
-    attachment_begin_info.pAttachments              = attachments.data();
+    attachment_begin_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO;
+    attachment_begin_info.pNext = VK_NULL_HANDLE;
+    attachment_begin_info.attachmentCount = attachments.size();
+    attachment_begin_info.pAttachments = attachments.data();
 
-    VkClearValue clear_value { .color { .float32 { 0.f, 0.f, 0.f, 1.f } } };
-    VkRenderPassBeginInfo render_pass_begin_info    = {};
-    render_pass_begin_info.sType                    = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
-    render_pass_begin_info.pNext                    = &attachment_begin_info;
-    render_pass_begin_info.renderPass               = render_pass;
-    render_pass_begin_info.framebuffer              = framebuffer.handle;
-    render_pass_begin_info.renderArea               = render_area;
-    render_pass_begin_info.clearValueCount          = 1;
-    render_pass_begin_info.pClearValues             = &clear_value;
+    VkClearValue clear_value{ .color{ .float32{ 0.f, 0.f, 0.f, 1.f } } };
+    VkRenderPassBeginInfo render_pass_begin_info = {};
+    render_pass_begin_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+    render_pass_begin_info.pNext = &attachment_begin_info;
+    render_pass_begin_info.renderPass = render_pass;
+    render_pass_begin_info.framebuffer = framebuffer.handle;
+    render_pass_begin_info.renderArea = render_area;
+    render_pass_begin_info.clearValueCount = 1;
+    render_pass_begin_info.pClearValues = &clear_value;
 
     vkCmdBeginRenderPass(command_buffer, &render_pass_begin_info, VK_SUBPASS_CONTENTS_INLINE);
 }
@@ -1167,7 +1149,6 @@ void vkapi::end_render_pass(VkCommandBuffer command_buffer) {
     vkCmdEndRenderPass(command_buffer);
 }
 
-
 void vkapi::run_compute_pipeline(VkCommandBuffer command_buffer, pipeline& pipeline, size_t group_count_x, size_t group_count_y, size_t group_count_z) {
     vkCmdBindDescriptorSets(command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, bindless_descriptor.pipeline_layout, 0, 1, &bindless_descriptor.set, 0, nullptr);
 
@@ -1192,86 +1173,85 @@ void vkapi::draw(VkCommandBuffer command_buffer, pipeline& pipeline, handle inde
 }
 
 void vkapi::blit_full(VkCommandBuffer command_buffer, handle src, handle dst) {
-    auto *src_image = images[src];
-    auto *dst_image = images[dst];
+    auto* src_image = images[src];
+    auto* dst_image = images[dst];
 
-    VkImageSubresourceLayers images_subres_layers {
-        .aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT,
-        .mipLevel       = 0,
+    VkImageSubresourceLayers images_subres_layers{
+        .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+        .mipLevel = 0,
         .baseArrayLayer = 0,
-        .layerCount     = 1,
+        .layerCount = 1,
     };
 
-    VkOffset3D start_offset {
-        .x  = 0,
-        .y  = 0,
-        .z  = 0,
+    VkOffset3D start_offset{
+        .x = 0,
+        .y = 0,
+        .z = 0,
     };
-    VkOffset3D end_offset {
-        .x  = (int32_t)dst_image->size.width,
-        .y  = (int32_t)dst_image->size.height,
-        .z  = (int32_t)dst_image->size.depth,
+    VkOffset3D end_offset{
+        .x = (int32_t)dst_image->size.width,
+        .y = (int32_t)dst_image->size.height,
+        .z = (int32_t)dst_image->size.depth,
     };
 
-    VkImageBlit blit_region {
+    VkImageBlit blit_region{
         .srcSubresource = images_subres_layers,
-        .srcOffsets     = { start_offset, end_offset },
+        .srcOffsets = { start_offset, end_offset },
         .dstSubresource = images_subres_layers,
-        .dstOffsets     = { start_offset, end_offset },
+        .dstOffsets = { start_offset, end_offset },
     };
 
     vkCmdBlitImage(command_buffer, src_image->handle, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst_image->handle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit_region, VK_FILTER_NEAREST);
 }
 
-void vkapi::end_record(VkCommandBuffer command_buffer) {
+void vkapi::end_record(VkCommandBuffer command_buffer){
     VKRESULT(vkEndCommandBuffer(command_buffer))
 }
 
 VkResult vkapi::submit(VkCommandBuffer command_buffers[], size_t command_buffers_count, VkSemaphore wait_semaphore, VkSemaphore signal_semaphore, VkFence submission_fence) const {
     VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
 
-    VkSubmitInfo submit_info            = {};
-    submit_info.sType                   = VK_STRUCTURE_TYPE_SUBMIT_INFO;
-    submit_info.pNext                   = nullptr;
-    submit_info.waitSemaphoreCount      = wait_semaphore != nullptr ? 1 : 0;
-    submit_info.pWaitSemaphores         = &wait_semaphore;
-    submit_info.pWaitDstStageMask       = wait_semaphore != nullptr ? &wait_stage : VK_NULL_HANDLE;
-    submit_info.signalSemaphoreCount    = signal_semaphore != nullptr ? 1 : 0;
-    submit_info.pSignalSemaphores       = &signal_semaphore;
-    submit_info.commandBufferCount      = command_buffers_count;
-    submit_info.pCommandBuffers         = command_buffers;
+    VkSubmitInfo submit_info = {};
+    submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+    submit_info.pNext = nullptr;
+    submit_info.waitSemaphoreCount = wait_semaphore != nullptr ? 1 : 0;
+    submit_info.pWaitSemaphores = &wait_semaphore;
+    submit_info.pWaitDstStageMask = wait_semaphore != nullptr ? &wait_stage : VK_NULL_HANDLE;
+    submit_info.signalSemaphoreCount = signal_semaphore != nullptr ? 1 : 0;
+    submit_info.pSignalSemaphores = &signal_semaphore;
+    submit_info.commandBufferCount = command_buffers_count;
+    submit_info.pCommandBuffers = command_buffers;
 
     return vkQueueSubmit(context.graphics_queue.handle, 1, &submit_info, submission_fence);
 }
 
 VkResult vkapi::present(swapchain& swapchain, uint32_t image_index, VkSemaphore wait_semaphore) const {
-    VkPresentInfoKHR present_info   = {};
-    present_info.sType              = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
-    present_info.pNext              = nullptr;
+    VkPresentInfoKHR present_info = {};
+    present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+    present_info.pNext = nullptr;
     present_info.waitSemaphoreCount = 1;
-    present_info.pWaitSemaphores    = &wait_semaphore;
-    present_info.swapchainCount     = 1;
-    present_info.pSwapchains        = &swapchain.handle;
-    present_info.pImageIndices      = &image_index;
-    present_info.pResults           = nullptr;
+    present_info.pWaitSemaphores = &wait_semaphore;
+    present_info.swapchainCount = 1;
+    present_info.pSwapchains = &swapchain.handle;
+    present_info.pImageIndices = &image_index;
+    present_info.pResults = nullptr;
 
     return vkQueuePresentKHR(context.graphics_queue.handle, &present_info);
 }
 
-
 const char* vkapi::shader_stage_extension(VkShaderStageFlags shader_stage) {
-    switch(shader_stage) {
-        case VK_SHADER_STAGE_VERTEX_BIT: {
-            return ".vert";
-        }
-        case VK_SHADER_STAGE_FRAGMENT_BIT: {
-            return ".frag";
-        }
-        case VK_SHADER_STAGE_COMPUTE_BIT: {
-            return ".comp";
-        }
-        default:
-            assert(true && "Stage not supported");
-            return "";
+    switch (shader_stage) {
+    case VK_SHADER_STAGE_VERTEX_BIT: {
+        return ".vert";
+    }
+    case VK_SHADER_STAGE_FRAGMENT_BIT: {
+        return ".frag";
+    }
+    case VK_SHADER_STAGE_COMPUTE_BIT: {
+        return ".comp";
+    }
+    default:
+        assert(true && "Stage not supported");
+        return "";
     }
 }
diff --git a/src/vk-context.cpp b/src/vk-context.cpp
index 824c216..1a6a78d 100644
--- a/src/vk-context.cpp
+++ b/src/vk-context.cpp
@@ -94,7 +94,7 @@ void vkcontext::create_instance() {
 
     check_available_instance_layers(needed_layers, needed_layers_count);
 
-    const char* needed_extensions[] = {
+    constexpr const char* needed_extensions[] = {
         VK_EXT_DEBUG_UTILS_EXTENSION_NAME,
         "VK_KHR_surface",
 #if defined(LINUX)
@@ -105,7 +105,7 @@ void vkcontext::create_instance() {
         "VK_EXT_metal_surface"
 #endif
     };
-    auto needed_extensions_count = sizeof(needed_extensions) / sizeof(needed_extensions[0]);
+    constexpr auto needed_extensions_count = sizeof(needed_extensions) / sizeof(needed_extensions[0]);
 
     check_available_instance_extensions(needed_extensions, needed_extensions_count);