texture.h

#ifndef OE_RENDER_TEXTURE_H
#define OE_RENDER_TEXTURE_H
 
#include <string>
#include <vector>
#include <functional>
#include <glm/vec4.hpp>
#include "../util/byte_array.h"
#include "../util/non_copyable.h"
#include "../common.h"
 
namespace oe::scene
{
    class Material;
}
 
namespace oe::render
{
    class Shader;
    class TextureManager;
    class Framebuffer;
 
    class Texture : public oe::util::NonCopyable
    {
        public:
            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 std::string& filename, const bool& is_srgb = false, 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
             );
 
            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 void use(const uint8_t& layer);
 
            virtual void enableBilinearFiltering(bool enabled = true);
 
            virtual void generateMipMaps();
 
            void clampToEdge();
            void wrapRepeat();
 
            void fillTextureData(const ByteArray& data, const unsigned int& face, const unsigned int& mip_level);
 
            ByteArray fetchTextureData(const unsigned int& face, const unsigned int& mip_level);
 
            unsigned int getWidth() const { return _width; }
            unsigned int getHeight() const { return _height; }
 
            // Todo put private / protected (Needed by dynamic cubemap)
            unsigned int getHandle() const { return _internal_id; }
 
            int getImageInternalFormat() const { return _internal_format; }
 
            int getImageFormat() const { return _format; }
            int getImageType() const { return _type; }
 
            virtual ~Texture();
        protected:
            Texture();
 
            Texture(const Texture&) = delete;
            Texture& operator=(const Texture&) = delete;
 
            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
            );
 
            //virtual void init();
            //virtual void clean();
 
            uint32_t _internal_id = 0;
 
            int32_t _width;
            int32_t _height;
 
            int _internal_format = 0;
 
            // Might be removed (_format / _type depends on image to fill and not need to be stored)
            int _format = 0;
            int _type = 0;
 
            friend class Framebuffer;
    };
}
 
#endif