Color.h

Go to the documentation of this file.

#pragma once
 
namespace RE
{
    struct Color
    {
    public:
        enum : std::size_t
        {
            kRed,
            kGreen,
            kBlue,
            kAlpha,
 
            kTotal
        };
 
        constexpr Color() noexcept :
            red(0),
            green(0),
            blue(0),
            alpha(0)
        {}
 
        constexpr Color(const Color& a_rhs) noexcept :
            red(a_rhs.red),
            green(a_rhs.green),
            blue(a_rhs.blue),
            alpha(a_rhs.alpha)
        {}
 
        constexpr Color(Color&& a_rhs) noexcept :
            red(std::move(a_rhs.red)),
            green(std::move(a_rhs.green)),
            blue(std::move(a_rhs.blue)),
            alpha(std::move(a_rhs.alpha))
        {}
 
        constexpr Color(std::uint8_t a_red, std::uint8_t a_green, std::uint8_t a_blue, std::uint8_t a_alpha) noexcept :
            red(a_red),
            green(a_green),
            blue(a_blue),
            alpha(a_alpha)
        {}
 
        ~Color() noexcept = default;
 
        constexpr Color& operator=(const Color& a_rhs) noexcept
        {
            if (this != std::addressof(a_rhs)) {
                red = a_rhs.red;
                green = a_rhs.green;
                blue = a_rhs.blue;
                alpha = a_rhs.alpha;
            }
            return *this;
        }
 
        constexpr Color& operator=(Color&& a_rhs) noexcept
        {
            if (this != std::addressof(a_rhs)) {
                red = std::move(a_rhs.red);
                green = std::move(a_rhs.green);
                blue = std::move(a_rhs.blue);
                alpha = std::move(a_rhs.alpha);
            }
            return *this;
        }
 
        [[nodiscard]] friend constexpr bool operator==(const Color& a_lhs, const Color& a_rhs) noexcept
        {
            for (std::size_t i = 0; i < kTotal; ++i) {
                if (a_lhs[i] != a_rhs[i]) {
                    return false;
                }
            }
            return true;
        }
 
        [[nodiscard]] friend constexpr bool operator!=(const Color& a_lhs, const Color& a_rhs) noexcept
        {
            return !(a_lhs == a_rhs);
        }
 
        [[nodiscard]] constexpr std::uint8_t& operator[](std::size_t a_idx) noexcept
        {
            assert(a_idx < kTotal);
            return std::addressof(red)[a_idx];
        }
 
        [[nodiscard]] constexpr const std::uint8_t& operator[](std::size_t a_idx) const noexcept
        {
            assert(a_idx < kTotal);
            return std::addressof(red)[a_idx];
        }
 
        // members
        std::uint8_t red;    // 0
        std::uint8_t green;  // 1
        std::uint8_t blue;   // 2
        std::uint8_t alpha;  // 3
    };
    static_assert(sizeof(Color) == 0x4);
}