instance.c

#include <kiba/gpu/vulkan/instance.h>
 
#include <kiba/containers/array.h>
#include <kiba/core/log.h>
#include <kiba/core/memory.h>
#include <kiba/core/string.h>
#include <kiba/gpu/vulkan/allocator.h>
#include <kiba/gpu/vulkan/util.h>
 
struct vk_instance_t vk_instance = { 0 };
 
struct vk_instance_requirements {
    array_of(const char *) extensions;
    array_of(const char *) layers;
};
 
static struct vk_instance_requirements vk_instance_requirements(void) {
    struct vk_instance_requirements req = {
        .extensions = array_create(const char *, 5, &vk_alloc.kiba_alloc),
        .layers     = array_create(const char *, 4, &vk_alloc.kiba_alloc),
    };
    KB_ASSERT(req.extensions != KB_NULL, "instance extension array creation must be successful");
    KB_ASSERT(req.layers != KB_NULL, "instance layer array creation must be successful");
 
    array_push(req.extensions, VK_KHR_SURFACE_EXTENSION_NAME);
#ifdef KB_LINUX
    array_push(req.extensions, "VK_KHR_xcb_surface");
#endif
#ifdef KB_DEBUG_BUILD
    array_push(req.extensions, VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
    array_push(req.layers, "VK_LAYER_KHRONOS_validation");
#endif
    return req;
}
 
b8 vk_verify_extension_availability(array_of(const char *) names);
b8 vk_verify_layer_availability(array_of(const char *) names);
 
b8 vk_debug_messenger_create(void);
void vk_debug_messenger_destroy(void);
 
b8 vk_instance_initialize(void) {
    VkApplicationInfo app_info = {
        .sType              = VK_STRUCTURE_TYPE_APPLICATION_INFO,
        .pApplicationName   = "kiba-vulkan-backend",  // TODO pass that and other app info into backend creation
        .applicationVersion = VK_MAKE_VERSION(1, 0, 0),
        .pEngineName        = "kiba",
        .engineVersion      = VK_MAKE_VERSION(0, 0, 1),
        .apiVersion         = VK_API_VERSION_1_0,
    };
 
    struct vk_instance_requirements requirements = vk_instance_requirements();
 
    if (!vk_verify_extension_availability(requirements.extensions)) {
        KB_ERROR("not all required extensions available");
        return false;
    }
 
    if (!vk_verify_layer_availability(requirements.layers)) {
        KB_ERROR("not all required layers available");
        return false;
    }
 
#ifdef KB_DEBUG_BUILD
    VkValidationFeatureEnableEXT enabled[] = {VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT};
    VkValidationFeaturesEXT      features  = {
              .sType                          = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT,
              .disabledValidationFeatureCount = 0,
              .enabledValidationFeatureCount  = 1,
              .pDisabledValidationFeatures    = VK_NULL_HANDLE,
              .pEnabledValidationFeatures     = enabled,
    };
#endif
 
    VkInstanceCreateInfo instance_info = {
        .sType                   = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
        .pApplicationInfo        = &app_info,
        .enabledLayerCount       = (u32) array_size(requirements.layers),
        .ppEnabledLayerNames     = requirements.layers,
        .enabledExtensionCount   = (u32) array_size(requirements.extensions),
        .ppEnabledExtensionNames = requirements.extensions,
#ifdef KB_DEBUG_BUILD
        .pNext = &features,
#endif
    };
 
    VK_CALL_B8(vkCreateInstance(&instance_info, &vk_alloc.vulkan_callbacks, &vk_instance.raw));
 
#ifdef KB_DEBUG_BUILD
    if (!vk_debug_messenger_create()) {
        KB_ERROR("could not create vulkan debug messenger");
        return false;
    }
    vk_instance.setDebugUtilsObjectName =
        (PFN_vkSetDebugUtilsObjectNameEXT) vkGetInstanceProcAddr(vk_instance.raw, "vkSetDebugUtilsObjectNameEXT");
    vk_instance.cmdBeginDebugUtilsLabel =
        (PFN_vkCmdBeginDebugUtilsLabelEXT) vkGetInstanceProcAddr(vk_instance.raw, "vkCmdBeginDebugUtilsLabelEXT");
    vk_instance.cmdEndDebugUtilsLabel =
        (PFN_vkCmdEndDebugUtilsLabelEXT) vkGetInstanceProcAddr(vk_instance.raw, "vkCmdEndDebugUtilsLabelEXT");
    vk_instance.cmdInsertDebugUtilsLabel =
        (PFN_vkCmdInsertDebugUtilsLabelEXT) vkGetInstanceProcAddr(vk_instance.raw, "vkCmdInsertDebugUtilsLabelEXT");
#endif
 
    return true;
}
 
void vk_instance_shutdown(void) {
    if (vk_instance.raw != VK_NULL_HANDLE) {
#ifdef KB_DEBUG_BUILD
        vk_debug_messenger_destroy();
#endif
        vkDestroyInstance(vk_instance.raw, &vk_alloc.vulkan_callbacks);
        vk_instance.raw = VK_NULL_HANDLE;
    } else {
        KB_WARN("tried to destroy uninitialized vulkan instance");
    }
}
 
b8 vk_verify_extension_availability(array_of(const char *) names) {
    u32 avail_extension_count = 0;
    VK_CALL_B8(vkEnumerateInstanceExtensionProperties(0, &avail_extension_count, 0))
    if (avail_extension_count < array_size(names)) {
        KB_INFO("not all required extensions available");
        return false;
    }
    array_of(VkExtensionProperties) available_extensions =
        array_create(VkExtensionProperties, avail_extension_count, array_alloc(names));
    array_resize(&available_extensions, avail_extension_count);
    if (available_extensions == KB_NULL) {
        KB_INFO("could not allocate enough memory for list of available extensions");
        return false;
    }
    // NOTE: this leaks in case it is unsuccessful
    VK_CALL_B8(vkEnumerateInstanceExtensionProperties(0, &avail_extension_count, available_extensions));
 
    b8 has_extensions = true;
    array_for_each(const char *, name, names) {
        b8 found = false;
        for (u32 j = 0; j < avail_extension_count; ++j) {
            if (string_equal(string_from_raw(*name), string_from_raw(available_extensions[j].extensionName))) {
                found = true;
                break;
            }
        }
        if (!found) {
            KB_ERROR("could not find required extension {raw_string}", *name);
            has_extensions = false;
        }
    }
    array_destroy(&available_extensions);
    return has_extensions;
}
 
b8 vk_verify_layer_availability(array_of(const char *) names) {
    u32 avail_layer_count = 0;
    VK_CALL_B8(vkEnumerateInstanceLayerProperties(&avail_layer_count, 0));
    if (avail_layer_count < array_size(names)) {
        KB_INFO("not all required extensions available");
        return false;
    }
    array_of(VkLayerProperties) avail_layers = array_create(VkLayerProperties, avail_layer_count, array_alloc(names));
    array_resize(&avail_layers, avail_layer_count);
    if (avail_layers == KB_NULL) {
        KB_INFO("could not allocate enough memory for list of available layers");
        return false;
    }
 
    // TODO: this leaks in case it is unsuccessful
    VK_CALL_B8(vkEnumerateInstanceLayerProperties(&avail_layer_count, avail_layers));
 
    b8 has_layers = true;
    array_for_each(const char *, name, names) {
        b8 found = false;
        for (u32 j = 0; j < avail_layer_count; ++j) {
            if (string_equal(string_from_raw(*name), string_from_raw(avail_layers[j].layerName))) {
                found = true;
                break;
            }
        }
        if (!found) {
            KB_ERROR("could not find required validation layer {raw_string}", *name);
            has_layers = false;
        }
    }
    array_destroy(&avail_layers);
    return has_layers;
}
 
VkDebugUtilsMessengerEXT       vk_debug_messenger = {0};
VKAPI_ATTR VkBool32 VKAPI_CALL vk_debug_callback(VkDebugUtilsMessageSeverityFlagBitsEXT      message_severity,
                                                 VkDebugUtilsMessageTypeFlagsEXT             message_types,
                                                 const VkDebugUtilsMessengerCallbackDataEXT *callback_data,
                                                 void                                       *user_data);
 
b8 vk_debug_messenger_create(void) {
    u32 log_severities =
        /*VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT |*/ VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT
        | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
    u32 message_types = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT
                      | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT;
    VkDebugUtilsMessengerCreateInfoEXT debug_create_info = {
        .sType           = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
        .messageSeverity = log_severities,
        .messageType     = message_types,
        .pfnUserCallback = vk_debug_callback,
    };
    PFN_vkCreateDebugUtilsMessengerEXT messenger_add_func =
        (PFN_vkCreateDebugUtilsMessengerEXT) vkGetInstanceProcAddr(vk_instance.raw, "vkCreateDebugUtilsMessengerEXT");
    if (messenger_add_func == KB_NULL) {
        KB_ERROR("could not create vulkan debug messenger");
        return false;
    }
    VK_CALL_B8(
        messenger_add_func(vk_instance.raw, &debug_create_info, &vk_alloc.vulkan_callbacks, &vk_debug_messenger));
    return true;
}
 
void vk_debug_messenger_destroy(void) {
    PFN_vkDestroyDebugUtilsMessengerEXT messenger_remove_func =
        (PFN_vkDestroyDebugUtilsMessengerEXT) vkGetInstanceProcAddr(vk_instance.raw, "vkDestroyDebugUtilsMessengerEXT");
    if (messenger_remove_func == KB_NULL) {
        KB_ERROR("received invalid function to destroy debug messenger");
        return;
    }
    messenger_remove_func(vk_instance.raw, vk_debug_messenger, &vk_alloc.vulkan_callbacks);
}
 
VKAPI_ATTR VkBool32 VKAPI_CALL vk_debug_callback(VkDebugUtilsMessageSeverityFlagBitsEXT      message_severity,
                                                 VkDebugUtilsMessageTypeFlagsEXT             message_types,
                                                 const VkDebugUtilsMessengerCallbackDataEXT *callback_data,
                                                 void                                       *user_data) {
    UNUSED(message_types);
    UNUSED(user_data);
    switch (message_severity) {
        case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT:
            KB_TRACE(callback_data->pMessage);
            break;
        case VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT:
            KB_INFO(callback_data->pMessage);
            break;
        case VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT:
            KB_WARN(callback_data->pMessage);
            break;
        case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT:
        default:
            KB_ERROR(callback_data->pMessage);
            break;
    }
    return VK_FALSE;
}