Texture.h

Go to the documentation of this file.

#pragma once
#include <cstring>
#include <Engine/Mesh/GltfLoader.h>
#include <Engine/Texture/Ktx2Loader.h>
#include <Engine/Texture/TextureType.h>
#include <filesystem>
#include <optional>
#include <tiny_gltf.h>
#include <vk_mem_alloc.h>
#include <vulkan/vulkan_core.h>
 
namespace Engine::Rendering
{
    class Renderer;
}  // namespace Engine::Rendering
 
namespace Engine::Core
{
    class ApplicationContext;
    class AssetManager;
}  // namespace Engine::Core
 
namespace Engine::Assets
{
    class RuntimeTexture
    {
    public:
        friend class Core::AssetManager;

        RuntimeTexture() = default;

        void setupImageFormat( const tinygltf::Image & imageData );

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

        RuntimeTexture( Textures::Ktx2TextureData ktx2Data, TextureType type, Core::ApplicationContext * context );

        RuntimeTexture( const tinygltf::Image & imageData, Core::ApplicationContext * context );

        ~RuntimeTexture() = default;

        RuntimeTexture( const RuntimeTexture & )             = delete;

        RuntimeTexture & operator=( const RuntimeTexture & ) = delete;

        RuntimeTexture( RuntimeTexture && other ) noexcept;

        RuntimeTexture & operator=( RuntimeTexture && 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, Rendering::Renderer * renderer ) const;

        [[nodiscard]] VkFormat getTextureFormat() const;

        [[nodiscard]] TextureType getTextureType() const
        {
            return textureType_;
        }

        [[nodiscard]] uint32_t getMipLevels() const
        {
            return mipLevels_;
        }

        [[nodiscard]] uint32_t getSourceMipLevels() const
        {
            return sourceMipLevels_;
        }

        [[nodiscard]] uint32_t getSourceBaseMip() const
        {
            return sourceBaseMip_;
        }

        [[nodiscard]] uint32_t getSourceWidth() const
        {
            return sourceWidth_;
        }

        [[nodiscard]] uint32_t getSourceHeight() const
        {
            return sourceHeight_;
        }

        [[nodiscard]] bool hasPrecomputedMipmaps() const
        {
            return hasPrecomputedMipmaps_;
        }

        static uint32_t calculateMipLevels( uint32_t width, uint32_t height );

        void generateMipmaps( VkCommandBuffer commandBuffer ) const;

        void createResources();

        void discardPreparedResources();
 
    private:
        void addPaddingToImage();
        void dilateLightmapImage();
 
        template <typename T>
        void addPaddingHelper();
 
        void setDebugName( const std::string & debugName ) const;
        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;
        uint32_t    mipLevels_             = 1; // how many mips does the VkImage of this texture have
        uint32_t    sourceMipLevels_       = 1; // how many mips did the original ktx texture have <= mipLevels_
        uint32_t    sourceBaseMip_         = 0; // what the base mip of the original image was
        uint32_t    sourceWidth_           = 1;
        uint32_t    sourceHeight_          = 1;
        bool        hasPrecomputedMipmaps_ = false;
 
        tinygltf::Image                          imageData;
        std::optional<Textures::Ktx2TextureData> ktx2Data_;
        Core::ApplicationContext *               context = nullptr;
    };
 
    template <typename T>
    void RuntimeTexture::addPaddingHelper()
    {
        constexpr size_t oldComponents = 3;
        constexpr size_t newComponents = 4;
        constexpr size_t oldPixelBytes = oldComponents * sizeof( T );
        constexpr size_t newPixelBytes = newComponents * sizeof( T );
 
        const size_t pixelCount = static_cast<size_t>( imageData.width ) * imageData.height;
 
        std::vector<unsigned char> paddedImage( pixelCount * newPixelBytes );
 
        T alphaVal;
        if constexpr ( std::is_floating_point_v<T> )
        {
            alphaVal = static_cast<T>( 1.0 );
        }
        else
        {
            alphaVal = std::numeric_limits<T>::max();
        }
 
        const unsigned char * src = imageData.image.data();
        unsigned char *       dst = paddedImage.data();
 
        for ( size_t i = 0; i < pixelCount; ++i )
        {
            memcpy( dst, src, oldPixelBytes );
            memcpy( dst + oldPixelBytes, &alphaVal, sizeof( T ) );
            src += oldPixelBytes;
            dst += newPixelBytes;
        }
 
        imageData.image     = std::move( paddedImage );
        imageData.component = 4;
    }
 
}  // namespace Engine::Assets