Working compute api with uniforms

6 files changed, 280 insertions, 67 deletions

diff --git a/api-test/CMakeLists.txt b/api-test/CMakeLists.txt
index 402ae10..93eceee 100644
--- a/api-test/CMakeLists.txt
+++ b/api-test/CMakeLists.txt
@@ -4,6 +4,7 @@ add_executable(
     vk-device.cpp
     command-buffer.cpp
     vk-bindless.cpp
+    vk-utils.cpp
     ${CMAKE_SOURCE_DIR}/src/window.cpp
     ${CMAKE_SOURCE_DIR}/src/utils.cpp
     ${CMAKE_SOURCE_DIR}/src/vulkan-loader.cpp
diff --git a/api-test/command-buffer.cpp b/api-test/command-buffer.cpp
index 8d2d8c7..799968c 100644
--- a/api-test/command-buffer.cpp
+++ b/api-test/command-buffer.cpp
@@ -18,12 +18,13 @@ void command_buffer::start() const {
 
     VKCHECK(vkBeginCommandBuffer(vk_command_buffer, &begin_info));
 
-    const auto& bindless = vkdevice::get_device()->get_bindingmodel();
+    const auto& bindless = vkdevice::get_render_device()->get_bindingmodel();
+    const auto* global_set = &bindless.sets[BindlessSetType::GLOBAL];
     if (queue_type == QueueType::GRAPHICS) {
-        vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, bindless.layout, 0, BindlessSetType::MAX, bindless.sets, 0, nullptr);
-        vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, bindless.layout, 0, BindlessSetType::MAX, bindless.sets, 0, nullptr);
+        vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, bindless.layout, 0, 1U, global_set, 0U, nullptr);
+        vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, bindless.layout, 0, 1U, global_set, 0U, nullptr);
     } else if (queue_type == QueueType::ASYNC_COMPUTE) {
-        vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, bindless.layout, 0, BindlessSetType::MAX, bindless.sets, 0, nullptr);
+        vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, bindless.layout, 0, 1U, global_set, 0U, nullptr);
     }
 }
 
@@ -32,7 +33,7 @@ void command_buffer::stop() const {
 }
 
 void command_buffer::barrier(handle<device_texture> texture_handle, VkPipelineStageFlags2 stage, VkAccessFlags2 access, VkImageLayout layout) const {
-    auto&                   texture     = vkdevice::get_device()->get_texture(texture_handle);
+    auto&                   texture     = vkdevice::get_render_device()->get_texture(texture_handle);
     VkImageAspectFlags      aspect_mask = ((texture.desc.usages & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0U)
                                               ? VK_IMAGE_ASPECT_DEPTH_BIT
                                               : VK_IMAGE_ASPECT_COLOR_BIT;
@@ -79,7 +80,7 @@ void command_buffer::barrier(handle<device_texture> texture_handle, VkPipelineSt
 }
 
 void command_buffer::copy(handle<device_buffer> buffer_handle, ::handle<device_texture> texture_handle, VkDeviceSize offset) const {
-    auto* device = vkdevice::get_device();
+    auto* device = vkdevice::get_render_device();
     const auto&              buffer      = device->get_buffer(buffer_handle);
     const auto&              texture     = device->get_texture(texture_handle);
     VkImageAspectFlags       aspect_mask = ((texture.desc.usages & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0U)
@@ -109,7 +110,9 @@ void command_buffer::copy(handle<device_buffer> buffer_handle, ::handle<device_t
 }
 
 void graphics_command_buffer::dispatch(const dispatch_params& params) {
-    const auto& pipeline = vkdevice::get_device()->get_pipeline(params.pipeline);
+    const auto& pipeline = vkdevice::get_render_device()->get_pipeline(params.pipeline);
+    const auto& bindless = vkdevice::get_render_device()->get_bindingmodel();
+    vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, bindless.layout, static_cast<uint32_t>(BindlessSetType::UNIFORMS), 1U, &bindless.sets[BindlessSetType::UNIFORMS], 1U, &params.uniforms_offset);
 
     vkCmdBindPipeline(vk_command_buffer, pipeline.bind_point, pipeline.vk_pipeline);
 
diff --git a/api-test/main.cpp b/api-test/main.cpp
index 4ac68ad..35b8639 100644
--- a/api-test/main.cpp
+++ b/api-test/main.cpp
@@ -97,6 +97,13 @@ int main() {
         .cs_code = std::span(code),
     });
 
+    auto vertex_code = read_file("shaders/api-test-ui.vert.spv");
+    auto fragment_code = read_file("shaders/api-test-ui.frag.spv");
+    auto graphics = device->create_pipeline({
+        .vs_code = std::span(vertex_code),
+        .fs_code = std::span(fragment_code),
+    });
+
 
     graphics_command_buffer command_buffer;
     device->allocate_command_buffers(&command_buffer, 1, QueueType::GRAPHICS);
@@ -108,14 +115,27 @@ int main() {
     command_buffer.copy(staging_buffer_handle, gpu_texture_handle);
     command_buffer.copy(staging_buffer_handle, second_texture, static_cast<VkDeviceSize>(offset));
 
-    command_buffer.barrier(gpu_texture_handle, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_GENERAL);
+    command_buffer.barrier(gpu_texture_handle, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL);
     command_buffer.barrier(second_texture, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_READ_BIT, VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL);
-    command_buffer.barrier(output_texture_handle, VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, VK_ACCESS_2_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_GENERAL);
+
+    struct compute_params {
+        uint32_t input1;
+        uint32_t input2;
+        uint32_t output;
+    };
+    const auto& uniform_buffer = device->get_bindingmodel().get_uniform_buffer();
+    compute_params params {
+        device->get_texture(second_texture).storage_index,
+        device->get_texture(gpu_texture_handle).storage_index,
+        device->get_texture(output_texture_handle).storage_index,
+    };
+    memcpy(uniform_buffer.mapped_ptr, &params, sizeof(params));
 
     command_buffer.dispatch({
         .pipeline = compute,
         .group_size = { image_size, image_size, 1U },
         .local_group_size = { 8U, 8U, 1U },
+        .uniforms_offset = 0U,
     });
 
     command_buffer.stop();
diff --git a/api-test/vk-bindless.cpp b/api-test/vk-bindless.cpp
index d1dbf03..c07db8e 100644
--- a/api-test/vk-bindless.cpp
+++ b/api-test/vk-bindless.cpp
@@ -1,15 +1,53 @@
 #include "vk-bindless.hpp"
 
+#include <vma/vk_mem_alloc.h>
+
+#include "vk-device.hpp"
 #include "vk-utils.hpp"
 #include "vulkan-loader.hpp"
 
-bindless_model bindless_model::create_bindless_model(VkDevice device) {
+const device_buffer& bindless_model::get_uniform_buffer() const {
+    auto* render_device = vkdevice::get_render_device();
+    return render_device->get_buffer(uniform_buffer);
+}
+
+bindless_model bindless_model::create_bindless_model() {
     bindless_model bindless;
+    auto* render_device = vkdevice::get_render_device();
+    auto* device = render_device->get_device();
 #ifndef USE_VK_DESCRIPTOR_BUFFER
     bindless.create_immutable_samplers(device);
     bindless.create_layout(device);
     bindless.create_descriptor_pool(device);
     bindless.allocate_sets(device);
+    bindless.uniform_buffer = render_device->create_buffer({
+        .size = 64U * 1024U,
+        .usages = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
+        .memory_properties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
+        .memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU,
+    });
+
+    const auto& buffer = render_device->get_buffer(bindless.uniform_buffer);
+    VkDescriptorBufferInfo buffer_info {
+        .buffer = buffer.vk_buffer,
+        .offset = 0U,
+        .range = VK_WHOLE_SIZE,
+    };
+
+    VkWriteDescriptorSet write_descriptor_set {
+        .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
+        .pNext = nullptr,
+        .dstSet = bindless.sets[BindlessSetType::UNIFORMS],
+        .dstBinding = 0U,
+        .dstArrayElement = 0U,
+        .descriptorCount = 1U,
+        .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
+        .pImageInfo = nullptr,
+        .pBufferInfo = &buffer_info,
+        .pTexelBufferView = nullptr,
+    };
+
+    vkUpdateDescriptorSets(device, 1U, &write_descriptor_set, 0U, nullptr);
 #else
     VkBufferCreateInfo create_info{
         .sType                 = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
@@ -23,7 +61,6 @@ bindless_model bindless_model::create_bindless_model(VkDevice device) {
     };
 
     VmaAllocatorCreateFlags alloc_create_flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
-
     VmaAllocationCreateInfo alloc_create_info{
         .flags          = alloc_create_flags,
         .usage          = VMA_MEMORY_USAGE_CPU_TO_GPU,
@@ -46,7 +83,8 @@ bindless_model bindless_model::create_bindless_model(VkDevice device) {
     return bindless;
 }
 
-void bindless_model::destroy_bindless_model(VkDevice device, bindless_model& bindless) {
+void bindless_model::destroy_bindless_model(bindless_model& bindless) {
+    auto* device = vkdevice::get_render_device()->get_device();
     vkDestroyDescriptorPool(device, bindless.descriptor_pool, nullptr);
 
     for (auto index{ 0U }; index < BindlessSetType::MAX; index++) {
@@ -112,6 +150,30 @@ void bindless_model::create_layout(VkDevice device) {
         VKCHECK(vkCreateDescriptorSetLayout(device, &create_info, nullptr, &sets_layout[BindlessSetType::GLOBAL]));
     }
 
+    // Set 1 uniforms
+    //  Binding 0 Uniforms
+    {
+        VkDescriptorSetLayoutBinding set_layout_bindings[]{
+            {
+                .binding            = 0U,
+                .descriptorType     = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
+                .descriptorCount    = 1,
+                .stageFlags         = VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
+                .pImmutableSamplers = nullptr,
+            },
+        };
+
+        VkDescriptorSetLayoutCreateInfo create_info{
+            .sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
+            .pNext        = nullptr,
+            .flags        = 0U,
+            .bindingCount = sizeof(set_layout_bindings) / sizeof(VkDescriptorSetLayoutBinding),
+            .pBindings    = set_layout_bindings,
+        };
+
+        VKCHECK(vkCreateDescriptorSetLayout(device, &create_info, nullptr, &sets_layout[BindlessSetType::UNIFORMS]));
+    }
+
     VkPipelineLayoutCreateInfo create_info{
         .sType                  = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
         .pNext                  = nullptr,
@@ -140,6 +202,10 @@ void bindless_model::create_descriptor_pool(VkDevice device) {
             .type            = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
             .descriptorCount = set_descriptors_count[BindlessSetType::MAX],
         },
+        {
+            .type            = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
+            .descriptorCount = set_descriptors_count[BindlessSetType::MAX],
+        },
     };
 
     VkDescriptorPoolCreateInfo descriptor_pool_create_info{
@@ -162,6 +228,9 @@ void bindless_model::allocate_sets(VkDevice device) {
         .pSetLayouts        = &sets_layout[BindlessSetType::GLOBAL],
     };
     VKCHECK(vkAllocateDescriptorSets(device, &allocate_info, &sets[BindlessSetType::GLOBAL]));
+
+    allocate_info.pSetLayouts        = &sets_layout[BindlessSetType::UNIFORMS],
+    VKCHECK(vkAllocateDescriptorSets(device, &allocate_info, &sets[BindlessSetType::UNIFORMS]));
 }
 
 void bindless_model::create_immutable_samplers(VkDevice device) {
diff --git a/api-test/vk-device.cpp b/api-test/vk-device.cpp
index 404cd43..0815592 100644
--- a/api-test/vk-device.cpp
+++ b/api-test/vk-device.cpp
@@ -1,7 +1,6 @@
 #include "vk-device.hpp"
 
 #include <cassert>
-#include <iostream>
 #include <vector>
 
 #define VMA_IMPLEMENTATION
@@ -13,47 +12,6 @@
 
 vkdevice* vkdevice::render_device = nullptr;
 
-VKAPI_ATTR VkBool32 VKAPI_CALL debug_callback(VkDebugUtilsMessageSeverityFlagBitsEXT      severity,
-                                              VkDebugUtilsMessageTypeFlagsEXT             type,
-                                              const VkDebugUtilsMessengerCallbackDataEXT* data,
-                                              void*) {
-    const char* severity_cstr = nullptr;
-    switch (severity) {
-    case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT:
-        severity_cstr = "VERBOSE";
-        break;
-    case VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT:
-        severity_cstr = "INFO";
-        break;
-    case VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT:
-        severity_cstr = "WARNING";
-        break;
-    case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT:
-        severity_cstr = "ERROR";
-        break;
-    default:
-        break;
-    }
-
-    const char* type_cstr = nullptr;
-    switch (type) {
-    case VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT:
-        type_cstr = "GENERAL";
-        break;
-    case VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT:
-        type_cstr = "VALIDATION";
-        break;
-    case VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT:
-        type_cstr = "PERFORMANCE";
-        break;
-    default:
-        break;
-    }
-
-    std::cerr << "[" << severity_cstr << "_" << type_cstr << "]: " << data->pMessage << std::endl;
-    return VK_FALSE;
-}
-
 vkdevice::vkdevice(const window& window)
         : queues{
         {
@@ -84,11 +42,12 @@ vkdevice::vkdevice(const window& window)
 
     create_swapchain();
 
-    bindless = bindless_model::create_bindless_model(device);
+    bindless = bindless_model::create_bindless_model();
 }
 
 vkdevice* vkdevice::init_device(const window& window) {
-    vkdevice::render_device = new vkdevice(window);
+    vkdevice::render_device = static_cast<vkdevice*>(malloc(sizeof(vkdevice)));
+    vkdevice::render_device = new (vkdevice::render_device) vkdevice(window);
     return render_device;
 }
 
@@ -100,7 +59,7 @@ void vkdevice::free_device() {
 vkdevice::~vkdevice() {
     vkDeviceWaitIdle(device);
 
-    bindless_model::destroy_bindless_model(device, bindless);
+    bindless_model::destroy_bindless_model(bindless);
 
     for (auto& texture : textures) {
         destroy_texture(texture);
@@ -271,17 +230,19 @@ handle<device_pipeline> vkdevice::create_pipeline(const pipeline_desc& desc) {
         .bindless = &bindless,
     };
     if (!desc.cs_code.empty()) {
-        const auto& code = desc.cs_code;
         VkShaderModule shader_module;
-        VkShaderModuleCreateInfo module_create_info {
-            .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
-            .pNext = nullptr,
-            .flags = 0U,
-            .codeSize = code.size(),
-            .pCode = (uint32_t*)code.data(),
-        };
+        {
+            const auto& code = desc.cs_code;
+            VkShaderModuleCreateInfo create_info {
+                .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
+                .pNext = nullptr,
+                .flags = 0U,
+                .codeSize = code.size(),
+                .pCode = (uint32_t*)code.data(),
+            };
 
-        VKCHECK(vkCreateShaderModule(device, &module_create_info, nullptr, &shader_module));
+            VKCHECK(vkCreateShaderModule(device, &create_info, nullptr, &shader_module));
+        }
 
         VkPipelineShaderStageCreateInfo stage_create_info {
             .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
@@ -308,12 +269,127 @@ handle<device_pipeline> vkdevice::create_pipeline(const pipeline_desc& desc) {
 
         vkDestroyShaderModule(device, shader_module, nullptr);
     } else {
+        VkPipelineShaderStageCreateInfo shader_stages_create_info[2U] {
+            {
+                .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
+                .pNext = nullptr,
+                .flags = 0U,
+                .stage = VK_SHADER_STAGE_VERTEX_BIT,
+                .pName = "main",
+                .pSpecializationInfo = nullptr,
+            },
+            {
+                .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
+                .pNext = nullptr,
+                .flags = 0U,
+                .stage = VK_SHADER_STAGE_FRAGMENT_BIT,
+                .pName = "main",
+                .pSpecializationInfo = nullptr,
+            },
+        };
+
+        {
+            const auto& code = desc.vs_code;
+            VkShaderModuleCreateInfo module_create_info {
+                .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
+                .pNext = nullptr,
+                .flags = 0U,
+                .codeSize = code.size(),
+                .pCode = (uint32_t*)code.data(),
+            };
+
+            VKCHECK(vkCreateShaderModule(device, &module_create_info, nullptr, &shader_stages_create_info[0U].module));
+
+        }
+        {
+            const auto& code = desc.fs_code;
+            VkShaderModuleCreateInfo module_create_info {
+                .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
+                .pNext = nullptr,
+                .flags = 0U,
+                .codeSize = code.size(),
+                .pCode = (uint32_t*)code.data(),
+            };
+
+            VKCHECK(vkCreateShaderModule(device, &module_create_info, nullptr, &shader_stages_create_info[1U].module));
+        }
+
+        VkPipelineVertexInputStateCreateInfo vertex_input_state_create_info {
+            .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
+        };
+
+        VkPipelineInputAssemblyStateCreateInfo input_assembly_create_info {
+            .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
+            .pNext = nullptr,
+            .flags = 0U,
+            .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
+            .primitiveRestartEnable = VK_FALSE,
+        };
+
+        VkPipelineViewportStateCreateInfo viewport_state_create_info {
+            .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
+            .pNext = nullptr,
+            .flags = 0U,
+            .viewportCount = 0U,
+            .pViewports = nullptr,
+            .scissorCount = 0U,
+            .pScissors = nullptr,
+        };
+
+        VkPipelineRasterizationStateCreateInfo rasterization_state_create_info {
+            .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
+            .pNext = nullptr,
+            .flags = 0U,
+            .depthClampEnable = VK_FALSE,
+            .rasterizerDiscardEnable = VK_FALSE,
+            .polygonMode = VK_POLYGON_MODE_FILL,
+            .cullMode = VK_CULL_MODE_NONE,
+            .frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE,
+            .depthBiasEnable = VK_FALSE,
+            .lineWidth = 1.f,
+        };
+
+        VkDynamicState dynamic_states[] {
+            VK_DYNAMIC_STATE_VIEWPORT,
+            VK_DYNAMIC_STATE_SCISSOR,
+        };
+
+        VkPipelineDynamicStateCreateInfo dynamic_state_create_info {
+            .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
+            .pNext = nullptr,
+            .flags = 0U,
+            .dynamicStateCount = sizeof(dynamic_states) / sizeof(VkDynamicState),
+            .pDynamicStates = dynamic_states,
+        };
+
+        VkPipelineRenderingCreateInfo pipeline_rendering_create_info {
+            .sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,
+            .pNext = nullptr,
+            .viewMask = 0U,
+            .colorAttachmentCount = 0U,
+            .pColorAttachmentFormats = nullptr,
+            .depthAttachmentFormat = VK_FORMAT_UNDEFINED,
+            .stencilAttachmentFormat = VK_FORMAT_UNDEFINED,
+        };
 
         VkGraphicsPipelineCreateInfo create_info {
             .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
-            .pNext = nullptr,
+            .pNext = &pipeline_rendering_create_info,
             .flags = 0U,
+            .stageCount = sizeof(shader_stages_create_info) / sizeof(VkPipelineShaderStageCreateInfo),
+            .pStages = shader_stages_create_info,
+            .pVertexInputState = &vertex_input_state_create_info,
+            .pInputAssemblyState = &input_assembly_create_info,
+            .pTessellationState = nullptr,
+            .pViewportState = &viewport_state_create_info,
+            .pRasterizationState = &rasterization_state_create_info,
+            .pMultisampleState = nullptr,
+            .pDepthStencilState = nullptr,
+            .pColorBlendState = nullptr,
+            .pDynamicState = &dynamic_state_create_info,
             .layout = bindless.layout, 
+            .renderPass = nullptr,
+            .subpass = 0U,
             .basePipelineHandle = nullptr,
             .basePipelineIndex = 0,
         };
diff --git a/api-test/vk-utils.cpp b/api-test/vk-utils.cpp
new file mode 100644
index 0000000..c9ad9c9
--- /dev/null
+++ b/api-test/vk-utils.cpp
@@ -0,0 +1,44 @@
+#include "vk-utils.hpp"
+
+#include <iostream>
+
+VKAPI_ATTR VkBool32 VKAPI_CALL debug_callback(VkDebugUtilsMessageSeverityFlagBitsEXT      severity,
+                                              VkDebugUtilsMessageTypeFlagsEXT             type,
+                                              const VkDebugUtilsMessengerCallbackDataEXT* data,
+                                              void*) {
+    const char* severity_cstr = nullptr;
+    switch (severity) {
+    case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT:
+        severity_cstr = "VERBOSE";
+        break;
+    case VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT:
+        severity_cstr = "INFO";
+        break;
+    case VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT:
+        severity_cstr = "WARNING";
+        break;
+    case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT:
+        severity_cstr = "ERROR";
+        break;
+    default:
+        break;
+    }
+
+    const char* type_cstr = nullptr;
+    switch (type) {
+    case VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT:
+        type_cstr = "GENERAL";
+        break;
+    case VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT:
+        type_cstr = "VALIDATION";
+        break;
+    case VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT:
+        type_cstr = "PERFORMANCE";
+        break;
+    default:
+        break;
+    }
+
+    std::cerr << "[" << severity_cstr << "_" << type_cstr << "]: " << data->pMessage << std::endl;
+    return VK_FALSE;
+}