texture.c

#include <kiba/renderer/vulkan/texture.h>
 
#define STB_IMAGE_IMPLEMENTATION
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wconversion"
#include <stb_image.h>
#pragma GCC diagnostic pop
#undef STB_IMAGE_IMPLEMENTATION
 
#include <kiba/core/memory.h>
#include <kiba/renderer/vulkan/buffer.h>
#include <kiba/renderer/vulkan/image.h>
 
static b8 vulkan_texture_sampler_create(vulkan_context *context) {
    VkPhysicalDeviceProperties properties;
    vkGetPhysicalDeviceProperties(context->device.physical, &properties);
    VkSamplerCreateInfo sampler_info = {
        .sType                   = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
        .magFilter               = VK_FILTER_LINEAR,
        .minFilter               = VK_FILTER_LINEAR,
        .addressModeU            = VK_SAMPLER_ADDRESS_MODE_REPEAT,
        .addressModeV            = VK_SAMPLER_ADDRESS_MODE_REPEAT,
        .addressModeW            = VK_SAMPLER_ADDRESS_MODE_REPEAT,
        .anisotropyEnable        = VK_TRUE,  // could optionally disable if feature not available
        .maxAnisotropy           = properties.limits.maxSamplerAnisotropy,  // go hard or go home
        .borderColor             = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
        .unnormalizedCoordinates = VK_FALSE,
        .compareEnable           = VK_FALSE,
        .compareOp               = VK_COMPARE_OP_ALWAYS,
        .mipmapMode              = VK_SAMPLER_MIPMAP_MODE_LINEAR,
        .mipLodBias              = 0.0f,
        .minLod                  = 0.0f,
        .maxLod                  = 0.0f,
    };
    VK_CALL_B8(vkCreateSampler(context->device.logical,
                               &sampler_info,
                               &context->alloc.vulkan_callbacks,
                               &context->texture.sampler));
    return true;
}
 
static void vulkan_texture_sampler_destroy(vulkan_context *context) {
    vkDestroySampler(context->device.logical, context->texture.sampler, &context->alloc.vulkan_callbacks);
}
 
b8 vulkan_texture_create(vulkan_context *context) {
    const int          image_mode = STBI_rgb_alpha;
    const VkDeviceSize pixel_size = 4;  // 4 bytes because we enforce alpha above
 
    int          width, height, channels;
    // stbi_uc     *pixels = stbi_load("assets/textures/dude.jpg", &width, &height, &channels, image_mode);
    stbi_uc     *pixels = stbi_load("assets/textures/viking_room.png", &width, &height, &channels, image_mode);
    // stbi_uc     *pixels = stbi_load("assets/textures/sphere.png", &width, &height, &channels, image_mode);
    if (!pixels) {
        KB_ERROR("failed to load texture data");
        return false;
    }
 
    VkDeviceSize image_size = (u64) (width * height) * pixel_size;
    vulkan_buffer staging_buffer;
    if (!vulkan_buffer_create(context,
                              image_size,
                              VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
                              VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
                              &staging_buffer)) {
        KB_ERROR("could not create staging buffer for texture");
        return false;
    }
 
    VK_CALL_B8(vkMapMemory(context->device.logical, staging_buffer.memory, 0, image_size, 0, &staging_buffer.mapped));
    memory_copy(staging_buffer.mapped, pixels, (usize) image_size);
 
    vkUnmapMemory(context->device.logical, staging_buffer.memory);
    stbi_image_free(pixels);
 
    if (!vulkan_image_create(
            context,
            (u32) width,
            (u32) height,
            VK_FORMAT_R8G8B8A8_SRGB,
            VK_IMAGE_TILING_OPTIMAL,  // cannot be changed, to directly access texels in memory use _LINEAR
            VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
            &context->texture.image)) {
        KB_ERROR("failed to create vulkan_image");
        return false;
    }
    if (!vulkan_image_transition_layout(context,
                                        &context->texture.image,
                                        VK_FORMAT_R8G8B8A8_SRGB,
                                        VK_IMAGE_LAYOUT_UNDEFINED,
                                        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL)) {
        KB_ERROR("failed to transition vulkan_image layout for copying");
        return false;
    }
    if (!vulkan_image_copy_from_buffer(context, &staging_buffer, &context->texture.image, (u32) width, (u32) height)) {
        KB_ERROR("failed to copy image data from buffer to vulkan_image");
        return false;
    }
    if (!vulkan_image_transition_layout(context,
                                        &context->texture.image,
                                        VK_FORMAT_R8G8B8A8_SRGB,
                                        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                                        VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)) {
        KB_ERROR("failed to transition vulkan_image layout for rendering");
        return false;
    }
    vulkan_buffer_destroy(context, &staging_buffer);
 
    if (!vulkan_image_view_create(context,
                                  context->texture.image.image,
                                  VK_FORMAT_R8G8B8A8_SRGB,
                                  VK_IMAGE_ASPECT_COLOR_BIT,
                                  &context->texture.view)) {
        KB_ERROR("failed to create image view for texture");
        return false;
    }
 
    return vulkan_texture_sampler_create(context);
}
 
void vulkan_texture_destroy(vulkan_context *context) {
    vulkan_texture_sampler_destroy(context);
    vulkan_image_view_destroy(context, &context->texture.view);
    vulkan_image_destroy(context, &context->texture.image);
}