SColor.hpp

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in duckcpp/duckcpp.hpp
 
#ifndef DCPP_S_COLOR_HPP_INCLUDED
#define DCPP_S_COLOR_HPP_INCLUDED
 
#include <duckcpp/core/engine/dcpp_types.hpp>
#include <duckcpp/core/engine/irrMath.hpp>
 
namespace dcpp
{
namespace video
{
 
    enum ECOLOR_FORMAT
    {
 
        ECF_A1R5G5B5 = 0,
 
        ECF_R5G6B5,
 
        //           format or even not working at all. It's mostly better to use 16-bit or 32-bit formats.
        ECF_R8G8B8,
 
        ECF_A8R8G8B8,
 
        ECF_DXT1,
 
        ECF_DXT2,
 
        ECF_DXT3,
 
        ECF_DXT4,
 
        ECF_DXT5,
 
        ECF_PVRTC_RGB2,
 
        ECF_PVRTC_ARGB2,
 
        ECF_PVRTC_RGB4,
 
        ECF_PVRTC_ARGB4,
 
        ECF_PVRTC2_ARGB2,
 
        ECF_PVRTC2_ARGB4,
 
        ECF_ETC1,
 
        ECF_ETC2_RGB,
 
        ECF_ETC2_ARGB,
 
        ECF_R16F,
 
        ECF_G16R16F,
 
        ECF_A16B16G16R16F,
 
        ECF_R32F,
 
        ECF_G32R32F,
 
        ECF_A32B32G32R32F,
 
        ECF_R8,
 
        ECF_R8G8,
 
        ECF_R16,
 
        ECF_R16G16,
 
        ECF_D16,
 
        ECF_D32,
 
        ECF_D24I8,
 
        ECF_UNKNOWN
    };
 
    const dcpp::char_kt* const ColorFormatNames[ECF_UNKNOWN+2] =
    {
        "A1R5G5B5",
        "R5G6B5",
        "R8G8B8",
        "A8R8G8B8",
        "DXT1",
        "DXT2",
        "DXT3",
        "DXT4",
        "DXT5",
        "PVRTC_RGB2",
        "PVRTC_ARGB2",
        "PVRTC_RGB4",
        "PVRTC_ARGB4",
        "PVRTC2_ARGB2",
        "PVRTC2_ARGB4",
        "ETC1",
        "ETC2_RGB",
        "ETC2_ARGB",
        "R16F",
        "G16R16F",
        "A16B16G16R16F",
        "R32F",
        "G32R32F",
        "A32B32G32R32F",
        "R8",
        "R8G8",
        "R16",
        "R16G16",
        "D16",
        "D32",
        "D24I8",
        "UNKNOWN",
        0
    };
 
 
    inline dcpp::uint16_kt RGBA16(dcpp::uint32_kt r, dcpp::uint32_kt g, dcpp::uint32_kt b, dcpp::uint32_kt a=0xFF)
    {
        return (dcpp::uint16_kt)((a & 0x80) << 8 |
            (r & 0xF8) << 7 |
            (g & 0xF8) << 2 |
            (b & 0xF8) >> 3);
    }
 
 
    inline dcpp::uint16_kt RGB16(dcpp::uint32_kt r, dcpp::uint32_kt g, dcpp::uint32_kt b)
    {
        return RGBA16(r,g,b);
    }
 
 
    inline dcpp::uint16_kt RGB16from16(dcpp::uint16_kt r, dcpp::uint16_kt g, dcpp::uint16_kt b)
    {
        return (0x8000 |
                (r & 0x1F) << 10 |
                (g & 0x1F) << 5  |
                (b & 0x1F));
    }
 
 
    inline dcpp::uint16_kt X8R8G8B8toA1R5G5B5(dcpp::uint32_kt color)
    {
        return (dcpp::uint16_kt)(0x8000 |
            ( color & 0x00F80000) >> 9 |
            ( color & 0x0000F800) >> 6 |
            ( color & 0x000000F8) >> 3);
    }
 
 
    inline dcpp::uint16_kt A8R8G8B8toA1R5G5B5(dcpp::uint32_kt color)
    {
        return (dcpp::uint16_kt)(( color & 0x80000000) >> 16|
            ( color & 0x00F80000) >> 9 |
            ( color & 0x0000F800) >> 6 |
            ( color & 0x000000F8) >> 3);
    }
 
 
    inline dcpp::uint16_kt A8R8G8B8toR5G6B5(dcpp::uint32_kt color)
    {
        return (dcpp::uint16_kt)(( color & 0x00F80000) >> 8 |
            ( color & 0x0000FC00) >> 5 |
            ( color & 0x000000F8) >> 3);
    }
 
 
 
    inline dcpp::uint32_kt A1R5G5B5toA8R8G8B8(dcpp::uint16_kt color)
    {
        return ( (( -( (dcpp::int32_kt) color & 0x00008000 ) >> (dcpp::int32_kt) 31 ) & 0xFF000000 ) |
                (( color & 0x00007C00 ) << 9) | (( color & 0x00007000 ) << 4) |
                (( color & 0x000003E0 ) << 6) | (( color & 0x00000380 ) << 1) |
                (( color & 0x0000001F ) << 3) | (( color & 0x0000001C ) >> 2)
                );
    }
 
 
    inline dcpp::uint32_kt R5G6B5toA8R8G8B8(dcpp::uint16_kt color)
    {
        return 0xFF000000 |
            ((color & 0xF800) << 8)|
            ((color & 0x07E0) << 5)|
            ((color & 0x001F) << 3);
    }
 
 
    inline dcpp::uint16_kt R5G6B5toA1R5G5B5(dcpp::uint16_kt color)
    {
        return 0x8000 | (((color & 0xFFC0) >> 1) | (color & 0x1F));
    }
 
 
    inline dcpp::uint16_kt A1R5G5B5toR5G6B5(dcpp::uint16_kt color)
    {
        return (((color & 0x7FE0) << 1) | (color & 0x1F));
    }
 
 
 
 
    inline dcpp::uint32_kt getAlpha(dcpp::uint16_kt color)
    {
        return ((color >> 15)&0x1);
    }
 
 
 
    inline dcpp::uint32_kt getRed(dcpp::uint16_kt color)
    {
        return ((color >> 10)&0x1F);
    }
 
 
 
    inline dcpp::uint32_kt getGreen(dcpp::uint16_kt color)
    {
        return ((color >> 5)&0x1F);
    }
 
 
 
    inline dcpp::uint32_kt getBlue(dcpp::uint16_kt color)
    {
        return (color & 0x1F);
    }
 
 
    inline dcpp::int32_kt getAverage(dcpp::int16_kt color)
    {
        return ((getRed(color)<<3) + (getGreen(color)<<3) + (getBlue(color)<<3)) / 3;
    }
 
 
 
    class SColor
    {
    public:
 
 
        SColor() {}
 
 
        SColor (dcpp::uint32_kt a, dcpp::uint32_kt r, dcpp::uint32_kt g, dcpp::uint32_kt b)
            : color(((a & 0xff)<<24) | ((r & 0xff)<<16) | ((g & 0xff)<<8) | (b & 0xff)) {}
 
        SColor(dcpp::uint32_kt clr)
            : color(clr) {}
 
 
        dcpp::uint32_kt getAlpha() const { return color>>24; }
 
 
        dcpp::uint32_kt getRed() const { return (color>>16) & 0xff; }
 
 
        dcpp::uint32_kt getGreen() const { return (color>>8) & 0xff; }
 
 
        dcpp::uint32_kt getBlue() const { return color & 0xff; }
 
        dcpp::float32_kt getLightness() const
        {
            return 0.5f*(dcpp::nub::max_(dcpp::nub::max_(getRed(),getGreen()),getBlue())+dcpp::nub::min_(dcpp::nub::min_(getRed(),getGreen()),getBlue()));
        }
 
        dcpp::float32_kt getLuminance() const
        {
            return 0.3f*getRed() + 0.59f*getGreen() + 0.11f*getBlue();
        }
 
        dcpp::uint32_kt getAverage() const
        {
            return ( getRed() + getGreen() + getBlue() ) / 3;
        }
 
 
        void setAlpha(dcpp::uint32_kt a) { color = ((a & 0xff)<<24) | (color & 0x00ffffff); }
 
 
        void setRed(dcpp::uint32_kt r) { color = ((r & 0xff)<<16) | (color & 0xff00ffff); }
 
 
        void setGreen(dcpp::uint32_kt g) { color = ((g & 0xff)<<8) | (color & 0xffff00ff); }
 
 
        void setBlue(dcpp::uint32_kt b) { color = (b & 0xff) | (color & 0xffffff00); }
 
 
        dcpp::uint16_kt toA1R5G5B5() const { return A8R8G8B8toA1R5G5B5(color); }
 
 
        void toOpenGLColor(dcpp::uint8_kt* dest) const
        {
            *dest =   (dcpp::uint8_kt)getRed();
            *++dest = (dcpp::uint8_kt)getGreen();
            *++dest = (dcpp::uint8_kt)getBlue();
            *++dest = (dcpp::uint8_kt)getAlpha();
        }
 
 
        void set(dcpp::uint32_kt a, dcpp::uint32_kt r, dcpp::uint32_kt g, dcpp::uint32_kt b)
        {
            color = (((a & 0xff)<<24) | ((r & 0xff)<<16) | ((g & 0xff)<<8) | (b & 0xff));
        }
        void set(dcpp::uint32_kt col) { color = col; }
 
 
        bool operator==(const SColor& other) const { return other.color == color; }
 
 
        bool operator!=(const SColor& other) const { return other.color != color; }
 
 
        bool operator<(const SColor& other) const { return (color < other.color); }
 
 
        SColor operator+(const SColor& other) const
        {
            return SColor(dcpp::nub::min_(getAlpha() + other.getAlpha(), 255u),
                    dcpp::nub::min_(getRed() + other.getRed(), 255u),
                    dcpp::nub::min_(getGreen() + other.getGreen(), 255u),
                    dcpp::nub::min_(getBlue() + other.getBlue(), 255u));
        }
 
 
        SColor getInterpolated(const SColor &other, dcpp::float32_kt d) const
        {
            d = dcpp::nub::clamp(d, 0.f, 1.f);
            const dcpp::float32_kt inv = 1.0f - d;
            return SColor((dcpp::uint32_kt)dcpp::nub::round32(other.getAlpha()*inv + getAlpha()*d),
                (dcpp::uint32_kt)dcpp::nub::round32(other.getRed()*inv + getRed()*d),
                (dcpp::uint32_kt)dcpp::nub::round32(other.getGreen()*inv + getGreen()*d),
                (dcpp::uint32_kt)dcpp::nub::round32(other.getBlue()*inv + getBlue()*d));
        }
 
 
        SColor getInterpolated_quadratic(const SColor& c1, const SColor& c2, dcpp::float32_kt d) const
        {
            // this*(1-d)*(1-d) + 2 * c1 * (1-d) + c2 * d * d;
            d = dcpp::nub::clamp(d, 0.f, 1.f);
            const dcpp::float32_kt inv = 1.f - d;
            const dcpp::float32_kt mul0 = inv * inv;
            const dcpp::float32_kt mul1 = 2.f * d * inv;
            const dcpp::float32_kt mul2 = d * d;
 
            return SColor(
                    dcpp::nub::clamp( dcpp::nub::floor32(
                            getAlpha() * mul0 + c1.getAlpha() * mul1 + c2.getAlpha() * mul2 ), 0, 255 ),
                    dcpp::nub::clamp( dcpp::nub::floor32(
                            getRed()   * mul0 + c1.getRed()   * mul1 + c2.getRed()   * mul2 ), 0, 255 ),
                    dcpp::nub::clamp ( dcpp::nub::floor32(
                            getGreen() * mul0 + c1.getGreen() * mul1 + c2.getGreen() * mul2 ), 0, 255 ),
                    dcpp::nub::clamp ( dcpp::nub::floor32(
                            getBlue()  * mul0 + c1.getBlue()  * mul1 + c2.getBlue()  * mul2 ), 0, 255 ));
        }
 
 
        void setData(const void *data, ECOLOR_FORMAT format)
        {
            switch (format)
            {
                case ECF_A1R5G5B5:
                    color = A1R5G5B5toA8R8G8B8(*(dcpp::uint16_kt*)data);
                    break;
                case ECF_R5G6B5:
                    color = R5G6B5toA8R8G8B8(*(dcpp::uint16_kt*)data);
                    break;
                case ECF_A8R8G8B8:
                    color = *(dcpp::uint32_kt*)data;
                    break;
                case ECF_R8G8B8:
                    {
                        const dcpp::uint8_kt* p = (dcpp::uint8_kt*)data;
                        set(255, p[0],p[1],p[2]);
                    }
                    break;
                default:
                    color = 0xffffffff;
                break;
            }
        }
 
 
        void getData(void *data, ECOLOR_FORMAT format) const
        {
            switch(format)
            {
                case ECF_A1R5G5B5:
                {
                    dcpp::uint16_kt * dest = (dcpp::uint16_kt*)data;
                    *dest = dcpp::video::A8R8G8B8toA1R5G5B5( color );
                }
                break;
 
                case ECF_R5G6B5:
                {
                    dcpp::uint16_kt * dest = (dcpp::uint16_kt*)data;
                    *dest = dcpp::video::A8R8G8B8toR5G6B5( color );
                }
                break;
 
                case ECF_R8G8B8:
                {
                    dcpp::uint8_kt* dest = (dcpp::uint8_kt*)data;
                    dest[0] = (dcpp::uint8_kt)getRed();
                    dest[1] = (dcpp::uint8_kt)getGreen();
                    dest[2] = (dcpp::uint8_kt)getBlue();
                }
                break;
 
                case ECF_A8R8G8B8:
                {
                    dcpp::uint32_kt * dest = (dcpp::uint32_kt*)data;
                    *dest = color;
                }
                break;
 
                default:
                break;
            }
        }
 
        dcpp::uint32_kt color;
    };
 
 
 
    class SColorf
    {
    public:
 
        SColorf() : r(0.0f), g(0.0f), b(0.0f), a(1.0f) {}
 
 
        SColorf(dcpp::float32_kt r, dcpp::float32_kt g, dcpp::float32_kt b, dcpp::float32_kt a = 1.0f) : r(r), g(g), b(b), a(a) {}
 
 
        SColorf(SColor c)
        {
            const dcpp::float32_kt inv = 1.0f / 255.0f;
            r = c.getRed() * inv;
            g = c.getGreen() * inv;
            b = c.getBlue() * inv;
            a = c.getAlpha() * inv;
        }
 
        SColor toSColor() const
        {
            return SColor((dcpp::uint32_kt)dcpp::nub::round32(a*255.0f), (dcpp::uint32_kt)dcpp::nub::round32(r*255.0f), (dcpp::uint32_kt)dcpp::nub::round32(g*255.0f), (dcpp::uint32_kt)dcpp::nub::round32(b*255.0f));
        }
 
 
        void set(dcpp::float32_kt rr, dcpp::float32_kt gg, dcpp::float32_kt bb) {r = rr; g =gg; b = bb; }
 
 
        void set(dcpp::float32_kt aa, dcpp::float32_kt rr, dcpp::float32_kt gg, dcpp::float32_kt bb) {a = aa; r = rr; g =gg; b = bb; }
 
 
        SColorf getInterpolated(const SColorf &other, dcpp::float32_kt d) const
        {
            d = dcpp::nub::clamp(d, 0.f, 1.f);
            const dcpp::float32_kt inv = 1.0f - d;
            return SColorf(other.r*inv + r*d,
                other.g*inv + g*d, other.b*inv + b*d, other.a*inv + a*d);
        }
 
 
        inline SColorf getInterpolated_quadratic(const SColorf& c1, const SColorf& c2,
                dcpp::float32_kt d) const
        {
            d = dcpp::nub::clamp(d, 0.f, 1.f);
            // this*(1-d)*(1-d) + 2 * c1 * (1-d) + c2 * d * d;
            const dcpp::float32_kt inv = 1.f - d;
            const dcpp::float32_kt mul0 = inv * inv;
            const dcpp::float32_kt mul1 = 2.f * d * inv;
            const dcpp::float32_kt mul2 = d * d;
 
            return SColorf (r * mul0 + c1.r * mul1 + c2.r * mul2,
                    g * mul0 + c1.g * mul1 + c2.g * mul2,
                    b * mul0 + c1.b * mul1 + c2.b * mul2,
                    a * mul0 + c1.a * mul1 + c2.a * mul2);
        }
 
 
        void setColorComponentValue(dcpp::int32_kt index, dcpp::float32_kt value)
        {
            switch(index)
            {
            case 0: r = value; break;
            case 1: g = value; break;
            case 2: b = value; break;
            case 3: a = value; break;
            }
        }
 
        dcpp::float32_kt getAlpha() const { return a; }
 
        dcpp::float32_kt getRed() const { return r; }
 
        dcpp::float32_kt getGreen() const { return g; }
 
        dcpp::float32_kt getBlue() const { return b; }
 
        dcpp::float32_kt r;
 
        dcpp::float32_kt g;
 
        dcpp::float32_kt b;
 
        dcpp::float32_kt a;
    };
 
 
 
    class SColorHSL
    {
    public:
        SColorHSL ( dcpp::float32_kt h = 0.f, dcpp::float32_kt s = 0.f, dcpp::float32_kt l = 0.f )
            : Hue ( h ), Saturation ( s ), Luminance ( l ) {}
 
        void fromRGB(const SColorf &color);
        void toRGB(SColorf &color) const;
 
        dcpp::float32_kt Hue;
        dcpp::float32_kt Saturation;
        dcpp::float32_kt Luminance;
 
    private:
        inline dcpp::float32_kt toRGB1(dcpp::float32_kt rm1, dcpp::float32_kt rm2, dcpp::float32_kt rh) const;
 
    };
 
    inline void SColorHSL::fromRGB(const SColorf &color)
    {
        const dcpp::float32_kt maxVal = dcpp::nub::max_(color.getRed(), color.getGreen(), color.getBlue());
        const dcpp::float32_kt minVal = (dcpp::float32_kt)dcpp::nub::min_(color.getRed(), color.getGreen(), color.getBlue());
        Luminance = (maxVal+minVal)*50;
        if (dcpp::nub::equals(maxVal, minVal))
        {
            Hue=0.f;
            Saturation=0.f;
            return;
        }
 
        const dcpp::float32_kt delta = maxVal-minVal;
        if ( Luminance <= 50 )
        {
            Saturation = (delta)/(maxVal+minVal);
        }
        else
        {
            Saturation = (delta)/(2-maxVal-minVal);
        }
        Saturation *= 100;
 
        if (dcpp::nub::equals(maxVal, color.getRed()))
            Hue = (color.getGreen()-color.getBlue())/delta;
        else if (dcpp::nub::equals(maxVal, color.getGreen()))
            Hue = 2+((color.getBlue()-color.getRed())/delta);
        else // blue is max
            Hue = 4+((color.getRed()-color.getGreen())/delta);
 
        Hue *= 60.0f;
        while ( Hue < 0.f )
            Hue += 360;
    }
 
 
    inline void SColorHSL::toRGB(SColorf &color) const
    {
        const dcpp::float32_kt l = Luminance/100;
        if (dcpp::nub::iszero(Saturation)) // grey
        {
            color.set(l, l, l);
            return;
        }
 
        dcpp::float32_kt rm2;
 
        if ( Luminance <= 50 )
        {
            rm2 = l + l * (Saturation/100);
        }
        else
        {
            rm2 = l + (1 - l) * (Saturation/100);
        }
 
        const dcpp::float32_kt rm1 = 2.0f * l - rm2;
 
        const dcpp::float32_kt h = Hue / 360.0f;
        color.set( toRGB1(rm1, rm2, h + 1.f/3.f),
            toRGB1(rm1, rm2, h),
            toRGB1(rm1, rm2, h - 1.f/3.f)
            );
    }
 
 
    // algorithm from Foley/Van-Dam
    inline dcpp::float32_kt SColorHSL::toRGB1(dcpp::float32_kt rm1, dcpp::float32_kt rm2, dcpp::float32_kt rh) const
    {
        if (rh<0)
            rh += 1;
        if (rh>1)
            rh -= 1;
 
        if (rh < 1.f/6.f)
            rm1 = rm1 + (rm2 - rm1) * rh*6.f;
        else if (rh < 0.5f)
            rm1 = rm2;
        else if (rh < 2.f/3.f)
            rm1 = rm1 + (rm2 - rm1) * ((2.f/3.f)-rh)*6.f;
 
        return rm1;
    }
 
} // end namespace video
} // end namespace dcpp
 
#endif