context.c

#include <kiba/renderer/vulkan/context.h>
 
#include <kiba/core/event.h>
#include <kiba/core/log.h>
#include <kiba/renderer/vulkan/allocator.h>
 
b8 vulkan_context_resize_callback(u16 code, void *sender, void *listener, event_context context);
 
b8 vulkan_context_resize_callback(u16 code, void *sender, void *listener, event_context context) {
    UNUSED(code);
    UNUSED(sender);
    UNUSED(context);
    vulkan_context *ctx = listener;
 
    ctx->swap_chain.recreate = true;
    return false;
}
 
b8 vulkan_default_context_create(vulkan_context *context, platform_window *window) {
    // allocator
    if (!vulkan_allocator_create(&context->alloc)) {
        return false;
    }
 
    // instance extensions and layers
    array_of(const char *) instance_extensions = array_create(const char *, 5, &context->alloc.kiba_alloc);
 
    if (instance_extensions == KB_NULL) {
        KB_ERROR("could not create array for instance extensions");
        return false;
    }
    array_push(instance_extensions, VK_KHR_SURFACE_EXTENSION_NAME);
    // TODO: move somewhere else
#ifdef KB_LINUX
    array_push(instance_extensions, "VK_KHR_xcb_surface");
#endif
#ifdef KB_DEBUG_BUILD
    array_push(instance_extensions, VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
#endif
 
    array_of(const char *) instance_layers = array_create(const char *, 4, &context->alloc.kiba_alloc);
    if (instance_layers == KB_NULL) {
        KB_ERROR("could not create array for instance layers");
        return false;
    }
#ifdef KB_DEBUG_BUILD
    array_push(instance_layers, "VK_LAYER_KHRONOS_validation");
#endif
 
    context->instance.extensions = instance_extensions;
    context->instance.layers     = instance_layers;
 
    // device extensions and requirements
    array_of(const char *) device_extensions = array_create(const char *, 4, &context->alloc.kiba_alloc);
    if (device_extensions == KB_NULL) {
        KB_ERROR("could not create array for device extensions");
        return false;
    }
    array_push(device_extensions, VK_KHR_SWAPCHAIN_EXTENSION_NAME);
    array_push(device_extensions, VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME);
 
    VkPhysicalDeviceFeatures features = {
        .samplerAnisotropy = VK_TRUE,
    };
 
    vulkan_device_requirements device_requirements = {
        .graphics     = true,
        .transfer     = true,
        .present      = true,
        .compute      = true,
        .discrete_gpu = true,
        .extensions   = device_extensions,
        .features     = features,
    };
 
    context->device.requirements = device_requirements;
 
    // swap chain
    VkSurfaceFormatKHR swap_chain_format = {
        .colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
        .format     = VK_FORMAT_B8G8R8A8_SRGB,
    };
    vulkan_swap_chain_requirements swap_chain_requirements = {
        .format       = swap_chain_format,
        .present_mode = VK_PRESENT_MODE_FIFO_KHR,  // VK_PRESENT_MODE_IMMEDIATE_KHR
    };
 
    context->swap_chain.requirements = swap_chain_requirements;
 
    // window
    context->window = window;
 
    event_register(EVENT_CODE_WINDOW_RESIZE, context, &vulkan_context_resize_callback, false);
 
    return true;
}
 
void vulkan_context_destroy(vulkan_context *context) {
    event_unregister(EVENT_CODE_WINDOW_RESIZE, context, &vulkan_context_resize_callback);
    array_destroy(&context->device.requirements.extensions);
    array_destroy(&context->instance.layers);
    array_destroy(&context->instance.extensions);
    vulkan_allocator_destroy(&context->alloc);
}