swap_chain.c

#include <kiba/renderer/vulkan/swap_chain.h>
 
#include <kiba/renderer/vulkan/image.h>
 
#include <limits.h>
 
#include <kiba/renderer/vulkan/depth.h>
#include <kiba/renderer/vulkan/framebuffers.h>
 
b8 vulkan_verify_swap_chain_format_availability(vulkan_context *context);
b8 vulkan_verify_swap_chain_present_mode_availability(vulkan_context *context);
b8 vulkan_query_swap_chain_capabilities(vulkan_context *context);
 
b8 vulkan_swap_chain_create(vulkan_context *context) {
    // setup and verification
    if (!vulkan_verify_swap_chain_format_availability(context)) {
        KB_INFO("did not find required swap chain format");
        return false;
    }
    if (!vulkan_verify_swap_chain_present_mode_availability(context)) {
        KB_INFO("did not find required swap chain present mode");
        return false;
    }
    if (!vulkan_query_swap_chain_capabilities(context)) {
        KB_INFO("could not query swap chain capabilities");
        return false;
    }
 
    // create swap chain
    VkSwapchainCreateInfoKHR swap_chain_info = {
        .sType            = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
        .surface          = context->surface,
        .imageExtent      = context->swap_chain.extent,
        .minImageCount    = context->swap_chain.image_count,
        .imageFormat      = context->swap_chain.requirements.format.format,
        .imageColorSpace  = context->swap_chain.requirements.format.colorSpace,
        .presentMode      = context->swap_chain.requirements.present_mode,
        .imageArrayLayers = 1,
        .imageUsage       = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
        .preTransform     = context->swap_chain.transform,
        // TODO: make configurable, maybe requirements
        .compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
        .clipped        = VK_TRUE,
        // TODO: swap chain recreation
        .oldSwapchain = VK_NULL_HANDLE,
    };
    u32 queue_family_indices[] = {context->device.graphics_queue.index, context->device.present_queue.index};
    if (context->device.graphics_queue.index != context->device.present_queue.index) {
        swap_chain_info.imageSharingMode      = VK_SHARING_MODE_CONCURRENT;
        swap_chain_info.queueFamilyIndexCount = 2;
        swap_chain_info.pQueueFamilyIndices   = queue_family_indices;
    } else {
        swap_chain_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
    }
 
    VK_CALL_B8(vkCreateSwapchainKHR(context->device.logical,
                                    &swap_chain_info,
                                    &context->alloc.vulkan_callbacks,
                                    &context->swap_chain.swap_chain));
 
    // get images
    u32 image_count = 0;
    VK_CALL_B8(vkGetSwapchainImagesKHR(context->device.logical, context->swap_chain.swap_chain, &image_count, 0));
    context->swap_chain.image_count = image_count;
    context->swap_chain.images      = array_create(VkImage, image_count, &context->alloc.kiba_alloc);
    if (context->swap_chain.images == KB_NULL) {
        KB_ERROR("could not allocate array for swap chain images");
        return false;
    }
    context->swap_chain.image_views = array_create(VkImageView, image_count, &context->alloc.kiba_alloc);
    if (context->swap_chain.image_views == KB_NULL) {
        KB_ERROR("could not allocate array for swap chain image views");
        return false;
    }
    VK_CALL_B8(vkGetSwapchainImagesKHR(context->device.logical,
                                       context->swap_chain.swap_chain,
                                       &image_count,
                                       context->swap_chain.images));
    array_resize(&context->swap_chain.images, image_count);
    array_resize(&context->swap_chain.image_views, image_count);
 
    usize i = 0;
    array_for_each(VkImage, image, context->swap_chain.images) {
        if (!vulkan_image_view_create(context,
                                      *image,
                                      context->swap_chain.requirements.format.format,
                                      VK_IMAGE_ASPECT_COLOR_BIT,
                                      &context->swap_chain.image_views[i++])) {
            return false;
        }
    }
 
    return true;
}
 
b8 vulkan_swap_chain_recreate(vulkan_context *context) {
    // wait until async stuff done
    vkDeviceWaitIdle(context->device.logical);
 
    vulkan_framebuffers_destroy(context);
    vulkan_depth_destroy(context);
    vulkan_swap_chain_destroy(context);
 
    // NOTE: may also recreate render pass e.g. in case window is dragged to high-res display
    // TODO: should also listen for resize events
    // TODO: should also handle minimization
 
    return vulkan_swap_chain_create(context) && vulkan_depth_create(context) && vulkan_framebuffers_create(context);
}
 
void vulkan_swap_chain_destroy(vulkan_context *context) {
    array_for_each(VkImageView, view, context->swap_chain.image_views) { vulkan_image_view_destroy(context, view); }
    array_destroy(&context->swap_chain.image_views);
    array_destroy(&context->swap_chain.images);
    vkDestroySwapchainKHR(context->device.logical, context->swap_chain.swap_chain, &context->alloc.vulkan_callbacks);
}
 
b8 vulkan_verify_swap_chain_format_availability(vulkan_context *context) {
    u32   available_format_count = 0;
    VK_CALL_B8(
        vkGetPhysicalDeviceSurfaceFormatsKHR(context->device.physical, context->surface, &available_format_count, 0));
    array_of(VkSurfaceFormatKHR) available_formats =
        array_create(VkSurfaceFormatKHR, available_format_count, &context->alloc.kiba_alloc);
    if (available_formats == KB_NULL) {
        KB_ERROR("could not create array to store available swap chain formats");
        return false;
    }
    VK_CALL_B8(vkGetPhysicalDeviceSurfaceFormatsKHR(context->device.physical,
                                                    context->surface,
                                                    &available_format_count,
                                                    available_formats));
    array_resize(&available_formats, available_format_count);
 
    b8 found_format = false;
    array_for_each(VkSurfaceFormatKHR, surface_format, available_formats) {
        if (surface_format->format == context->swap_chain.requirements.format.format
            && surface_format->colorSpace == context->swap_chain.requirements.format.colorSpace) {
            found_format = true;
            break;
        }
    }
 
    array_destroy(&available_formats);
    return found_format;
}
 
b8 vulkan_verify_swap_chain_present_mode_availability(vulkan_context *context) {
    u32   available_present_mode_count = 0;
    VK_CALL_B8(vkGetPhysicalDeviceSurfacePresentModesKHR(context->device.physical,
                                                         context->surface,
                                                         &available_present_mode_count,
                                                         0));
    array_of(VkPresentModeKHR) available_present_modes =
        array_create(VkPresentModeKHR, available_present_mode_count, &context->alloc.kiba_alloc);
    if (available_present_modes == KB_NULL) {
        KB_ERROR("could not create array to store available swap chain present modes");
        return false;
    }
    VK_CALL_B8(vkGetPhysicalDeviceSurfacePresentModesKHR(context->device.physical,
                                                         context->surface,
                                                         &available_present_mode_count,
                                                         available_present_modes));
    array_resize(&available_present_modes, available_present_mode_count);
 
    b8 found_present_mode = false;
    array_for_each(VkPresentModeKHR, present_mode, available_present_modes) {
        if (*present_mode == context->swap_chain.requirements.present_mode) {
            found_present_mode = true;
            break;
        }
    }
 
    array_destroy(&available_present_modes);
    return found_present_mode;
}
 
b8 vulkan_query_swap_chain_capabilities(vulkan_context *context) {
    VkSurfaceCapabilitiesKHR capabilities;
    VK_CALL_B8(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(context->device.physical, context->surface, &capabilities));
    if (capabilities.currentExtent.width == UINT_MAX) {
        context->swap_chain.extent.height =
            KB_CLAMP(context->window->h, capabilities.minImageExtent.height, capabilities.maxImageExtent.height);
        context->swap_chain.extent.width =
            KB_CLAMP(context->window->w, capabilities.minImageExtent.width, capabilities.maxImageExtent.width);
    } else {
        context->swap_chain.extent = capabilities.currentExtent;
    }
    context->swap_chain.image_count = capabilities.minImageCount;
    if (capabilities.maxImageCount > capabilities.minImageCount) {
        ++context->swap_chain.image_count;
    }
    context->swap_chain.transform = capabilities.currentTransform;
    return true;
}