AColor.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2024 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
 
#include <glm/glm.hpp>
#include <AUI/Core.h>
#include <glm/gtx/norm.hpp>
#include <ostream>
#include "AUI/Traits/values.h"
 
class AString;

class AColor : public glm::vec4 {
public:
    constexpr AColor() : glm::vec4(0, 0, 0, 1.f) {}
    constexpr AColor(const glm::vec4& v) : glm::vec4(v) {}
 
    API_AUI_CORE AColor(const AString& s);
    constexpr AColor(float scalar) : glm::vec4(scalar) {}
    constexpr AColor(float r, float g, float b) : glm::vec4(r, g, b, 1.f) {}
    constexpr AColor(float r, float g, float b, float a) : glm::vec4(r, g, b, a) {}

    constexpr AColor(unsigned int color)
      : glm::vec4(((color >> 24) & 0xff) / 255.f, ((color >> 16) & 0xff) / 255.f, ((color >> 8) & 0xff) / 255.f,
                  ((color) & 0xff) / 255.f) {}

    static constexpr AColor fromAARRGGBB(unsigned int color) {
        return {
            ((color >> 16) & 0xff) / 255.f,
            ((color >> 8) & 0xff) / 255.f,
            ((color) & 0xff) / 255.f,
            ((color >> 24) & 0xff) / 255.f,
        };
    }

    static constexpr AColor fromRRGGBB(unsigned int color) {
        return {
            ((color >> 16) & 0xff) / 255.f,
            ((color >> 8) & 0xff) / 255.f,
            ((color) & 0xff) / 255.f,
            1,
        };
    }
 
    constexpr AColor operator*(float other) const { return AColor(x * other, y * other, z * other, w * other); }
 
    API_AUI_CORE AString toString() const;
 
    API_AUI_CORE float readabilityOfForegroundColor(const AColor& foreground);

    [[nodiscard]]
    AColor opacify(float alpha) const noexcept {
        AColor c = *this;
        c.a += alpha;
        return c;
    }

    [[nodiscard]]
    AColor transparentize(float alpha) const noexcept {
        AColor c = *this;
        c.a -= alpha;
        return c;
    }

    inline constexpr AColor mul(float d) const {
        return glm::clamp(glm::vec4(r * d, g * d, b * d, a), glm::vec4(0.f), glm::vec4(1.f));
    }
    inline constexpr AColor darker(float d) const { return mul(1.f - d); }
    inline constexpr AColor lighter(float d) const { return mul(1.f + d); }
 
    bool isFullyTransparent() const { return a < 0.001f; }
    bool isFullyOpaque() const { return a > 0.999f; }
 
    AColor readableBlackOrWhite() const {
        return glm::length2(glm::vec3 { *this }) > 1.5f ? fromRRGGBB(0) : fromRRGGBB(0xffffff);
    }
 
    AColor opacify(float d) { return { x, y, z, a * d }; }
 
    static const AColor BLACK;
    static const AColor WHITE;
    static const AColor RED;
    static const AColor GREEN;
    static const AColor BLUE;
    static const AColor GRAY;
};
 
inline const AColor AColor::BLACK = { 0.f, 0.f, 0.f, 1.f };
inline const AColor AColor::WHITE = { 1.f, 1.f, 1.f, 1.f };
inline const AColor AColor::RED = { 1.f, 0.f, 0.f, 1.f };
inline const AColor AColor::GREEN = { 0.f, 1.f, 0.f, 1.f };
inline const AColor AColor::BLUE = { 0.f, 0.f, 1.f, 1.f };
inline const AColor AColor::GRAY = { 0.5f, 0.5f, 0.5f, 1.f };
 
inline std::ostream& operator<<(std::ostream& o, const AColor& color) {
    o << "#";
    char buf[16];
    if (!color.isFullyOpaque()) {
        std::snprintf(buf, sizeof(buf), "%02x", uint8_t(color.a * 255.f));
        o << buf;
    }
    std::snprintf(
        buf, sizeof(buf), "%02x%02x%02x", uint8_t(color.r * 255.f), uint8_t(color.g * 255.f), uint8_t(color.b * 255.f));
    o << buf;
    return o;
}

inline constexpr AColor operator""_argb(unsigned long long v) { return AColor::fromAARRGGBB(unsigned(v)); }

inline constexpr AColor operator""_rgb(unsigned long long v) {
    assert(("_rgb literal should be in 0xrrggbb format, not 0xaarrggbb" && !(v & 0xff000000u)));
    return AColor::fromRRGGBB(unsigned(v));
}

struct API_AUI_CORE AColorHSV {
    aui::float_within_0_1 hue = 0.f;
    aui::float_within_0_1 saturation = 0.f;
    aui::float_within_0_1 value = 0.f;
 
    [[nodiscard]] static AColorHSV fromRGB(AColor color) noexcept;
 
    [[nodiscard]] AColor toRGB() const noexcept;
};