instance.c

#include <kiba/renderer/vulkan/instance.h>
 
#include <kiba/containers/array.h>
#include <kiba/core/string.h>
 
b8 verify_extension_availability(array_of(const char *) names);
 
b8 verify_layer_availability(array_of(const char *) names);
 
b8 vulkan_instance_create(vulkan_context *context) {
    VkApplicationInfo app_info = {
        .sType              = VK_STRUCTURE_TYPE_APPLICATION_INFO,
        .pApplicationName   = "Vulkan POC",  // 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,
    };
 
    if (!verify_extension_availability(context->instance.extensions)) {
        KB_ERROR("not all required extensions available");
        return false;
    }
 
    if (!verify_layer_availability(context->instance.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(context->instance.layers),
        .ppEnabledLayerNames     = context->instance.layers,
        .enabledExtensionCount   = (u32) array_size(context->instance.extensions),
        .ppEnabledExtensionNames = context->instance.extensions,
#ifdef KB_DEBUG_BUILD
        .pNext = &features,
#endif
    };
 
    VK_CALL_B8(vkCreateInstance(&instance_info, &context->alloc.vulkan_callbacks, &context->instance.instance));
 
    return true;
}
 
void vulkan_instance_destroy(vulkan_context *context) {
    vkDestroyInstance(context->instance.instance, &context->alloc.vulkan_callbacks);
}
 
b8 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));
    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));
    array_resize(&available_extensions, avail_extension_count);
 
    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 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));
    if (avail_layers == KB_NULL) {
        KB_INFO("could not allocate enough memory for list of available layers");
        return false;
    }
 
    // NOTE: this leaks in case it is unsuccessful
    VK_CALL_B8(vkEnumerateInstanceLayerProperties(&avail_layer_count, avail_layers));
    array_resize(&avail_layers, avail_layer_count);
 
    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;
}