Color.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
 
#include "CeresEngine/Math/Math.hpp"
#include "CeresEngine/Math/Vector.hpp"
 
namespace CeresEngine::inline Math {
 
    template<typename T> class TColor {
    public:
        T r, g, b, a;
 
    public:
        constexpr explicit TColor(T value = 0.0) noexcept : TColor(value, value, value, value) {}
        constexpr explicit TColor(T value, T alpha) noexcept : TColor(value, value, value, alpha) {}
 
        constexpr explicit TColor(T red, T green, T blue, T alpha = 1.0) noexcept : r(red), g(green), b(blue), a(alpha) {}
 
        constexpr TColor(const TColor&) noexcept = default;
        constexpr TColor& operator=(const TColor&) noexcept = default;
 
        template<typename U> constexpr explicit TColor(const TColor<U>& other) noexcept : r(T(other.r)), g(T(other.g)), b(T(other.b)), a(T(other.a)) {}
 
        static TColor fromString(StringView string);
 
    public:
        [[nodiscard]] constexpr TColor changeRed(T red) const { return TColor(red, g, b, a); }
 
        [[nodiscard]] constexpr TColor changeGreen(T green) const { return TColor(r, green, b, a); }
 
        [[nodiscard]] constexpr TColor changeBlue(T blue) const { return TColor(r, g, blue, a); }
 
        [[nodiscard]] constexpr TColor changeAlpha(T alpha) const { return TColor(r, g, b, alpha); }
 
    public:
        [[nodiscard]] constexpr TColor toHSL() const {
            const double M = std::max({r, g, b});
            const double m = std::min({r, g, b});
            const double C = M - m;
 
            const double L = 0.5 * (M + m);
            const double S = L > 0.99999 ? 0.0 : C / (1.0 - std::abs(2.0 * L - 1.0));
            const double H = [&]() {
                double H_prime;
 
                if(C < 0.00001) {
                    H_prime = 0.0;
                } else if(M == r) {
                    H_prime = ((g - b) / C);
                } else if(M == g) {
                    H_prime = ((b - r) / C) + 2.0;
                } else if(M == b) {
                    H_prime = ((r - g) / C) + 4.0;
                } else {
                    H_prime = 0;
                    assert(false);
                }
 
                return H_prime > 0.0 ? H_prime / 6.0 : H_prime / 6.0 + 1.0;
            }();
 
            return TColor(H, S, L, a);
        }
 
        [[nodiscard]] TColor toRGB() const {
            const double H = r;
            const double S = g;
            const double L = b;
 
            const double C = (1.0 - std::abs(2.0 * L - 1.0)) * S;
            const double m = L - 0.5 * C;
 
            const double H_prime = H * 6.0;
            const double H_prime_mod_2 = [&]() {
                if(H_prime < 2.0) {
                    return H_prime;
                } else if(H_prime < 4.0) {
                    return H_prime - 2.0;
                } else if(H_prime <= 6.0) {
                    return H_prime - 4.0;
                }
 
                CE_ASSERT_UNDEFINED();
            }();
 
            const double X = C * (1.0 - std::abs(H_prime_mod_2 - 1.0));
 
            const TColor rgb_color_base = [&]() {
                if(H_prime < 1.0) {
                    return TColor(C, X, 0.0, 0.0);
                } else if(H_prime < 2.0) {
                    return TColor(X, C, 0.0, 0.0);
                } else if(H_prime < 3.0) {
                    return TColor(0.0, C, X, 0.0);
                } else if(H_prime < 4.0) {
                    return TColor(0.0, X, C, 0.0);
                } else if(H_prime < 5.0) {
                    return TColor(X, 0.0, C, 0.0);
                } else if(H_prime <= 6.0) {
                    return TColor(C, 0.0, X, 0.0);
                }
 
                CE_ASSERT_UNDEFINED();
            }();
 
            return rgb_color_base + TColor(m, m, m);
        }
 
    public:
        [[nodiscard]] constexpr TColor darken(T amount) const {
            TColor hsl = toHSL();
            hsl.b -= amount;
            hsl.b = Math::clamp(hsl.b, 0.0, 1.0);
            return hsl.toRGB();
        }
 
        [[nodiscard]] constexpr TColor invert(T amount = 0.0, bool applyOnAlpha = false) const noexcept {
            return TColor((T(1.0) - amount) - r, (T(1.0) - amount) - g, (T(1.0) - amount) - b, applyOnAlpha ? (T(1.0) - amount) - a : a);
        }
 
        [[nodiscard]] constexpr TColor opacity(T amount) const noexcept { return TColor(r, g, b, a * amount); }
 
        [[nodiscard]] constexpr TColor saturate(T saturation) const noexcept {
            const T s = saturation;
            using std::clamp;
            return TColor(clamp((0.213 + 0.787 * s) * r + (0.715 - 0.715 * s) * g + (0.072 - 0.072 * s) * b, 0.0, 1.0),
                clamp((0.213 - 0.213 * s) * r + (0.715 + 0.285 * s) * g + (0.072 - 0.072 * s) * b, 0.0, 1.0),
                clamp((0.213 - 0.213 * s) * r + (0.715 - 0.715 * s) * g + (0.072 + 0.928 * s) * b, 0.0, 1.0), a);
        }
 
        //        /// Converts the color to sepia.
        //        ///
        //        /// The passed parameter defines the proportion of the conversion. A
        //        /// value of `1.0` is completely sepia. A value of `0.0` leaves the
        //        /// input unchanged. Values between `0.0` and `1.0` are linear
        //        /// multipliers on the effect.
        //        [[nodiscard]] TColor sepia() const noexcept {
        //            // TODO
        //            return *this;
        //        }
 
    public:
        constexpr TColor operator+(const TColor& rhs) const { return TColor(r + rhs.r, g + rhs.g, b + rhs.b, a + rhs.a); }
        constexpr TColor operator-(const TColor& rhs) const { return TColor(r - rhs.r, g - rhs.g, b - rhs.b, a - rhs.a); }
        constexpr TColor operator*(T rhs) const { return TColor(rhs * r, rhs * g, rhs * b, rhs * a); }
        constexpr TColor operator*(const TColor& rhs) const { return TColor(rhs.r * r, rhs.g * g, rhs.b * b, rhs.a * a); }
        constexpr TColor operator/(const TColor& rhs) const { return TColor(r / rhs.r, g / rhs.g, b / rhs.b, a / rhs.a); }
 
        constexpr TColor operator/(T rhs) const {
            assert(rhs != T(0));
            const T invRhs = T(1) / rhs;
 
            return TColor(r * invRhs, g * invRhs, b * invRhs, a * invRhs);
        }
 
        friend constexpr TColor operator*(T lhs, const TColor& rhs) { return TColor(lhs * rhs.r, lhs * rhs.g, lhs * rhs.b, lhs * rhs.a); }
 
        constexpr TColor& operator+=(const TColor& rhs) {
            r += rhs.r;
            g += rhs.g;
            b += rhs.b;
            a += rhs.a;
 
            return *this;
        }
 
        constexpr TColor& operator+=(T rhs) {
            r += rhs;
            g += rhs;
            b += rhs;
            a += rhs;
            return *this;
        }
 
        constexpr TColor& operator-=(const TColor& rhs) {
            r -= rhs.r;
            g -= rhs.g;
            b -= rhs.b;
            a -= rhs.a;
 
            return *this;
        }
 
        constexpr TColor& operator-=(T rhs) {
            r -= rhs;
            g -= rhs;
            b -= rhs;
            a -= rhs;
            return *this;
        }
 
        constexpr TColor& operator*=(const TColor& rhs) {
            r *= rhs.r;
            g *= rhs.g;
            b *= rhs.b;
            a *= rhs.a;
 
            return *this;
        }
 
        constexpr TColor& operator*=(T rhs) {
            r *= rhs;
            g *= rhs;
            b *= rhs;
            a *= rhs;
            return *this;
        }
 
        constexpr TColor& operator/=(const TColor& rhs) {
            assert(rhs.r != T(0));
            assert(rhs.g != T(0));
            assert(rhs.b != T(0));
            assert(rhs.a != T(0));
 
            r /= rhs.r;
            g /= rhs.g;
            b /= rhs.b;
            a /= rhs.a;
 
            return *this;
        }
 
        constexpr TColor& operator/=(T rhs) {
            assert(rhs != T(0));
            const T invRhs = T(1) / rhs;
 
            r *= invRhs;
            g *= invRhs;
            b *= invRhs;
            a *= invRhs;
 
            return *this;
        }
 
    public:
        constexpr bool operator==(const TColor& rhs) const { return r == rhs.r && g == rhs.g && b == rhs.b && a == rhs.a; }
        constexpr bool operator!=(const TColor& rhs) const { return !(*this == rhs); }
 
        explicit constexpr operator TVector4<T>() const { return TVector4<T>{r, g, b, a}; }
 
    public:
        static const TColor zero;
        static const TColor white;
        static const TColor black;
        static const TColor red;
        static const TColor green;
        static const TColor blue;
    };
 
    extern template TColor<double> TColor<double>::fromString(StringView);
    extern template TColor<float> TColor<float>::fromString(StringView);
 
    // clang-format off
    template<typename T> const TColor<T> TColor<T>::zero{0, 0, 0, 0};
    template<typename T> const TColor<T> TColor<T>::white{1, 1, 1, 1};
    template<typename T> const TColor<T> TColor<T>::black{0, 0, 0, 1};
    template<typename T> const TColor<T> TColor<T>::red{1, 0, 0, 1};
    template<typename T> const TColor<T> TColor<T>::green{0, 1, 0, 1};
    template<typename T> const TColor<T> TColor<T>::blue{0, 0, 1, 1};
    // clang-format on
 
    using Color CE_SCRIPT_EXPORT(name = "Color", external = true, plain = true)
    = TColor<double>;
 
    using Colorf CE_SCRIPT_EXPORT(name = "Color", external = true, plain = true)
    = TColor<float>;
 
} // namespace CeresEngine::inline Math
 
template<typename T> struct std::hash<CeresEngine::Math::TColor<T>> {
    using Type = CeresEngine::Math::TColor<T>;
    constexpr size_t operator()(const Type& obj) const { return std::hash<CeresEngine::TVector4<T>>{}(CeresEngine::TVector4<T>(obj)); }
};
 
#define REFL_DECLARE_CE_COLOR(T)
REFL_DECLARE_CE_COLOR(double);
REFL_DECLARE_CE_COLOR(float);