color.h

#pragma once
 
#include "pixelbullet/serialization/node.h"
 
#define GLM_ENABLE_EXPERIMENTAL
#include <glm/geometric.hpp>
#include <glm/vec4.hpp>
 
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <iomanip>
#include <sstream>
#include <stdexcept>
#include <string>
 
namespace pixelbullet
{

class Color
{
public:
    enum class Packing
    {
        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, Packing packing = Packing::Rgb)
    {
        switch (packing)
        {
        case Packing::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 Packing::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 Packing::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 packing");
        }
    }

    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 = 0;
        for (char digit : hex)
        {
            const int value = hex_digit_value(digit);
            if (value < 0)
            {
                throw std::runtime_error("Invalid hex color string");
            }
            hexValue = (hexValue << 4u) | static_cast<uint32_t>(value);
        }
 
        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 normalized() 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 length_squared() const noexcept
    {
        return glm::dot(value, value);
    }

    float length() const noexcept
    {
        return std::sqrt(length_squared());
    }

    constexpr uint32_t packed(Packing packing = Packing::Rgba) const
    {
        switch (packing)
        {
        case Packing::Rgba:
            return (static_cast<uint32_t>(to_byte(value.x)) << 24) | (static_cast<uint32_t>(to_byte(value.y)) << 16) |
                   (static_cast<uint32_t>(to_byte(value.z)) << 8) | static_cast<uint32_t>(to_byte(value.w));
        case Packing::Argb:
            return (static_cast<uint32_t>(to_byte(value.w)) << 24) | (static_cast<uint32_t>(to_byte(value.x)) << 16) |
                   (static_cast<uint32_t>(to_byte(value.y)) << 8) | static_cast<uint32_t>(to_byte(value.z));
        case Packing::Rgb:
            return (static_cast<uint32_t>(to_byte(value.x)) << 16) | (static_cast<uint32_t>(to_byte(value.y)) << 8) |
                   static_cast<uint32_t>(to_byte(value.z));
        default:
            throw std::runtime_error("Unknown Color packing");
        }
    }

    std::string to_hex() const
    {
        std::stringstream stream;
        stream << "#" << std::uppercase << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(to_byte(value.x))
               << std::setw(2) << static_cast<int>(to_byte(value.y)) << std::setw(2) << static_cast<int>(to_byte(value.z));
        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 + 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 - rhs);
    }
 
    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:
    static constexpr uint8_t to_byte(float component) noexcept
    {
        if (!(component > 0.0f))
        {
            return 0u;
        }
        if (component >= 1.0f)
        {
            return 255u;
        }
        return static_cast<uint8_t>(component * 255.0f + 0.5f);
    }
 
    static constexpr int hex_digit_value(char digit) noexcept
    {
        if (digit >= '0' && digit <= '9')
        {
            return digit - '0';
        }
        if (digit >= 'A' && digit <= 'F')
        {
            return digit - 'A' + 10;
        }
        if (digit >= 'a' && digit <= 'f')
        {
            return digit - 'a' + 10;
        }
        return -1;
    }
 
    glm::vec4 value;
};
 
// Node conversion operators for Color.
inline const Node& operator>>(const Node& node, Color& color)
{
    if (!node.properties().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