spk_uniform_object.hpp

#pragma once
 
#include "structure/design_pattern/spk_activable_object.hpp"
#include "structure/design_pattern/spk_synchronizable_object.hpp"
#include "structure/math/spk_matrix.hpp"
#include "structure/math/spk_vector2.hpp"
#include "structure/math/spk_vector3.hpp"
#include "structure/math/spk_vector4.hpp"
#include "structure/opengl/spk_opengl_includes.hpp"
#include <cmath>
#include <cstdint>
#include <stdexcept>
#include <type_traits>
#include <utility>
#include <variant>
 
namespace spk
{
    namespace OpenGL
    {
        namespace detail
        {
            template <typename T>
            struct IsSupportedUniformTypeChecker : std::false_type
            {
            };
 
            template <>
            struct IsSupportedUniformTypeChecker<float_t> : std::true_type
            {
            };
            template <>
            struct IsSupportedUniformTypeChecker<int32_t> : std::true_type
            {
            };
            template <>
            struct IsSupportedUniformTypeChecker<uint32_t> : std::true_type
            {
            };
            template <>
            struct IsSupportedUniformTypeChecker<bool> : std::true_type
            {
            };
            template <>
            struct IsSupportedUniformTypeChecker<spk::Vector2> : std::true_type
            {
            };
            template <>
            struct IsSupportedUniformTypeChecker<spk::Vector2Int> : std::true_type
            {
            };
            template <>
            struct IsSupportedUniformTypeChecker<spk::Vector2UInt> : std::true_type
            {
            };
            template <>
            struct IsSupportedUniformTypeChecker<spk::Vector3> : std::true_type
            {
            };
            template <>
            struct IsSupportedUniformTypeChecker<spk::Vector3Int> : std::true_type
            {
            };
            template <>
            struct IsSupportedUniformTypeChecker<spk::Vector3UInt> : std::true_type
            {
            };
            template <>
            struct IsSupportedUniformTypeChecker<spk::Vector4> : std::true_type
            {
            };
            template <>
            struct IsSupportedUniformTypeChecker<spk::Vector4Int> : std::true_type
            {
            };
            template <>
            struct IsSupportedUniformTypeChecker<spk::Vector4UInt> : std::true_type
            {
            };
            template <>
            struct IsSupportedUniformTypeChecker<spk::Matrix2x2> : std::true_type
            {
            };
            template <>
            struct IsSupportedUniformTypeChecker<spk::Matrix3x3> : std::true_type
            {
            };
            template <>
            struct IsSupportedUniformTypeChecker<spk::Matrix4x4> : std::true_type
            {
            };
 
            template <typename TType>
            inline constexpr bool IsSupportedUniformType = IsSupportedUniformTypeChecker<std::decay_t<TType>>::value;
        }

        class UniformObject : public spk::ActivableObject, public spk::SynchronizableObject
        {
        private:
            using ValueStorage = std::variant<
                std::monostate,
                float_t,
                int32_t,
                uint32_t,
                bool,
                spk::Vector2,
                spk::Vector2Int,
                spk::Vector2UInt,
                spk::Vector3,
                spk::Vector3Int,
                spk::Vector3UInt,
                spk::Vector4,
                spk::Vector4Int,
                spk::Vector4UInt,
                spk::Matrix2x2,
                spk::Matrix3x3,
                spk::Matrix4x4>;
 
            int32_t _uniformLocation = -1;
            ValueStorage _value = std::monostate{};
 
            void _applyValue(const std::monostate &);
            void _applyValue(const float_t &p_value);
            void _applyValue(const int32_t &p_value);
            void _applyValue(const uint32_t &p_value);
            void _applyValue(const bool &p_value);
            void _applyValue(const spk::Vector2 &p_value);
            void _applyValue(const spk::Vector2Int &p_value);
            void _applyValue(const spk::Vector2UInt &p_value);
            void _applyValue(const spk::Vector3 &p_value);
            void _applyValue(const spk::Vector3Int &p_value);
            void _applyValue(const spk::Vector3UInt &p_value);
            void _applyValue(const spk::Vector4 &p_value);
            void _applyValue(const spk::Vector4Int &p_value);
            void _applyValue(const spk::Vector4UInt &p_value);
            void _applyValue(const spk::Matrix2x2 &p_value);
            void _applyValue(const spk::Matrix3x3 &p_value);
            void _applyValue(const spk::Matrix4x4 &p_value);
 
            void _onSynchronize() override;
            void _registerCallbacks();
 
        public:
            explicit UniformObject(GLint p_uniformLocation = -1);
            UniformObject(const UniformObject &p_other);
            UniformObject &operator=(const UniformObject &p_other);
 
            template <typename TType>
            void set(TType &&p_value)
            {
                using Decayed = std::decay_t<TType>;
                static_assert(detail::IsSupportedUniformType<Decayed>, "Unsupported uniform type for UniformObject");
 
                _value = std::forward<TType>(p_value);
                requestSynchronization();
            }
 
            template <typename TType>
            const TType &get() const
            {
                return (std::get<TType>(_value));
            }

            bool hasValue() const;
        };
    }
}