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>
 
namespace globjects {
class Texture;
}
 
namespace Ra {
namespace Engine {
namespace Data {
struct TextureParameters {
    std::string name {};
    GLenum target { GL_TEXTURE_2D };
    size_t width { 1 };
    size_t height { 1 };
    size_t depth { 1 };
    GLenum format { GL_RGB };
    GLenum internalFormat { GL_RGB };
    GLenum type { GL_UNSIGNED_BYTE };
    GLenum wrapS { GL_CLAMP_TO_EDGE };
    GLenum wrapT { GL_CLAMP_TO_EDGE };
    GLenum wrapP { GL_CLAMP_TO_EDGE };
    GLenum minFilter { GL_LINEAR };
    GLenum magFilter { GL_LINEAR };
    void* texels { nullptr };
};
 
class RA_ENGINE_API Texture final
{
  public:
    Texture( const Texture& ) = delete;
 
    void operator=( const Texture& ) = delete;
 
    explicit Texture( const TextureParameters& texParameters );
 
    ~Texture();
 
    void initializeGL( bool linearize = false );
 
    void bind( int unit = -1 );
 
    void bindImageTexture( int unit, GLint level, GLboolean layered, GLint layer, GLenum access );
 
    inline std::string getName() const { return m_textureParameters.name; }
 
    void updateData( void* newData );
 
    void updateParameters();
 
    void linearize();
 
    GLenum format() const { return m_textureParameters.format; }
    size_t width() const { return m_textureParameters.width; }
    size_t height() const { return m_textureParameters.height; }
    size_t depth() const { return m_textureParameters.depth; }
 
    void* texels() { return m_textureParameters.texels; }
    globjects::Texture* texture() const { return m_texture.get(); }
 
    void resize( size_t w = 1, size_t h = 1, size_t d = 1, void* pix = nullptr );
 
    const TextureParameters& getParameters() const { return m_textureParameters; }
 
    TextureParameters& getParameters() { return m_textureParameters; }
 
    void setParameters( const TextureParameters& textureParameters ) {
        std::lock_guard<std::mutex> lock( m_updateMutex );
        m_textureParameters = textureParameters;
    }
 
  private:
    void updateGL();
 
    void sRGBToLinearRGB( uint8_t* texels, uint numComponent, bool hasAlphaChannel );
 
    void linearizeCubeMap( uint numComponent, bool hasAlphaChannel );
 
    TextureParameters m_textureParameters;
 
    std::unique_ptr<globjects::Texture> m_texture;
    bool m_isMipMapped { false };
    bool m_isLinear { false };
    Core::TaskQueue::TaskId m_updateDataTaskId;
    std::mutex m_updateMutex;
};
} // namespace Data
} // namespace Engine
} // namespace Ra