texture.h

#ifndef OE_RENDER_TEXTURE_H
#define OE_RENDER_TEXTURE_H
 
#include <string>
#include <functional>
#include <glm/vec2.hpp>
#include <glm/vec4.hpp>
#include "../util/byte_array.h"
 
namespace oe::scene
{
    class Material;
}
 
namespace oe::render
{
    class Shader;
    class TextureManager;
    class Framebuffer;
 
    enum class ColorSpace
    {
        SRGB, 
        Linear, 
    };
 
    class Texture
    {
        public:
            explicit Texture(const uint32_t opengl_id);
 
            Texture(const Texture&) = delete;
            Texture& operator=(const Texture&) = delete;
 
            Texture(Texture&& other) noexcept:
                _internal_id(other.releaseOwnership()),
                _internal_format(other._internal_format),
                _format(other._format),
                _type(other._type)
            {}
 
            Texture(
                const int32_t width,
                const int32_t height,
                const uint8_t* data,
                const int32_t nb_channels = 0, // Used as hint to fill formats/type if no other argument provided after
                const int32_t internal_format = 0,
                const int32_t format = 0,
                const int32_t type = 0,
                const uint8_t max_mips = 1
            );
 
            Texture(
                const ByteSpan data,
                const ColorSpace color_space,
                const int32_t wanted_channels = 4,
                const uint8_t max_mips = 1
            );
 
            Texture(const std::string& filename, const ColorSpace color_space, const uint8_t max_mips = 1);
 
            Texture(
                const uint32_t width,
                const uint32_t height,
                const std::function<glm::vec4(const uint32_t i, const uint32_t j)> generator,
                const uint8_t max_mips = 1
            );
 
            Texture(
                const uint32_t width,
                const uint32_t height,
                const oe::scene::Material& generator,
                const int32_t nb_channels = 0,
                const int32_t internal_format = 0,
                const int32_t format = 0,
                const int32_t type = 0,
                const uint8_t max_mips = 1
            );
 
            // Commented: Not work and never used and
            /*static Texture* generateFromCompressed(
                const int32_t compression,
                const int32_t width,
                const int32_t height,
                const int32_t data_size,
                const uint8_t* data
            );*/
 
            virtual ~Texture();
 
            void use(const uint8_t layer);
 
            virtual void enableBilinearFiltering(bool enabled = true);
 
            virtual void generateMipMaps();
 
            void clampToEdge();
            void wrapRepeat();
 
            void fillTextureData(ByteSpan data, const uint32_t face, const uint32_t mip_level);
 
            ByteArray fetchTextureData(const uint32_t face, const uint32_t mip_level);
 
            glm::ivec2 getDimensions(const uint8_t mip_level = 0) const;
 
            uint32_t releaseOwnership();
 
        protected:
            Texture()
            {}
 
            void _generate_texture
            (
                const int32_t width,
                const int32_t height,
                const uint8_t* data,
                const int32_t nb_channels = 0,
                const int32_t internal_format = 0,
                const int32_t format = 0,
                const int32_t type = 0,
                const uint8_t max_mips = 1
            );
 
            uint32_t _internal_id = 0;
 
            // Might be removed (_format / _type depends on image to fill and not need to be stored)
            int32_t _internal_format = 0;
            int32_t _format = 0;
            int32_t _type = 0;
 
            friend class Framebuffer;
            friend class DynamicCubemap;
    };
}
 
#endif