source: golgotha/src/max_plugin/sdk_inc/gamma.h @ 80 Tweet

/**********************************************************************
 *<
        FILE:  gamma.h

        DESCRIPTION:  Gamma utilities

        CREATED BY: Dan Silva

        HISTORY: created 26 December 1995

 *>     Copyright (c) 1995, All Rights Reserved.
 **********************************************************************/


#ifndef __GAMMA__H
#define __GAMMA__H

#define WRDMAX 65535
#define FWRDMAX 65535.0f

#define RCBITS 13   // number of bits used to represent colors before gamma correction.
                                        // this keeps the lookup table a reasonable size
#define RCOLN (1<<RCBITS)    
#define RCMAX (RCOLN-1) 
#define FRCMAX ((float)RCMAX) 
#define RCHALF (RCOLN>>1)
#define RCSH (RCBITS-8)           /* shift amount from 8 bit to RCBITS */
#define RCSH16 (16-RCBITS)        /* shift amount from 16 bit to RCBITS */
#define RCFRACMASK ((ulong)((1<<RCSH)-1))         
#define RC_SCL (1<<RCSH)
#define RC_SCLHALF (1<<(RCSH-1))
#define FRC_SCL ((float)RC_SCL)
#define RCSHMASK (0xffffffffL<<RCSH)
#define RCSHMAX (0xffL<<RCSH)


#define GAMMA_NTSC              2.2f
#define GAMMA_PAL               2.8f

class GammaMgr {
        public:
                BOOL enable;
                BOOL dithTrue;
                BOOL dithPaletted;
                float dispGamma;
                float fileInGamma;
                float fileOutGamma;
                UBYTE disp_gamtab[256];           // (8->8) display gamma for drawing color swatches (8->8) 
                UBYTE disp_gamtabw[RCOLN];    // (RCBITS->8) display gamma 
                UBYTE file_in_gamtab[256];    // (8->8) 
                UWORD file_in_degamtab[256];  // (8->16)  for de-gamifying bitmaps on input
                UWORD file_out_gamtab[RCOLN]; // (RCBITS->16) gamma correct for file output, before dither 

                inline COLORREF DisplayGammaCorrect(COLORREF col) {
                        return RGB(disp_gamtab[GetRValue(col)], disp_gamtab[GetGValue(col)], disp_gamtab[GetBValue(col)]);              
                        }

                CoreExport Color DisplayGammaCorrect(Color c);
                        
                CoreExport void Enable(BOOL onOff);
                BOOL IsEnabled() { return enable;}

                CoreExport void  SetDisplayGamma(float gam);
                float GetDisplayGamma() { return dispGamma; }

                CoreExport void SetFileInGamma(float gam);
                float GetFileInGamma() { return fileInGamma; }

                CoreExport void SetFileOutGamma(float gam);
                float GetFileOutGamma() { return fileOutGamma; }

                GammaMgr();


        };

CoreExport extern GammaMgr gammaMgr;


inline COLORREF gammaCorrect(DWORD c) { return gammaMgr.DisplayGammaCorrect(c); }
inline UBYTE gammaCorrect(UBYTE b) { return gammaMgr.disp_gamtab[b]; }


#define GAMMA16to8(b)  gammaMgr.disp_gamtabw[b>>RCSH16]

// Build Gamma table that maps 8->8  
CoreExport void BuildGammaTab8(UBYTE gamtab[256], float gamma, int onoff=TRUE);

// Build a Gamma table that maps 8->16
CoreExport void BuildGammaTab8(UWORD gamtab[256], float gamma, int onoff=TRUE);

// Build Gamma table that maps RCBITS->8
CoreExport void BuildGammaTab(UBYTE gamtab[RCOLN], float gamma, int onoff=TRUE);

// Build Gamma table that  maps RCBITS->16
CoreExport void BuildGammaTab(UWORD gamtab[RCOLN], float gamma, int onoff=TRUE);

CoreExport float gammaCorrect(float v, float gamma);
CoreExport float deGammaCorrect(float v, float gamma);
CoreExport UBYTE gammaCorrect(UBYTE v, float gamma);
CoreExport UBYTE deGammaCorrect(UBYTE v, float gamma);
CoreExport UWORD gammaCorrect(UWORD c, float gamma);
CoreExport UWORD deGammaCorrect(UWORD c, float gamma);


// Temporary table for converting 16->16.
class GamConvert16 {
        float gamma;
        UWORD* gtab;
        public: 
                GamConvert16(float gam=1.0f);  
                ~ GamConvert16();  
                void SetGamma(float gam);
                UWORD Convert(UWORD v) { return gtab[v>>RCSH16]; }

        };

// Temporary table for converting 8->16.
class GamConvert8 {
        float gamma;
        UWORD gtab[256];
        public: 
                GamConvert8(float gam=1.0f);  
                void SetGamma(float gam);
                UWORD Convert(UBYTE v) { return gtab[v]; }

        };

#endif