Colour.hpp

Go to the documentation of this file.

 
 
#ifndef GALAXY_GRAPHICS_COLOUR_HPP_
#define GALAXY_GRAPHICS_COLOUR_HPP_
 
#include <array>
#include <compare>
 
#include <glm/vec4.hpp>
 
#undef OPAQUE
#undef TRANSPARENT
 
namespace galaxy
{
    namespace graphics
    {
        class Colour final
        {
        public:
            inline static const constexpr std::uint8_t OPAQUE = 255;
 
            inline static const constexpr std::uint8_t TRANSPARENT = 0;
 
        public:
            Colour();
 
            Colour(Colour&&);
 
            Colour(const Colour&);
 
            Colour& operator=(Colour&&);
 
            Colour& operator=(const Colour&);
 
            ~Colour();
 
            void set_r(const std::uint8_t r);
 
            void set_g(const std::uint8_t g);
 
            void set_b(const std::uint8_t b);
 
            void set_a(const std::uint8_t a);
 
            template<typename R>
            requires std::is_same_v<std::uint8_t, R> || std::is_same_v<float, R>
            R r() const;
 
            template<typename G>
            requires std::is_same_v<std::uint8_t, G> || std::is_same_v<float, G>
            G g() const;
 
            template<typename B>
            requires std::is_same_v<std::uint8_t, B> || std::is_same_v<float, B>
            B b() const;
 
            template<typename A>
            requires std::is_same_v<std::uint8_t, A> || std::is_same_v<float, A>
            A a() const;
 
            void set_rgba(const glm::vec4& rgba);
 
            [[nodiscard]]
            std::array<std::uint8_t, 4>& array();
 
            [[nodiscard]]
            glm::vec4& vec4();
 
            [[nodiscard]]
            const std::array<std::uint8_t, 4>& array() const;
 
            [[nodiscard]]
            const glm::vec4& vec4() const;
 
            [[nodiscard]]
            auto operator<=>(const Colour&) const = default;
 
        private:
            std::array<std::uint8_t, 4> m_array;
 
            glm::vec4 m_vec4;
        };
 
        template<>
        inline float Colour::r() const
        {
            return m_vec4.x;
        }
 
        template<>
        inline std::uint8_t Colour::r() const
        {
            return m_array[0];
        }
 
        template<>
        inline float Colour::g() const
        {
            return m_vec4.y;
        }
 
        template<>
        inline std::uint8_t Colour::g() const
        {
            return m_array[1];
        }
 
        template<>
        inline float Colour::b() const
        {
            return m_vec4.z;
        }
 
        template<>
        inline std::uint8_t Colour::b() const
        {
            return m_array[2];
        }
 
        template<>
        inline float Colour::a() const
        {
            return m_vec4.w;
        }
 
        template<>
        inline std::uint8_t Colour::a() const
        {
            return m_array[3];
        }
    } // namespace graphics
} // namespace galaxy
 
#endif