[Scummvm-cvs-logs] CVS: scummvm/scumm cursor.cpp,NONE,2.1 palette.cpp,NONE,2.1 bomp.h,2.5,2.6 gfx.cpp,2.247,2.248 module.mk,1.27,1.28
Max Horn
fingolfin at users.sourceforge.net
Sun Jan 4 06:37:56 CET 2004
Update of /cvsroot/scummvm/scummvm/scumm
In directory sc8-pr-cvs1:/tmp/cvs-serv8581
Modified Files:
bomp.h gfx.cpp module.mk
Added Files:
cursor.cpp palette.cpp
Log Message:
split out cursor/palette code into separate source files
--- NEW FILE: cursor.cpp ---
/* ScummVM - Scumm Interpreter
* Copyright (C) 2001 Ludvig Strigeus
* Copyright (C) 2001-2003 The ScummVM project
*
* 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 2
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* $Header: /cvsroot/scummvm/scummvm/scumm/cursor.cpp,v 2.1 2004/01/04 14:35:31 fingolfin Exp $
*
*/
#include "stdafx.h"
#include "scumm/bomp.h"
#include "scumm/scumm.h"
namespace Scumm {
/*
* Mouse cursor cycle colors (for the default crosshair).
*/
static const byte default_v1_cursor_colors[4] = {
1, 1, 12, 11
};
static const byte default_cursor_colors[4] = {
15, 15, 7, 8
};
static const uint16 default_cursor_images[5][16] = {
/* cross-hair */
{ 0x0080, 0x0080, 0x0080, 0x0080, 0x0080, 0x0080, 0x0000, 0x7e3f,
0x0000, 0x0080, 0x0080, 0x0080, 0x0080, 0x0080, 0x0080, 0x0000 },
/* hourglass */
{ 0x0000, 0x7ffe, 0x6006, 0x300c, 0x1818, 0x0c30, 0x0660, 0x03c0,
0x0660, 0x0c30, 0x1998, 0x33cc, 0x67e6, 0x7ffe, 0x0000, 0x0000 },
/* arrow */
{ 0x0000, 0x4000, 0x6000, 0x7000, 0x7800, 0x7c00, 0x7e00, 0x7f00,
0x7f80, 0x78c0, 0x7c00, 0x4600, 0x0600, 0x0300, 0x0300, 0x0180 },
/* hand */
{ 0x1e00, 0x1200, 0x1200, 0x1200, 0x1200, 0x13ff, 0x1249, 0x1249,
0xf249, 0x9001, 0x9001, 0x9001, 0x8001, 0x8001, 0x8001, 0xffff },
/* cross-hair zak256 - chrilith palmos */
/*
{ 0x0080, 0x0080, 0x02a0, 0x01c0, 0x0080, 0x1004, 0x0808, 0x7c1f,
0x0808, 0x1004, 0x0080, 0x01c0, 0x02a0, 0x0080, 0x0080, 0x0000 },
*/
{ 0x0080, 0x02a0, 0x01c0, 0x0080, 0x0000, 0x2002, 0x1004, 0x780f,
0x1004, 0x2002, 0x0000, 0x0080, 0x01c0, 0x02a0, 0x0080, 0x0000 },
};
static const byte default_cursor_hotspots[10] = {
8, 7, 8, 7, 1, 1, 5, 0,
8, 7, //zak256
};
void ScummEngine::setupCursor() {
_cursor.animate = 1;
if (_gameId == GID_TENTACLE && res.roomno[rtRoom][60]) {
// HACK: For DOTT we manually set the default cursor. See also bug #786994
setCursorImg(697, 60, 1);
makeCursorColorTransparent(1);
}
}
void ScummEngine::grabCursor(int x, int y, int w, int h) {
VirtScreen *vs = findVirtScreen(y);
if (vs == NULL) {
warning("grabCursor: invalid Y %d", y);
return;
}
grabCursor(vs->screenPtr + (y - vs->topline) * vs->width + x, w, h);
}
void ScummEngine::grabCursor(byte *ptr, int width, int height) {
uint size;
byte *dst;
size = width * height;
if (size > sizeof(_grabbedCursor))
error("grabCursor: grabbed cursor too big");
_cursor.width = width;
_cursor.height = height;
_cursor.animate = 0;
dst = _grabbedCursor;
for (; height; height--) {
memcpy(dst, ptr, width);
dst += width;
ptr += _screenWidth;
}
updateCursor();
}
void ScummEngine::useIm01Cursor(const byte *im, int w, int h) {
VirtScreen *vs = &virtscr[0];
byte *buf, *dst;
const byte *src;
int i;
w *= 8;
h *= 8;
dst = buf = (byte *) malloc(w * h);
src = vs->screenPtr + vs->xstart;
for (i = 0; i < h; i++) {
memcpy(dst, src, w);
dst += w;
src += vs->width;
}
drawBox(0, 0, w - 1, h - 1, 0xFF);
vs->alloctwobuffers = false;
gdi.disableZBuffer();
gdi.drawBitmap(im, vs, _screenStartStrip, 0, w, h, 0, w / 8, 0);
vs->alloctwobuffers = true;
gdi.enableZBuffer();
grabCursor(vs->screenPtr + vs->xstart, w, h);
src = buf;
dst = vs->screenPtr + vs->xstart;
for (i = 0; i < h; i++) {
memcpy(dst, src, w);
dst += vs->width;
src += w;
}
free(buf);
}
void ScummEngine::setCursor(int cursor) {
if (cursor >= 0 && cursor <= 3)
_currentCursor = cursor;
else
warning("setCursor(%d)", cursor);
}
void ScummEngine::setCursorHotspot(int x, int y) {
_cursor.hotspotX = x;
_cursor.hotspotY = y;
// FIXME this hacks around offset cursor in the humongous games
if (_features & GF_HUMONGOUS) {
_cursor.hotspotX += 15;
_cursor.hotspotY += 15;
}
}
void ScummEngine::updateCursor() {
_system->set_mouse_cursor(_grabbedCursor, _cursor.width, _cursor.height,
_cursor.hotspotX, _cursor.hotspotY);
}
void ScummEngine::animateCursor() {
if (_cursor.animate) {
if (!(_cursor.animateIndex & 0x1)) {
decompressDefaultCursor((_cursor.animateIndex >> 1) & 3);
}
_cursor.animateIndex++;
}
}
void ScummEngine::useBompCursor(const byte *im, int width, int height) {
uint size;
width *= 8;
height *= 8;
size = width * height;
if (size > sizeof(_grabbedCursor))
error("useBompCursor: cursor too big (%d)", size);
_cursor.width = width;
_cursor.height = height;
_cursor.animate = 0;
// Skip the header
if (_version == 8) {
im += 16;
} else {
im += 18;
}
decompressBomp(_grabbedCursor, im, width, height);
updateCursor();
}
void ScummEngine::decompressDefaultCursor(int idx) {
int i, j;
byte color;
memset(_grabbedCursor, 0xFF, sizeof(_grabbedCursor));
if (_version == 1)
color = default_v1_cursor_colors[idx];
else
color = default_cursor_colors[idx];
// FIXME: None of the stock cursors are right for Loom. Why is that?
if (_gameId == GID_LOOM || _gameId == GID_LOOM256) {
int w = 0;
_cursor.width = 8;
_cursor.height = 8;
_cursor.hotspotX = 0;
_cursor.hotspotY = 0;
for (i = 0; i < 8; i++) {
w += (i >= 6) ? -2 : 1;
for (j = 0; j < w; j++)
_grabbedCursor[i * 8 + j] = color;
}
} else if (_version <= 2) {
_cursor.width = 23;
_cursor.height = 21;
_cursor.hotspotX = 11;
_cursor.hotspotY = 10;
byte *hotspot = _grabbedCursor + _cursor.hotspotY * _cursor.width + _cursor.hotspotX;
// Crosshair, slightly assymetric
for (i = 0; i < 7; i++) {
*(hotspot - 5 - i) = color;
*(hotspot + 5 + i) = color;
}
for (i = 0; i < 8; i++) {
*(hotspot - _cursor.width * (3 + i)) = color;
*(hotspot + _cursor.width * (3 + i)) = color;
}
// Arrow heads, diagonal lines
for (i = 1; i <= 3; i++) {
*(hotspot - _cursor.width * i - 5 - i) = color;
*(hotspot + _cursor.width * i - 5 - i) = color;
*(hotspot - _cursor.width * i + 5 + i) = color;
*(hotspot + _cursor.width * i + 5 + i) = color;
*(hotspot - _cursor.width * (i + 3) - i) = color;
*(hotspot - _cursor.width * (i + 3) + i) = color;
*(hotspot + _cursor.width * (i + 3) - i) = color;
*(hotspot + _cursor.width * (i + 3) + i) = color;
}
// Final touches
*(hotspot - _cursor.width - 7) = color;
*(hotspot - _cursor.width + 7) = color;
*(hotspot + _cursor.width - 7) = color;
*(hotspot + _cursor.width + 7) = color;
*(hotspot - (_cursor.width * 5) - 1) = color;
*(hotspot - (_cursor.width * 5) + 1) = color;
*(hotspot + (_cursor.width * 5) - 1) = color;
*(hotspot + (_cursor.width * 5) + 1) = color;
} else {
byte currentCursor = _currentCursor;
#ifdef __PALM_OS__
if (_gameId == GID_ZAK256 && currentCursor == 0)
currentCursor = 4;
#endif
_cursor.width = 16;
_cursor.height = 16;
_cursor.hotspotX = default_cursor_hotspots[2 * currentCursor];
_cursor.hotspotY = default_cursor_hotspots[2 * currentCursor + 1];
for (i = 0; i < 16; i++) {
for (j = 0; j < 16; j++) {
if (default_cursor_images[currentCursor][i] & (1 << j))
_grabbedCursor[16 * i + 15 - j] = color;
}
}
}
updateCursor();
}
void ScummEngine::makeCursorColorTransparent(int a) {
int i, size;
size = _cursor.width * _cursor.height;
for (i = 0; i < size; i++)
if (_grabbedCursor[i] == (byte)a)
_grabbedCursor[i] = 0xFF;
updateCursor();
}
} // End of namespace Scumm
--- NEW FILE: palette.cpp ---
/* ScummVM - Scumm Interpreter
* Copyright (C) 2001 Ludvig Strigeus
* Copyright (C) 2001-2003 The ScummVM project
*
* 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 2
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* $Header: /cvsroot/scummvm/scummvm/scumm/palette.cpp,v 2.1 2004/01/04 14:35:31 fingolfin Exp $
*
*/
#include "stdafx.h"
#include "common/util.h"
#include "scumm/scumm.h"
#include "scumm/intern.h"
#include "scumm/resource.h"
namespace Scumm {
void ScummEngine::setupAmigaPalette() {
setPalColor( 0, 0, 0, 0);
setPalColor( 1, 0, 0, 187);
setPalColor( 2, 0, 187, 0);
setPalColor( 3, 0, 187, 187);
setPalColor( 4, 187, 0, 0);
setPalColor( 5, 187, 0, 187);
setPalColor( 6, 187, 119, 0);
setPalColor( 7, 187, 187, 187);
setPalColor( 8, 119, 119, 119);
setPalColor( 9, 119, 119, 255);
setPalColor(10, 0, 255, 0);
setPalColor(11, 0, 255, 255);
setPalColor(12, 255, 136, 136);
setPalColor(13, 255, 0, 255);
setPalColor(14, 255, 255, 0);
setPalColor(15, 255, 255, 255);
}
void ScummEngine::setupEGAPalette() {
setPalColor( 0, 0, 0, 0);
setPalColor( 1, 0, 0, 168);
setPalColor( 2, 0, 168, 0);
setPalColor( 3, 0, 168, 168);
setPalColor( 4, 168, 0, 0);
setPalColor( 5, 168, 0, 168);
setPalColor( 6, 168, 84, 0);
setPalColor( 7, 168, 168, 168);
setPalColor( 8, 84, 84, 84);
setPalColor( 9, 84, 84, 252);
setPalColor(10, 84, 252, 84);
setPalColor(11, 84, 252, 252);
setPalColor(12, 252, 84, 84);
setPalColor(13, 252, 84, 252);
setPalColor(14, 252, 252, 84);
setPalColor(15, 252, 252, 252);
}
void ScummEngine::setupV1ManiacPalette() {
setPalColor( 0, 0, 0, 0);
setPalColor( 1, 252, 252, 252);
setPalColor( 2, 168, 0, 0);
setPalColor( 3, 0, 168, 168);
setPalColor( 4, 168, 0, 168);
setPalColor( 5, 0, 168, 0);
setPalColor( 6, 0, 0, 168);
setPalColor( 7, 252, 252, 84);
setPalColor( 8, 252, 84, 84);
setPalColor( 9, 168, 84, 0);
setPalColor(10, 252, 84, 84);
setPalColor(11, 84, 84, 84);
setPalColor(12, 168, 168, 168);
setPalColor(13, 84, 252, 84);
setPalColor(14, 84, 84, 252);
setPalColor(15, 84, 84, 84);
setPalColor(16, 252, 84, 252);
}
void ScummEngine::setupV1ZakPalette() {
setPalColor( 0, 0, 0, 0);
setPalColor( 1, 252, 252, 252);
setPalColor( 2, 168, 0, 0);
setPalColor( 3, 0, 168, 168);
setPalColor( 4, 168, 0, 168);
setPalColor( 5, 0, 168, 0);
setPalColor( 6, 0, 0, 168);
setPalColor( 7, 252, 252, 84);
setPalColor( 8, 252, 84, 84);
setPalColor( 9, 168, 84, 0);
setPalColor(10, 252, 84, 84);
setPalColor(11, 84, 84, 84);
setPalColor(12, 168, 168, 168);
setPalColor(13, 84, 252, 84);
setPalColor(14, 84, 84, 252);
setPalColor(15, 168, 168, 168);
setPalColor(16, 252, 84, 252);
}
void ScummEngine::setPaletteFromPtr(const byte *ptr) {
int i;
byte *dest, r, g, b;
int numcolor;
if (_features & GF_SMALL_HEADER) {
if (_features & GF_OLD256)
numcolor = 256;
else
numcolor = READ_LE_UINT16(ptr + 6) / 3;
ptr += 8;
} else {
numcolor = getResourceDataSize(ptr) / 3;
}
checkRange(256, 0, numcolor, "Too many colors (%d) in Palette");
dest = _currentPalette;
for (i = 0; i < numcolor; i++) {
r = *ptr++;
g = *ptr++;
b = *ptr++;
// This comparison might look weird, but it's what the disassembly (DOTT) says!
// FIXME: Fingolfin still thinks it looks weird: the value 252 = 4*63 clearly comes from
// the days 6/6/6 palettes were used, OK. But it breaks MonkeyVGA, so I had to add a
// check for that. And somebody before me added a check for V7 games, turning this
// off there, too... I wonder if it hurts other games, too? What exactly is broken
// if we remove this patch?
// Since it also causes problems in Zak256, I am turning it off for all V4 games and older.
if ((_version <= 4) || (_version >= 7) || (i <= 15 || r < 252 || g < 252 || b < 252)) {
*dest++ = r;
*dest++ = g;
*dest++ = b;
} else {
dest += 3;
}
}
setDirtyColors(0, numcolor - 1);
}
void ScummEngine::setPaletteFromRes() {
byte *ptr;
ptr = getResourceAddress(rtRoom, _roomResource) + _CLUT_offs;
setPaletteFromPtr(ptr);
}
void ScummEngine::setDirtyColors(int min, int max) {
if (_palDirtyMin > min)
_palDirtyMin = min;
if (_palDirtyMax < max)
_palDirtyMax = max;
}
void ScummEngine::initCycl(const byte *ptr) {
int j;
ColorCycle *cycl;
memset(_colorCycle, 0, sizeof(_colorCycle));
if (_features & GF_SMALL_HEADER) {
cycl = _colorCycle;
ptr += 6;
for (j = 0; j < 16; ++j, ++cycl) {
uint16 delay = READ_BE_UINT16(ptr);
ptr += 2;
byte start = *ptr++;
byte end = *ptr++;
if (!delay || delay == 0x0aaa || start >= end)
continue;
cycl->counter = 0;
cycl->delay = 16384 / delay;
cycl->flags = 2;
cycl->start = start;
cycl->end = end;
}
} else {
while ((j = *ptr++) != 0) {
if (j < 1 || j > 16) {
error("Invalid color cycle index %d", j);
}
cycl = &_colorCycle[j - 1];
ptr += 2;
cycl->counter = 0;
cycl->delay = 16384 / READ_BE_UINT16(ptr);
ptr += 2;
cycl->flags = READ_BE_UINT16(ptr);
ptr += 2;
cycl->start = *ptr++;
cycl->end = *ptr++;
}
}
}
void ScummEngine::stopCycle(int i) {
ColorCycle *cycl;
checkRange(16, 0, i, "Stop Cycle %d Out Of Range");
if (i != 0) {
_colorCycle[i - 1].delay = 0;
return;
}
for (i = 0, cycl = _colorCycle; i < 16; i++, cycl++)
cycl->delay = 0;
}
/**
* Cycle the colors in the given palette in the intervael [cycleStart, cycleEnd]
* either one step forward or backward.
*/
static void doCyclePalette(byte *palette, int cycleStart, int cycleEnd, int size, bool forward) {
byte *start = palette + cycleStart * size;
byte *end = palette + cycleEnd * size;
int num = cycleEnd - cycleStart;
byte tmp[6];
assert(size <= 6);
if (forward) {
memmove(tmp, end, size);
memmove(start + size, start, num * size);
memmove(start, tmp, size);
} else {
memmove(tmp, start, size);
memmove(start, start + size, num * size);
memmove(end, tmp, size);
}
}
/**
* Adjust an 'indirect' color palette for the color cycling performed on its
* master palette. An indirect palette is a palette which contains indices
* pointing into another palette - it provides a level of indirection to map
* palette colors to other colors. Now when the target palette is cycled, the
* indirect palette suddenly point at the wrong color(s). This function takes
* care of adjusting an indirect palette by searching through it and replacing
* all indices that are in the cycle range by the new (cycled) index.
*
* Finally, the palette entries still have to be cycled normally.
*/
static void doCycleIndirectPalette(byte *palette, int cycleStart, int cycleEnd, bool forward) {
int num = cycleEnd - cycleStart + 1;
int i;
int offset = forward ? 1 : num - 1;
for (i = 0; i < 256; i++) {
if (cycleStart <= palette[i] && palette[i] <= cycleEnd) {
palette[i] = (palette[i] - cycleStart + offset) % num + cycleStart;
}
}
doCyclePalette(palette, cycleStart, cycleEnd, 1, forward);
}
void ScummEngine::cyclePalette() {
ColorCycle *cycl;
int valueToAdd;
int i, j;
if (VAR_TIMER == 0xFF) {
// FIXME - no idea if this is right :-/
// Needed for both V2 and V8 at this time
valueToAdd = VAR(VAR_TIMER_NEXT);
} else {
valueToAdd = VAR(VAR_TIMER);
if (valueToAdd < VAR(VAR_TIMER_NEXT))
valueToAdd = VAR(VAR_TIMER_NEXT);
}
if (!_colorCycle) // FIXME
return;
for (i = 0, cycl = _colorCycle; i < 16; i++, cycl++) {
if (!cycl->delay || cycl->start > cycl->end)
continue;
cycl->counter += valueToAdd;
if (cycl->counter >= cycl->delay) {
cycl->counter %= cycl->delay;
setDirtyColors(cycl->start, cycl->end);
moveMemInPalRes(cycl->start, cycl->end, cycl->flags & 2);
if (!(_features & GF_SMALL_HEADER && _version > 2))
doCyclePalette(_currentPalette, cycl->start, cycl->end, 3, !(cycl->flags & 2));
// Also cycle the other, indirect palettes
if (_proc_special_palette) {
doCycleIndirectPalette(_proc_special_palette, cycl->start, cycl->end, !(cycl->flags & 2));
}
if (_shadowPalette) {
if (_version >= 7) {
for (j = 0; j < NUM_SHADOW_PALETTE; j++)
doCycleIndirectPalette(_shadowPalette + j * 256, cycl->start, cycl->end, !(cycl->flags & 2));
} else {
doCycleIndirectPalette(_shadowPalette, cycl->start, cycl->end, !(cycl->flags & 2));
}
}
}
}
}
/**
* Perform color cycling on the palManipulate data, too, otherwise
* color cycling will be disturbed by the palette fade.
*/
void ScummEngine::moveMemInPalRes(int start, int end, byte direction) {
if (!_palManipCounter)
return;
doCyclePalette(_palManipPalette, start, end, 3, !direction);
doCyclePalette(_palManipIntermediatePal, start, end, 6, !direction);
}
void ScummEngine::palManipulateInit(int resID, int start, int end, int time) {
byte *pal, *target, *between;
byte *string1, *string2, *string3;
int i;
string1 = getStringAddress(resID);
string2 = getStringAddress(resID + 1);
string3 = getStringAddress(resID + 2);
if (!string1 || !string2 || !string3) {
warning("palManipulateInit(%d,%d,%d,%d): Cannot obtain string resources %d, %d and %d",
resID, start, end, time, resID, resID + 1, resID + 2);
return;
}
string1 += start;
string2 += start;
string3 += start;
_palManipStart = start;
_palManipEnd = end;
_palManipCounter = 0;
if (!_palManipPalette)
_palManipPalette = (byte *)calloc(0x300, 1);
if (!_palManipIntermediatePal)
_palManipIntermediatePal = (byte *)calloc(0x600, 1);
pal = _currentPalette + start * 3;
target = _palManipPalette + start * 3;
between = _palManipIntermediatePal + start * 6;
for (i = start; i < end; ++i) {
*target++ = *string1++;
*target++ = *string2++;
*target++ = *string3++;
*(uint16 *)between = ((uint16) *pal++) << 8;
between += 2;
*(uint16 *)between = ((uint16) *pal++) << 8;
between += 2;
*(uint16 *)between = ((uint16) *pal++) << 8;
between += 2;
}
_palManipCounter = time;
}
void ScummEngine_v6::palManipulateInit(int resID, int start, int end, int time) {
byte *pal, *target, *between;
const byte *new_pal;
int i;
new_pal = getPalettePtr(resID);
new_pal += start*3;
_palManipStart = start;
_palManipEnd = end;
_palManipCounter = 0;
if (!_palManipPalette)
_palManipPalette = (byte *)calloc(0x300, 1);
if (!_palManipIntermediatePal)
_palManipIntermediatePal = (byte *)calloc(0x600, 1);
pal = _currentPalette + start * 3;
target = _palManipPalette + start * 3;
between = _palManipIntermediatePal + start * 6;
for (i = start; i < end; ++i) {
*target++ = *new_pal++;
*target++ = *new_pal++;
*target++ = *new_pal++;
*(uint16 *)between = ((uint16) *pal++) << 8;
between += 2;
*(uint16 *)between = ((uint16) *pal++) << 8;
between += 2;
*(uint16 *)between = ((uint16) *pal++) << 8;
between += 2;
}
_palManipCounter = time;
}
void ScummEngine::palManipulate() {
byte *target, *pal, *between;
int i, j;
if (!_palManipCounter || !_palManipPalette || !_palManipIntermediatePal)
return;
target = _palManipPalette + _palManipStart * 3;
pal = _currentPalette + _palManipStart * 3;
between = _palManipIntermediatePal + _palManipStart * 6;
for (i = _palManipStart; i < _palManipEnd; ++i) {
j = (*((uint16 *)between) += ((*target++ << 8) - *((uint16 *)between)) / _palManipCounter);
*pal++ = j >> 8;
between += 2;
j = (*((uint16 *)between) += ((*target++ << 8) - *((uint16 *)between)) / _palManipCounter);
*pal++ = j >> 8;
between += 2;
j = (*((uint16 *)between) += ((*target++ << 8) - *((uint16 *)between)) / _palManipCounter);
*pal++ = j >> 8;
between += 2;
}
setDirtyColors(_palManipStart, _palManipEnd);
_palManipCounter--;
}
void ScummEngine::setupShadowPalette(int slot, int redScale, int greenScale, int blueScale, int startColor, int endColor) {
byte *table;
int i;
byte *curpal;
if (slot < 0 || slot >= NUM_SHADOW_PALETTE)
error("setupShadowPalette: invalid slot %d", slot);
if (startColor < 0 || startColor > 255 || endColor < 0 || startColor > 255 || endColor < startColor)
error("setupShadowPalette: invalid range from %d to %d", startColor, endColor);
table = _shadowPalette + slot * 256;
for (i = 0; i < 256; i++)
table[i] = i;
table += startColor;
curpal = _currentPalette + startColor * 3;
for (i = startColor; i <= endColor; i++) {
*table++ = remapPaletteColor((curpal[0] * redScale) >> 8,
(curpal[1] * greenScale) >> 8,
(curpal[2] * blueScale) >> 8,
(uint) - 1);
curpal += 3;
}
}
static inline uint colorWeight(int red, int green, int blue) {
return 3 * red * red + 6 * green * green + 2 * blue * blue;
}
void ScummEngine::setupShadowPalette(int redScale, int greenScale, int blueScale, int startColor, int endColor) {
const byte *basepal = getPalettePtr(_curPalIndex);
const byte *pal = basepal;
const byte *compareptr;
byte *table = _shadowPalette;
int i;
// This is a correction of the patch supplied for BUG #588501.
// It has been tested in all four known rooms where unkRoomFunc3 is used:
//
// 1) FOA Room 53: subway departing Knossos for Atlantis.
// 2) FOA Room 48: subway crashing into the Atlantis entrance area
// 3) FOA Room 82: boat/sub shadows while diving near Thera
// 4) FOA Room 23: the big machine room inside Atlantis
//
// The implementation behaves well in all tests.
// Pixel comparisons show that the resulting palette entries being
// derived from the shadow palette generated here occassionally differ
// slightly from the ones derived in the LEC executable.
// Not sure yet why, but the differences are VERY minor.
//
// There seems to be no explanation for why this function is called
// from within Room 23 (the big machine), as it has no shadow effects
// and thus doesn't result in any visual differences.
for (i = 0; i <= 255; i++) {
int r = (int) (*pal++ * redScale) >> 8;
int g = (int) (*pal++ * greenScale) >> 8;
int b = (int) (*pal++ * blueScale) >> 8;
// The following functionality is similar to remapPaletteColor, except
// 1) we have to work off the original CLUT rather than the current palette, and
// 2) the target shadow palette entries must be bounded to the upper and lower
// bounds provided by the opcode. (This becomes significant in Room 48, but
// is not an issue in all other known case studies.)
int j;
int ar, ag, ab;
uint sum, bestsum, bestitem = 0;
if (r > 255)
r = 255;
if (g > 255)
g = 255;
if (b > 255)
b = 255;
bestsum = (uint)-1;
r &= ~3;
g &= ~3;
b &= ~3;
compareptr = basepal + startColor * 3;
for (j = startColor; j <= endColor; j++, compareptr += 3) {
ar = compareptr[0] & ~3;
ag = compareptr[1] & ~3;
ab = compareptr[2] & ~3;
if (ar == r && ag == g && ab == b) {
bestitem = j;
break;
}
sum = colorWeight(ar - r, ag - g, ab - b);
if (sum < bestsum) {
bestsum = sum;
bestitem = j;
}
}
*table++ = bestitem;
}
}
/** This function create the specialPalette used for semi-transparency in SamnMax */
void ScummEngine::createSpecialPalette(int16 from, int16 to, int16 redScale, int16 greenScale, int16 blueScale,
int16 startColor, int16 endColor) {
const byte *palPtr, *curPtr;
const byte *searchPtr;
uint bestResult;
uint currentResult;
byte currentIndex;
int i, j;
palPtr = getPalettePtr(_curPalIndex);
for (i = 0; i < 256; i++)
_proc_special_palette[i] = i;
curPtr = palPtr + startColor * 3;
for (i = startColor; i < endColor; i++) {
int r = (int) (*curPtr++ * redScale) >> 8;
int g = (int) (*curPtr++ * greenScale) >> 8;
int b = (int) (*curPtr++ * blueScale) >> 8;
if (r > 255)
r = 255;
if (g > 255)
g = 255;
if (b > 255)
b = 255;
searchPtr = palPtr + from * 3;
bestResult = (uint)-1;
currentIndex = (byte) from;
for (j = from; j <= to; j++) {
int ar = (*searchPtr++);
int ag = (*searchPtr++);
int ab = (*searchPtr++);
currentResult = colorWeight(ar - r, ag - g, ab - b);
if (currentResult < bestResult) {
_proc_special_palette[i] = currentIndex;
bestResult = currentResult;
}
currentIndex++;
}
}
}
void ScummEngine::darkenPalette(int redScale, int greenScale, int blueScale, int startColor, int endColor) {
if (_roomResource == 0) // FIXME - HACK to get COMI demo working
return;
if (startColor <= endColor) {
const byte *cptr;
byte *cur;
int j;
int color;
cptr = getPalettePtr(_curPalIndex) + startColor * 3;
cur = _currentPalette + startColor * 3;
for (j = startColor; j <= endColor; j++) {
// FIXME: Hack to fix Amiga palette adjustments
if ((_features & GF_AMIGA && _version == 5) && (j >= 16 && j < 81)) {
cptr += 3;
cur += 3;
continue;
}
color = *cptr++;
color = color * redScale / 0xFF;
if (color > 255)
color = 255;
*cur++ = color;
color = *cptr++;
color = color * greenScale / 0xFF;
if (color > 255)
color = 255;
*cur++ = color;
color = *cptr++;
color = color * blueScale / 0xFF;
if (color > 255)
color = 255;
*cur++ = color;
}
setDirtyColors(startColor, endColor);
}
}
static int HSL2RGBHelper(int n1, int n2, int hue) {
if (hue > 360)
hue = hue - 360;
else if (hue < 0)
hue = hue + 360;
if (hue < 60)
return n1 + (n2 - n1) * hue / 60;
if (hue < 180)
return n2;
if (hue < 240)
return n1 + (n2 - n1) * (240 - hue) / 60;
return n1;
}
/**
* This function scales the HSL (Hue, Saturation and Lightness)
* components of the palette colors. It's used in CMI when Guybrush
* walks from the beach towards the swamp.
*/
void ScummEngine::desaturatePalette(int hueScale, int satScale, int lightScale, int startColor, int endColor) {
if (startColor <= endColor) {
const byte *cptr;
byte *cur;
int j;
cptr = getPalettePtr(_curPalIndex) + startColor * 3;
cur = _currentPalette + startColor * 3;
for (j = startColor; j <= endColor; j++) {
int R = *cptr++;
int G = *cptr++;
int B = *cptr++;
// RGB to HLS (Foley and VanDam)
const int min = MIN(R, MIN(G, B));
const int max = MAX(R, MAX(G, B));
const int diff = (max - min);
const int sum = (max + min);
if (diff != 0) {
int H, S, L;
if (sum <= 255)
S = 255 * diff / sum;
else
S = 255 * diff / (255 * 2 - sum);
if (R == max)
H = 60 * (G - B) / diff;
else if (G == max)
H = 120 + 60 * (B - R) / diff;
else
H = 240 + 60 * (R - G) / diff;
if (H < 0)
H = H + 360;
// Scale the result
H = (H * hueScale) / 255;
S = (S * satScale) / 255;
L = (sum * lightScale) / 255;
// HLS to RGB (Foley and VanDam)
int m1, m2;
if (L <= 255)
m2 = L * (255 + S) / (255 * 2);
else
m2 = L * (255 - S) / (255 * 2) + S;
m1 = L - m2;
R = HSL2RGBHelper(m1, m2, H + 120);
G = HSL2RGBHelper(m1, m2, H);
B = HSL2RGBHelper(m1, m2, H - 120);
} else {
// Maximal color = minimal color -> R=G=B -> it's a grayscale.
R = G = B = (R * lightScale) / 255;
}
*cur++ = R;
*cur++ = G;
*cur++ = B;
}
setDirtyColors(startColor, endColor);
}
}
int ScummEngine::remapPaletteColor(int r, int g, int b, uint threshold) {
int i;
int ar, ag, ab;
uint sum, bestsum, bestitem = 0;
byte *pal = _currentPalette;
if (r > 255)
r = 255;
if (g > 255)
g = 255;
if (b > 255)
b = 255;
bestsum = (uint) - 1;
r &= ~3;
g &= ~3;
b &= ~3;
for (i = 0; i < 256; i++, pal += 3) {
ar = pal[0] & ~3;
ag = pal[1] & ~3;
ab = pal[2] & ~3;
if (ar == r && ag == g && ab == b)
return i;
sum = colorWeight(ar - r, ag - g, ab - b);
if (sum < bestsum) {
bestsum = sum;
bestitem = i;
}
}
if (threshold != (uint) - 1 && bestsum > colorWeight(threshold, threshold, threshold)) {
// Best match exceeded threshold. Try to find an unused palette entry and
// use it for our purpose.
pal = _currentPalette + (256 - 2) * 3;
for (i = 254; i > 48; i--, pal -= 3) {
if (pal[0] >= 252 && pal[1] >= 252 && pal[2] >= 252) {
setPalColor(i, r, g, b);
return i;
}
}
}
return bestitem;
}
void ScummEngine::swapPalColors(int a, int b) {
byte *ap, *bp;
byte t;
if ((uint) a >= 256 || (uint) b >= 256)
error("swapPalColors: invalid values, %d, %d", a, b);
ap = &_currentPalette[a * 3];
bp = &_currentPalette[b * 3];
t = ap[0];
ap[0] = bp[0];
bp[0] = t;
t = ap[1];
ap[1] = bp[1];
bp[1] = t;
t = ap[2];
ap[2] = bp[2];
bp[2] = t;
setDirtyColors(a, a);
setDirtyColors(b, b);
}
void ScummEngine::copyPalColor(int dst, int src) {
byte *dp, *sp;
if ((uint) dst >= 256 || (uint) src >= 256)
error("copyPalColor: invalid values, %d, %d", dst, src);
dp = &_currentPalette[dst * 3];
sp = &_currentPalette[src * 3];
dp[0] = sp[0];
dp[1] = sp[1];
dp[2] = sp[2];
setDirtyColors(dst, dst);
}
void ScummEngine::setPalColor(int idx, int r, int g, int b) {
_currentPalette[idx * 3 + 0] = r;
_currentPalette[idx * 3 + 1] = g;
_currentPalette[idx * 3 + 2] = b;
setDirtyColors(idx, idx);
}
void ScummEngine::setPalette(int palindex) {
const byte *pals;
_curPalIndex = palindex;
pals = getPalettePtr(_curPalIndex);
setPaletteFromPtr(pals);
}
const byte *ScummEngine::findPalInPals(const byte *pal, int idx) {
const byte *offs;
uint32 size;
pal = findResource(MKID('WRAP'), pal);
if (pal == NULL)
return NULL;
offs = findResourceData(MKID('OFFS'), pal);
if (offs == NULL)
return NULL;
size = getResourceDataSize(offs) / 4;
if ((uint32)idx >= (uint32)size)
return NULL;
return offs + READ_LE_UINT32(offs + idx * sizeof(uint32));
}
const byte *ScummEngine::getPalettePtr(int palindex) {
const byte *cptr;
cptr = getResourceAddress(rtRoom, _roomResource);
assert(cptr);
if (_CLUT_offs) {
cptr += _CLUT_offs;
} else {
cptr = findPalInPals(cptr + _PALS_offs, palindex);
}
assert(cptr);
return cptr;
}
void ScummEngine::updatePalette() {
if (_palDirtyMax == -1)
return;
bool noir_mode = (_gameId == GID_SAMNMAX && readVar(0x8000));
int first = _palDirtyMin;
int num = _palDirtyMax - first + 1;
int i;
byte palette_colors[1024];
byte *p = palette_colors;
for (i = _palDirtyMin; i <= _palDirtyMax; i++) {
byte *data;
if (_features & GF_SMALL_HEADER && _version > 2)
data = _currentPalette + _shadowPalette[i] * 3;
else
data = _currentPalette + i * 3;
// Sam & Max film noir mode. Convert the colours to grayscale
// before uploading them to the backend.
if (noir_mode) {
int r, g, b;
byte brightness;
r = data[0];
g = data[1];
b = data[2];
brightness = (byte)((0.299 * r + 0.587 * g + 0.114 * b) + 0.5);
*p++ = brightness;
*p++ = brightness;
*p++ = brightness;
*p++ = 0;
} else {
*p++ = data[0];
*p++ = data[1];
*p++ = data[2];
*p++ = 0;
}
}
_system->set_palette(palette_colors, first, num);
_palDirtyMax = -1;
_palDirtyMin = 256;
}
} // End of namespace Scumm
Index: bomp.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/bomp.h,v
retrieving revision 2.5
retrieving revision 2.6
diff -u -d -r2.5 -r2.6
--- bomp.h 3 Oct 2003 18:33:53 -0000 2.5
+++ bomp.h 4 Jan 2004 14:35:31 -0000 2.6
@@ -22,6 +22,8 @@
#ifndef BOMP_H
#define BOMP_H
+#include "common/scummsys.h"
+
namespace Scumm {
int32 setupBompScale(byte *scaling, int32 size, byte scale);
Index: gfx.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/gfx.cpp,v
retrieving revision 2.247
retrieving revision 2.248
diff -u -d -r2.247 -r2.248
--- gfx.cpp 4 Jan 2004 13:49:02 -0000 2.247
+++ gfx.cpp 4 Jan 2004 14:35:31 -0000 2.248
@@ -20,12 +20,9 @@
*/
#include "stdafx.h"
-#include "common/util.h"
#include "scumm/scumm.h"
#include "scumm/actor.h"
-#include "scumm/bomp.h"
#include "scumm/charset.h"
-#include "scumm/intern.h"
#include "scumm/resource.h"
#include "scumm/usage_bits.h"
[...1273 lines suppressed...]
- }
- }
- }
-
- updateCursor();
-}
-
-void ScummEngine::makeCursorColorTransparent(int a) {
- int i, size;
-
- size = _cursor.width * _cursor.height;
-
- for (i = 0; i < size; i++)
- if (_grabbedCursor[i] == (byte)a)
- _grabbedCursor[i] = 0xFF;
-
- updateCursor();
}
} // End of namespace Scumm
Index: module.mk
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/module.mk,v
retrieving revision 1.27
retrieving revision 1.28
diff -u -d -r1.27 -r1.28
--- module.mk 6 Dec 2003 05:47:24 -0000 1.27
+++ module.mk 4 Jan 2004 14:35:31 -0000 1.28
@@ -10,6 +10,7 @@
scumm/camera.o \
scumm/charset.o \
scumm/costume.o \
+ scumm/cursor.o \
scumm/debugger.o \
scumm/dialogs.o \
scumm/gfx.o \
@@ -22,6 +23,7 @@
scumm/midiparser_eup.o \
scumm/nut_renderer.o \
scumm/object.o \
+ scumm/palette.o \
scumm/player_mod.o \
scumm/player_v1.o \
scumm/player_v2.o \
More information about the Scummvm-git-logs
mailing list