palette.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Palette Allocator Definitions
 */

#ifndef TINSEL_PALETTE_H    // prevent multiple includes
#define TINSEL_PALETTE_H

#include "tinsel/dw.h"

namespace Tinsel {

typedef uint32  COLORREF;

#define TINSEL_RGB(r,g,b)   ((COLORREF)((uint8)(r)|((uint16)(g)<<8))|(((uint32)(uint8)(b))<<16))
#define TINSEL_PSX_RGB(r,g,b) ((uint16)(((uint8)(r))|((uint16)(g)<<5)|(((uint16)(b))<<10)))

enum {
    MAX_COLORS      = 256,  
    BITS_PER_PIXEL  = 8,    
    MAX_INTENSITY   = 255,  
    NUM_PALETTES    = 32,   

    // Discworld has some fixed apportioned bits in the palette.
    BGND_DAC_INDEX  = 0,    
    FGND_DAC_INDEX  = 1,    
    TBLUE1          = 228,  
    TBLUE2          = 229,  
    TBLUE3          = 230,  
    TBLUE4          = 231,  
    TALKFONT_COL    = 233
};

// some common colors

#define BLACK   (TINSEL_RGB(0, 0, 0))
#define WHITE   (TINSEL_RGB(MAX_INTENSITY, MAX_INTENSITY, MAX_INTENSITY))
#define RED     (TINSEL_RGB(MAX_INTENSITY, 0, 0))
#define GREEN   (TINSEL_RGB(0, MAX_INTENSITY, 0))
#define BLUE    (TINSEL_RGB(0, 0, MAX_INTENSITY))
#define YELLOW  (TINSEL_RGB(MAX_INTENSITY, MAX_INTENSITY, 0))
#define MAGENTA (TINSEL_RGB(MAX_INTENSITY, 0, MAX_INTENSITY))
#define CYAN    (TINSEL_RGB(0, MAX_INTENSITY, MAX_INTENSITY))

struct PALETTE {
    int32 numColors;              
    COLORREF palRGB[MAX_COLORS];  
    byte palette[MAX_COLORS * 3]; 
};

struct PALQ {
    SCNHANDLE hPal;     
    int objCount;       
    int posInDAC;       
    int32 numColors;        
    // Discworld 2 fields
    bool bFading;       // Whether or not fading
    COLORREF palRGB[MAX_COLORS];    // actual palette colors
};

#define PALETTE_MOVED   0x8000  // when this bit is set in the "posInDAC"
                // field - the palette entry has moved

// Translucent objects have NULL pPal
#define HasPalMoved(pPal) (((pPal) != NULL) && ((pPal)->posInDAC & PALETTE_MOVED))


/*----------------------------------------------------------------------*\
|*          Palette Manager Function Prototypes     *|
\*----------------------------------------------------------------------*/

void ResetPalAllocator();   // wipe out all palettes

#ifdef  DEBUG
void PaletteStats();    // Shows the maximum number of palettes used at once
#endif

void psxPaletteMapper(PALQ *originalPal, uint8 *psxClut, byte *mapperTable); // Maps PSX CLUTs to original palette in resource file

void PalettesToVideoDAC();  // Update the video DAC with palettes currently in the DAC queue

void UpdateDACqueueHandle(
    int posInDAC,       // position in video DAC
    int numColors,      // number of colors in palette
    SCNHANDLE hPalette);    // handle to palette

void UpdateDACqueue(        // places a palette in the video DAC queue
    int posInDAC,       // position in video DAC
    int numColors,      // number of colors in palette
    COLORREF *pColors); // list of RGB tripples

void UpdateDACqueue(int posInDAC, COLORREF color);

PALQ *AllocPalette(     // allocate a new palette
    SCNHANDLE hNewPal); // palette to allocate

void FreePalette(       // free a palette allocated with "AllocPalette"
    PALQ *pFreePal);    // palette queue entry to free

PALQ *FindPalette(      // find a palette in the palette queue
    SCNHANDLE hSrchPal);    // palette to search for

void SwapPalette(       // swaps palettes at the specified palette queue position
    PALQ *pPalQ,        // palette queue position
    SCNHANDLE hNewPal); // new palette

PALQ *GetNextPalette(       // returns the next palette in the queue
    PALQ *pStrtPal);    // queue position to start from - when NULL will start from beginning of queue

COLORREF GetBgndColor();    // returns current background color

void SetBgndColor(      // sets current background color
    COLORREF color);    // color to set the background to

void FadingPalette(PALQ *pPalQ, bool bFading);

void CreateTranslucentPalette(SCNHANDLE BackPal);

void NoFadingPalettes();    // All fading processes have just been killed

void DimPartPalette(
    SCNHANDLE hPal,
    int startColor,
    int length,
    int brightness);    // 0 = black, 10 == 100%


int TranslucentColor();
int DarkGreen();

#define BoxColor (TinselVersion == 3 ? DarkGreen : TranslucentColor)

int HighlightColor();

int TalkColor();

void SetTalkColorRef(COLORREF colRef);

COLORREF GetTalkColorRef();

void SetTagColorRef(COLORREF colRef);

COLORREF GetTagColorRef();

void SetTalkTextOffset(int offset);

void SetTranslucencyOffset(int offset);

} // End of namespace Tinsel

#endif  // TINSEL_PALETTE_H