ParaColor.h

#pragma once

#define COLOR_ARGB(a,r,g,b)     Color(r,g,b,a)
#define COLOR_RGBA(r,g,b,a)     Color(r,g,b,a)
#define COLOR_XRGB(r,g,b)       Color(r,g,b)

namespace ParaEngine
{
    struct LinearColor
    {
        float   r,      g,      b,      a;

        static float PowOneOver255Table[256];

        inline LinearColor() {}
        inline explicit LinearColor(EnumForceInit)
            : r(0), g(0), b(0), a(0)
        {}
        inline LinearColor(float InR, float InG, float InB, float InA = 1.0f) : r(InR), g(InG), b(InB), a(InA) {}
        LinearColor(const class Color& C);
        LinearColor(uint32 C);
        LinearColor(const float * colors);
        LinearColor(const class Vector3& Vector);
#ifdef __D3DX9_H__
        LinearColor(const D3DCOLORVALUE& color);
        operator D3DCOLORVALUE& ();
        operator const D3DCOLORVALUE& () const;
#endif      
        operator const float*() const;
    
        // Operators.

        inline float& Component(int32 Index)
        {
            return (&r)[Index];
        }

        inline const float& Component(int32 Index) const
        {
            return (&r)[Index];
        }

        LinearColor& operator=(uint32 color);
        LinearColor& operator=(const Color& color);

        operator uint32() const;

        inline LinearColor operator+(const LinearColor& ColorB) const
        {
            return LinearColor(
                this->r + ColorB.r,
                this->g + ColorB.g,
                this->b + ColorB.b,
                this->a + ColorB.a
                );
        }
        inline LinearColor& operator+=(const LinearColor& ColorB)
        {
            r += ColorB.r;
            g += ColorB.g;
            b += ColorB.b;
            a += ColorB.a;
            return *this;
        }

        inline LinearColor operator-(const LinearColor& ColorB) const
        {
            return LinearColor(
                this->r - ColorB.r,
                this->g - ColorB.g,
                this->b - ColorB.b,
                this->a - ColorB.a
                );
        }
        inline LinearColor& operator-=(const LinearColor& ColorB)
        {
            r -= ColorB.r;
            g -= ColorB.g;
            b -= ColorB.b;
            a -= ColorB.a;
            return *this;
        }

        inline LinearColor operator*(const LinearColor& ColorB) const
        {
            return LinearColor(
                this->r * ColorB.r,
                this->g * ColorB.g,
                this->b * ColorB.b,
                this->a * ColorB.a
                );
        }
        inline LinearColor& operator*=(const LinearColor& ColorB)
        {
            r *= ColorB.r;
            g *= ColorB.g;
            b *= ColorB.b;
            a *= ColorB.a;
            return *this;
        }

        inline LinearColor operator*(float Scalar) const
        {
            return LinearColor(
                this->r * Scalar,
                this->g * Scalar,
                this->b * Scalar,
                this->a * Scalar
                );
        }

        inline LinearColor& operator*=(float Scalar)
        {
            r *= Scalar;
            g *= Scalar;
            b *= Scalar;
            a *= Scalar;
            return *this;
        }

        inline LinearColor operator/(const LinearColor& ColorB) const
        {
            return LinearColor(
                this->r / ColorB.r,
                this->g / ColorB.g,
                this->b / ColorB.b,
                this->a / ColorB.a
                );
        }
        inline LinearColor& operator/=(const LinearColor& ColorB)
        {
            r /= ColorB.r;
            g /= ColorB.g;
            b /= ColorB.b;
            a /= ColorB.a;
            return *this;
        }

        inline LinearColor operator/(float Scalar) const
        {
            const float InvScalar = 1.0f / Scalar;
            return LinearColor(
                this->r * InvScalar,
                this->g * InvScalar,
                this->b * InvScalar,
                this->a * InvScalar
                );
        }
        inline LinearColor& operator/=(float Scalar)
        {
            const float InvScalar = 1.0f / Scalar;
            r *= InvScalar;
            g *= InvScalar;
            b *= InvScalar;
            a *= InvScalar;
            return *this;
        }

        inline bool operator==(const LinearColor& ColorB) const
        {
            return this->r == ColorB.r && this->g == ColorB.g && this->b == ColorB.b && this->a == ColorB.a;
        }
        inline bool operator!=(const LinearColor& Other) const
        {
            return this->r != Other.r || this->g != Other.g || this->b != Other.b || this->a != Other.a;
        }

        // Error-tolerant comparison.
        inline bool Equals(const LinearColor& ColorB, float Tolerance = KINDA_SMALL_NUMBER) const
        {
            return Math::Abs(this->r - ColorB.r) < Tolerance && Math::Abs(this->g - ColorB.g) < Tolerance && Math::Abs(this->b - ColorB.b) < Tolerance && Math::Abs(this->a - ColorB.a) < Tolerance;
        }

        LinearColor CopyWithNewOpacity(float NewOpacicty)
        {
            LinearColor NewCopy = *this;
            NewCopy.a = NewOpacicty;
            return NewCopy;
        }

        static LinearColor FGetHSV(uint8 H, uint8 S, uint8 V);

        static inline float Dist(const LinearColor &V1, const LinearColor &V2)
        {
            return Math::Sqrt(Math::Sqr(V2.r - V1.r) + Math::Sqr(V2.g - V1.g) + Math::Sqr(V2.b - V1.b) + Math::Sqr(V2.a - V1.a));
        }

        LinearColor LinearRGBToHSV() const;

        LinearColor HSVToLinearRGB() const;

        Color Quantize() const;

        Color ToColor(bool bSRGB = false) const;

        Vector3 ToVector3() const;

        LinearColor Desaturate(float Desaturation) const;

        float ComputeLuminance() const;

        inline float GetMax() const
        {
            return Math::Max(Math::Max(Math::Max(r, g), b), a);
        }

        bool IsAlmostBlack() const
        {
            return Math::Sqr(r) < DELTA && Math::Sqr(g) < DELTA && Math::Sqr(b) < DELTA;
        }

        inline float GetMin() const
        {
            return Math::Min(Math::Min(Math::Min(r, g), b), a);
        }

        inline float GetLuminance() const
        {
            return r * 0.3f + g * 0.59f + b * 0.11f;
        }

        // Common colors.   
        static const LinearColor White;
        static const LinearColor Gray;
        static const LinearColor Black;
        static const LinearColor Transparent;
        static const LinearColor Red;
        static const LinearColor Green;
        static const LinearColor Blue;
        static const LinearColor Yellow;
    };

    inline LinearColor operator*(float Scalar, const LinearColor& Color)
    {
        return Color.operator*(Scalar);
    }

    //
    //  color
    //

    class Color
    {
    public:
        // Variables.
#if PLATFORM_LITTLE_ENDIAN
#if _MSC_VER
        // Win32 x86
        union { struct{ uint8 b, g, r, a; }; uint32 AlignmentDummy; };
#else
        // Linux x86, etc
        /*uint8 b GCC_ALIGN(4);
        uint8 g, r, a;*/
        union { struct{ uint8 b, g, r, a; }; uint32 AlignmentDummy; };
#endif
#else // PLATFORM_LITTLE_ENDIAN
        union { struct{ uint8 a, r, g, b; }; uint32 AlignmentDummy; };
#endif

        uint32& DWColor(void) { return *((uint32*)this); }
        const uint32& DWColor(void) const { return *((uint32*)this); }
        operator const uint32 () const { return DWColor(); };
        void operator=(const uint32 color);
        void operator=(const LinearColor& color);

        // Constructors.
        inline Color() {}
        inline explicit Color(EnumForceInit)
        {
            // put these into the body for proper ordering with INTEL vs non-INTEL_BYTE_ORDER
            r = g = b = a = 0;
        }
        inline Color(uint8 InR, uint8 InG, uint8 InB, uint8 InA = 255)
        {
            // put these into the body for proper ordering with INTEL vs non-INTEL_BYTE_ORDER
            r = InR;
            g = InG;
            b = InB;
            a = InA;
        }

        // fast, for more accuracy use LinearColor::ToColor()
        // TODO: doesn't handle negative colors well, implicit constructor can cause
        // accidental conversion (better use .ToColor(true))
        Color(const LinearColor& C);
        // put these into the body for proper ordering with INTEL vs non-INTEL_BYTE_ORDER;
        Color(uint32 InColor);

        std::string ToRGBString();
        std::string ToRGBAString();

        // Operators.
        inline bool operator==(const Color &C) const
        {
            return DWColor() == C.DWColor();
        }

        inline bool operator!=(const Color& C) const
        {
            return DWColor() != C.DWColor();
        }

        inline void operator+=(const Color& C)
        {
            r = (uint8)Math::Min((int32)r + (int32)C.r, (int32)255);
            g = (uint8)Math::Min((int32)g + (int32)C.g, (int32)255);
            b = (uint8)Math::Min((int32)b + (int32)C.b, (int32)255);
            a = (uint8)Math::Min((int32)a + (int32)C.a, (int32)255);
        }

        inline Color MutiplyOpacity(float fOpacity)
        {
            if (fOpacity == 1.f)
                return *this;
            else
            {
                Color c = *this;
                c.a = (uint8)(c.a * fOpacity);
                return c;
            }
        }

        LinearColor FromRGBE() const;

        static uint16 convert32_16(uint32 rgb);

        static uint32 convert16_32(uint16 rgb);

        static Color MakeRandomColor();

        static Color MakeRedToGreenColorFromScalar(float Scalar);

        
        inline LinearColor ReinterpretAsLinear() const
        {
            return LinearColor(r / 255.f, g / 255.f, b / 255.f, a / 255.f);
        }
        static Color FromString(const char* sColor);

        static const Color White;
        static const Color Black;
        static const Color Red;
        static const Color Green;
        static const Color Blue;
        static const Color Yellow;
        static const Color Cyan;
        static const Color Magenta;
    };

    inline uint32 GetTypeHash(const Color& Color)
    {
        return Color.DWColor();
    }

    extern void ComputeAndFixedColorAndIntensity(const LinearColor& InLinearColor, Color& OutColor, float& OutIntensity);
}