gaming-core/src/VulkanUtils.cpp

#include "VulkanUtils.hpp"

#include <core/Array.hpp>
#include <core/Logger.hpp>

#include "core/VulkanUtility.hpp"

static u32 getSwapImageCount(const VkSurfaceCapabilitiesKHR* caps) {
    u32 c = caps->minImageCount + 1;
    // according to VkSurfaceCapabilitiesKHR doc:
    // maxImageCount is 0 when there is no strict limit
    if(caps->maxImageCount != 0) {
        return Core::min(c, caps->maxImageCount);
    }
    return c;
}

bool initVulkanSwapchain(Swapchain& sc, VulkanSwapchainData* d) {
    VkSurfaceCapabilitiesKHR caps = {0};
    if(d->base.getSurfaceCapabilities(caps)) {
        return true;
    }
    VkSwapchainCreateInfoKHR ci = {
        .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
        .surface = d->base,
        .minImageCount = getSwapImageCount(&caps),
        .imageFormat = d->surfaceFormat.format,
        .imageColorSpace = d->surfaceFormat.colorSpace,
        .imageExtent = d->size,
        .imageArrayLayers = 1,
        .imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
        .imageSharingMode = d->sharingMode,
        .queueFamilyIndexCount = static_cast<u32>(d->queueFamilies.getLength()),
        .pQueueFamilyIndices = &d->queueFamilies[0],
        .preTransform = caps.currentTransform,
        .compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
        .presentMode = d->presentMode,
        .clipped = VK_TRUE,
        .oldSwapchain = VK_NULL_HANDLE};
    VK_CHECK_TRUE(vkCreateSwapchainKHR(d->base, &ci, nullptr, sc));
    sc.device = d->base;
    return false;
}

static bool createImageView(
    ImageView& view, VkDevice d, VkImage image, VkFormat format) {
    VkImageViewCreateInfo info = {
        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
        .image = image,
        .viewType = VK_IMAGE_VIEW_TYPE_2D,
        .format = format,
        .subresourceRange = {
            .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
            .baseMipLevel = 0,
            .levelCount = 1,
            .baseArrayLayer = 0,
            .layerCount = 1}};
    VK_CHECK_TRUE(vkCreateImageView(d, &info, nullptr, view));
    view.device = d;
    return false;
}

bool initVulkanSwapchainImages(
    VulkanSwapchainImages& si, VkDevice d, VkSwapchainKHR sc, VkFormat format) {
    u32 c = 0;
    VK_CHECK_TRUE(vkGetSwapchainImagesKHR(d, sc, &c, nullptr));
    si.images.resize(c);
    si.imageViews.resize(c);
    VK_CHECK_TRUE(vkGetSwapchainImagesKHR(d, sc, &c, &si.images[0]));
    for(u32 x = 0; x < c; x++) {
        if(createImageView(si.imageViews[x], d, si.images[x], format)) {
            return true;
        }
    }
    return false;
}

bool initVulkanFramebuffers(
    List<Framebuffer>& f, const List<ImageView>& iv, VkRenderPass rp, u32 width,
    u32 height) {
    for(u32 i = 0; i < iv.getLength(); i++) {
        Framebuffer fb;
        fb.device = iv[i].device;
        VkFramebufferCreateInfo info = {
            .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
            .renderPass = rp,
            .attachmentCount = 1,
            .pAttachments = iv[i],
            .width = width,
            .height = height,
            .layers = 1};
        VK_CHECK_TRUE(vkCreateFramebuffer(fb.device, &info, nullptr, fb));
        f.put(Core::move(fb));
    }
    return false;
}

bool initCommandVulkanBuffer(
    VkCommandBuffer* cb, VkDevice d, VkCommandPool cp) {
    VkCommandBufferAllocateInfo info = {
        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
        .commandPool = cp,
        .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
        .commandBufferCount = 1};
    VK_CHECK_TRUE(vkAllocateCommandBuffers(d, &info, cb));
    return false;
}