gls_color.h

Go to the documentation of this file.

/*! \file
  \brief  The Color class: Implements a 4 component RGBA color.

  \par Copyright Information

  Copyright (c) 2017 by The DiSTI Corporation.<br>
  11301 Corporate Blvd; Suite 100<br>
  Orlando, Florida 32817<br>
  USA<br>
  <br>
  All rights reserved.<br>

  This Software contains proprietary trade secrets of DiSTI and may not be
reproduced, in whole or part, in any form, or by any means of electronic,
mechanical, or otherwise, without the written permission of DiSTI.  Said
permission may be derived through the purchase of applicable DiSTI product
licenses which detail the distribution rights of this content and any
Derivative Works based on this or other copyrighted DiSTI Software.

  NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.

  LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH DAMAGES.  DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
EXCEED FIVE DOLLARS (US$5.00).

  The aforementioned terms and restrictions are governed by the laws of the
State of Florida and the United States of America.

*/
#ifndef _GLS_COLOR_H
#define _GLS_COLOR_H

#include "disti_include.h"
#include "unhide_globals.h"
#include <iosfwd>   // Forward references for the stream operators
#include <string.h> // For memcmp

namespace disti
{
/** \class GlsColor
  The Color class: Implements a 4 component RGBA color.
*/
class GlsColor
{
    unsigned char rgba[ 4 ]; /** Red, Green, Blue, Alpha 0-255 range */

public:
    /** default constructor. Intializes rgba data to zero */
    GlsColor( void )
    {
        rgba[ 0 ] = rgba[ 1 ] = rgba[ 2 ] = rgba[ 3 ] = 0;
    }

    /** 4ub constructor.  Intializes using rgba values
      * \param r  Red value, range 0-255
      * \param g  Green value, range 0-255
      * \param b  Blue value, range 0-255
      * \param a  Alpha value, range 0-255
      */
    GlsColor( unsigned char r, unsigned char g, unsigned char b, unsigned char a = 255 )
    {
        rgba[ 0 ] = r;
        rgba[ 1 ] = g;
        rgba[ 2 ] = b;
        rgba[ 3 ] = a;
    }

    /** 4ubv constructor.  Intializes using rgba value
      * \param newColor 4 character RGBA array, range 0-255
      */
    GlsColor( const unsigned char newColor[] )
    {
        rgba[ 0 ] = newColor[ 0 ];
        rgba[ 1 ] = newColor[ 1 ];
        rgba[ 2 ] = newColor[ 2 ];
        rgba[ 3 ] = newColor[ 3 ];
    }

    /** 4ul constructor.
      * \param rgbaVal  Unsigned long containing color in the form RRGGBBAA (8 bits per component 
      */
    GlsColor( unsigned long rgbaVal )
    {
        rgba[ 0 ] = (unsigned char)( ( rgbaVal & 0xFF000000 ) >> 24 );
        rgba[ 1 ] = (unsigned char)( ( rgbaVal & 0x00FF0000 ) >> 16 );
        rgba[ 2 ] = (unsigned char)( ( rgbaVal & 0x0000FF00 ) >> 8 );
        rgba[ 3 ] = (unsigned char)( ( rgbaVal & 0x000000FF ) );
    }

    /** copy constructor.  */
    GlsColor( const GlsColor& color )
    {
        memcpy( rgba, color.rgba, sizeof( unsigned char ) * 4 );
    }

    /** Sets RGBA value using floats
      * \param r  Red value, range 0-1.0
      * \param g  Green value, range 0-1.0
      * \param b  Blue value, range 0-1.0
      * \param a  Alpha value, range 0-1.0
      */
    void SetRGBA4f( float r, float g, float b, float a = 1 )
    {
        rgba[ 0 ] = (unsigned char)( r * 255.0f );
        rgba[ 1 ] = (unsigned char)( g * 255.0f );
        rgba[ 2 ] = (unsigned char)( b * 255.0f );
        rgba[ 3 ] = (unsigned char)( a * 255.0f );
    }

    /** Gets RGBA value using floats
      * \param r  Red value, range 0-1.0
      * \param g  Green value, range 0-1.0
      * \param b  Blue value, range 0-1.0
      * \param a  Alpha value, range 0-1.0
      */
    void GetRGBA4f( float& r, float& g, float& b, float& a ) const
    {
        r = (float)rgba[ 0 ] / 255.0f;
        g = (float)rgba[ 1 ] / 255.0f;
        b = (float)rgba[ 2 ] / 255.0f;
        a = (float)rgba[ 3 ] / 255.0f;
    }

    /** Sets RGBA value using doubles
      * \param r  Red value, range 0-1.0
      * \param g  Green value, range 0-1.0
      * \param b  Blue value, range 0-1.0
      * \param a  Alpha value, range 0-1.0
      */
    void SetRGBA4d( double r, double g, double b, double a = 1 )
    {
        rgba[ 0 ] = (unsigned char)( r * 255.0 );
        rgba[ 1 ] = (unsigned char)( g * 255.0 );
        rgba[ 2 ] = (unsigned char)( b * 255.0 );
        rgba[ 3 ] = (unsigned char)( a * 255.0 );
    }

    /** Gets RGBA value using doubles
      * \param r  Red value, range 0-1.0
      * \param g  Green value, range 0-1.0
      * \param b  Blue value, range 0-1.0
      * \param a  Alpha value, range 0-1.0
      */
    void GetRGBA4d( double& r, double& g, double& b, double& a ) const
    {
        r = (double)rgba[ 0 ] / 255.0;
        g = (double)rgba[ 1 ] / 255.0;
        b = (double)rgba[ 2 ] / 255.0;
        a = (double)rgba[ 3 ] / 255.0;
    }

    /** Sets RGBA value
      * \param r  Red value, range 0-255
      * \param g  Green value, range 0-255
      * \param b  Blue value, range 0-255
      * \param a  Alpha value, range 0-255
      */
    void RGBA( unsigned char r, unsigned char g, unsigned char b, unsigned char a = 255 )
    {
        rgba[ 0 ] = r;
        rgba[ 1 ] = g;
        rgba[ 2 ] = b;
        rgba[ 3 ] = a;
    }

    /** Sets RGBA value
      * \param newColor 4 character RGBA array, range 0-255
      */
    void RGBA( const unsigned char newColor[] )
    {
        memcpy( rgba, newColor, sizeof( unsigned char ) * 4 );
    }

    /** Sets RGBA value
      * \param rgbaVal  Unsigned long containing color in the form RRGGBBAA (8 bits per component 
      */
    void RGBA( unsigned long rgbaVal )
    {
        rgba[ 0 ] = (unsigned char)( ( rgbaVal & 0xFF000000 ) >> 24 );
        rgba[ 1 ] = (unsigned char)( ( rgbaVal & 0x00FF0000 ) >> 16 );
        rgba[ 2 ] = (unsigned char)( ( rgbaVal & 0x0000FF00 ) >> 8 );
        rgba[ 3 ] = (unsigned char)( ( rgbaVal & 0x000000FF ) );
    }

    /** Gets RGBA value
      * \return Pointer to array of 4 unsigned chars containing rgba (0-255 range)
      */
    unsigned char*       RGBA( void ) { return rgba; }
    const unsigned char* RGBA( void ) const { return rgba; }

    /** \return  RGBA value packed into a 32 bit unsigned int in host byte order */
    unsigned long RGBA_ULong( void ) const
    {
        return ( rgba[ 0 ] << 24 ) | ( rgba[ 1 ] << 16 ) | ( rgba[ 2 ] << 8 ) | rgba[ 3 ];
    }

    /** \return  The Red component of this color */
    unsigned char R( void ) const { return rgba[ 0 ]; }

    /** \return  The Green component of this color */
    unsigned char G( void ) const { return rgba[ 1 ]; }

    /** \return  The Blue component of this color */
    unsigned char B( void ) const { return rgba[ 2 ]; }

    /** \return  The Alpha component of this color */
    unsigned char A( void ) const { return rgba[ 3 ]; }

    /** Set the Red component of this color
      * \param val  The new value for the component
      */
    void R( const unsigned char val ) { rgba[ 0 ] = val; }

    /** Set the Green component of this color
      * \param val  The new value for the component
      */
    void G( const unsigned char val ) { rgba[ 1 ] = val; }

    /** Set the Blue component of this color
      * \param val  The new value for the component
      */
    void B( const unsigned char val ) { rgba[ 2 ] = val; }

    /** Set the Alpha component of this color
      * \param val  The new value for the component
      */
    void A( const unsigned char val ) { rgba[ 3 ] = val; }

    /** Determines if the color is identical to the supplied color
      \param arg color to compare to
      \return TRUE if equal, else FALSE
      */
    bool operator==( const GlsColor& arg ) const
    {
        return 0 == memcmp( rgba, arg.rgba, sizeof( unsigned char ) * 4 );
    }

    /** Determines if the color is NOT identical to the supplied color
      \param arg color to compare to
      \return TRUE if NOT equal, else FALSE
      */
    bool operator!=( const GlsColor& arg ) const
    {
        return 0 != memcmp( rgba, arg.rgba, sizeof( unsigned char ) * 4 );
    }

    /** Copy another color into this one */
    GlsColor& operator=( const GlsColor& color )
    {
        if( &color != this )
        {
            memcpy( rgba, color.rgba, sizeof( unsigned char ) * 4 );
        }
        return *this;
    }
};

DISTI_EXPORT std::ostream& operator<<( std::ostream& outstr, const GlsColor& color );
DISTI_EXPORT std::istream& operator>>( std::istream& instr, GlsColor& color );

/// Alias for backwards compatibility
typedef GlsColor glsColor;

} // namespace disti

#endif