//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : EGkColor.h           Data : 24.02.14          Versione : 1.5b6
// Contenuto : Implementazione della classe Color.
//
//
//
// Modifiche : 24.02.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

#pragma once

#include <stdlib.h>

//-----------------------------------------------------------------------------
class Color
{
   public :
      Color( void)
             { m_Col[RED] = 0 ; m_Col[GREEN] = 0 ; m_Col[BLUE] = 0 ; m_Col[ALPHA] = 0 ; }
      Color( int nRed, int nGreen, int nBlue, int nAlpha = MAX_ALPHA)
            { Set( nRed, nGreen, nBlue, nAlpha) ; }
      Color( double dRed, double dGreen, double dBlue, double dAlpha = 1)
            { Set( dRed, dGreen, dBlue, dAlpha) ; }
      void Set( int nRed, int nGreen, int nBlue, int nAlpha = MAX_ALPHA)
            { m_Col[RED] = (( nRed < 0) ? 0 : (( nRed > MAX_RGB) ? MAX_RGB : nRed)) ;
              m_Col[GREEN] = (( nGreen < 0) ? 0 : (( nGreen > MAX_RGB) ? MAX_RGB : nGreen)) ;
              m_Col[BLUE] = (( nBlue < 0) ? 0 : (( nBlue > MAX_RGB) ? MAX_RGB : nBlue)) ;
              m_Col[ALPHA] = (( nAlpha < 0) ? 0 : (( nAlpha > MAX_ALPHA) ? MAX_ALPHA : nAlpha)) ; }
      void Set( double dRed, double dGreen, double dBlue, double dAlpha = 1)
            { m_Col[RED] = (( dRed < 0) ? 0 : (( dRed > 1) ? MAX_RGB : int( dRed * MAX_RGB))) ;
              m_Col[GREEN] = (( dGreen < 0) ? 0 : (( dGreen > 1) ? MAX_RGB : int( dGreen * MAX_RGB))) ;
              m_Col[BLUE] = (( dBlue < 0) ? 0 : (( dBlue > 1) ? MAX_RGB : int( dBlue * MAX_RGB))) ;
              m_Col[ALPHA] = (( dAlpha < 0) ? 0 : (( dAlpha > 1) ? MAX_ALPHA : int( dAlpha * MAX_ALPHA))) ; }
      int GetIntRed( void)
            { return m_Col[RED] ; }
      int GetIntGreen( void)
            { return m_Col[GREEN] ; }
      int GetIntBlue( void)
            { return m_Col[BLUE] ; }
      int GetIntAlpha( void)
            { return m_Col[ALPHA] ; }
      float GetRed( void)
            { return ( (float) m_Col[RED] / MAX_RGB) ; }
      float GetGreen( void)
            { return ( (float) m_Col[GREEN] / MAX_RGB) ; }
      float GetBlue( void)
            { return ( (float) m_Col[BLUE] / MAX_RGB) ; }
      float GetAlpha( void)
            { return ( (float) m_Col[ALPHA] / MAX_ALPHA) ; }
      bool operator == ( const Color& other)
            { return ( m_Col[RED] == other.m_Col[RED] &&
                       m_Col[GREEN] == other.m_Col[GREEN] &&
                       m_Col[BLUE] == other.m_Col[BLUE] &&
                       m_Col[ALPHA] == other.m_Col[ALPHA]) ; }

   private :
      enum { RED = 0, GREEN = 1, BLUE = 2, ALPHA = 3, DIM = 4} ;
      static const int MAX_RGB = 255 ;
      static const int MAX_ALPHA = 100 ;

   private :
      unsigned char m_Col[DIM] ;
} ;