gfx_rgba.hh

Go to the documentation of this file.

/*
 * LEGAL:   COPYRIGHT (C) 2004 JIM E. BROOKS
 *          THIS SOURCE CODE IS RELEASED UNDER THE TERMS
 *          OF THE GNU GENERAL PUBLIC LICENSE VERSION 2 (GPL 2).
 *****************************************************************************/

#ifndef GFX_RGBA_HH
#define GFX_RGBA_HH 1

namespace gfx {

// Index to bytes of RGBA object.
// In OpenGL, RGBA byte-order is independent of CPU endianness.
// glColor4ubv() always expects red at GLubyte[0].
enum { RR, GG, BB, AA };

#define RGBA_LEN    4
#define RGBA8_LEN   4
#define BGRA_LEN    4
#define BGRA8_LEN   4

class RGBA
{
public:

// Cast uint8[4] as uint32.
#define RGBA_CAST(RGBA)       *reinterpret_cast<uint32*>( RGBA )
#define CONST_RGBA_CAST(RGBA) *reinterpret_cast<const uint32*>( RGBA )

    RGBA( void )
    {
        RGBA_CAST( mRgba ) = 0;  // idiom: RGBA_CAST() is a cast, not a call
    }

    explicit RGBA( const uint8 rgba[4] )
    {
        // rgba[4] input is implicity clamped to a byte.
        RGBA_CAST( mRgba ) = CONST_RGBA_CAST( rgba );
    }

    explicit RGBA( const fp rgba[4] )
    {
        Set( rgba[RR], rgba[GG], rgba[BB], rgba[AA] );
    }

    RGBA( int r, int g, int b, int a )
    {
        Set( r, g, b, a );  // Set(int,int,int,int)
    }

    RGBA( uint r, uint g, uint b, uint a )
    {
        Set( r, g, b, a );  // Set(uint,uint,uint,uint)
    }

    RGBA( fp r, fp g, fp b, fp a )
    {
        Set( r, g, b, a );
    }

    RGBA( const RGBA& src )
    {
        RGBA_CAST( mRgba ) = CONST_RGBA_CAST( src.mRgba );
    }

    void Set( const uint8 rgba[4] )
    {
        RGBA_CAST( mRgba ) = CONST_RGBA_CAST( rgba );
    }

    // Set(int)/Set(uint) differ.
    // ClampFF(int) clamps negatives at 0 but ClampFF(uint) doesn't.
    void Set( int r, int g, int b, int a )
    {
        mRgba[RR] = ClampFF( r );
        mRgba[GG] = ClampFF( g );
        mRgba[BB] = ClampFF( b );
        mRgba[AA] = ClampFF( a );
    }

    void Set( uint r, uint g, uint b, uint a )
    {
        mRgba[RR] = ClampFF( r );
        mRgba[GG] = ClampFF( g );
        mRgba[BB] = ClampFF( b );
        mRgba[AA] = ClampFF( a );
    }

    void Set( fp r, fp g, fp b, fp a )
    {
        mRgba[RR] = ClampFF( uint(r * 256.0) );
        mRgba[GG] = ClampFF( uint(g * 256.0) );
        mRgba[BB] = ClampFF( uint(b * 256.0) );
        mRgba[AA] = ClampFF( uint(a * 256.0) );
    }

    void Set( int same )
    {
        mRgba[RR] = mRgba[GG] = mRgba[BB] = mRgba[AA] = same;
    }

    const uint8* Get( void ) const
    {
        return mRgba;
    }

    // RGBA object --> fp[4] (rare).
    template<typename FP>  // should be a float type
    void Get4f( FP out[4] /*OUT*/ ) const
    {
        out[RR] = mRgba[RR] / 256.0;
        out[GG] = mRgba[GG] / 256.0;
        out[BB] = mRgba[BB] / 256.0;
        out[AA] = mRgba[AA] / 256.0;
    }

    void Get4f( TinyArray<4,fp>& out /*OUT*/ ) const
    {
        out[RR] = mRgba[RR] / 256.0;
        out[GG] = mRgba[GG] / 256.0;
        out[BB] = mRgba[BB] / 256.0;
        out[AA] = mRgba[AA] / 256.0;
    }

    // RGBA object --> uint[4]
    void Get4ub( uint8 out[4]/*OUT*/ ) const
    {
        RGBA_CAST( out ) = CONST_RGBA_CAST( mRgba );
    }

    RGBA& operator=( const RGBA& src )
    {
        RGBA_CAST( mRgba ) = CONST_RGBA_CAST( src.mRgba );
        return *this;
    }

    uint8& operator[]( uint i )
    {
        ASSERT( i < 4 );
        return mRgba[i];
    }

    const uint8& operator[]( uint i ) const // compiled when object is const
    {
        ASSERT( i < 4 );
        return mRgba[i];
    }

    bool IfZero( void ) const
    {
        return CONST_RGBA_CAST( mRgba ) == 0;
    }

    friend inline bool operator<( const RGBA src1, const RGBA src2 )
    {
        return CONST_RGBA_CAST( src1.mRgba ) < CONST_RGBA_CAST( src2.mRgba );
    }

    friend inline bool operator==( const RGBA src1, const RGBA src2 )
    {
        return CONST_RGBA_CAST( src1.mRgba ) == CONST_RGBA_CAST( src2.mRgba );
    }

    friend inline bool operator!=( const RGBA src1, const RGBA src2 )
    {
        return CONST_RGBA_CAST( src1.mRgba ) != CONST_RGBA_CAST( src2.mRgba );
    }

private:
    uint8   mRgba[4];
};

RGBA
Interpolate( const RGBA rgba0, const RGBA rgba1, const fp factor = 0.5 );

INLINE ostream&
operator<<( ostream& strm, const RGBA rgba )
{
    ios::fmtflags savedFlags = strm.flags();
    strm << '('
         << OMANIP_FIELD(3) << uint(rgba[RR]) << ','  // print numbers, not chars
         << OMANIP_FIELD(3) << uint(rgba[GG]) << ','  // (uint8 is uchar)
         << OMANIP_FIELD(3) << uint(rgba[BB]) << ','
         << OMANIP_FIELD(3) << uint(rgba[AA]) << ')';
    strm.flags(savedFlags);
    return strm;
}


#define RGB_BROWN       0.7,    0.35,   0.2
#define RGB_GRAY        0.55,   0.55,   0.55
#define RGB_GREEN       0.05,   0.9,    0.05
#define RGB_DARK_GREEN  0.05,   0.5,    0.05
#define RGB_DARK_GREEN2 0.05,   0.45,   0.05
#define RGB_PURPLE      0.6,    0.1,    0.6
#define RGB_RED         0.8,    0.1,    0.1
#define RGB_BLUE        0.1,    0.1,    0.8
#define RGB_SKY_BLUE    0.468,  0.684,  0.922   // natural
#define RGB_SKY_BLUE2   0.2,    0.6,    0.99    // artificial
#define RGB_SHADOW      0.35,   0.35,   0.35
#define RGB_WHITE       0.95,   0.95,   0.95
#define RGB_YELLOW      1.0,    1.0,    0.0

} // namespace gfx

#endif // GFX_RGBA_HH

Palomino 3D Engine documents generated by doxygen 1.5.3 on Fri Nov 23 11:26:11 2007