texture.c

#include <kiba/gpu/texture.h>
 
#include <kiba/gpu/vulkan/allocator.h>
#include <kiba/gpu/vulkan/conv.h>
#include <kiba/gpu/vulkan/device.h>
#include <kiba/gpu/vulkan/util.h>
 
b8 gpu_backend_texture_create(struct gpu_backend_texture   *texture,
                              struct gpu_backend_device     device,
                              struct gpu_texture_descriptor desc) {
    VkExtent3D image_extent = {
        .width  = (u32) desc.size.width,
        .height = (u32) desc.size.height,
        .depth  = 1,
    };
    if (desc.dimension == GPU_TEXTURE_DIMENSION_D3) {
        image_extent.depth = (u32) desc.size.depth;
    }
    VkImageCreateInfo image_info = {
        .sType         = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
        .imageType     = vk_convert_texture_dimension(desc.dimension),
        .extent        = image_extent,
        .mipLevels     = (u32) desc.mip_level_count,
        .arrayLayers   = 1,
        .format        = vk_convert_texture_format(desc.format),
        .tiling        = VK_IMAGE_TILING_OPTIMAL,
        .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
        .usage         = vk_convert_texture_use(gpu_convert_texture_usage_to_use(desc.usage, desc.format)),
        .sharingMode   = VK_SHARING_MODE_EXCLUSIVE,
        .samples       = vk_convert_sample_count(desc.sample_count),
        .flags         = 0,  // TODO view_formats and cube textures would set flags
    };
    if (desc.dimension == GPU_TEXTURE_DIMENSION_D2) {
        image_info.arrayLayers = (u32) desc.size.layers;
    }
    VK_CALL_B8(vkCreateImage(device.logical, &image_info, &vk_alloc.vulkan_callbacks, &texture->raw));
 
    VkMemoryRequirements memory_requirements;
    vkGetImageMemoryRequirements(device.logical, texture->raw, &memory_requirements);
 
    if (!vk_device_allocate_memory(device,
                                   &texture->memory,
                                   memory_requirements,
                                   VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)) {
        KB_ERROR("could not allocate memory for image");
        return false;
    }
    VK_CALL_B8(vkBindImageMemory(device.logical, texture->raw, texture->memory, 0));
    vk_device_set_object_name(device.logical, VK_OBJECT_TYPE_IMAGE, texture->raw, desc.label);
    return true;
}
 
void gpu_backend_texture_destroy(struct gpu_backend_texture *texture, struct gpu_backend_device device) {
    vkDestroyImage(device.logical, texture->raw, &vk_alloc.vulkan_callbacks);
    vkFreeMemory(device.logical, texture->memory, &vk_alloc.vulkan_callbacks);
}
 
b8 gpu_backend_texture_view_create(struct gpu_backend_texture_view   *view,
                                   struct gpu_backend_device          device,
                                   struct gpu_backend_texture         texture,
                                   struct gpu_texture_view_descriptor desc) {
    VkImageSubresourceRange subresource_range = {
        .aspectMask     = vk_convert_texture_format_aspect(gpu_format_aspect_from_format(desc.format)),
        .baseMipLevel   = (u32) desc.base_mip_level,
        .levelCount     = desc.mip_level_count == 0 ? VK_REMAINING_MIP_LEVELS : (u32) desc.mip_level_count,
        .baseArrayLayer = (u32) desc.base_array_layer,
        .layerCount     = desc.array_layer_count == 0 ? VK_REMAINING_ARRAY_LAYERS : (u32) desc.array_layer_count,
    };
    VkImageViewCreateInfo view_info = {
        .sType            = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
        .image            = texture.raw,
        .viewType         = vk_convert_texture_view_dimension(desc.dimension),
        .format           = vk_convert_texture_format(desc.format),
        .subresourceRange = subresource_range,
    };
    VK_CALL_B8(vkCreateImageView(device.logical, &view_info, &vk_alloc.vulkan_callbacks, &view->raw));
    vk_device_set_object_name(device.logical, VK_OBJECT_TYPE_IMAGE_VIEW, view->raw, desc.label);
    return true;
}
 
void gpu_backend_texture_view_destroy(struct gpu_backend_texture_view *view, struct gpu_backend_device device) {
    if (view->raw != VK_NULL_HANDLE) {
        vkDestroyImageView(device.logical, view->raw, &vk_alloc.vulkan_callbacks);
        view->raw = VK_NULL_HANDLE;
    } else {
        KB_WARN("tried to destroy uninitialized texture view");
    }
}