← Back to branch summary

~ubuntu-branches/ubuntu/raring/scummvm/raring

« back to all changes in this revision

Viewing changes to engines/tinsel/palette.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Moritz Muehlenhoff
  • Date: 2011-05-25 19:02:23 UTC
  • mto: (21.1.2 sid)
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: james.westby@ubuntu.com-20110525190223-fiqm0oaec714xk31
Tags: upstream-1.3.0
Import upstream version 1.3.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
engines/tinsel/palette.cpp
18
18
 * along with this program; if not, write to the Free Software
19
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20
20
 *
21
 
 * $URL: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/tags/release-1-2-1/engines/tinsel/palette.cpp $
22
 
 * $Id: palette.cpp 47541 2010-01-25 01:39:44Z lordhoto $
 
21
 * $URL$
 
22
 * $Id$
23
23
 *
24
24
 * Palette Allocator for IBM PC.
25
25
 */
32
32
#include "tinsel/tinsel.h"
33
33
 
34
34
#include "common/system.h"
 
35
#include "common/textconsole.h"
 
36
#include "graphics/palette.h"
35
37
 
36
38
namespace Tinsel {
37
39
 
41
43
struct VIDEO_DAC_Q {
42
44
        union {
43
45
                SCNHANDLE hRGBarray;    ///< handle of palette or
44
 
                COLORREF *pRGBarray;    ///< list of palette colours
 
46
                COLORREF *pRGBarray;    ///< list of palette colors
 
47
                COLORREF  singleRGB;
45
48
        } pal;
46
49
        bool bHandle;           ///< when set - use handle of palette
47
50
        int destDACindex;       ///< start index of palette in video DAC
48
 
        int numColours;         ///< number of colours in "hRGBarray"
 
51
        int numColors;          ///< number of colors in "hRGBarray"
49
52
};
50
53
 
51
54
 
52
55
//----------------- LOCAL GLOBAL DATA --------------------
53
56
 
54
 
/** background colour */
55
 
static COLORREF bgndColour = BLACK;
 
57
// FIXME: Avoid non-const global vars
56
58
 
57
59
/** palette allocator data */
58
60
static PALQ palAllocData[NUM_PALETTES];
67
69
/** video DAC transfer Q head pointer */
68
70
static VIDEO_DAC_Q *pDAChead;
69
71
 
70
 
/** colour index of the 4 colours used for the translucent palette */
 
72
/** color index of the 4 colors used for the translucent palette */
71
73
#define COL_HILIGHT     TBLUE1
72
74
 
73
75
/** the translucent palette lookup table */
74
 
uint8 transPalette[MAX_COLOURS];        // used in graphics.cpp
 
76
uint8 transPalette[MAX_COLORS]; // used in graphics.cpp
75
77
 
76
 
uint8 ghostPalette[MAX_COLOURS];
 
78
uint8 ghostPalette[MAX_COLORS];
77
79
 
78
80
static int translucentIndex     = 228;
79
81
 
111
113
                        }
112
114
 
113
115
                        // Check for correspondent color
114
 
                        for (uint i = 0; (i < FROM_LE_32(pal->numColours)) && !colorFound; i++) {
 
116
                        for (uint i = 0; (i < FROM_LE_32(pal->numColors)) && !colorFound; i++) {
115
117
                                // get R G B values in the same way as psx format converters
116
118
                                uint16 psxEquivalent = TINSEL_PSX_RGB(TINSEL_GetRValue(pal->palRGB[i]) >> 3, TINSEL_GetGValue(pal->palRGB[i]) >> 3, TINSEL_GetBValue(pal->palRGB[i]) >> 3);
117
119
 
133
135
void PalettesToVideoDAC() {
134
136
        PALQ *pPalQ;                            // palette Q iterator
135
137
        VIDEO_DAC_Q *pDACtail = vidDACdata;     // set tail pointer
 
138
        byte pal[768];
136
139
 
137
140
        // while Q is not empty
138
141
        while (pDAChead != pDACtail) {
139
 
                PALETTE *pPalette;      // pointer to hardware palette
140
 
                COLORREF *pColours;     // pointer to list of RGB triples
 
142
                const PALETTE *pPalette;        // pointer to hardware palette
 
143
                const COLORREF *pColors;        // pointer to list of RGB triples
141
144
 
142
145
#ifdef  DEBUG
143
146
                // make sure palette does not overlap
144
 
                assert(pDACtail->destDACindex + pDACtail->numColours <= MAX_COLOURS);
 
147
                assert(pDACtail->destDACindex + pDACtail->numColors <= MAX_COLORS);
145
148
#else
146
149
                // make sure palette does not overlap
147
 
                if (pDACtail->destDACindex + pDACtail->numColours > MAX_COLOURS)
148
 
                        pDACtail->numColours = MAX_COLOURS - pDACtail->destDACindex;
 
150
                if (pDACtail->destDACindex + pDACtail->numColors > MAX_COLORS)
 
151
                        pDACtail->numColors = MAX_COLORS - pDACtail->destDACindex;
149
152
#endif
150
153
 
151
154
                if (pDACtail->bHandle) {
152
155
                        // we are using a palette handle
153
156
 
154
157
                        // get hardware palette pointer
155
 
                        pPalette = (PALETTE *)LockMem(pDACtail->pal.hRGBarray);
 
158
                        pPalette = (const PALETTE *)LockMem(pDACtail->pal.hRGBarray);
156
159
 
157
160
                        // get RGB pointer
158
 
                        pColours = pPalette->palRGB;
 
161
                        pColors = pPalette->palRGB;
 
162
                } else if (pDACtail->numColors == 1) {
 
163
                        // we are using a single color palette
 
164
                        pColors = &pDACtail->pal.singleRGB;
159
165
                } else {
160
166
                        // we are using a palette pointer
161
 
                        pColours = pDACtail->pal.pRGBarray;
 
167
                        pColors = pDACtail->pal.pRGBarray;
 
168
                }
 
169
 
 
170
                for (int i = 0; i < pDACtail->numColors; ++i) {
 
171
                        pal[i * 3 + 0] = TINSEL_GetRValue(pColors[i]);
 
172
                        pal[i * 3 + 1] = TINSEL_GetGValue(pColors[i]);
 
173
                        pal[i * 3 + 2] = TINSEL_GetBValue(pColors[i]);
162
174
                }
163
175
 
164
176
                // update the system palette
165
 
                g_system->setPalette((byte *)pColours, pDACtail->destDACindex, pDACtail->numColours);
 
177
                g_system->getPaletteManager()->setPalette(pal, pDACtail->destDACindex, pDACtail->numColors);
166
178
 
167
179
                // update tail pointer
168
180
                pDACtail++;
198
210
 * Shows the maximum number of palettes used at once.
199
211
 */
200
212
void PaletteStats() {
201
 
        printf("%i palettes of %i used.\n", maxPals, NUM_PALETTES);
202
 
        printf("%i DAC queue entries of %i used.\n", maxDACQ, VDACQLENGTH);
 
213
        debug("%i palettes of %i used", maxPals, NUM_PALETTES);
 
214
        debug("%i DAC queue entries of %i used", maxDACQ, VDACQLENGTH);
203
215
}
204
216
#endif
205
217
 
206
218
/**
207
219
 * Places a palette in the video DAC queue.
208
220
 * @param posInDAC                      Position in video DAC
209
 
 * @param numColours            Number of colours in palette
 
221
 * @param numColors             Number of colors in palette
210
222
 * @param hPalette                      Handle to palette
211
223
 */
212
 
void UpdateDACqueueHandle(int posInDAC, int numColours, SCNHANDLE hPalette) {
 
224
void UpdateDACqueueHandle(int posInDAC, int numColors, SCNHANDLE hPalette) {
213
225
        // check Q overflow
214
226
        assert(pDAChead < vidDACdata + VDACQLENGTH);
215
227
 
216
228
        pDAChead->destDACindex = posInDAC & ~PALETTE_MOVED;     // set index in video DAC
217
 
        pDAChead->numColours = numColours;      // set number of colours
 
229
        pDAChead->numColors = numColors;        // set number of colors
218
230
        pDAChead->pal.hRGBarray = hPalette;     // set handle of palette
219
231
        pDAChead->bHandle = true;               // we are using a palette handle
220
232
 
230
242
/**
231
243
 * Places a palette in the video DAC queue.
232
244
 * @param posInDAC                      Position in video DAC
233
 
 * @param numColours,           Number of colours in palette
234
 
 * @param pColours                      List of RGB triples
235
 
 */
236
 
void UpdateDACqueue(int posInDAC, int numColours, COLORREF *pColours) {
237
 
        // check Q overflow
238
 
        assert(pDAChead < vidDACdata + NUM_PALETTES);
239
 
 
240
 
        pDAChead->destDACindex = posInDAC & ~PALETTE_MOVED;     // set index in video DAC
241
 
        pDAChead->numColours = numColours;      // set number of colours
242
 
        pDAChead->pal.pRGBarray = pColours;     // set addr of palette
 
245
 * @param numColors             Number of colors in palette
 
246
 * @param pColors                       List of RGB triples
 
247
 */
 
248
void UpdateDACqueue(int posInDAC, int numColors, COLORREF *pColors) {
 
249
        // check Q overflow
 
250
        assert(pDAChead < vidDACdata + NUM_PALETTES);
 
251
 
 
252
        pDAChead->destDACindex = posInDAC & ~PALETTE_MOVED;     // set index in video DAC
 
253
        pDAChead->numColors = numColors;        // set number of colors
 
254
        if (numColors == 1)
 
255
                pDAChead->pal.singleRGB = *pColors;     // set single color of which the "palette" consists
 
256
        else
 
257
                pDAChead->pal.pRGBarray = pColors;      // set addr of palette
 
258
        pDAChead->bHandle = false;              // we are not using a palette handle
 
259
 
 
260
        // update head pointer
 
261
        ++pDAChead;
 
262
 
 
263
#ifdef DEBUG
 
264
        if ((pDAChead-vidDACdata) > maxDACQ)
 
265
                maxDACQ = pDAChead-vidDACdata;
 
266
#endif
 
267
}
 
268
 
 
269
 
 
270
/**
 
271
 * Places a "palette" consisting of a single color in the video DAC queue.
 
272
 * @param posInDAC                      Position in video DAC
 
273
 * @param color                         Single RGB triple
 
274
 */
 
275
void UpdateDACqueue(int posInDAC, COLORREF color) {
 
276
        // check Q overflow
 
277
        assert(pDAChead < vidDACdata + NUM_PALETTES);
 
278
 
 
279
        pDAChead->destDACindex = posInDAC & ~PALETTE_MOVED;     // set index in video DAC
 
280
        pDAChead->numColors = 1;        // set number of colors
 
281
        pDAChead->pal.singleRGB = color;        // set single color of which the "palette" consists
243
282
        pDAChead->bHandle = false;              // we are not using a palette handle
244
283
 
245
284
        // update head pointer
257
296
 */
258
297
PALQ *AllocPalette(SCNHANDLE hNewPal) {
259
298
        PALQ *pPrev, *p;                // walks palAllocData
260
 
        int iDAC;               // colour index in video DAC
 
299
        int iDAC;               // color index in video DAC
261
300
        PALQ *pNxtPal;          // next PALQ struct in palette allocator
262
301
        PALETTE *pNewPal;
263
302
 
274
313
        }
275
314
 
276
315
        // search all structs in palette allocator - find a free slot
277
 
        iDAC = FGND_DAC_INDEX;  // init DAC index to first available foreground colour
 
316
        iDAC = FGND_DAC_INDEX;  // init DAC index to first available foreground color
278
317
 
279
318
        for (p = palAllocData; p < palAllocData + NUM_PALETTES; p++) {
280
319
                if (p->hPal == 0) {
282
321
                        p->objCount = 1;        // init number of objects using palette
283
322
                        p->posInDAC = iDAC;     // set palettes start pos in video DAC
284
323
                        p->hPal = hNewPal;      // set hardware palette data
285
 
                        p->numColours = FROM_LE_32(pNewPal->numColours);        // set number of colours in palette
 
324
                        p->numColors = FROM_LE_32(pNewPal->numColors);  // set number of colors in palette
286
325
 
287
326
                        if (TinselV2)
288
 
                                // Copy all the colours
289
 
                                memcpy(p->palRGB, pNewPal->palRGB, p->numColours * sizeof(COLORREF));
 
327
                                // Copy all the colors
 
328
                                memcpy(p->palRGB, pNewPal->palRGB, p->numColors * sizeof(COLORREF));
290
329
 
291
330
#ifdef DEBUG
292
331
                        // one more palette in use
296
335
 
297
336
                        // Q the change to the video DAC
298
337
                        if (TinselV2)
299
 
                                UpdateDACqueue(p->posInDAC, p->numColours, p->palRGB);
 
338
                                UpdateDACqueue(p->posInDAC, p->numColors, p->palRGB);
300
339
                        else
301
 
                                UpdateDACqueueHandle(p->posInDAC, p->numColours, p->hPal);
 
340
                                UpdateDACqueueHandle(p->posInDAC, p->numColors, p->hPal);
302
341
 
303
342
                        // move all palettes after this one down (if necessary)
304
343
                        for (pPrev = p, pNxtPal = pPrev + 1; pNxtPal < palAllocData + NUM_PALETTES; pNxtPal++) {
305
344
                                if (pNxtPal->hPal != 0) {
306
345
                                        // palette slot is in use
307
 
                                        if (pNxtPal->posInDAC >= pPrev->posInDAC + pPrev->numColours)
 
346
                                        if (pNxtPal->posInDAC >= pPrev->posInDAC + pPrev->numColors)
308
347
                                                // no need to move palettes down
309
348
                                                break;
310
349
 
311
350
                                        // move palette down - indicate change
312
351
                                        pNxtPal->posInDAC = (pPrev->posInDAC
313
 
                                                + pPrev->numColours) | PALETTE_MOVED;
 
352
                                                + pPrev->numColors) | PALETTE_MOVED;
314
353
 
315
354
                                        // Q the palette change in position to the video DAC
316
355
                                        if (!TinselV2)
317
356
                                                UpdateDACqueueHandle(pNxtPal->posInDAC,
318
 
                                                        pNxtPal->numColours,
 
357
                                                        pNxtPal->numColors,
319
358
                                                        pNxtPal->hPal);
320
359
                                        else if (!pNxtPal->bFading)
321
360
                                                UpdateDACqueue(pNxtPal->posInDAC,
322
 
                                                        pNxtPal->numColours,
 
361
                                                        pNxtPal->numColors,
323
362
                                                        pNxtPal->palRGB);
324
363
 
325
364
                                        // update previous palette to current palette
332
371
                }
333
372
 
334
373
                // set new DAC index
335
 
                iDAC = p->posInDAC + p->numColours;
 
374
                iDAC = p->posInDAC + p->numColors;
336
375
        }
337
376
 
338
377
        // no free palettes
394
433
        // validate palette Q pointer
395
434
        assert(pPalQ >= palAllocData && pPalQ <= palAllocData + NUM_PALETTES - 1);
396
435
 
397
 
        if (pPalQ->numColours >= (int)FROM_LE_32(pNewPal->numColours)) {
 
436
        if (pPalQ->numColors >= (int)FROM_LE_32(pNewPal->numColors)) {
398
437
                // new palette will fit the slot
399
438
 
400
439
                // install new palette
401
440
                pPalQ->hPal = hNewPal;
402
441
 
403
442
                if (TinselV2) {
404
 
                        pPalQ->numColours = FROM_LE_32(pNewPal->numColours);
 
443
                        pPalQ->numColors = FROM_LE_32(pNewPal->numColors);
405
444
 
406
 
                        // Copy all the colours
407
 
                        memcpy(pPalQ->palRGB, pNewPal->palRGB, FROM_LE_32(pNewPal->numColours) * sizeof(COLORREF));
 
445
                        // Copy all the colors
 
446
                        memcpy(pPalQ->palRGB, pNewPal->palRGB, FROM_LE_32(pNewPal->numColors) * sizeof(COLORREF));
408
447
 
409
448
                        if (!pPalQ->bFading)
410
449
                                // Q the change to the video DAC
411
 
                                UpdateDACqueue(pPalQ->posInDAC, FROM_LE_32(pNewPal->numColours), pPalQ->palRGB);
 
450
                                UpdateDACqueue(pPalQ->posInDAC, FROM_LE_32(pNewPal->numColors), pPalQ->palRGB);
412
451
                } else {
413
452
                        // Q the change to the video DAC
414
 
                        UpdateDACqueueHandle(pPalQ->posInDAC, FROM_LE_32(pNewPal->numColours), hNewPal);
 
453
                        UpdateDACqueueHandle(pPalQ->posInDAC, FROM_LE_32(pNewPal->numColors), hNewPal);
415
454
                }
416
455
        } else {
417
 
                // # colours are different - will have to update all following palette entries
 
456
                // # colors are different - will have to update all following palette entries
418
457
                assert(!TinselV2); // Fatal error for Tinsel 2
419
458
 
420
459
                PALQ *pNxtPalQ;         // next palette queue position
421
460
 
422
461
                for (pNxtPalQ = pPalQ + 1; pNxtPalQ < palAllocData + NUM_PALETTES; pNxtPalQ++) {
423
 
                        if (pNxtPalQ->posInDAC >= pPalQ->posInDAC + pPalQ->numColours)
 
462
                        if (pNxtPalQ->posInDAC >= pPalQ->posInDAC + pPalQ->numColors)
424
463
                                // no need to move palettes down
425
464
                                break;
426
465
 
427
466
                        // move palette down
428
467
                        pNxtPalQ->posInDAC = (pPalQ->posInDAC
429
 
                                + pPalQ->numColours) | PALETTE_MOVED;
 
468
                                + pPalQ->numColors) | PALETTE_MOVED;
430
469
 
431
470
                        // Q the palette change in position to the video DAC
432
471
                        UpdateDACqueueHandle(pNxtPalQ->posInDAC,
433
 
                                pNxtPalQ->numColours,
 
472
                                pNxtPalQ->numColors,
434
473
                                pNxtPalQ->hPal);
435
474
 
436
475
                        // update previous palette to current palette
464
503
}
465
504
 
466
505
/**
467
 
 * Sets the current background colour.
468
 
 * @param colour                        Colour to set the background to
 
506
 * Sets the current background color.
 
507
 * @param color                 Color to set the background to
469
508
 */
470
 
void SetBgndColour(COLORREF colour) {
471
 
        // update background colour struct
472
 
        bgndColour = colour;
473
 
 
474
 
        // Q the change to the video DAC
475
 
        UpdateDACqueue(BGND_DAC_INDEX, 1, &bgndColour);
 
509
void SetBgndColor(COLORREF color) {
 
510
        // update background color struct by queuing the change to the video DAC
 
511
        UpdateDACqueue(BGND_DAC_INDEX, color);
476
512
}
477
513
 
478
514
/**
480
516
 * @param pPalQ                 Palette queue position
481
517
 * @param bFading               Whether it is fading
482
518
 */
483
 
void FadingPalette(PPALQ pPalQ, bool bFading) {
 
519
void FadingPalette(PALQ *pPalQ, bool bFading) {
484
520
        // validate palette Q pointer
485
521
        assert(pPalQ >= palAllocData && pPalQ <= palAllocData + NUM_PALETTES - 1);
486
522
 
495
531
 * palettes are fading.
496
532
 */
497
533
void NoFadingPalettes() {
498
 
        PPALQ pPalQ;
 
534
        PALQ *pPalQ;
499
535
 
500
536
        for (pPalQ = palAllocData; pPalQ <= palAllocData + NUM_PALETTES - 1; pPalQ++) {
501
537
                pPalQ->bFading = false;
510
546
        // get a pointer to the palette
511
547
        PALETTE *pPal = (PALETTE *)LockMem(hPalette);
512
548
 
513
 
        // leave background colour alone
 
549
        // leave background color alone
514
550
        transPalette[0] = 0;
515
551
 
516
 
        for (uint i = 0; i < FROM_LE_32(pPal->numColours); i++) {
517
 
                // get the RGB colour model values
 
552
        for (uint i = 0; i < FROM_LE_32(pPal->numColors); i++) {
 
553
                // get the RGB color model values
518
554
                uint8 red   = TINSEL_GetRValue(pPal->palRGB[i]);
519
555
                uint8 green = TINSEL_GetGValue(pPal->palRGB[i]);
520
556
                uint8 blue  = TINSEL_GetBValue(pPal->palRGB[i]);
521
557
 
522
 
                // calculate the Value field of the HSV colour model
 
558
                // calculate the Value field of the HSV color model
523
559
                unsigned val = (red > green) ? red : green;
524
560
                val = (val > blue) ? val : blue;
525
561
 
526
 
                // map the Value field to one of the 4 colours reserved for the translucent palette
 
562
                // map the Value field to one of the 4 colors reserved for the translucent palette
527
563
                val /= 63;
528
564
                transPalette[i + 1] = (uint8)((val == 0) ? 0 : val +
529
 
                        (TinselV2 ? TranslucentColour() : COL_HILIGHT) - 1);
 
565
                        (TinselV2 ? TranslucentColor() : COL_HILIGHT) - 1);
530
566
        }
531
567
}
532
568
 
538
574
        PALETTE *pPal = (PALETTE *)LockMem(hPalette);
539
575
        int i;
540
576
 
541
 
        // leave background colour alone
 
577
        // leave background color alone
542
578
        ghostPalette[0] = 0;
543
579
 
544
 
        for (i = 0; i < (int)FROM_LE_32(pPal->numColours); i++) {
545
 
                // get the RGB colour model values
 
580
        for (i = 0; i < (int)FROM_LE_32(pPal->numColors); i++) {
 
581
                // get the RGB color model values
546
582
                uint8 red   = TINSEL_GetRValue(pPal->palRGB[i]);
547
583
                uint8 green = TINSEL_GetGValue(pPal->palRGB[i]);
548
584
                uint8 blue  = TINSEL_GetBValue(pPal->palRGB[i]);
549
585
 
550
 
                // calculate the Value field of the HSV colour model
 
586
                // calculate the Value field of the HSV color model
551
587
                unsigned val = (red > green) ? red : green;
552
588
                val = (val > blue) ? val : blue;
553
589
 
554
 
                // map the Value field to one of the 4 colours reserved for the translucent palette
 
590
                // map the Value field to one of the 4 colors reserved for the translucent palette
555
591
                val /= 64;
556
592
                assert(/*val >= 0 &&*/ val <= 3);
557
593
                ghostPalette[i + 1] = (uint8)(val + SysVar(ISV_GHOST_BASE));
560
596
 
561
597
 
562
598
/**
563
 
 * Returns an adjusted colour RGB
564
 
 * @param colour                Colour to scale
 
599
 * Returns an adjusted color RGB
 
600
 * @param color         Color to scale
565
601
 */
566
 
static COLORREF DimColour(COLORREF colour, int factor) {
 
602
static COLORREF DimColor(COLORREF color, int factor) {
567
603
        uint32 red, green, blue;
568
604
 
569
605
        if (factor == 10) {
570
606
                // No change
571
 
                return colour;
 
607
                return color;
572
608
        } else if (factor == 0) {
573
609
                // No brightness
574
610
                return 0;
575
611
        } else {
576
612
                // apply multiplier to RGB components
577
 
                red   = TINSEL_GetRValue(colour) * factor / 10;
578
 
                green = TINSEL_GetGValue(colour) * factor / 10;
579
 
                blue  = TINSEL_GetBValue(colour) * factor / 10;
 
613
                red   = TINSEL_GetRValue(color) * factor / 10;
 
614
                green = TINSEL_GetGValue(color) * factor / 10;
 
615
                blue  = TINSEL_GetBValue(color) * factor / 10;
580
616
 
581
 
                // return new colour
 
617
                // return new color
582
618
                return TINSEL_RGB(red, green, blue);
583
619
        }
584
620
}
586
622
/**
587
623
 * DimPartPalette
588
624
 */
589
 
void DimPartPalette(SCNHANDLE hDimPal, int startColour, int length, int brightness) {
 
625
void DimPartPalette(SCNHANDLE hDimPal, int startColor, int length, int brightness) {
590
626
        PALQ *pPalQ;
591
627
        PALETTE *pDimPal;
592
 
        int iColour;
 
628
        int iColor;
593
629
 
594
630
        pPalQ = FindPalette(hDimPal);
595
631
        assert(pPalQ);
597
633
        // get pointer to dim palette
598
634
        pDimPal = (PALETTE *)LockMem(hDimPal);
599
635
 
600
 
        // Adjust for the fact that palettes don't contain colour 0
601
 
        startColour -= 1;
 
636
        // Adjust for the fact that palettes don't contain color 0
 
637
        startColor -= 1;
602
638
 
603
639
        // Check some other things
604
 
        if (startColour + length > pPalQ->numColours)
605
 
                error("DimPartPalette(): colour overrun");
 
640
        if (startColor + length > pPalQ->numColors)
 
641
                error("DimPartPalette(): color overrun");
606
642
 
607
 
        for (iColour = startColour ; iColour < startColour + length; iColour++) {
608
 
                pPalQ->palRGB[iColour] = DimColour(pDimPal->palRGB[iColour], brightness);
 
643
        for (iColor = startColor; iColor < startColor + length; iColor++) {
 
644
                pPalQ->palRGB[iColor] = DimColor(pDimPal->palRGB[iColor], brightness);
609
645
        }
610
646
 
611
647
        if (!pPalQ->bFading) {
612
648
                // Q the change to the video DAC
613
 
                UpdateDACqueue(pPalQ->posInDAC + startColour, length, &pPalQ->palRGB[startColour]);
 
649
                UpdateDACqueue(pPalQ->posInDAC + startColor, length, &pPalQ->palRGB[startColor]);
614
650
        }
615
651
}
616
652
 
617
 
int TranslucentColour() {
 
653
int TranslucentColor() {
618
654
        return translucentIndex;
619
655
}
620
656
 
621
 
int HighlightColour() {
622
 
        static COLORREF cRef;
623
 
 
624
 
        cRef = (COLORREF)SysVar(SYS_HighlightRGB);
625
 
        UpdateDACqueue(talkIndex, 1, &cRef);
 
657
int HighlightColor() {
 
658
        UpdateDACqueue(talkIndex, (COLORREF)SysVar(SYS_HighlightRGB));
626
659
 
627
660
        return talkIndex;
628
661
}
629
662
 
630
 
int TalkColour() {
 
663
int TalkColor() {
631
664
        return TinselV2 ? talkIndex : TALKFONT_COL;
632
665
}
633
666
 
634
 
void SetTalkColourRef(COLORREF colRef) {
 
667
void SetTalkColorRef(COLORREF colRef) {
635
668
        talkColRef = colRef;
636
669
}
637
670
 
638
 
COLORREF GetTalkColourRef() {
 
671
COLORREF GetTalkColorRef() {
639
672
        return talkColRef;
640
673
}
641
674