Texture.h

Go to the documentation of this file.

#pragma once
#include <filesystem>
#include <tiny_gltf.h>
#include <vulkan/vulkan_core.h>
#include <vk_mem_alloc.h>
#include <Engine/Mesh/GltfLoader.h>
#include <Engine/Texture/TextureType.h>
 
namespace EngineCore
{
class AssetManager;
class Engine;
struct TextureLoadData;
class ApplicationContext;
class Renderer;
} // namespace EngineCore
 
namespace EngineCore
{
class Texture
{
  public:
    friend AssetManager;
    // load image from path
    Texture() = default;
    void setupImageFormat(const tinygltf::Image& imageData);

    Texture(const tinygltf::Image& imageData, TextureType type, ApplicationContext* context);

    Texture(const tinygltf::Image& imageData, ApplicationContext* context);
    ~Texture();
 
    static std::string createTexturePath(const std::filesystem::path& assetPath,
                                         const GltfLoader::GltfMeshPrimitiveData& primitiveData);
 
    // Delete copy constructor and copy assignment operator
    Texture(const Texture&) = delete;
    Texture& operator=(const Texture&) = delete;
 
    // Move constructor
    Texture(Texture&& other) noexcept;
    Texture& operator=(Texture&& other) noexcept;
 
    [[nodiscard]] VkImage getVkImage() const;
    [[nodiscard]] VkDeviceMemory getVkImageMemory() const;
    [[nodiscard]] VkImageView getVkImageView() const;
    [[nodiscard]] VkSampler getVkImageSampler() const;
 
    [[nodiscard]] bool isDescriptorIndexInitialized() const;
    [[nodiscard]] uint32_t getDescriptorIndex() const;
 
    void createDataUploadCommand(VkCommandBuffer commandBuffer, Renderer* renderer) const;
 
    [[nodiscard]] VkFormat getTextureFormat() const;

    [[nodiscard]] TextureType getTextureType() const { return textureType_; }
 
  private:
    void addPaddingToImage();
 
    template <typename T> void addPaddingHelper();
 
    void setDebugName(const std::string& debugName);
    void createResources();
    void cleanup() const;
    void reset();
 
    VkImage vkTexture{};
    VmaAllocation textureAllocation_ = VK_NULL_HANDLE;  
    VkImageView vkTextureView{};
    VkSampler vkTextureSampler{};
 
    uint32_t descriptorIndex = std::numeric_limits<uint32_t>::max();
 
    VkFormat format = VK_FORMAT_R8G8B8A8_SRGB;
    TextureType textureType_ = TextureType::BaseColor;
 
    tinygltf::Image imageData;
    ApplicationContext* context = nullptr;
};
 
template<typename T>
void Texture::addPaddingHelper()
{
    size_t bytesPerComponent = sizeof(T);
    size_t oldPixelSizeBytes = 3 * bytesPerComponent; // 3 components * T_size bytes/component
    size_t newPixelSizeBytes = 4 * bytesPerComponent; // 4 components * T_size bytes/component
 
    std::vector<unsigned char> paddedImage;
    paddedImage.reserve(imageData.width * imageData.height * newPixelSizeBytes);
 
    // Determine opaque alpha value based on type
    T alphaVal;
    if constexpr (std::is_floating_point_v<T>) {
        alphaVal = 1.0f; // Standard opaque for float textures
    } else {
        alphaVal = std::numeric_limits<T>::max(); // Max value for integer types
    }
 
    // Get byte representation of alpha value
    unsigned char alphaBytes[sizeof(T)];
    memcpy(alphaBytes, &alphaVal, sizeof(T));
 
    // Iterate through original image data and create padded version
    // Assume tinygltf::Image::image.size() is correct for original 3-component data
    for (size_t i = 0; i < imageData.image.size(); i += oldPixelSizeBytes)
    {
        // Copy R, G, B bytes
        for (size_t j = 0; j < oldPixelSizeBytes; ++j)
        {
            paddedImage.push_back(imageData.image[i + j]);
        }
        // Append A bytes
        for (size_t j = 0; j < sizeof(T); ++j)
        {
            paddedImage.push_back(alphaBytes[j]);
        }
    }
 
    // Replace original image data with padded data
    imageData.image = std::move(paddedImage); // Use move for efficiency
    imageData.component = 4; // Update component count
    // imageData.bits remains the same (e.g., 8, 16, 32)
}
 
} // namespace EngineCore