spk_texture_object.hpp

#pragma once
 
#include "structure/design_pattern/spk_activable_object.hpp"
#include "structure/design_pattern/spk_cached_data.hpp"
#include "structure/design_pattern/spk_synchronizable_object.hpp"
#include "structure/math/spk_vector2.hpp"
#include "structure/opengl/spk_opengl_includes.hpp"
#include "type/spk_activation_status.hpp"
#include "type/spk_orientation.hpp"
#include "utils/spk_opengl_utils.hpp"
#include <cstdint>
#include <cstring>
#include <stdexcept>
#include <vector>
 
namespace spk
{
    namespace OpenGL
    {
        class TextureObject : public spk::ActivableObject, public spk::SynchronizableObject
        {
        public:
            enum class Format : GLenum
            {
                RGB = GL_RGB,
                RGBA = GL_RGBA,
                BGR = GL_BGR,
                BGRA = GL_BGRA,
                GreyLevel = GL_RED,
                DualChannel = GL_RG,
                DepthComponent = GL_DEPTH_COMPONENT,
                DepthStencil = GL_DEPTH_STENCIL,
                Error = GL_NONE
            };

            enum class Filtering : GLenum
            {
                Nearest = GL_NEAREST,
                Linear = GL_LINEAR
            };

            struct Filter
            {
                Filtering major;
                Filtering minor;
            };

            enum class Wrap : GLenum
            {
                Repeat = GL_REPEAT,
                ClampToEdge = GL_CLAMP_TO_EDGE,
                ClampToBorder = GL_CLAMP_TO_BORDER
            };

            struct Wrapper
            {
                Wrap s;
                Wrap t;
            };

            using Mipmap = spk::ActivationStatus;
 
        private:
            using SynchronizableObject::forceSynchronization;
            using SynchronizableObject::synchronize;
 
            GLenum _target;
            Format _format;
            Filter _filter;
            Wrapper _wrapper;
            Mipmap _mipmap = Mipmap::Deactivated;
            spk::CachedData<GLuint> _id;
            std::vector<uint8_t> _content;
            spk::Vector2UInt _size = {0, 0};
 
            static size_t _componentCount(Format p_format);
 
            size_t _expectedByteSize(const spk::Vector2UInt &p_size) const;
 
            static GLenum _pixelDataType(Format p_format);
 
            void _applyParameters();
 
            void _storeData(std::vector<uint8_t> p_data, const spk::Vector2UInt &p_size);
            void _storeData(const uint8_t *p_data, const spk::Vector2UInt &p_size);
 
            void _registerCallbacks();
 
        protected:
            void _onSynchronize() override;
 
        public:
            TextureObject(
                Format p_format = Format::RGBA,
                Filter p_filter = {Filtering::Linear, Filtering::Linear},
                Wrapper p_wrapper = {Wrap::Repeat, Wrap::Repeat},
                Mipmap p_mipmap = Mipmap::Activated);
            TextureObject(const TextureObject &p_other);
            TextureObject &operator=(const TextureObject &p_other);
            TextureObject(TextureObject &&p_other) noexcept;
            TextureObject &operator=(TextureObject &&p_other) noexcept;
 
            using ActivableObject::activate;
            using ActivableObject::deactivate;

            void activate() const;
            void deactivate() const;

            Format format() const;
            Filter filter() const;
            Wrapper wrapper() const;
            Mipmap mipmap() const;

            void setFormat(Format p_format);
            void setFiltering(Filter p_filter);
            void setFiltering(Filtering p_minFilter, Filtering p_magFilter);
            void setWrap(Wrapper p_wrapper);
            void setWrap(Wrap p_wrapS, Wrap p_wrapT);
            void setMipmap(Mipmap p_mipmap);

            spk::Vector2UInt size() const;
            size_t sizeAsBytes() const;
            GLuint id() const;

            void setData(const uint8_t *p_data, const spk::Vector2UInt &p_size, Format p_format = Format::RGBA);
            void setData(std::vector<uint8_t> p_data, const spk::Vector2UInt &p_size, Format p_format = Format::RGBA);

            void clearData();
            void resize(const spk::Vector2UInt &p_size);

            std::vector<uint8_t> &data();

            const std::vector<uint8_t> &data() const;

            void flip(const spk::Orientation &p_orientation);
        };
    }
}