GPUTexture.hpp

/*
** ETIB PROJECT, 2026
** xider
** File description:
** GPUTexture
*/
 
#pragma once
 
#include <utility/graphic/texture.hpp>
 
#include "utility/logging/logger.hpp"
#include "utility/logging/default_logger.hpp"
 
#include "EvanPlatform.hpp"
 
#include "DeviceContext.hpp"
 
#include <cmath>
#include <math.h>
#include <algorithm>
 
namespace evan
{
    class GPUTexture:
        protected utility::logging::Loggable<GPUTexture,
                                             utility::logging::DefaultLogger>
    {
        public:
        enum class TextureType {
            Albedo,       
            Normal,       
            Roughness,    
            FontAtlas     
        };
 
        struct SamplerSettings {
            SamplerSettings()
                : minLod(0.0f)
                , maxLod(-1.0f)
                , anisotropyEnable(VK_TRUE)
                , maxAnisotropy(0.0f)
                , addressModeU(VK_SAMPLER_ADDRESS_MODE_REPEAT)
                , addressModeV(VK_SAMPLER_ADDRESS_MODE_REPEAT)
                , addressModeW(VK_SAMPLER_ADDRESS_MODE_REPEAT)
            {
            }
 
            float minLod;
 
            float maxLod;
 
            VkBool32 anisotropyEnable;
 
            float maxAnisotropy;
 
            VkSamplerAddressMode addressModeU;
 
            VkSamplerAddressMode addressModeV;
 
            VkSamplerAddressMode addressModeW;
        };
 
        struct GenerateMipmapsProperties {
            VkCommandPool
                _commandPool;    
 
            VkQueue _graphicsQueue;    
 
            VkImage _image;    
 
            VkFormat _imageFormat;    
 
            uint32_t _texWidth;    
 
            uint32_t
                _texHeight;    
 
            uint32_t _mipLevels;    
        };
 
        GPUTexture(std::shared_ptr<DeviceContext> deviceContext,
                   const utility::graphic::Texture &texture,
                   TextureType type                = TextureType::Albedo,
                   const SamplerSettings &settings = SamplerSettings {});
 
        ~GPUTexture();
 
        void destroy(VkDevice device);
 
        static uint32_t computeMipLevels(uint32_t width, uint32_t height);
 
        static float computeMaxLod(uint32_t mipLevels);
 
        [[nodiscard]] uint32_t getMipLevels() const
        {
            return _mipLevel;
        }
 
        VkImageView view = VK_NULL_HANDLE;
 
        VkSampler sampler = VK_NULL_HANDLE;
 
        TextureType type;
 
        protected:
        void cleanup();
 
        void createImage(const ADeviceBackend &deviceBackend,
                         const utility::graphic::Texture &texture,
                         VkCommandPool commandPool, VkQueue graphicsQueue);
 
        void createImageView(const ADeviceBackend &deviceBackend);
 
        void
            createSampler(const ADeviceBackend &deviceBackend,
                          VkSamplerCreateInfo samplerInfo,
                          const SamplerSettings &settings = SamplerSettings {});
 
        VkImage _image = VK_NULL_HANDLE;
 
        VkDeviceMemory _memory = VK_NULL_HANDLE;
 
        uint32_t _mipLevel = 1;
 
        std::shared_ptr<DeviceContext> _deviceContext;
 
        private:
        void generateMipmaps(const GenerateMipmapsProperties &properties,
                             const ADeviceBackend &deviceBackend);
 
        void applySamplerSettings(VkSamplerCreateInfo &samplerInfo,
                                  const SamplerSettings &settings);
 
        VkSamplerCreateInfo
            getDefaultSamplerInfo(const VkPhysicalDeviceProperties &properties);
    };
}    // namespace evan