color.h

#pragma once
 
#include "pixelbullet/serialization/node.h"
 
#define GLM_ENABLE_EXPERIMENTAL
#include <glm/geometric.hpp>
#include <glm/vec4.hpp>
 
#include <cmath>
#include <cstdint>
#include <iomanip>
#include <sstream>
#include <stdexcept>
#include <string>
 
namespace pixelbullet
{
 
class Color
{
public:
    enum class Type
    {
        RGBA,
        ARGB,
        RGB
    };
 
    constexpr Color() noexcept
        : value(1.0f) // Defaults to white (1,1,1,1)
    {
    }
 
    constexpr Color(float r, float g, float b, float a = 1.0f) noexcept
        : value(r, g, b, a)
    {
    }
 
    constexpr Color(uint32_t i, Type type = Type::RGB)
    {
        switch (type)
        {
        case Type::RGBA:
            value.x = static_cast<float>((i >> 24) & 0xFF) / 255.0f;
            value.y = static_cast<float>((i >> 16) & 0xFF) / 255.0f;
            value.z = static_cast<float>((i >> 8) & 0xFF) / 255.0f;
            value.w = static_cast<float>(i & 0xFF) / 255.0f;
            break;
        case Type::ARGB:
            value.w = static_cast<float>((i >> 24) & 0xFF) / 255.0f;
            value.x = static_cast<float>((i >> 16) & 0xFF) / 255.0f;
            value.y = static_cast<float>((i >> 8) & 0xFF) / 255.0f;
            value.z = static_cast<float>(i & 0xFF) / 255.0f;
            break;
        case Type::RGB:
            value.x = static_cast<float>((i >> 16) & 0xFF) / 255.0f;
            value.y = static_cast<float>((i >> 8) & 0xFF) / 255.0f;
            value.z = static_cast<float>(i & 0xFF) / 255.0f;
            value.w = 1.0f;
            break;
        default:
            throw std::runtime_error("Unknown Color type");
        }
    }
 
    explicit Color(std::string hex, float a = 1.0f)
    {
        if (!hex.empty() && hex[0] == '#')
        {
            hex.erase(0, 1);
        }
        if (hex.size() != 6)
        {
            throw std::runtime_error("Invalid hex color string");
        }
        uint32_t hexValue = std::stoul(hex, nullptr, 16);
        value.x = static_cast<float>((hexValue >> 16) & 0xFF) / 255.0f;
        value.y = static_cast<float>((hexValue >> 8) & 0xFF) / 255.0f;
        value.z = static_cast<float>(hexValue & 0xFF) / 255.0f;
        value.w = a;
    }
 
    constexpr Color Lerp(const Color& other, float t) const noexcept
    {
        return Color(value.x + (other.value.x - value.x) * t, value.y + (other.value.y - value.y) * t,
                     value.z + (other.value.z - value.z) * t, value.w + (other.value.w - value.w) * t);
    }
 
    Color Normalize() const
    {
        float len = Length();
        if (len == 0.0f)
        {
            throw std::runtime_error("Cannot normalize zero-length color");
        }
        return Color(value.x / len, value.y / len, value.z / len, value.w / len);
    }
 
    constexpr float Length2() const noexcept
    {
        return glm::dot(value, value);
    }
 
    float Length() const noexcept
    {
        return std::sqrt(Length2());
    }
 
    constexpr uint32_t GetInt(Type type = Type::RGBA) const
    {
        switch (type)
        {
        case Type::RGBA:
            return (static_cast<uint32_t>(value.x * 255.0f) << 24) | (static_cast<uint32_t>(value.y * 255.0f) << 16) |
                   (static_cast<uint32_t>(value.z * 255.0f) << 8) | (static_cast<uint32_t>(value.w * 255.0f));
        case Type::ARGB:
            return (static_cast<uint32_t>(value.w * 255.0f) << 24) | (static_cast<uint32_t>(value.x * 255.0f) << 16) |
                   (static_cast<uint32_t>(value.y * 255.0f) << 8) | (static_cast<uint32_t>(value.z * 255.0f));
        case Type::RGB:
            return (static_cast<uint32_t>(value.x * 255.0f) << 16) | (static_cast<uint32_t>(value.y * 255.0f) << 8) |
                   (static_cast<uint32_t>(value.z * 255.0f));
        default:
            throw std::runtime_error("Unknown Color type");
        }
    }
 
    std::string GetHex() const
    {
        std::stringstream stream;
        stream << "#" << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(value.x * 255.0f) << std::setw(2)
               << static_cast<int>(value.y * 255.0f) << std::setw(2) << static_cast<int>(value.z * 255.0f);
        return stream.str();
    }
 
    constexpr float operator[](uint32_t i) const noexcept
    {
        return (i == 0) ? value.x : (i == 1) ? value.y : (i == 2) ? value.z : value.w;
    }
    constexpr float& operator[](uint32_t i)
    {
        return (i == 0) ? value.x : (i == 1) ? value.y : (i == 2) ? value.z : value.w;
    }
 
    constexpr bool operator==(const Color& rhs) const noexcept
    {
        return value == rhs.value;
    }
    constexpr bool operator!=(const Color& rhs) const noexcept
    {
        return !(*this == rhs);
    }
 
    // Arithmetic operators:
    friend constexpr Color operator+(const Color& lhs, const Color& rhs) noexcept
    {
        return Color(lhs.value.x + rhs.value.x, lhs.value.y + rhs.value.y, lhs.value.z + rhs.value.z, lhs.value.w + rhs.value.w);
    }
    friend constexpr Color operator-(const Color& lhs, const Color& rhs) noexcept
    {
        return Color(lhs.value.x - rhs.value.x, lhs.value.y - rhs.value.y, lhs.value.z - rhs.value.z, lhs.value.w - rhs.value.w);
    }
    friend constexpr Color operator*(const Color& lhs, const Color& rhs) noexcept
    {
        return Color(lhs.value.x * rhs.value.x, lhs.value.y * rhs.value.y, lhs.value.z * rhs.value.z, lhs.value.w * rhs.value.w);
    }
    friend constexpr Color operator/(const Color& lhs, const Color& rhs) noexcept
    {
        return Color(lhs.value.x / rhs.value.x, lhs.value.y / rhs.value.y, lhs.value.z / rhs.value.z, lhs.value.w / rhs.value.w);
    }
    friend constexpr Color operator*(float lhs, const Color& rhs) noexcept
    {
        return Color(lhs * rhs.value.x, lhs * rhs.value.y, lhs * rhs.value.z, lhs * rhs.value.w);
    }
    friend constexpr Color operator*(const Color& lhs, float rhs) noexcept
    {
        return rhs * lhs;
    }
    friend constexpr Color operator/(const Color& lhs, float rhs) noexcept
    {
        return Color(lhs.value.x / rhs, lhs.value.y / rhs, lhs.value.z / rhs, lhs.value.w / rhs);
    }
    friend constexpr Color operator+(const Color& lhs, float rhs) noexcept
    {
        return Color(lhs.value.x + rhs, lhs.value.y + rhs, lhs.value.z + rhs, lhs.value.w);
    }
    friend constexpr Color operator-(const Color& lhs, float rhs) noexcept
    {
        return Color(lhs.value.x - rhs, lhs.value.y - rhs, lhs.value.z - rhs, lhs.value.w);
    }
 
    constexpr Color& operator+=(const Color& rhs) noexcept
    {
        *this = *this + rhs;
        return *this;
    }
    constexpr Color& operator-=(const Color& rhs) noexcept
    {
        *this = *this - rhs;
        return *this;
    }
    constexpr Color& operator*=(const Color& rhs) noexcept
    {
        *this = *this * rhs;
        return *this;
    }
    constexpr Color& operator/=(const Color& rhs) noexcept
    {
        *this = *this / rhs;
        return *this;
    }
    constexpr Color& operator+=(float rhs) noexcept
    {
        *this = *this + rhs;
        return *this;
    }
    constexpr Color& operator-=(float rhs) noexcept
    {
        *this = *this - rhs;
        return *this;
    }
    constexpr Color& operator*=(float rhs) noexcept
    {
        *this = *this * rhs;
        return *this;
    }
    constexpr Color& operator/=(float rhs) noexcept
    {
        *this = *this / rhs;
        return *this;
    }
 
    friend const Node& operator>>(const Node& node, Color& color);
    friend Node& operator<<(Node& node, const Color& color);
 
    static const Color clear;
    static const Color black;
    static const Color grey;
    static const Color silver;
    static const Color white;
    static const Color maroon;
    static const Color red;
    static const Color olive;
    static const Color yellow;
    static const Color green;
    static const Color lime;
    static const Color teal;
    static const Color aqua;
    static const Color navy;
    static const Color blue;
    static const Color purple;
    static const Color fuchsia;
 
private:
    glm::vec4 value;
};
 
// Node conversion operators for Color.
inline const Node& operator>>(const Node& node, Color& color)
{
    if (!node.GetProperties().empty())
    {
        node["r"] >> color.value.x;
        node["g"] >> color.value.y;
        node["b"] >> color.value.z;
        node["a"] >> color.value.w;
    }
    else
    {
        std::string hex;
        node >> hex;
        color = Color(hex);
    }
    return node;
}
 
inline Node& operator<<(Node& node, const Color& color)
{
    node["r"] << color.value.x;
    node["g"] << color.value.y;
    node["b"] << color.value.z;
    node["a"] << color.value.w;
    return node;
}
} // namespace pixelbullet