Texture.cpp

Go to the documentation of this file.

#include "Engine/Texture/Texture.h"
#include "Engine/Core/Engine.h"
#include "Engine/Core/VulkanHelper.h"
#include "Engine/Logging/TracyMacros.hpp"
#include "Engine/Renderer/RenderProcess.h"
#include "Engine/Renderer/Renderer.h"
#include "Engine/Mesh/GltfLoader.h"
#include "vulkan/vulkan_core.h"
 
namespace EngineCore
{
 
void Texture::setupImageFormat(const tinygltf::Image& imageData)
{
    if (imageData.bits == 8)
    {
        if (imageData.component == 1) format = VK_FORMAT_R8_SRGB; // Grayscale
        else if (imageData.component == 2) format = VK_FORMAT_R8G8_SRGB; // Grayscale + Alpha, or other 2-channel
        else if (imageData.component == 3) format = VK_FORMAT_R8G8B8_SRGB; // RGB (Less common, better to pad)
        else if (imageData.component == 4) format = VK_FORMAT_R8G8B8A8_SRGB; // RGBA
    }
    else if (imageData.bits == 16)
    {
        if (imageData.component == 1) format = VK_FORMAT_R16_SFLOAT;
        else if (imageData.component == 2) format = VK_FORMAT_R16G16_SFLOAT;
        else if (imageData.component == 3) format = VK_FORMAT_R16G16B16_SFLOAT;
        else if (imageData.component == 4) format = VK_FORMAT_R16G16B16A16_SFLOAT;
    }
    else if (imageData.bits == 32)
    {
        if (imageData.component == 1) format = VK_FORMAT_R32_SFLOAT;
        else if (imageData.component == 2) format = VK_FORMAT_R32G32_SFLOAT;
        else if (imageData.component == 3) format = VK_FORMAT_R32G32B32_SFLOAT;
        else if (imageData.component == 4) format = VK_FORMAT_R32G32B32A32_SFLOAT;
    }
 
    if (format == VK_FORMAT_UNDEFINED)
    {
        PLOGE << "Unsupported image format: bits=" << imageData.bits << ", components=" << imageData.component << ". Falling back to VK_FORMAT_R8G8B8A8_SRGB.";
        format = VK_FORMAT_R8G8B8A8_SRGB; // As a last resort fallback
    }
    PLOGI << "Image format: " << format;
}
Texture::Texture(const tinygltf::Image& imageData, TextureType type, ApplicationContext* context)
    : imageData(imageData), textureType_(type), context(context)
{
    // imagedata needs to be padded
    addPaddingToImage();
 
    // Use type-aware format selection instead of setupImageFormat()
    format = getVkFormat(type, this->imageData.bits, this->imageData.component);
    PLOGI << "Texture format (type-aware): " << format << " for type " << static_cast<int>(type)
          << " bits=" << this->imageData.bits << " components=" << this->imageData.component;
}
 
Texture::Texture(const tinygltf::Image& imageData, ApplicationContext* context)
    : imageData(imageData), textureType_(TextureType::BaseColor), context(context)
{
    // imagedata needs to be padded
    addPaddingToImage();
 
    // Legacy constructor - uses old format selection (defaults to SRGB for 8-bit)
    setupImageFormat(this->imageData);
}
 
#include <limits>
 
// Move constructor
EngineCore::Texture::Texture(Texture&& other) noexcept
    : // Copy the reference; note that you cannot "move" a reference
      context(other.context),
      vkTexture(other.vkTexture),
      textureAllocation_(other.textureAllocation_),
      vkTextureView(other.vkTextureView),
      vkTextureSampler(other.vkTextureSampler),
      descriptorIndex(other.descriptorIndex),
      format(other.format),
      textureType_(other.textureType_)
{
    imageData = std::move(other.imageData);
    // Invalidate the moved-from object's Vulkan handles so its destructor doesn't release them
    other.vkTexture = VK_NULL_HANDLE;
    other.textureAllocation_ = VK_NULL_HANDLE;
    other.vkTextureView = VK_NULL_HANDLE;
    other.vkTextureSampler = VK_NULL_HANDLE;
    other.imageData = tinygltf::Image();
    other.descriptorIndex = std::numeric_limits<uint32_t>::max();
    other.textureType_ = TextureType::BaseColor;
 
    addPaddingToImage();
    // Format was already set by the moved-from object, no need to recalculate
}
 
// Move assignment operator
Texture& Texture::operator=(Texture&& other) noexcept
{
    if (this != &other)
    {
        // Clean up current resources before taking ownership of new ones.
        cleanup();
 
        // Move Vulkan objects
        vkTexture = other.vkTexture;
        textureAllocation_ = other.textureAllocation_;
        vkTextureView = other.vkTextureView;
        vkTextureSampler = other.vkTextureSampler;
        descriptorIndex = other.descriptorIndex;
        format = other.format;
        textureType_ = other.textureType_;
        imageData = other.imageData;
 
        // context is a raw pointer so we can just copy it.
        context = other.context;
 
        // Invalidate the moved-from object
        other.vkTexture = VK_NULL_HANDLE;
        other.textureAllocation_ = VK_NULL_HANDLE;
        other.vkTextureView = VK_NULL_HANDLE;
        other.vkTextureSampler = VK_NULL_HANDLE;
        other.imageData = tinygltf::Image();
        other.descriptorIndex = std::numeric_limits<uint32_t>::max();
        other.textureType_ = TextureType::BaseColor;
    }
    return *this;
}
 
void Texture::createResources()
{
    if (imageData.uri.empty()) throw std::runtime_error("Cannot create resources for a texture with no contents");
 
    #ifdef ENABLE_TRACY
    std::stringstream tracyZoneName;
    tracyZoneName << __FUNCTION__ << ": " << imageData.uri;
    TRACY_ZONE_SCOPED_FUNCTION;
    ZoneName(tracyZoneName.str().c_str(), tracyZoneName.str().size());
#endif
 
    // Create image using VMA
    VkImageCreateInfo imageInfo{VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};
    imageInfo.imageType = VK_IMAGE_TYPE_2D;
    imageInfo.extent.width = imageData.width;
    imageInfo.extent.height = imageData.height;
    imageInfo.extent.depth = 1;
    imageInfo.mipLevels = 1;
    imageInfo.arrayLayers = 1;
    imageInfo.format = format;
    imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
    imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
    imageInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
    imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
    imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
    imageInfo.flags = 0;
 
    VmaAllocationCreateInfo allocCI{};
    allocCI.usage = VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE;
 
    VmaAllocator allocator = context->getVmaAllocator();
    if (vmaCreateImage(allocator, &imageInfo, &allocCI, &vkTexture, &textureAllocation_, nullptr) != VK_SUCCESS)
    {
        throw std::runtime_error("Failed to create texture image with VMA: " + imageData.uri);
    }
 
    // Create an image view for the texture image so it can be used in shaders.
    VkImageViewCreateInfo viewInfo{};
    viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
    viewInfo.image = vkTexture;
    viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
    viewInfo.format = format;
    viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    viewInfo.subresourceRange.baseMipLevel = 0;
    viewInfo.subresourceRange.levelCount = 1;
    viewInfo.subresourceRange.baseArrayLayer = 0;
    viewInfo.subresourceRange.layerCount = 1;
 
    if(vkCreateImageView(context->getVkDevice(), &viewInfo, nullptr, &vkTextureView) != VK_SUCCESS)
    {
        throw std::runtime_error("failed to create texture image view!");
    }
 
    // Create a sampler for the texture image.
    VkSamplerCreateInfo samplerCreateInfo{};
    samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
    samplerCreateInfo.magFilter = VK_FILTER_LINEAR;
    samplerCreateInfo.minFilter = VK_FILTER_LINEAR;
    samplerCreateInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
    samplerCreateInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
    samplerCreateInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
    samplerCreateInfo.anisotropyEnable = VK_TRUE;
    samplerCreateInfo.maxAnisotropy = 16.0f;
    samplerCreateInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
    samplerCreateInfo.unnormalizedCoordinates = VK_FALSE;
    samplerCreateInfo.compareEnable = VK_FALSE;
    samplerCreateInfo.compareOp = VK_COMPARE_OP_ALWAYS;
    samplerCreateInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
    samplerCreateInfo.mipLodBias = 0.0f;
    samplerCreateInfo.minLod = 0.0f;
    samplerCreateInfo.maxLod = 0.0f; // For now, no mipmapping
 
    if(vkCreateSampler(context->getVkDevice(), &samplerCreateInfo, nullptr, &vkTextureSampler) != VK_SUCCESS)
    {
        throw std::runtime_error("failed to create texture sampler!");
    } // Create an image view for the texture image so it can be used in shaders.
 
    setDebugName(imageData.uri);
}
 
void Texture::setDebugName(const std::string &debugName) {
    if(vkTexture) VulkanHelper::setObjectName(context->getVkDevice(), vkTexture, debugName.c_str());
    if(vkTextureView) VulkanHelper::setObjectName(context->getVkDevice(), vkTextureView, (debugName + " image view").c_str());
    if(vkTextureSampler) VulkanHelper::setObjectName(context->getVkDevice(), vkTextureSampler, (debugName + " image sampler").c_str());
    // Set VMA allocation name for debugging
    if(textureAllocation_ && context)
    {
        vmaSetAllocationName(context->getVmaAllocator(), textureAllocation_, (debugName + " allocation").c_str());
    }
}
 
Texture::~Texture() {}
std::string Texture::createTexturePath(const std::filesystem::path& assetPath,
                                       const GltfLoader::GltfMeshPrimitiveData& primitiveData)
{
    std::stringstream texturePathString {};
    texturePathString << assetPath.parent_path() << "/" << primitiveData.getMaterialData().getTextureData().getImage().uri;
    return texturePathString.str();
}
 
void Texture::cleanup() const {
    if(vkTextureSampler)
        vkDestroySampler(context->getVkDevice(), vkTextureSampler, nullptr);
    if(vkTextureView)
        vkDestroyImageView(context->getVkDevice(), vkTextureView, nullptr);
    // Use VMA to destroy image and free memory together
    if(vkTexture && textureAllocation_ && context)
    {
        vmaDestroyImage(context->getVmaAllocator(), vkTexture, textureAllocation_);
    }
}
 
void Texture::reset()
{
    cleanup();
    vkTexture = VK_NULL_HANDLE;
    textureAllocation_ = VK_NULL_HANDLE;
    vkTextureView = VK_NULL_HANDLE;
    vkTextureSampler = VK_NULL_HANDLE;
    descriptorIndex = std::numeric_limits<uint32_t>::max();
}
 
VkImage Texture::getVkImage() const
{
    return vkTexture;
}
 
VkDeviceMemory Texture::getVkImageMemory() const
{
    if (textureAllocation_ && context)
    {
        VmaAllocationInfo info{};
        vmaGetAllocationInfo(context->getVmaAllocator(), textureAllocation_, &info);
        return info.deviceMemory;
    }
    return VK_NULL_HANDLE;
}
 
VkImageView Texture::getVkImageView() const
{
    return vkTextureView;
}
 
VkSampler Texture::getVkImageSampler() const
{
    return vkTextureSampler;
}
bool Texture::isDescriptorIndexInitialized() const
{
    return descriptorIndex != std::numeric_limits<uint32_t>::max();
}
uint32_t Texture::getDescriptorIndex() const
{
    return descriptorIndex;
}
void Texture::createDataUploadCommand(VkCommandBuffer commandBuffer, Renderer* renderer) const
{
    PLOGI << "Updating texture with " << imageData.width << "x" << imageData.height << " and URI: " << imageData.uri;
    const VkDeviceSize imageDataSize = imageData.width * imageData.height * (imageData.bits/8u) * imageData.component;
    assert(imageDataSize == imageData.image.size() && "Calculated image data size mismatch with tinygltf::Image::image vector size!");
 
    if(imageDataSize == 0)
    {
        PLOGE << "Image data size of " << imageData.uri << " is zero!";
        return;
    }
 
    // Create the staging buffer with the CORRECT size
    VulkanBuffer stagingBuffer;
    new (&stagingBuffer) VulkanBuffer(context);
 
    stagingBuffer.create(imageDataSize, // <-- Use the calculated size of the pixel data
                         VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
                         VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
    std::string bufferName = "Image upload staging buffer for " + imageData.uri;
    stagingBuffer.setDebugName(bufferName);
 
    // Map the memory (now the requested size matches the allocated size)
    void* mappedData = stagingBuffer.map();
    if(stagingBuffer.isMapped())
    {
        memcpy(mappedData, imageData.image.data(), static_cast<size_t>(imageData.image.size()));
        stagingBuffer.unmap();
 
        // --- Image Layout Transition and Copy ---
        VkImageMemoryBarrier2 imageMemoryBarrier1{};
        imageMemoryBarrier1.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
        imageMemoryBarrier1.srcStageMask = VK_PIPELINE_STAGE_2_NONE;
        imageMemoryBarrier1.srcAccessMask = VK_ACCESS_2_NONE;
        imageMemoryBarrier1.dstStageMask = VK_PIPELINE_STAGE_2_COPY_BIT;
        imageMemoryBarrier1.dstAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT;
        imageMemoryBarrier1.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
        imageMemoryBarrier1.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
        imageMemoryBarrier1.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        imageMemoryBarrier1.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        imageMemoryBarrier1.image = vkTexture;
        imageMemoryBarrier1.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
        imageMemoryBarrier1.subresourceRange.baseMipLevel = 0;
        imageMemoryBarrier1.subresourceRange.levelCount = 1;
        imageMemoryBarrier1.subresourceRange.baseArrayLayer = 0;
        imageMemoryBarrier1.subresourceRange.layerCount = 1;
 
        VkDependencyInfo dependencyInfo1{VK_STRUCTURE_TYPE_DEPENDENCY_INFO};
        dependencyInfo1.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
        dependencyInfo1.pImageMemoryBarriers = &imageMemoryBarrier1;
        dependencyInfo1.imageMemoryBarrierCount = 1;
        vkCmdPipelineBarrier2(commandBuffer, &dependencyInfo1);
 
        VkBufferImageCopy region{};
        region.bufferOffset = 0;
        region.bufferRowLength = 0;   // Tightly packed
        region.bufferImageHeight = 0; // Tightly packed
        region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
        region.imageSubresource.mipLevel = 0;
        region.imageSubresource.baseArrayLayer = 0;
        region.imageSubresource.layerCount = 1;
        region.imageOffset = {0, 0, 0};
        region.imageExtent = {static_cast<uint32_t>(imageData.width), static_cast<uint32_t>(imageData.height), 1};
 
        vkCmdCopyBufferToImage(commandBuffer, stagingBuffer.getBuffer(), vkTexture,
                               VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
 
        // For transfer queue, we only transition to a transfer-complete state
        // The final transition to shader-readable will happen on the graphics queue
        VkImageMemoryBarrier2 imageMemoryBarrier2{};
        imageMemoryBarrier2.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
        imageMemoryBarrier2.srcStageMask = VK_PIPELINE_STAGE_2_COPY_BIT;
        imageMemoryBarrier2.srcAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT;
        imageMemoryBarrier2.dstStageMask = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT;  // Transfer-compatible stage
        imageMemoryBarrier2.dstAccessMask = VK_ACCESS_2_NONE;  // No access needed at end of transfer
        imageMemoryBarrier2.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
        imageMemoryBarrier2.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;  // Keep in transfer layout for graphics queue
        imageMemoryBarrier2.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        imageMemoryBarrier2.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        imageMemoryBarrier2.image = vkTexture;
        imageMemoryBarrier2.subresourceRange = imageMemoryBarrier1.subresourceRange;
 
        VkDependencyInfo dependencyInfo2{VK_STRUCTURE_TYPE_DEPENDENCY_INFO};
        dependencyInfo2.imageMemoryBarrierCount = 1;
        dependencyInfo2.pImageMemoryBarriers = &imageMemoryBarrier2;
        vkCmdPipelineBarrier2(commandBuffer, &dependencyInfo2);
 
        renderer->getCurrentRenderProcess()->addStagingBufferForCleanup(std::move(stagingBuffer));
    }
    else
    {
        PLOGE << "Failed to map staging buffer memory for texture " << imageData.uri;
        stagingBuffer.destroy();
    }
 
    // If map failed, stagingBuffer might still exist but shouldn't be used.
    // Proper cleanup still needs to happen eventually, potentially immediately if map failed.
    // How you handle this depends on your VulkanBuffer destructor/cleanup logic.
    // If map failed, maybe: stagingBuffer.destroy();
}
 
VkFormat Texture::getTextureFormat() const
{
    return format;
}
 
void Texture::addPaddingToImage()
{
    // Only pad if it currently has 3 components.
    // If it already has 4 components, or 1/2, no padding is needed to make it RGBA.
    if (imageData.component == 3)
    {
        if (imageData.bits == 8)
        {
            addPaddingHelper<uint8_t>();
        }
        else if (imageData.bits == 16)
        {
            addPaddingHelper<uint16_t>();
        }
        else if (imageData.bits == 32)
        {
            addPaddingHelper<float>(); // 32-bit components are typically float for images
        }
        else
        {
            PLOGE << "Unsupported bit depth for padding (3-component image): " << imageData.bits << ". Skipping padding for " << imageData.uri;
        }
    }
}
 
} // namespace EngineCore