surface.c

#include <kiba/gpu/vulkan/surface.h>
 
#include <kiba/containers/array.h>
#include <kiba/gpu/command.h>
#include <kiba/gpu/surface.h>
#include <kiba/gpu/vulkan/allocator.h>
#include <kiba/gpu/vulkan/conv.h>
#include <kiba/gpu/vulkan/device.h>
#include <kiba/gpu/vulkan/instance.h>
#include <kiba/gpu/vulkan/queue.h>
#include <kiba/gpu/vulkan/util.h>
 
void vk_surface_destroy(VkSurfaceKHR *surface) {
    if (*surface != VK_NULL_HANDLE) {
        vkDestroySurfaceKHR(vk_instance.raw, *surface, &vk_alloc.vulkan_callbacks);
        *surface = VK_NULL_HANDLE;
    } else {
        KB_WARN("tried to destroy uninitialized surface");
    }
}
 
b8 gpu_backend_surface_create(struct gpu_backend_surface *surface, void *window_data) {
    return vk_surface_create(&surface->raw, window_data);
}
 
void gpu_backend_surface_destroy(struct gpu_backend_surface *surface) { vk_surface_destroy(&surface->raw); }
 
static b8 vk_verify_swap_chain_format_availability(struct gpu_backend_surface *surface,
                                                   struct gpu_backend_device   device,
                                                   enum gpu_texture_format     format) {
    u32 available_format_count = 0;
    VK_CALL_B8(vkGetPhysicalDeviceSurfaceFormatsKHR(device.physical, surface->raw, &available_format_count, 0));
    array_of(VkSurfaceFormatKHR) available_formats =
        array_create(VkSurfaceFormatKHR, available_format_count, &vk_alloc.kiba_alloc);
    array_resize(&available_formats, available_format_count);
    if (available_formats == KB_NULL) {
        KB_ERROR("could not create array to store available swap chain formats");
        return false;
    }
    VK_CALL_B8(vkGetPhysicalDeviceSurfaceFormatsKHR(device.physical,
                                                    surface->raw,
                                                    &available_format_count,
                                                    available_formats));
 
    b8 found_format = false;
    array_for_each(VkSurfaceFormatKHR, surface_format, available_formats) {
        if (format == vk_convert_vk_surface_format(*surface_format)) {
            found_format = true;
            break;
        }
    }
 
    array_destroy(&available_formats);
    return found_format;
}
 
static b8 vk_verify_swap_chain_present_mode_availability(struct gpu_backend_surface *surface,
                                                         struct gpu_backend_device   device,
                                                         enum gpu_present_mode       present_mode) {
    u32 available_present_mode_count = 0;
    VK_CALL_B8(
        vkGetPhysicalDeviceSurfacePresentModesKHR(device.physical, surface->raw, &available_present_mode_count, 0));
    array_of(VkPresentModeKHR) available_present_modes =
        array_create(VkPresentModeKHR, available_present_mode_count, &vk_alloc.kiba_alloc);
    array_resize(&available_present_modes, available_present_mode_count);
    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(device.physical,
                                                         surface->raw,
                                                         &available_present_mode_count,
                                                         available_present_modes));
 
    VkPresentModeKHR target             = vk_convert_present_mode(present_mode);
    b8               found_present_mode = false;
    array_for_each(VkPresentModeKHR, available_present_mode, available_present_modes) {
        if (*available_present_mode == target) {
            found_present_mode = true;
            break;
        }
    }
 
    array_destroy(&available_present_modes);
    return found_present_mode;
}
 
static b8 vk_query_swap_chain_capabilities(struct gpu_backend_surface      *surface,
                                           struct gpu_backend_device        device,
                                           struct gpu_surface_configuration config) {
    VkSurfaceCapabilitiesKHR capabilities;
    VK_CALL_B8(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device.physical, surface->raw, &capabilities));
    if (capabilities.currentExtent.width == UINT_MAX) {
        surface->extent.height =
            KB_CLAMP(config.height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height);
        surface->extent.width =
            KB_CLAMP(config.width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width);
    } else {
        surface->extent = capabilities.currentExtent;
    }
    u32 image_count = capabilities.minImageCount;
    if (capabilities.maxImageCount > capabilities.minImageCount) {
        ++image_count;
    }
    surface->image_count = image_count;
    return true;
}
 
static void swap_chain_destroy(struct gpu_backend_surface *surface, struct gpu_backend_device device) {
    if (surface->swap_chain != VK_NULL_HANDLE) {
        vkDestroySwapchainKHR(device.logical, surface->swap_chain, &vk_alloc.vulkan_callbacks);
        surface->swap_chain = VK_NULL_HANDLE;
    } else {
        KB_WARN("tried to destroy uninitialized swap chain");
    }
}
 
static b8 swap_chain_create(struct gpu_backend_surface      *surface,
                            struct gpu_backend_device        device,
                            struct gpu_surface_configuration config) {
    // setup and verification
    if (!vk_verify_swap_chain_format_availability(surface, device, config.format)) {
        KB_INFO("did not find required swap chain format");
        return false;
    }
    if (!vk_verify_swap_chain_present_mode_availability(surface, device, config.present_mode)) {
        KB_INFO("did not find required swap chain present mode");
        return false;
    }
    if (!vk_query_swap_chain_capabilities(surface, device, config)) {
        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          = surface->raw,
        .imageExtent      = surface->extent,
        .minImageCount    = surface->image_count,
        .imageFormat      = vk_convert_texture_format(config.format),
        .imageColorSpace  = config.format == GPU_TEXTURE_FORMAT_RGBA16_FLOAT ? VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT
                                                                             : VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
        .presentMode      = vk_convert_present_mode(config.present_mode),
        .imageArrayLayers = 1,
        .imageUsage       = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
        .preTransform     = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR,
        .compositeAlpha   = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,  // TODO composite alpha would be applied here
        .clipped          = VK_TRUE,
        .oldSwapchain     = surface->swap_chain,
    };
    u32 queue_family_indices[] = {device.graphics_queue.index, device.present_queue.index};
    // TODO is this still needed?
    if (device.graphics_queue.index != 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;
    }
 
    VkSwapchainKHR new_swapchain = VK_NULL_HANDLE;
    VK_CALL_B8(vkCreateSwapchainKHR(device.logical, &swap_chain_info, &vk_alloc.vulkan_callbacks, &new_swapchain));
    if (surface->swap_chain != VK_NULL_HANDLE) {
        // TODO should ideally also be done in the error case above
        swap_chain_destroy(surface, device);
    }
    surface->swap_chain = new_swapchain;
 
    // get images
    u32 image_count = 0;
    VK_CALL_B8(vkGetSwapchainImagesKHR(device.logical, surface->swap_chain, &image_count, 0));
    KB_ASSERT(image_count <= 3, "address todo of the structure");  // TODO
    surface->image_count = image_count;
    VK_CALL_B8(vkGetSwapchainImagesKHR(device.logical, surface->swap_chain, &image_count, surface->images));
    return true;
}
 
b8 gpu_backend_surface_configure(struct gpu_backend_surface      *surface,
                                 struct gpu_backend_device       *device,
                                 struct gpu_surface_configuration config) {
    vkQueueWaitIdle(device->graphics_queue.queue);
    if (surface->fc_image_aquire == VK_NULL_HANDLE) {
        VkFenceCreateInfo fc_create_info = {
            .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
            .flags = VK_FENCE_CREATE_SIGNALED_BIT,
        };
        VK_CALL_B8(
            vkCreateFence(device->logical, &fc_create_info, &vk_alloc.vulkan_callbacks, &surface->fc_image_aquire));
    }
    // TODO cleanup and recreate certain resources
    return swap_chain_create(surface, *device, config);
}
 
void gpu_backend_surface_unconfigure(struct gpu_backend_surface *surface, struct gpu_backend_device *device) {
    // TODO could probably inline this
    swap_chain_destroy(surface, *device);
    if (surface->fc_image_aquire != VK_NULL_HANDLE) {
        vkDestroyFence(device->logical, surface->fc_image_aquire, &vk_alloc.vulkan_callbacks);
        surface->fc_image_aquire = VK_NULL_HANDLE;
    }
}
 
b8 gpu_backend_surface_get_current_texture(struct gpu_backend_surface *surface,
                                           struct gpu_backend_device  *device,
                                           struct gpu_backend_texture *texture,
                                           b8                         *suboptimal) {
    u32      image_index = 0;
    VK_CALL_ASSERT(vkResetFences(device->logical, 1, &surface->fc_image_aquire));
    VkResult res = vkAcquireNextImageKHR(device->logical,
                                         surface->swap_chain,
                                         UINT64_MAX,  // TODO could introduce timeout here
                                         VK_NULL_HANDLE,
                                         surface->fc_image_aquire,
                                         &image_index);
    VK_CALL_ASSERT(vkWaitForFences(device->logical, 1, &surface->fc_image_aquire, VK_TRUE, UINT64_MAX));
    VK_CALL_ASSERT(vkResetFences(device->logical, 1, &surface->fc_image_aquire));
    if (res == VK_NOT_READY || res == VK_SUBOPTIMAL_KHR || res == VK_ERROR_OUT_OF_DATE_KHR) {
        KB_WARN("suboptimal");
        *suboptimal = true;
    }
    if (res == VK_SUCCESS) {
        texture->raw                      = surface->images[image_index];
        surface->presentation_image_index = image_index;
        KB_DEBUG("using tex {pointer} at index {u32}", texture->raw, surface->presentation_image_index);
        return true;
    }
    return false;
}
 
b8 gpu_backend_surface_present(struct gpu_backend_surface *surface,
                               struct gpu_backend_device  *device,
                               struct gpu_backend_texture *texture,
                               b8                         *suboptimal) {
    UNUSED(texture);
    VkResult res = vk_queue_present_surface(surface, device);
    if (res == VK_ERROR_OUT_OF_DATE_KHR || res == VK_SUBOPTIMAL_KHR) {
        KB_WARN("suboptimal");
        *suboptimal = true;
    }
    return res == VK_SUCCESS;
}