Texture.hpp

#pragma once
 
#include <Core/Tasks/TaskQueue.hpp>
#include <Core/Utils/Color.hpp>
#include <Engine/OpenGL.hpp>
#include <Engine/RaEngine.hpp>
 
#include <memory>
#include <mutex>
#include <string>
#include <variant>
 
namespace globjects {
class Texture;
}
 
namespace Ra {
namespace Engine {
namespace Data {
 
struct SamplerParameters {
    GLenum wrapS { GL_CLAMP_TO_EDGE };
    GLenum wrapT { GL_CLAMP_TO_EDGE };
    GLenum wrapR { GL_CLAMP_TO_EDGE };
    GLenum minFilter { GL_LINEAR };
    GLenum magFilter { GL_LINEAR };
};
 
struct ImageParameters {
    using ImageType   = std::shared_ptr<void>;
    using CubeMapType = std::array<std::shared_ptr<void>, 6>;
 
    template <typename TexelType>
    bool isTexelOfType() const {
        return std::holds_alternative<TexelType>( texels );
    }
 
    ImageType getImage() const {
        CORE_ASSERT( isTexelOfType<ImageType>(), "texture variant is not ImageType" );
        return std::get<ImageType>( texels );
    }
    void setImage( ImageType image ) { texels = image; }
 
    const void* getTexels() const { return getImage().get(); }
 
    const CubeMapType getCubeMap() const {
        CORE_ASSERT( isTexelOfType<CubeMapType>(), "texture variant is not CubeMapType" );
        return std::get<CubeMapType>( texels );
    }
    void setCubeMap( CubeMapType cubeMap ) { texels = cubeMap; }
 
    GLenum target { GL_TEXTURE_2D }; //< OpenGL target
    size_t width { 1 };              //< width of the texture (s dimension)
    size_t height { 1 };             //< height of the texture (t dimension)
    size_t depth { 1 };              //< depth of the texture (r dimension)
    GLenum format { GL_RGB };        //< Format of the external data
    GLenum internalFormat { GL_RGB };
    GLenum type { GL_UNSIGNED_BYTE }; //< Type of the components in external data
    bool isLinear { false };
    std::variant<ImageType, CubeMapType> texels { nullptr }; //< texels OR cubeMap, shared ownership
};
 
struct TextureParameters {
    std::string name {};
    SamplerParameters sampler {};
    ImageParameters image {};
};
 
class RA_ENGINE_API Texture final
{
  public:
    Texture( const Texture& ) = delete;
 
    void operator=( const Texture& ) = delete;
 
    explicit Texture( const TextureParameters& texParameters );
 
    ~Texture();
 
    void initialize();
 
    void initializeNow();
 
    void destroy();
 
    void destroyNow();
 
    inline std::string getName() const { return m_textureParameters.name; }
    inline void setName( const std::string& name ) { m_textureParameters.name = name; }
 
    GLenum getFormat() const { return m_textureParameters.image.format; }
 
    size_t getWidth() const { return m_textureParameters.image.width; }
 
    size_t getHeight() const { return m_textureParameters.image.height; }
 
    size_t getDepth() const { return m_textureParameters.image.depth; }
 
    const void* getTexels() { return m_textureParameters.image.getTexels(); }
 
    globjects::Texture* getGpuTexture() const { return m_texture.get(); }
 
    const TextureParameters& getParameters() const { return m_textureParameters; }
    TextureParameters& getParameters() { return m_textureParameters; }
 
    void updateData( std::shared_ptr<void> newData );
 
    void resize( size_t w = 1, size_t h = 1, size_t d = 1, std::shared_ptr<void> pix = nullptr );
 
    void setParameters( const TextureParameters& textureParameters );
    void setImageParameters( const ImageParameters& imageParameters );
    void setSamplerParameters( const SamplerParameters& samplerParameters );
 
    void bind( int unit = -1 );
 
    void bindImageTexture( int unit, GLint level, GLboolean layered, GLint layer, GLenum access );
 
    static void linearize( ImageParameters& image );
 
    void registerUpdateImageDataTask();
 
    void registerUpdateSamplerParametersTask();
 
    void sendImageDataToGpu();
    void readFromGpu( int level = 0 );
 
    void sendSamplerParametersToGpu();
 
  private:
    bool isSupportedTarget();
 
    void computeIsMipMappedFlag();
 
    bool createTexture();
 
    static void srgbToLinearRgb( uint8_t* texels,
                                 uint width,
                                 uint height,
                                 uint depth,
                                 uint numComponent,
                                 bool hasAlphaChannel );
 
    static void linearizeCubeMap( ImageParameters& image, uint numComponent, bool hasAlphaChannel );
 
    TextureParameters m_textureParameters;         
    std::unique_ptr<globjects::Texture> m_texture; 
    bool m_isMipMapped { false };                  
    Core::TaskQueue::TaskId m_updateImageTaskId;
 
    Core::TaskQueue::TaskId m_updateSamplerTaskId;
 
    std::mutex m_updateMutex;
};
} // namespace Data
} // namespace Engine
} // namespace Ra