tb_color.hpp

 
#ifndef TurtleBrains_Color_hpp
#define TurtleBrains_Color_hpp
 
#include <turtle_brains/core/tb_types.hpp>
#include <turtle_brains/core/tb_dynamic_structure.hpp>
#include <turtle_brains/math/tb_math.hpp>
 
namespace TurtleBrains::Graphics
{
 
    class Color
    {
    public:
        constexpr Color(void) noexcept :
            mAlpha(1.0f),
            mRed(1.0f),
            mGreen(1.0f),
            mBlue(1.0f),
            mARGB(0xFFFFFFFF)
        {
        }
 
        constexpr explicit Color(const tbCore::uint32& colorARGB) noexcept :
            mAlpha(static_cast<float>((colorARGB >> 24) & 0xFF) / 255.0f),
            mRed(static_cast<float>((colorARGB >> 16) & 0xFF) / 255.0f),
            mGreen(static_cast<float>((colorARGB >> 8) & 0xFF) / 255.0f),
            mBlue(static_cast<float>((colorARGB) & 0xFF) / 255.0f),
            mARGB(colorARGB)
        {
        }
 
        constexpr explicit Color(const float clampedAlpha, const float clampedRed, const float clampedGreen, const float clampedBlue) noexcept :
            mAlpha(tbMath::Clamp(clampedAlpha, 0.0f, 1.0f)),
            mRed(tbMath::Clamp(clampedRed, 0.0f, 1.0f)),
            mGreen(tbMath::Clamp(clampedGreen, 0.0f, 1.0f)),
            mBlue(tbMath::Clamp(clampedBlue, 0.0f, 1.0f)),
            mARGB((((static_cast<tbCore::uint32>(mAlpha * 255.0f) & 0xFF) << 24) | ((static_cast<tbCore::uint32>(mRed * 255.0f) & 0xFF) << 16) |
                ((static_cast<tbCore::uint32>(mGreen * 255.0f) & 0xFF) << 8) | (static_cast<tbCore::uint32>(mBlue * 255.0f) & 0xFF)))
        {
        }
 
        bool SetColor(const tbCore::DynamicStructure& colorData, bool triggerErrorOnFailure = true);
 
        void SetColor(const tbCore::uint32& colorARGB);
 
        void SetColor(const float clampedAlpha, const float clampedRed, const float clampedGreen, const float clampedBlue);
 
        void SetColor(const float clampedTween, const Color& startColor, const Color& finalColor);
 
        tbCore::uint32 GetColorARGB(void) const;
 
        tbCore::uint32 GetColorABGR(void) const;
 
        tbCore::uint8 GetAlphaByte(void) const;
 
        tbCore::uint8 GetRedByte(void) const;
 
        tbCore::uint8 GetGreenByte(void) const;
 
        tbCore::uint8 GetBlueByte(void) const;
 
        float GetAlpha(void) const;
 
        void SetAlpha(const float alpha);
        void SetAlpha(const int alpha);
 
        float GetRed(void) const;
 
        void SetRed(const float red);
        void SetRed(const int red);
 
        float GetGreen(void) const;
 
        void SetGreen(const float green);
        void SetGreen(const int green);
 
        float GetBlue(void) const;
 
        void SetBlue(const float blue);
        void SetBlue(const int blue);
 
    private:
        //The floats may disappear for size reasons and use GetChannelAsFloat()
        float mAlpha;
        float mRed;
        float mGreen;
        float mBlue;
 
        tbCore::uint32 mARGB;
    };
 
    namespace Implementation { Color RampedColor(const Color& color500, const float rampValue); };
 
    namespace ColorPalette
    {
        template<const Color& baseColor, int lightness = 500> Color Lightness =
            Implementation::RampedColor(baseColor, static_cast<float>(lightness) / 1000.0f);
 
        template<const Color& baseColor> Color Lighter = Lightness<baseColor, 100>;
        template<const Color& baseColor> Color Light = Lightness<baseColor, 300>;
        template<const Color& baseColor> Color Dark = Lightness<baseColor, 700>;
        template<const Color& baseColor> Color Darker = Lightness<baseColor, 900>;
 
        constexpr Color Opaque(0xFFFFFFFF);      
        constexpr Color Transparent(0x00FFFFFF); 
 
        constexpr Color Black(0xFF000000);
        constexpr Color White(0xFFFFFFFF);
        constexpr Color Magenta(0xFFFF00FF);
 
#define tb_make_color(name, rgb) \
        constexpr Color name(0xFF000000 | rgb); \
        inline const Color Light##name = Light<name>; \
        inline const Color Lighter##name = Lighter<name>; \
        inline const Color Dark##name = Dark<name>; \
        inline const Color Darker##name = Darker<name>;
 
        tb_make_color(Purple, 0xFF6F42C1);
        tb_make_color(Indigo, 0xFF6610F2);
        tb_make_color(Blue, 0xFF0D6EFD);
        tb_make_color(Cyan, 0xFF0DCAF0);
        tb_make_color(Teal, 0xFF20C997);
        tb_make_color(Green, 0xFF198754);
        tb_make_color(Yellow, 0xFFFFC107);
        tb_make_color(Orange, 0xFFFD7E14);
        tb_make_color(Pink, 0xFFD63384);
        tb_make_color(Red, 0xFFDC3545);
        tb_make_color(Gray, 0xFFADB5BD);
    };
 
 
    //template<typename Type> DynamicStructure ToDynamicStructure(const Type& object)
    //{
    //  return tbCore::ToDynamicStructure(object);
    //}
 
    //template<typename Type> Type FromDynamicStructure(const DynamicStructure& data)
    //{
    //  return tbCore::FromDynamicStructure(data);
    //}
 
    //template<> inline DynamicStructure ToDynamicStructure<Color>(const Color& color)
    //{
    //  return tbCore::DynamicStructure(Core::ToString(color));
    //}
 
    //template<> inline Color FromDynamicStructure<Color>(const DynamicStructure& data)
    //{
    //  return Core::FromString<Color>(data.AsString());
    //}
 
 
}; /* namespace TurtleBrains::Graphics */
 
namespace tbGraphics = TurtleBrains::Graphics;
 
namespace TurtleBrains
{
    using Color = Graphics::Color;
    namespace ColorPalette = Graphics::ColorPalette;
 
    template<> inline DynamicStructure ToDynamicStructure<Graphics::Color>(const Graphics::Color& color)
    {
        //return tbCore::DynamicStructure(Core::ToString(color));
        tb_unused(color);
        return tbCore::DynamicStructure("this is a color");
    }
 
    template<> inline Graphics::Color FromDynamicStructure<Graphics::Color>(const DynamicStructure& data)
    {
        tb_unused(data);
        return Graphics::Color();
 
        //return Core::FromString<Graphics::Color>(data.AsString());
    }
};
 
 
// 2025-11-23: This may eventually move into TyreBytes::ToolBox. Depend on it at your own risk.
namespace TyreBytes
{
    namespace ColorPalette
    {
        static const TurtleBrains::Graphics::Color Blue(0xFF2E9FFF);
        static const TurtleBrains::Graphics::Color Pink(0xFFFF2E9F);
        static const TurtleBrains::Graphics::Color Orange(0xFFFF9F2E);
 
        static const TurtleBrains::Graphics::Color Red(0xFFF1284E);
        static const TurtleBrains::Graphics::Color Green(0xFF2EFF50);
    };
};
 
#endif /* TurtleBrains_Color_hpp */