SColor.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h

#ifndef __COLOR_H_INCLUDED__
#define __COLOR_H_INCLUDED__

#include "irrTypes.h"
#include "irrMath.h"

namespace irr
{
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_D24S8,

                ECF_UNKNOWN
        };

        const c8* 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",
                "D24S8",
                "UNKNOWN",
                0
        };


        inline u16 RGBA16(u32 r, u32 g, u32 b, u32 a=0xFF)
        {
                return (u16)((a & 0x80) << 8 |
                        (r & 0xF8) << 7 |
                        (g & 0xF8) << 2 |
                        (b & 0xF8) >> 3);
        }


        inline u16 RGB16(u32 r, u32 g, u32 b)
        {
                return RGBA16(r,g,b);
        }


        inline u16 RGB16from16(u16 r, u16 g, u16 b)
        {
                return (0x8000 |
                                (r & 0x1F) << 10 |
                                (g & 0x1F) << 5  |
                                (b & 0x1F));
        }


        inline u16 X8R8G8B8toA1R5G5B5(u32 color)
        {
                return (u16)(0x8000 |
                        ( color & 0x00F80000) >> 9 |
                        ( color & 0x0000F800) >> 6 |
                        ( color & 0x000000F8) >> 3);
        }


        inline u16 A8R8G8B8toA1R5G5B5(u32 color)
        {
                return (u16)(( color & 0x80000000) >> 16|
                        ( color & 0x00F80000) >> 9 |
                        ( color & 0x0000F800) >> 6 |
                        ( color & 0x000000F8) >> 3);
        }


        inline u16 A8R8G8B8toR5G6B5(u32 color)
        {
                return (u16)(( color & 0x00F80000) >> 8 |
                        ( color & 0x0000FC00) >> 5 |
                        ( color & 0x000000F8) >> 3);
        }



        inline u32 A1R5G5B5toA8R8G8B8(u16 color)
        {
                return ( (( -( (s32) color & 0x00008000 ) >> (s32) 31 ) & 0xFF000000 ) |
                                (( color & 0x00007C00 ) << 9) | (( color & 0x00007000 ) << 4) |
                                (( color & 0x000003E0 ) << 6) | (( color & 0x00000380 ) << 1) |
                                (( color & 0x0000001F ) << 3) | (( color & 0x0000001C ) >> 2)
                                );
        }


        inline u32 R5G6B5toA8R8G8B8(u16 color)
        {
                return 0xFF000000 |
                        ((color & 0xF800) << 8)|
                        ((color & 0x07E0) << 5)|
                        ((color & 0x001F) << 3);
        }


        inline u16 R5G6B5toA1R5G5B5(u16 color)
        {
                return 0x8000 | (((color & 0xFFC0) >> 1) | (color & 0x1F));
        }


        inline u16 A1R5G5B5toR5G6B5(u16 color)
        {
                return (((color & 0x7FE0) << 1) | (color & 0x1F));
        }




        inline u32 getAlpha(u16 color)
        {
                return ((color >> 15)&0x1);
        }



        inline u32 getRed(u16 color)
        {
                return ((color >> 10)&0x1F);
        }



        inline u32 getGreen(u16 color)
        {
                return ((color >> 5)&0x1F);
        }



        inline u32 getBlue(u16 color)
        {
                return (color & 0x1F);
        }


        inline s32 getAverage(s16 color)
        {
                return ((getRed(color)<<3) + (getGreen(color)<<3) + (getBlue(color)<<3)) / 3;
        }



        class SColor
        {
        public:


                SColor() {}


                SColor (u32 a, u32 r, u32 g, u32 b)
                        : color(((a & 0xff)<<24) | ((r & 0xff)<<16) | ((g & 0xff)<<8) | (b & 0xff)) {}

                SColor(u32 clr)
                        : color(clr) {}


                u32 getAlpha() const { return color>>24; }


                u32 getRed() const { return (color>>16) & 0xff; }


                u32 getGreen() const { return (color>>8) & 0xff; }


                u32 getBlue() const { return color & 0xff; }

                f32 getLightness() const
                {
                        return 0.5f*(core::max_(core::max_(getRed(),getGreen()),getBlue())+core::min_(core::min_(getRed(),getGreen()),getBlue()));
                }

                f32 getLuminance() const
                {
                        return 0.3f*getRed() + 0.59f*getGreen() + 0.11f*getBlue();
                }

                u32 getAverage() const
                {
                        return ( getRed() + getGreen() + getBlue() ) / 3;
                }


                void setAlpha(u32 a) { color = ((a & 0xff)<<24) | (color & 0x00ffffff); }


                void setRed(u32 r) { color = ((r & 0xff)<<16) | (color & 0xff00ffff); }


                void setGreen(u32 g) { color = ((g & 0xff)<<8) | (color & 0xffff00ff); }


                void setBlue(u32 b) { color = (b & 0xff) | (color & 0xffffff00); }


                u16 toA1R5G5B5() const { return A8R8G8B8toA1R5G5B5(color); }


                void toOpenGLColor(u8* dest) const
                {
                        *dest =   (u8)getRed();
                        *++dest = (u8)getGreen();
                        *++dest = (u8)getBlue();
                        *++dest = (u8)getAlpha();
                }


                void set(u32 a, u32 r, u32 g, u32 b)
                {
                        color = (((a & 0xff)<<24) | ((r & 0xff)<<16) | ((g & 0xff)<<8) | (b & 0xff));
                }
                void set(u32 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(core::min_(getAlpha() + other.getAlpha(), 255u),
                                        core::min_(getRed() + other.getRed(), 255u),
                                        core::min_(getGreen() + other.getGreen(), 255u),
                                        core::min_(getBlue() + other.getBlue(), 255u));
                }


                SColor getInterpolated(const SColor &other, f32 d) const
                {
                        d = core::clamp(d, 0.f, 1.f);
                        const f32 inv = 1.0f - d;
                        return SColor((u32)core::round32(other.getAlpha()*inv + getAlpha()*d),
                                (u32)core::round32(other.getRed()*inv + getRed()*d),
                                (u32)core::round32(other.getGreen()*inv + getGreen()*d),
                                (u32)core::round32(other.getBlue()*inv + getBlue()*d));
                }


                SColor getInterpolated_quadratic(const SColor& c1, const SColor& c2, f32 d) const
                {
                        // this*(1-d)*(1-d) + 2 * c1 * (1-d) + c2 * d * d;
                        d = core::clamp(d, 0.f, 1.f);
                        const f32 inv = 1.f - d;
                        const f32 mul0 = inv * inv;
                        const f32 mul1 = 2.f * d * inv;
                        const f32 mul2 = d * d;

                        return SColor(
                                        core::clamp( core::floor32(
                                                        getAlpha() * mul0 + c1.getAlpha() * mul1 + c2.getAlpha() * mul2 ), 0, 255 ),
                                        core::clamp( core::floor32(
                                                        getRed()   * mul0 + c1.getRed()   * mul1 + c2.getRed()   * mul2 ), 0, 255 ),
                                        core::clamp ( core::floor32(
                                                        getGreen() * mul0 + c1.getGreen() * mul1 + c2.getGreen() * mul2 ), 0, 255 ),
                                        core::clamp ( core::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(*(u16*)data);
                                        break;
                                case ECF_R5G6B5:
                                        color = R5G6B5toA8R8G8B8(*(u16*)data);
                                        break;
                                case ECF_A8R8G8B8:
                                        color = *(u32*)data;
                                        break;
                                case ECF_R8G8B8:
                                        {
                                                const u8* p = (u8*)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:
                                {
                                        u16 * dest = (u16*)data;
                                        *dest = video::A8R8G8B8toA1R5G5B5( color );
                                }
                                break;

                                case ECF_R5G6B5:
                                {
                                        u16 * dest = (u16*)data;
                                        *dest = video::A8R8G8B8toR5G6B5( color );
                                }
                                break;

                                case ECF_R8G8B8:
                                {
                                        u8* dest = (u8*)data;
                                        dest[0] = (u8)getRed();
                                        dest[1] = (u8)getGreen();
                                        dest[2] = (u8)getBlue();
                                }
                                break;

                                case ECF_A8R8G8B8:
                                {
                                        u32 * dest = (u32*)data;
                                        *dest = color;
                                }
                                break;

                                default:
                                break;
                        }
                }

                u32 color;
        };



        class SColorf
        {
        public:

                SColorf() : r(0.0f), g(0.0f), b(0.0f), a(1.0f) {}


                SColorf(f32 r, f32 g, f32 b, f32 a = 1.0f) : r(r), g(g), b(b), a(a) {}


                SColorf(SColor c)
                {
                        const f32 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((u32)core::round32(a*255.0f), (u32)core::round32(r*255.0f), (u32)core::round32(g*255.0f), (u32)core::round32(b*255.0f));
                }


                void set(f32 rr, f32 gg, f32 bb) {r = rr; g =gg; b = bb; }


                void set(f32 aa, f32 rr, f32 gg, f32 bb) {a = aa; r = rr; g =gg; b = bb; }


                SColorf getInterpolated(const SColorf &other, f32 d) const
                {
                        d = core::clamp(d, 0.f, 1.f);
                        const f32 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,
                                f32 d) const
                {
                        d = core::clamp(d, 0.f, 1.f);
                        // this*(1-d)*(1-d) + 2 * c1 * (1-d) + c2 * d * d;
                        const f32 inv = 1.f - d;
                        const f32 mul0 = inv * inv;
                        const f32 mul1 = 2.f * d * inv;
                        const f32 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(s32 index, f32 value)
                {
                        switch(index)
                        {
                        case 0: r = value; break;
                        case 1: g = value; break;
                        case 2: b = value; break;
                        case 3: a = value; break;
                        }
                }

                f32 getAlpha() const { return a; }

                f32 getRed() const { return r; }

                f32 getGreen() const { return g; }

                f32 getBlue() const { return b; }

                f32 r;

                f32 g;

                f32 b;

                f32 a;
        };



        class SColorHSL
        {
        public:
                SColorHSL ( f32 h = 0.f, f32 s = 0.f, f32 l = 0.f )
                        : Hue ( h ), Saturation ( s ), Luminance ( l ) {}

                void fromRGB(const SColorf &color);
                void toRGB(SColorf &color) const;

                f32 Hue;
                f32 Saturation;
                f32 Luminance;

        private:
                inline f32 toRGB1(f32 rm1, f32 rm2, f32 rh) const;

        };

        inline void SColorHSL::fromRGB(const SColorf &color)
        {
                const f32 maxVal = core::max_(color.getRed(), color.getGreen(), color.getBlue());
                const f32 minVal = (f32)core::min_(color.getRed(), color.getGreen(), color.getBlue());
                Luminance = (maxVal+minVal)*50;
                if (core::equals(maxVal, minVal))
                {
                        Hue=0.f;
                        Saturation=0.f;
                        return;
                }

                const f32 delta = maxVal-minVal;
                if ( Luminance <= 50 )
                {
                        Saturation = (delta)/(maxVal+minVal);
                }
                else
                {
                        Saturation = (delta)/(2-maxVal-minVal);
                }
                Saturation *= 100;

                if (core::equals(maxVal, color.getRed()))
                        Hue = (color.getGreen()-color.getBlue())/delta;
                else if (core::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 f32 l = Luminance/100;
                if (core::iszero(Saturation)) // grey
                {
                        color.set(l, l, l);
                        return;
                }

                f32 rm2;

                if ( Luminance <= 50 )
                {
                        rm2 = l + l * (Saturation/100);
                }
                else
                {
                        rm2 = l + (1 - l) * (Saturation/100);
                }

                const f32 rm1 = 2.0f * l - rm2;

                const f32 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 f32 SColorHSL::toRGB1(f32 rm1, f32 rm2, f32 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 irr

#endif