image.c

#include <kiba/renderer/vulkan/image.h>
 
#include <kiba/renderer/vulkan/buffer.h>
#include <kiba/renderer/vulkan/command_buffer.h>
 
b8 vulkan_image_create(vulkan_context       *context,
                       u32                   width,
                       u32                   height,
                       VkFormat              format,
                       VkImageTiling         tiling,
                       VkImageUsageFlags     usage,
                       VkMemoryPropertyFlags properties,
                       vulkan_image         *image) {
    VkExtent3D image_extent = {
        .width  = width,
        .height = height,
        .depth  = 1,
    };
    VkImageCreateInfo image_info = {
        .sType         = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
        .imageType     = VK_IMAGE_TYPE_2D,
        .extent        = image_extent,
        .mipLevels     = 1,
        .arrayLayers   = 1,
        .format        = format,
        .tiling        = tiling,
        .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
        .usage         = usage,
        .sharingMode   = VK_SHARING_MODE_EXCLUSIVE,
        .samples       = VK_SAMPLE_COUNT_1_BIT,
        .flags         = 0,
    };
    VK_CALL_B8(vkCreateImage(context->device.logical, &image_info, &context->alloc.vulkan_callbacks, &image->image));
 
    VkMemoryRequirements memory_requirements;
    vkGetImageMemoryRequirements(context->device.logical, image->image, &memory_requirements);
 
    u32 memory_type = vulkan_get_memory_type(context, memory_requirements.memoryTypeBits, properties);
    KB_ASSERT(memory_type != U32_MAX,
              "memory type must be available for the vulkan_image memory");  // TODO should have fallback handling
    VkMemoryAllocateInfo alloc_info = {
        .sType           = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
        .allocationSize  = memory_requirements.size,
        .memoryTypeIndex = memory_type,
    };
    VK_CALL_B8(
        vkAllocateMemory(context->device.logical, &alloc_info, &context->alloc.vulkan_callbacks, &image->memory));
    VK_CALL_B8(vkBindImageMemory(context->device.logical, image->image, image->memory, 0));
    return true;
}
 
VkFormat vulkan_image_fitting_format(vulkan_context      *context,
                                     VkFormat            *candidates,
                                     usize                n,
                                     VkImageTiling        tiling,
                                     VkFormatFeatureFlags features) {
    KB_ASSERT(n > 0, "must provide at least one candidate");
    for (usize i = 0; i < n; ++i) {
        VkFormat           format = candidates[i];
        VkFormatProperties properties;
        vkGetPhysicalDeviceFormatProperties(context->device.physical, format, &properties);
        if (tiling == VK_IMAGE_TILING_OPTIMAL && KB_FLAGS_ALL_SET(properties.optimalTilingFeatures, features)) {
            return format;
        }
        if (tiling == VK_IMAGE_TILING_LINEAR && KB_FLAGS_ALL_SET(properties.linearTilingFeatures, features)) {
            return format;
        }
        return format;
    }
    return VK_FORMAT_MAX_ENUM;
}
 
b8 vulkan_image_transition_layout(vulkan_context *context,
                                  vulkan_image   *image,
                                  VkFormat        format,
                                  VkImageLayout   src,
                                  VkImageLayout   dst) {
    VkCommandBuffer command_buffer;
    if (!vulkan_command_buffer_start_single_time_command(context, &command_buffer)) {
        return false;
    }
 
    VkImageSubresourceRange subresource_range = {
        .aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT,
        .baseMipLevel   = 0,
        .levelCount     = 1,
        .baseArrayLayer = 0,
        .layerCount     = 1,
    };
    VkImageMemoryBarrier barrier = {
        .sType               = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
        .oldLayout           = src,
        .newLayout           = dst,
        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,  // these two could be set to transfer queue ownership
        .image               = image->image,
        .subresourceRange    = subresource_range,
    };
 
    VkPipelineStageFlags src_stage;
    VkPipelineStageFlags dst_stage;
 
    if (src == VK_IMAGE_LAYOUT_UNDEFINED && dst == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
        barrier.srcAccessMask = 0;
        barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
        src_stage             = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
        dst_stage             = VK_PIPELINE_STAGE_TRANSFER_BIT;
    } else if (src == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL && dst == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
        barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
        barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
        src_stage             = VK_PIPELINE_STAGE_TRANSFER_BIT;
        dst_stage             = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
    } else if (src == VK_IMAGE_LAYOUT_UNDEFINED && dst == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL) {
        barrier.srcAccessMask = 0;
        barrier.dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
        src_stage             = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
        dst_stage             = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
    } else if (src == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR && dst == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL) {
        barrier.srcAccessMask = 0;
        barrier.dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
        src_stage             = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
        dst_stage             = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
    } else if (src == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL && dst == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR) {
        barrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
        barrier.dstAccessMask = 0;
        src_stage             = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
        dst_stage             = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
    } else {
        KB_ASSERT(false, "unsupported combination of src({u32}) and dst({u32}) layout", src, dst);
    }
 
    vkCmdPipelineBarrier(command_buffer, src_stage, dst_stage, 0, 0, KB_NULL, 0, KB_NULL, 1, &barrier);
    UNUSED(format);  // TODO for now, revisit in depth buffer section
 
    return vulkan_command_buffer_end_single_time_command(context, &command_buffer);
}
 
b8 vulkan_image_copy_from_buffer(vulkan_context *context,
                                 vulkan_buffer  *buffer,
                                 vulkan_image   *image,
                                 u32             width,
                                 u32             height) {
    VkCommandBuffer command_buffer;
    if (!vulkan_command_buffer_start_single_time_command(context, &command_buffer)) {
        return false;
    }
 
    VkImageSubresourceLayers subresource = {
        .aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT,
        .mipLevel       = 0,
        .baseArrayLayer = 0,
        .layerCount     = 1,
    };
    VkOffset3D image_offset = {0, 0, 0};
    VkExtent3D image_extent = {
        .width  = width,
        .height = height,
        .depth  = 1,
    };
    VkBufferImageCopy region = {
        .bufferOffset      = 0,
        .bufferRowLength   = 0,
        .bufferImageHeight = 0,
        .imageSubresource  = subresource,
        .imageOffset       = image_offset,
        .imageExtent       = image_extent,
    };
    vkCmdCopyBufferToImage(command_buffer,
                           buffer->buffer,
                           image->image,
                           VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                           1,
                           &region);
 
    return vulkan_command_buffer_end_single_time_command(context, &command_buffer);
}
 
void vulkan_image_destroy(vulkan_context *context, vulkan_image *image) {
    vkDestroyImage(context->device.logical, image->image, &context->alloc.vulkan_callbacks);
    vkFreeMemory(context->device.logical, image->memory, &context->alloc.vulkan_callbacks);
}
 
b8 vulkan_image_view_create(vulkan_context    *context,
                            VkImage            image,
                            VkFormat           format,
                            VkImageAspectFlags aspect_flags,
                            VkImageView       *view) {
    VkImageSubresourceRange subresource_range = {
        .aspectMask     = aspect_flags,
        .baseMipLevel   = 0,
        .levelCount     = 1,
        .baseArrayLayer = 0,
        .layerCount     = 1,
    };
    VkImageViewCreateInfo view_info = {
        .sType            = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
        .image            = image,
        .viewType         = VK_IMAGE_VIEW_TYPE_2D,
        .format           = format,
        .subresourceRange = subresource_range,
    };
    VK_CALL_B8(vkCreateImageView(context->device.logical, &view_info, &context->alloc.vulkan_callbacks, view));
    return true;
}
 
void vulkan_image_view_destroy(vulkan_context *context, VkImageView *view) {
    vkDestroyImageView(context->device.logical, *view, &context->alloc.vulkan_callbacks);
}