libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2024-12-16 06:39:17 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
953f7112e3
scummvm/scumm/gfx.cpp
Paweł Kołodziejski 953f7112e3 applied patch: #610954 
svn-id: r4966
2002-09-18 11:48:00 +00:00

3309 lines
69 KiB
C++
Raw Blame History

/* ScummVM - Scumm Interpreter
* Copyright (C) 2001 Ludvig Strigeus
* Copyright (C) 2001/2002 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$
*
*/
#include "stdafx.h"
#include "scumm.h"
#include "actor.h"
#include "gui/gui.h"
#include "gui/newgui.h"
#include "resource.h"
#include "util.h"
enum {
kScrolltime = 500, // ms scrolling is supposed to take
kPictureDelay = 20
};
void Scumm::getGraphicsPerformance()
{
int i;
for (i = 10; i != 0; i--) {
initScreens(0, 0, _realWidth, _realHeight); //ender
}
if (!(_features & GF_SMALL_HEADER)) /* FIXME TEST: Enders Zak fix */
_vars[VAR_PERFORMANCE_1] = 0; //_scummTimer;
for (i = 10; i != 0; i--) {
setDirtyRange(0, 0, _realHeight); //ender
drawDirtyScreenParts();
}
if (!(_features & GF_SMALL_HEADER)) /* FIXME TEST: Enders Zak fix */
_vars[VAR_PERFORMANCE_2] = 0; //_scummTimer;
if (_gameId == GID_DIG)
initScreens(0, 0, _realWidth, _realHeight);
else
initScreens(0, 16, _realWidth, 144);
}
void Scumm::initScreens(int a, int b, int w, int h)
{
int i;
for (i = 0; i < 3; i++) {
nukeResource(rtBuffer, i + 1);
nukeResource(rtBuffer, i + 5);
}
if (!getResourceAddress(rtBuffer, 4)) {
initVirtScreen(3, 0, 80, _realWidth, 13, false, false);
}
initVirtScreen(0, 0, b, _realWidth, h - b, true, true);
initVirtScreen(1, 0, 0, _realWidth, b, false, false);
initVirtScreen(2, 0, h, _realWidth, _realHeight - h, false, false); //ender
_screenB = b;
_screenH = h;
}
void Scumm::initVirtScreen(int slot, int number, int top, int width, int height, bool twobufs,
bool fourextra)
{
VirtScreen *vs = &virtscr[slot];
int size;
int i;
byte *ptr;
assert(height >= 0);
assert(slot >= 0 && slot < 4);
vs->number = slot;
vs->unk1 = 0;
vs->width = _realWidth;
vs->topline = top;
vs->height = height;
vs->alloctwobuffers = twobufs;
vs->scrollable = fourextra;
vs->xstart = 0;
size = vs->width * vs->height;
vs->size = size;
vs->backBuf = NULL;
if (vs->scrollable)
size += _realWidth * 4;
createResource(rtBuffer, slot + 1, size);
vs->screenPtr = getResourceAddress(rtBuffer, slot + 1);
ptr = vs->screenPtr;
for (i = 0; i < size; i++) // reset background ?
*ptr++ = 0;
if (twobufs) {
createResource(rtBuffer, slot + 5, size);
}
if (slot != 3) {
setDirtyRange(slot, 0, height);
}
}
void Scumm::setDirtyRange(int slot, int top, int bottom)
{
int i;
VirtScreen *vs = &virtscr[slot];
for (i = 0; i < NUM_STRIPS; i++) {
vs->tdirty[i] = top;
vs->bdirty[i] = bottom;
}
}
/* power of 2 */
#define NUM_SHAKE_POSITIONS 8
static const int8 shake_positions[NUM_SHAKE_POSITIONS] = {
0, 1 * 2, 2 * 2, 1 * 2, 0 * 2, 2 * 2, 3 * 2, 1 * 2
};
void Scumm::drawDirtyScreenParts()
{
int i;
VirtScreen *vs;
byte *src;
updateDirtyScreen(2);
if (_features & GF_OLD256)
updateDirtyScreen(1);
if ((camera._last.x == camera._cur.x && camera._last.y == camera._cur.y && (_features & GF_AFTER_V7))
|| (camera._last.x == camera._cur.x)) {
updateDirtyScreen(0);
} else {
vs = &virtscr[0];
src = vs->screenPtr + _screenStartStrip * 8 + camera._cur.y - (_realHeight / 2);
_system->copy_rect(src, _realWidth, 0, vs->topline, _realWidth, vs->height);
for (i = 0; i < NUM_STRIPS; i++) {
vs->tdirty[i] = (byte)vs->height;
vs->bdirty[i] = 0;
}
}
/* Handle shaking */
if (_shakeEnabled && !_gui->isActive() && !_newgui->isActive()) {
_shakeFrame = (_shakeFrame + 1) & (NUM_SHAKE_POSITIONS - 1);
_system->set_shake_pos(shake_positions[_shakeFrame]);
} else if (!_shakeEnabled &&_shakeFrame != 0) {
_shakeFrame = 0;
_system->set_shake_pos(shake_positions[_shakeFrame]);
}
}
void Scumm::updateDirtyScreen(int slot)
{
gdi.updateDirtyScreen(&virtscr[slot]);
}
void Gdi::updateDirtyScreen(VirtScreen *vs)
{
int i;
int start, w, top, bottom;
if (vs->height == 0)
return;
_readOffs = 0;
if (vs->scrollable)
_readOffs = vs->xstart;
w = 8;
start = 0;
for (i = 0; i < NUM_STRIPS; i++) {
bottom = vs->bdirty[i];
if (_vm->_features & GF_AFTER_V7 && (_vm->camera._cur.y != _vm->camera._last.y))
drawStripToScreen(vs, start, w, 0, vs->height);
else if (bottom) {
top = vs->tdirty[i];
vs->tdirty[i] = (byte)vs->height;
vs->bdirty[i] = 0;
if (i != (NUM_STRIPS-1) && vs->bdirty[i + 1] == (byte)bottom && vs->tdirty[i + 1] == (byte)top) {
w += 8;
continue;
}
if (_vm->_features & GF_AFTER_V7)
drawStripToScreen(vs, start, w, 0, vs->height);
else
drawStripToScreen(vs, start, w, top, bottom);
w = 8;
}
start = i + 1;
}
}
void Gdi::drawStripToScreen(VirtScreen *vs, int x, int w, int t, int b)
{
byte *ptr;
int scrollY;
int height;
if (b <= t)
return;
if (t > vs->height)
t = 0;
if (b > vs->height)
b = vs->height;
height = b - t;
if (height > _vm->_realHeight)
height = _vm->_realHeight;
scrollY = _vm->camera._cur.y - (_vm->_realHeight / 2);
if (scrollY == -(_vm->_realHeight / 2))
scrollY = 0;
ptr = vs->screenPtr + (t * NUM_STRIPS + x) * 8 + _readOffs + scrollY * _vm->_realWidth;
_vm->_system->copy_rect(ptr, _vm->_realWidth, x * 8, vs->topline + t, w, height);
}
void Scumm::blit(byte *dst, byte *src, int w, int h)
{
assert(h > 0);
assert(src != NULL);
assert(dst != NULL);
do {
memcpy(dst, src, w);
dst += _realWidth;
src += _realWidth;
} while (--h);
}
void Scumm::setCursor(int cursor)
{
warning("setCursor(%d)", cursor);
}
void Scumm::setCameraAt(int pos_x, int pos_y)
{
if (_features & GF_AFTER_V7) {
ScummPoint old;
old = camera._cur;
camera._cur.x = pos_x;
camera._cur.y = pos_y;
clampCameraPos(&camera._cur);
camera._dest = camera._cur;
assert(camera._cur.x >= (_realWidth / 2) && camera._cur.y >= (_realHeight / 2));
if ((camera._cur.x != old.x || camera._cur.y != old.y)
&& _vars[VAR_SCROLL_SCRIPT]) {
_vars[VAR_CAMERA_POS_X] = camera._cur.x;
_vars[VAR_CAMERA_POS_Y] = camera._cur.y;
runScript(_vars[VAR_SCROLL_SCRIPT], 0, 0, 0);
}
} else {
int t;
if (camera._mode != CM_FOLLOW_ACTOR || abs(pos_x - camera._cur.x) > (_realWidth / 2)) {
camera._cur.x = pos_x;
}
camera._dest.x = pos_x;
t = _vars[VAR_CAMERA_MIN_X];
if (camera._cur.x < t)
camera._cur.x = t;
t = _vars[VAR_CAMERA_MAX_X];
if (camera._cur.x > t)
camera._cur.x = t;
if (_vars[VAR_SCROLL_SCRIPT]) {
_vars[VAR_CAMERA_POS_X] = camera._cur.x;
runScript(_vars[VAR_SCROLL_SCRIPT], 0, 0, 0);
}
if (camera._cur.x != camera._last.x && charset._hasMask)
stopTalk();
}
}
void Scumm::setCameraFollows(Actor *a)
{
if (_features & GF_AFTER_V7) {
byte oldfollow = camera._follows;
int ax, ay;
camera._follows = a->number;
if (!a->isInCurrentRoom()) {
startScene(a->getRoom(), 0, 0);
}
ax = abs(a->x - camera._cur.x);
ay = abs(a->y - camera._cur.y);
if (ax > _vars[VAR_CAMERA_THRESHOLD_X] || ay > _vars[VAR_CAMERA_THRESHOLD_Y] || ax > (_realWidth / 2) || ay > (_realHeight / 2)) {
setCameraAt(a->x, a->y);
}
if (a->number != oldfollow)
runHook(0);
} else {
int t, i;
camera._mode = CM_FOLLOW_ACTOR;
camera._follows = a->number;
if (!a->isInCurrentRoom()) {
startScene(a->getRoom(), 0, 0);
camera._mode = CM_FOLLOW_ACTOR;
camera._cur.x = a->x;
setCameraAt(camera._cur.x, 0);
}
t = (a->x >> 3);
if (t - _screenStartStrip < camera._leftTrigger || t - _screenStartStrip > camera._rightTrigger)
setCameraAt(a->x, 0);
for (i = 1, a = getFirstActor(); ++a, i < NUM_ACTORS; i++) {
if (a->isInCurrentRoom())
a->needRedraw = true;
}
runHook(0);
}
}
void Scumm::initBGBuffers(int height)
{
byte *ptr;
int size, itemsize, i;
byte *room;
if (_features & GF_AFTER_V7) {
initVirtScreen(0, 0, virtscr[0].topline, _realHeight, height, 1, 1);
}
room = getResourceAddress(rtRoom, _roomResource);
if (_features & GF_OLD256) {
// FIXME - maybe this should check for multiple planes like we do
// for GF_SMALL_HEADER already.
gdi._numZBuffer = 2;
} else if (_features & GF_SMALL_HEADER) {
//#define DEBUG_ZPLANE_CODE
ptr = findResourceData(MKID('SMAP'), room);
#ifdef DEBUG_ZPLANE_CODE
printf("Trying to determine room zplanes:\n");
hexdump(ptr-6, 0x20);
#endif
int off;
gdi._numZBuffer = 0;
off = READ_LE_UINT32(ptr);
for (i = 0; off && (i < 4); i++) {
#ifdef DEBUG_ZPLANE_CODE
printf("Plane %d\n", i);
hexdump(ptr, 0x20);
#endif
gdi._numZBuffer++;
ptr += off;
off = READ_LE_UINT16(ptr);
}
#ifdef DEBUG_ZPLANE_CODE
printf("Real plane count = %d\n", gdi._numZBuffer);
#endif
} else {
ptr = findResource(MKID('RMIH'), findResource(MKID('RMIM'), room));
gdi._numZBuffer = READ_LE_UINT16(ptr + 8) + 1;
}
assert(gdi._numZBuffer >= 1 && gdi._numZBuffer <= 5);
if (_features & GF_AFTER_V7)
itemsize = (virtscr[0].height + 4) * NUM_STRIPS;
else
itemsize = (_scrHeight + 4) * NUM_STRIPS;
size = itemsize * gdi._numZBuffer;
createResource(rtBuffer, 9, size);
for (i = 0; i < 4; i++)
gdi._imgBufOffs[i] = i * itemsize;
}
void Scumm::setPaletteFromPtr(byte *ptr)
{
int i, r, g, b;
byte *dest;
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++;
if (i <= 15 || r < 252 || g < 252 || b < 252) {
*dest++ = r;
*dest++ = g;
*dest++ = b;
} else {
dest += 3;
}
}
setDirtyColors(0, numcolor - 1);
}
void Scumm::setPaletteFromRes()
{
byte *ptr;
ptr = getResourceAddress(rtRoom, _roomResource) + _CLUT_offs;
setPaletteFromPtr(ptr);
}
void Scumm::setDirtyColors(int min, int max)
{
if (_palDirtyMin > min)
_palDirtyMin = min;
if (_palDirtyMax < max)
_palDirtyMax = max;
}
void Scumm::initCycl(byte *ptr)
{
int j;
ColorCycle *cycl;
memset(_colorCycle, 0, sizeof(_colorCycle));
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_UNALIGNED(ptr);
ptr += 2;
cycl->flags = READ_BE_UINT16_UNALIGNED(ptr);
ptr += 2;
cycl->start = *ptr++;
cycl->end = *ptr++;
}
}
void Scumm::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;
}
void Scumm::cyclePalette()
{
ColorCycle *cycl;
int valueToAdd;
int i, num;
byte *start, *end;
byte tmp[3];
valueToAdd = _vars[VAR_TIMER];
if (valueToAdd < _vars[VAR_TIMER_NEXT])
valueToAdd = _vars[VAR_TIMER_NEXT];
if (!_colorCycle) // FIXME
return;
for (i = 0, cycl = _colorCycle; i < 16; i++, cycl++) {
if (cycl->delay && (cycl->counter += valueToAdd) >= cycl->delay) {
do {
cycl->counter -= cycl->delay;
} while (cycl->delay <= cycl->counter);
setDirtyColors(cycl->start, cycl->end);
moveMemInPalRes(cycl->start, cycl->end, cycl->flags & 2);
start = &_currentPalette[cycl->start * 3];
end = &_currentPalette[cycl->end * 3];
num = cycl->end - cycl->start;
if (!(cycl->flags & 2)) {
memmove(tmp, end, 3);
memmove(start + 3, start, num * 3);
memmove(start, tmp, 3);
} else {
memmove(tmp, start, 3);
memmove(start, start + 3, num * 3);
memmove(end, tmp, 3);
}
}
}
}
// Perform color cycling on the palManipulate data, too, otherwise
// color cycling will be disturbed by the palette fade.
void Scumm::moveMemInPalRes(int start, int end, byte direction)
{
byte *startptr, *endptr;
byte *startptr2, *endptr2;
int num;
byte tmp[6];
byte tmp2[6];
if (!_palManipCounter)
return;
startptr = getResourceAddress(rtTemp, 4) + start * 6;
endptr = getResourceAddress(rtTemp, 4) + end * 6;
startptr2 = getResourceAddress(rtTemp, 5) + start * 6;
endptr2 = getResourceAddress(rtTemp, 5) + end * 6;
num = end - start;
if (!endptr) {
warning("moveMemInPalRes(%d,%d): Bad end pointer\n", start, end);
return;
}
if (!direction) {
memmove(tmp, endptr, 6);
memmove(startptr + 6, startptr, num * 6);
memmove(startptr, tmp, 6);
memmove(tmp2, endptr2, 6);
memmove(startptr2 + 6, startptr2, num * 6);
memmove(startptr2, tmp2, 6);
} else {
memmove(tmp, startptr, 6);
memmove(startptr, startptr + 6, num * 6);
memmove(endptr, tmp, 6);
memmove(tmp2, startptr2, 6);
memmove(startptr2, startptr2 + 6, num * 6);
memmove(endptr2, tmp2, 6);
}
}
void Scumm::drawFlashlight()
{
static byte *flashBuffer = NULL;
static int flashX, flashY, flashW, flashH;
int i, j, offset;
int topline = virtscr[0].topline;
// Remove the flash light first if it was previously drawn
if (_flashlightIsDrawn) {
updateDirtyRect(0, flashX<<3, (flashX+flashW)<<3, flashY, flashY+flashH, 0x80000000);
if (flashBuffer) {
offset = _realWidth - flashW*8;
i = flashH;
do {
j = flashW*2;
do {
*(uint32 *)flashBuffer = 0;
flashBuffer += 4;
} while (--j);
flashBuffer += offset;
} while (--i);
}
_flashlightIsDrawn = false;
}
if (_flashlightXStrips == 0 || _flashlightYStrips == 0)
return;
// Calculate the area of the flashlight
Actor *a = a = derefActorSafe(_vars[VAR_EGO], "drawFlashlight");
flashW = _flashlightXStrips;
flashH = _flashlightYStrips * 8;
flashX = a->x/8 - flashW/2 - _screenStartStrip;
flashY = a->y - flashH/2;
// Clip the flashlight at the borders
if (flashX < 0)
flashX = 0;
else if (flashX > NUM_STRIPS - flashW)
flashX = NUM_STRIPS - flashW;
if (flashY < 0)
flashY = 0;
else if (flashY > virtscr[0].height - flashH)
flashY = virtscr[0].height - flashH;
// Redraw any actors "under" the flashlight
for (i = flashX; i < flashX+flashW; i++) {
gfxUsageBits[_screenStartStrip + i] |= 0x80000000;
virtscr[0].tdirty[i] = 0;
virtscr[0].bdirty[i] = virtscr[0].height;
}
byte *bgbak;
offset = (flashY - topline) * _realWidth + virtscr[0].xstart + flashX * 8;
flashBuffer = virtscr[0].screenPtr + offset;
bgbak = getResourceAddress(rtBuffer, 5) + offset;
blit(flashBuffer, bgbak, flashW*8, flashH);
// Round the corners. To do so, we simply hard-code a set of nicely
// rounded corners.
int corner_data[] = { 8, 6, 4, 3, 2, 2, 1, 1 };
int minrow = 0;
int maxcol = flashW * 8 - 1;
int maxrow = (flashH - 1) * _realWidth;
for (i = 0; i < 8; i++, minrow += _realWidth, maxrow -= _realWidth) {
int d = corner_data[i];
for (j = 0; j < d; j++) {
flashBuffer[minrow + j] = 0;
flashBuffer[minrow + maxcol - j] = 0;
flashBuffer[maxrow + j] = 0;
flashBuffer[maxrow + maxcol - j] = 0;
}
}
_flashlightIsDrawn = true;
}
void Scumm::fadeIn(int effect)
{
switch (effect) {
case 1:
case 2:
case 3:
case 4:
transitionEffect(effect - 1);
break;
case 128:
unkScreenEffect6();
break;
case 130:
case 131:
case 132:
case 133:
scrollEffect(133 - effect);
break;
case 134:
dissolveEffect(1, 1);
break;
case 135:
unkScreenEffect5(1);
break;
case 129:
break;
default:
warning("Unknown screen effect, %d", effect);
}
_screenEffectFlag = true;
}
void Scumm::fadeOut(int a)
{
VirtScreen *vs;
setDirtyRange(0, 0, 0);
if (!(_features & GF_AFTER_V7))
camera._last.x = camera._cur.x;
if (!_screenEffectFlag)
return;
_screenEffectFlag = false;
if (a == 0)
return;
// Fill screen 0 with black
vs = &virtscr[0];
gdi._backbuff_ptr = vs->screenPtr + vs->xstart;
memset(gdi._backbuff_ptr, 0, vs->size);
// Fade to black with the specified effect, if any.
switch (a) {
case 1:
case 2:
case 3:
case 4:
transitionEffect(a - 1);
break;
case 128:
unkScreenEffect6();
break;
case 129:
// Just blit screen 0 to the display (i.e. display will be black)
setDirtyRange(0, 0, vs->height);
updateDirtyScreen(0);
break;
case 134:
dissolveEffect(1, 1);
break;
case 135:
unkScreenEffect5(1);
break;
default:
warning("fadeOut: default case %d", a);
}
}
void Scumm::redrawBGAreas()
{
int i;
int val;
int diff;
if (!(_features & GF_AFTER_V7))
if (camera._cur.x != camera._last.x && charset._hasMask)
stopTalk();
val = 0;
if (!_fullRedraw && _BgNeedsRedraw) {
for (i = 0; i != NUM_STRIPS; i++) {
if (gfxUsageBits[_screenStartStrip + i] & 0x80000000) {
redrawBGStrip(i, 1);
}
}
}
if (_features & GF_AFTER_V7) {
diff = (camera._cur.x >> 3) - (camera._last.x >> 3);
if (_fullRedraw == 0 && diff == 1) {
val = 2;
redrawBGStrip(NUM_STRIPS-1, 1);
} else if (_fullRedraw == 0 && diff == -1) {
val = 1;
redrawBGStrip(0, 1);
} else if (_fullRedraw != 0 || diff != 0) {
_BgNeedsRedraw = false;
_fullRedraw = false;
redrawBGStrip(0, NUM_STRIPS);
}
} else {
if (_fullRedraw == 0 && camera._cur.x - camera._last.x == 8) {
val = 2;
redrawBGStrip(NUM_STRIPS-1, 1);
} else if (_fullRedraw == 0 && camera._cur.x - camera._last.x == -8) {
val = 1;
redrawBGStrip(0, 1);
} else if (_fullRedraw != 0 || camera._cur.x != camera._last.x) {
_BgNeedsRedraw = false;
_flashlightIsDrawn = false;
redrawBGStrip(0, NUM_STRIPS);
}
}
drawRoomObjects(val);
_BgNeedsRedraw = false;
}
const uint32 zplane_tags[] = {
MKID('ZP00'),
MKID('ZP01'),
MKID('ZP02'),
MKID('ZP03'),
MKID('ZP04')
};
void Gdi::drawBitmap(byte *ptr, VirtScreen *vs, int x, int y, int h,
int stripnr, int numstrip, byte flag)
{
byte *smap_ptr, *where_draw_ptr;
int i;
byte *zplane_list[6];
int bottom;
byte twobufs;
int numzbuf;
int sx;
bool lightsOn;
// Check whether lights are turned on or not
lightsOn = (_vm->_features & GF_AFTER_V6) || (vs->number != 0) || (_vm->_vars[_vm->VAR_CURRENT_LIGHTS] & LIGHTMODE_screen);
CHECK_HEAP;
if (_vm->_features & GF_SMALL_HEADER)
smap_ptr = _smap_ptr = ptr;
else
smap_ptr = findResource(MKID('SMAP'), ptr);
assert(smap_ptr);
numzbuf = _disable_zbuffer ? 0 : _numZBuffer;
if (_vm->_features & GF_SMALL_HEADER) {
/* this is really ugly, FIXME */
if (ptr[-2] == 'B' && ptr[-1] == 'M' && READ_LE_UINT32(ptr - 6) > (READ_LE_UINT32(ptr) + 10)) {
zplane_list[1] = smap_ptr + READ_LE_UINT32(ptr);
// FIXME - how does GF_OLD256 encode the multiple zplanes?
if (!(_vm->_features & GF_OLD256))
for (i = 2; i < numzbuf; i++) {
zplane_list[i] = zplane_list[i-1] + READ_LE_UINT16(zplane_list[i-1]);
}
} else if (ptr[-4] == 'O' && ptr[-3] == 'I' && READ_LE_UINT32(ptr - 8) > READ_LE_UINT32(ptr) + 12) {
zplane_list[1] = smap_ptr + READ_LE_UINT32(ptr);
// FIXME - how does GF_OLD256 encode the multiple zplanes?
if (!(_vm->_features & GF_OLD256))
for (i = 2; i < numzbuf; i++) {
zplane_list[i] = zplane_list[i-1] + READ_LE_UINT16(zplane_list[i-1]);
}
} else {
zplane_list[1] = 0;
}
} else {
for (i = 1; i < numzbuf; i++) {
zplane_list[i] = findResource(zplane_tags[i], ptr);
}
}
bottom = y + h;
if (bottom > vs->height) {
warning("Gdi::drawBitmap, strip drawn to %d below window bottom %d", bottom, vs->height);
}
twobufs = vs->alloctwobuffers;
_vertStripNextInc = h * _vm->_realWidth - 1;
_numLinesToProcess = h;
do {
if (_vm->_features & GF_SMALL_HEADER)
_smap_ptr = smap_ptr + READ_LE_UINT32(smap_ptr + stripnr * 4 + 4);
else
_smap_ptr = smap_ptr + READ_LE_UINT32(smap_ptr + stripnr * 4 + 8);
CHECK_HEAP;
sx = x;
if (vs->scrollable)
sx -= vs->xstart >> 3;
if ((uint) sx >= NUM_STRIPS)
return;
if (y < vs->tdirty[sx])
vs->tdirty[sx] = y;
if (bottom > vs->bdirty[sx])
vs->bdirty[sx] = bottom;
_backbuff_ptr = vs->screenPtr + (y * NUM_STRIPS + x) * 8;
if (twobufs)
_bgbak_ptr = _vm->getResourceAddress(rtBuffer, vs->number + 5) + (y * NUM_STRIPS + x) * 8;
else
_bgbak_ptr = _backbuff_ptr;
_mask_ptr = _vm->getResourceAddress(rtBuffer, 9) + (y * NUM_STRIPS + x);
where_draw_ptr = _bgbak_ptr;
decompressBitmap();
CHECK_HEAP;
if (twobufs) {
_bgbak_ptr = where_draw_ptr;
if (_vm->hasCharsetMask(sx << 3, y, (sx + 1) << 3, bottom)) {
if (flag & dbClear || !lightsOn)
clear8ColWithMasking();
else
draw8ColWithMasking();
} else {
if (flag & dbClear || !lightsOn)
clear8Col();
else
_vm->blit(_backbuff_ptr, _bgbak_ptr, 8, h);
}
}
CHECK_HEAP;
if (flag & dbDrawMaskOnBoth) {
_z_plane_ptr = zplane_list[1] + READ_LE_UINT16(zplane_list[1] + stripnr * 2 + 8);
_mask_ptr_dest = _vm->getResourceAddress(rtBuffer, 9) + y * NUM_STRIPS + x;
if (_useOrDecompress && flag & dbAllowMaskOr)
decompressMaskImgOr();
else
decompressMaskImg();
}
for (i = 1; i < numzbuf; i++) {
uint16 offs;
if (!zplane_list[i])
continue;
if (_vm->_features & GF_SMALL_HEADER)
if (_vm->_features & GF_OLD256)
offs = READ_LE_UINT16(zplane_list[i] + stripnr * 2 + 4);
else
offs = READ_LE_UINT16(zplane_list[i] + stripnr * 2 + 2);
else
offs = READ_LE_UINT16(zplane_list[i] + stripnr * 2 + 8);
_mask_ptr_dest = _vm->getResourceAddress(rtBuffer, 9) + y * NUM_STRIPS + x + _imgBufOffs[i];
if (offs) {
_z_plane_ptr = zplane_list[i] + offs;
if (_useOrDecompress && flag & dbAllowMaskOr)
decompressMaskImgOr();
else
decompressMaskImg();
} else {
if (_useOrDecompress && flag & dbAllowMaskOr); /* nothing */
else
for (int h = 0; h < _numLinesToProcess; h++)
_mask_ptr_dest[h * NUM_STRIPS] = 0;
/* needs better abstraction, FIXME */
}
}
CHECK_HEAP;
x++;
stripnr++;
} while (--numstrip);
}
void Gdi::decompressBitmap()
{
const byte decompress_table[] = {
0x0, 0x1, 0x3, 0x7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x0,
};
_useOrDecompress = false;
byte code = *_smap_ptr++;
assert(_numLinesToProcess);
if (_vm->_features & GF_AMIGA)
_palette_mod = 16;
else
_palette_mod = 0;
switch (code) {
case 1:
unkDecode7();
break;
case 2:
unkDecode8(); /* Ender - Zak256/Indy256 */
break;
case 3:
unkDecode9(); /* Ender - Zak256/Indy256 */
break;
case 4:
unkDecode10(); /* Ender - Zak256/Indy256 */
break;
case 7:
unkDecode11(); /* Ender - Zak256/Indy256 */
break;
case 14:
case 15:
case 16:
case 17:
case 18:
_decomp_shr = code - 10;
_decomp_mask = decompress_table[code - 10];
unkDecode6();
break;
case 24:
case 25:
case 26:
case 27:
case 28:
_decomp_shr = code - 20;
_decomp_mask = decompress_table[code - 20];
unkDecode5();
break;
case 34:
case 35:
case 36:
case 37:
case 38:
_useOrDecompress = true;
_decomp_shr = code - 30;
_decomp_mask = decompress_table[code - 30];
unkDecode4();
break;
case 44:
case 45:
case 46:
case 47:
case 48:
_useOrDecompress = true;
_decomp_shr = code - 40;
_decomp_mask = decompress_table[code - 40];
unkDecode2();
break;
case 64:
case 65:
case 66:
case 67:
case 68:
_decomp_shr = code - 60;
_decomp_mask = decompress_table[code - 60];
unkDecode1();
break;
case 84:
case 85:
case 86:
case 87:
case 88:
_useOrDecompress = true;
_decomp_shr = code - 80;
_decomp_mask = decompress_table[code - 80];
unkDecode3();
break;
/* New since version 6 */
case 104:
case 105:
case 106:
case 107:
case 108:
_decomp_shr = code - 100;
_decomp_mask = decompress_table[code - 100];
unkDecode1();
break;
/* New since version 6 */
case 124:
case 125:
case 126:
case 127:
case 128:
_useOrDecompress = true;
_decomp_shr = code - 120;
_decomp_mask = decompress_table[code - 120];
unkDecode3();
break;
default:
error("Gdi::decompressBitmap: default case %d", code);
}
}
int Scumm::hasCharsetMask(int x, int y, int x2, int y2)
{
if (!charset._hasMask || y > gdi._mask_bottom || x > gdi._mask_right ||
y2 < gdi._mask_top || x2 < gdi._mask_left)
return 0;
return 1;
}
void Gdi::draw8ColWithMasking()
{
int height = _numLinesToProcess;
byte *mask = _mask_ptr;
byte *dst = _backbuff_ptr;
byte *src = _bgbak_ptr;
byte maskbits;
do {
maskbits = *mask;
if (maskbits) {
if (!(maskbits & 0x80))
dst[0] = src[0];
if (!(maskbits & 0x40))
dst[1] = src[1];
if (!(maskbits & 0x20))
dst[2] = src[2];
if (!(maskbits & 0x10))
dst[3] = src[3];
if (!(maskbits & 0x08))
dst[4] = src[4];
if (!(maskbits & 0x04))
dst[5] = src[5];
if (!(maskbits & 0x02))
dst[6] = src[6];
if (!(maskbits & 0x01))
dst[7] = src[7];
} else {
((uint32 *)dst)[0] = ((uint32 *)src)[0];
((uint32 *)dst)[1] = ((uint32 *)src)[1];
}
src += _vm->_realWidth;
dst += _vm->_realWidth;
mask += NUM_STRIPS;
} while (--height);
}
void Gdi::clear8ColWithMasking()
{
int height = _numLinesToProcess;
byte *mask = _mask_ptr;
byte *dst = _backbuff_ptr;
byte maskbits;
do {
maskbits = *mask;
if (maskbits) {
if (!(maskbits & 0x80))
dst[0] = 0;
if (!(maskbits & 0x40))
dst[1] = 0;
if (!(maskbits & 0x20))
dst[2] = 0;
if (!(maskbits & 0x10))
dst[3] = 0;
if (!(maskbits & 0x08))
dst[4] = 0;
if (!(maskbits & 0x04))
dst[5] = 0;
if (!(maskbits & 0x02))
dst[6] = 0;
if (!(maskbits & 0x01))
dst[7] = 0;
} else {
((uint32 *)dst)[0] = 0;
((uint32 *)dst)[1] = 0;
}
dst += _vm->_realWidth;
mask += NUM_STRIPS;
} while (--height);
}
void Gdi::clear8Col()
{
int height = _numLinesToProcess;
byte *dst = _backbuff_ptr;
do {
((uint32 *)dst)[0] = 0;
((uint32 *)dst)[1] = 0;
dst += _vm->_realWidth;
} while (--height);
}
void Gdi::decompressMaskImg()
{
byte *src = _z_plane_ptr;
byte *dst = _mask_ptr_dest;
int height = _numLinesToProcess;
byte b, c;
while (1) {
b = *src++;
if (b & 0x80) {
b &= 0x7F;
c = *src++;
do {
*dst = c;
dst += NUM_STRIPS;
if (!--height)
return;
} while (--b);
} else {
do {
*dst = *src++;
dst += NUM_STRIPS;
if (!--height)
return;
} while (--b);
}
}
}
void Gdi::decompressMaskImgOr()
{
byte *src = _z_plane_ptr;
byte *dst = _mask_ptr_dest;
int height = _numLinesToProcess;
byte b, c;
while (1) {
b = *src++;
if (b & 0x80) {
b &= 0x7F;
c = *src++;
do {
*dst |= c;
dst += NUM_STRIPS;
if (!--height)
return;
} while (--b);
} else {
do {
*dst |= *src++;
dst += NUM_STRIPS;
if (!--height)
return;
} while (--b);
}
}
}
void Scumm::redrawBGStrip(int start, int num)
{
int s = _screenStartStrip + start;
assert(s >= 0 && (size_t) s < sizeof(gfxUsageBits) / sizeof(gfxUsageBits[0]));
_curVirtScreen = &virtscr[0];
for (int i = 0; i < num; i++)
gfxUsageBits[s + i] |= 0x80000000;
/*if (_curVirtScreen->height < _scrHeight) {
warning("Screen Y size %d < Room height %d",
_curVirtScreen->height,
_scrHeight);
} */
gdi.drawBitmap(getResourceAddress(rtRoom, _roomResource) + _IM00_offs,
_curVirtScreen, s, 0, _curVirtScreen->height, s, num, 0);
}
#define READ_BIT (cl--,bit = bits&1, bits>>=1,bit)
#define FILL_BITS if (cl <= 8) { bits |= (*src++ << cl); cl += 8;}
void Gdi::unkDecode1()
{
byte *src = _smap_ptr;
byte *dst = _bgbak_ptr;
byte color = *src++;
uint bits = *src++;
byte cl = 8;
byte bit;
byte incm, reps;
_tempNumLines = _numLinesToProcess;
do {
_currentX = 8;
do {
FILL_BITS *dst++ = color + _palette_mod;;
againPos:;
if (!READ_BIT) {
} else if (READ_BIT) {
incm = (bits & 7) - 4;
cl -= 3;
bits >>= 3;
if (!incm) {
FILL_BITS reps = bits & 0xFF;
do {
if (!--_currentX) {
_currentX = 8;
dst += 312;
if (!--_tempNumLines)
return;
}
*dst++ = color + _palette_mod;
} while (--reps);
bits >>= 8;
bits |= (*src++) << (cl - 8);
goto againPos;
} else {
color += incm;
}
} else {
FILL_BITS color = bits & _decomp_mask;
cl -= _decomp_shr;
bits >>= _decomp_shr;
}
} while (--_currentX);
dst += 312;
} while (--_tempNumLines);
}
void Gdi::unkDecode2()
{
byte *src = _smap_ptr;
byte *dst = _bgbak_ptr;
byte color = *src++;
int8 inc = -1;
uint bits = *src++;
byte cl = 8;
byte bit;
_tempNumLines = _numLinesToProcess;
do {
_currentX = 8;
do {
FILL_BITS if (color != _transparency)
*dst = color + _palette_mod;
dst++;
if (!READ_BIT) {
} else if (!READ_BIT) {
FILL_BITS color = bits & _decomp_mask;
bits >>= _decomp_shr;
cl -= _decomp_shr;
inc = -1;
} else if (!READ_BIT) {
color += inc;
} else {
inc = -inc;
color += inc;
}
} while (--_currentX);
dst += 312;
} while (--_tempNumLines);
}
void Gdi::unkDecode3()
{
byte *src = _smap_ptr;
byte *dst = _bgbak_ptr;
byte color = *src++;
uint bits = *src++;
byte cl = 8;
byte bit;
byte incm, reps;
_tempNumLines = _numLinesToProcess;
do {
_currentX = 8;
do {
FILL_BITS if (color != _transparency)
*dst = color + _palette_mod;
dst++;
againPos:;
if (!READ_BIT) {
} else if (READ_BIT) {
incm = (bits & 7) - 4;
cl -= 3;
bits >>= 3;
if (incm) {
color += incm;
} else {
FILL_BITS reps = bits & 0xFF;
if (color == _transparency) {
do {
if (!--_currentX) {
_currentX = 8;
dst += 312;
if (!--_tempNumLines)
return;
}
dst++;
} while (--reps);
} else {
do {
if (!--_currentX) {
_currentX = 8;
dst += 312;
if (!--_tempNumLines)
return;
}
*dst++ = color + _palette_mod;
} while (--reps);
}
bits >>= 8;
bits |= (*src++) << (cl - 8);
goto againPos;
}
} else {
FILL_BITS color = bits & _decomp_mask;
cl -= _decomp_shr;
bits >>= _decomp_shr;
}
} while (--_currentX);
dst += 312;
} while (--_tempNumLines);
}
void Gdi::unkDecode4()
{
byte *src = _smap_ptr;
byte *dst = _bgbak_ptr;
byte color = *src++;
int8 inc = -1;
uint bits = *src++;
byte cl = 8;
byte bit;
_currentX = 8;
do {
_tempNumLines = _numLinesToProcess;
do {
FILL_BITS if (color != _transparency)
*dst = color + _palette_mod;
dst += _vm->_realWidth;
if (!READ_BIT) {
} else if (!READ_BIT) {
FILL_BITS color = bits & _decomp_mask;
bits >>= _decomp_shr;
cl -= _decomp_shr;
inc = -1;
} else if (!READ_BIT) {
color += inc;
} else {
inc = -inc;
color += inc;
}
} while (--_tempNumLines);
dst -= _vertStripNextInc;
} while (--_currentX);
}
void Gdi::unkDecode5()
{
byte *src = _smap_ptr;
byte *dst = _bgbak_ptr;
byte color = *src++;
int8 inc = -1;
uint bits = *src++;
byte cl = 8;
byte bit;
_tempNumLines = _numLinesToProcess;
do {
_currentX = 8;
do {
FILL_BITS *dst++ = color + _palette_mod;
if (!READ_BIT) {
} else if (!READ_BIT) {
FILL_BITS color = bits & _decomp_mask;
bits >>= _decomp_shr;
cl -= _decomp_shr;
inc = -1;
} else if (!READ_BIT) {
color += inc;
} else {
inc = -inc;
color += inc;
}
} while (--_currentX);
dst += 312;
} while (--_tempNumLines);
}
void Gdi::unkDecode6()
{
byte *src = _smap_ptr;
byte *dst = _bgbak_ptr;
byte color = *src++;
int8 inc = -1;
uint bits = *src++;
byte cl = 8;
byte bit;
_currentX = 8;
do {
_tempNumLines = _numLinesToProcess;
do {
FILL_BITS *dst = color + _palette_mod;
dst += _vm->_realWidth;
if (!READ_BIT) {
} else if (!READ_BIT) {
FILL_BITS color = bits & _decomp_mask;
bits >>= _decomp_shr;
cl -= _decomp_shr;
inc = -1;
} else if (!READ_BIT) {
color += inc;
} else {
inc = -inc;
color += inc;
}
} while (--_tempNumLines);
dst -= _vertStripNextInc;
} while (--_currentX);
}
/* Ender - Zak256/Indy256 decoders */
#define READ_256BIT \
if ((mask <<= 1) == 256) {buffer = *src++; mask = 1;} \
bits = ((buffer & mask) != 0);
#define NEXT_ROW \
dst += _vm->_realWidth; \
if (--h == 0) { \
if (!--_currentX) \
return; \
dst -= _vertStripNextInc; \
h = _numLinesToProcess; \
}
void Gdi::unkDecode7()
{
byte *src = _smap_ptr;
byte *dst = _bgbak_ptr;
int height = _numLinesToProcess;
uint h = _numLinesToProcess;
if (_vm->_features & GF_OLD256) {
_currentX = 8;
for (;;) {
byte color = *src++;
*dst = color;
NEXT_ROW}
return;
}
do {
/* Endian safe */
#if defined(SCUMM_NEED_ALIGNMENT)
memcpy(dst, src, 8);
#else
((uint32 *)dst)[0] = ((uint32 *)src)[0];
((uint32 *)dst)[1] = ((uint32 *)src)[1];
#endif
dst += _vm->_realWidth;
src += 8;
} while (--height);
}
void Gdi::unkDecode8()
{
byte *src = _smap_ptr;
byte *dst = _bgbak_ptr;
uint h = _numLinesToProcess;
_currentX = 8;
for (;;) {
uint run = (*src++) + 1;
byte color = *src++;
do {
*dst = color;
NEXT_ROW} while (--run);
}
}
void Gdi::unkDecode9()
{
byte *src = _smap_ptr;
byte *dst = _bgbak_ptr;
unsigned char c, bits, color, run;
int x, y, i, z;
uint buffer = 0, mask = 128;
int h = _numLinesToProcess;
x = y = i = z = run = 0;
_currentX = 8;
for (;;) {
c = 0;
for (i = 0; i < 4; i++) {
READ_256BIT;
c += (bits << i);
}
switch ((c >> 2)) {
case 0:
color = 0;
for (i = 0; i < 4; i++) {
READ_256BIT;
color += bits << i;
}
for (i = 0; i < ((c & 3) + 2); i++) {
*dst = (run * 16 + color);
NEXT_ROW}
break;
case 1:
for (i = 0; i < ((c & 3) + 1); i++) {
color = 0;
for (z = 0; z < 4; z++) {
READ_256BIT;
color += bits << z;
}
*dst = (run * 16 + color);
NEXT_ROW}
break;
case 2:
run = 0;
for (i = 0; i < 4; i++) {
READ_256BIT;
run += bits << i;
}
break;
}
}
}
void Gdi::unkDecode10()
{
byte *src = _smap_ptr;
byte *dst = _bgbak_ptr;
int i;
unsigned char local_palette[256], numcolors = *src++;
uint h = _numLinesToProcess;
for (i = 0; i < numcolors; i++)
local_palette[i] = *src++;
_currentX = 8;
for (;;) {
byte color = *src++;
if (color < numcolors) {
*dst = local_palette[color];
NEXT_ROW} else {
uint run = color - numcolors + 1;
color = *src++;
do {
*dst = color;
NEXT_ROW} while (--run);
}
}
}
void Gdi::unkDecode11()
{
byte *src = _smap_ptr;
byte *dst = _bgbak_ptr;
int bits, i;
uint buffer = 0, mask = 128;
unsigned char inc = 1, color = *src++;
_currentX = 8;
do {
_tempNumLines = _numLinesToProcess;
do {
*dst = color;
dst += _vm->_realWidth;
for (i = 0; i < 3; i++) {
READ_256BIT if (!bits)
break;
}
switch (i) {
case 1:
inc = -inc;
color -= inc;
break;
case 2:
color -= inc;
break;
case 3:
color = 0;
inc = 1;
for (i = 0; i < 8; i++) {
READ_256BIT color += bits << i;
}
break;
}
} while (--_tempNumLines);
dst -= _vertStripNextInc;
} while (--_currentX);
}
#undef NEXT_ROW
#undef READ_256BIT
#undef READ_BIT
#undef FILL_BITS
void Scumm::restoreCharsetBg()
{
_bkColor = 0;
if (gdi._mask_left != -1) {
restoreBG(gdi._mask_left, gdi._mask_top, gdi._mask_right, gdi._mask_bottom);
charset._hasMask = false;
gdi._mask_left = -1;
charset._strLeft = -1;
charset._left = -1;
}
charset._xpos2 = string[0].xpos;
charset._ypos2 = string[0].ypos;
}
void Scumm::restoreBG(int left, int top, int right, int bottom)
{
VirtScreen *vs;
int topline, height, width, widthmod;
byte *backbuff, *bgbak, *mask;
if (left == right || top == bottom)
return;
if (top < 0)
top = 0;
if ((vs = findVirtScreen(top)) == NULL)
return;
topline = vs->topline;
height = topline + vs->height;
if (vs->number == 0) {
left += _lastXstart - vs->xstart;
right += _lastXstart - vs->xstart;
}
right++;
if (left < 0)
left = 0;
if (right < 0)
right = 0;
if (left > _realWidth)
return;
if (right > _realWidth)
right = _realWidth;
if (bottom >= height)
bottom = height;
updateDirtyRect(vs->number, left, right, top - topline, bottom - topline, 0x40000000);
height = (top - topline) * _realWidth + vs->xstart + left;
backbuff = vs->screenPtr + height;
bgbak = getResourceAddress(rtBuffer, vs->number + 5) + height;
mask = getResourceAddress(rtBuffer, 9) + top * NUM_STRIPS + (left >> 3) + _screenStartStrip;
if (vs->number == 0) {
mask += vs->topline * 216;
}
height = bottom - top;
width = right - left;
widthmod = (width >> 2) + 2;
if (vs->alloctwobuffers && _currentRoom != 0 /*&& _vars[VAR_V5_DRAWFLAGS]&2 */ ) {
blit(backbuff, bgbak, width, height);
if (vs->number == 0 && charset._hasMask && height) {
do {
memset(mask, 0, widthmod);
mask += NUM_STRIPS;
} while (--height);
}
} else {
if (height) {
do {
memset(backbuff, _bkColor, width);
backbuff += _realWidth;
} while (--height);
}
}
}
void Scumm::updateDirtyRect(int virt, int left, int right, int top, int bottom, uint32 dirtybits)
{
VirtScreen *vs = &virtscr[virt];
int lp, rp;
uint32 *sp;
int num;
if (top > vs->height || left > vs->width || right < 0 || bottom < 0)
return;
if (top < 0)
top = 0;
if (left < 0)
left = 0;
if (bottom > vs->height)
bottom = vs->height;
if (right > vs->width)
right = vs->width;
if (virt == 0 && dirtybits) {
rp = (right >> 3) + _screenStartStrip;
lp = (left >> 3) + _screenStartStrip;
if (lp < 0)
lp = 0;
if (rp >= _realHeight)
rp = _realHeight;
if (lp <= rp) {
num = rp - lp + 1;
sp = &gfxUsageBits[lp];
do {
*sp++ |= dirtybits;
} while (--num);
}
}
setVirtscreenDirty(vs, left, top, right, bottom);
}
void Scumm::setVirtscreenDirty(VirtScreen *vs, int left, int top, int right, int bottom)
{
int lp = left >> 3;
int rp = right >> 3;
if (lp >= NUM_STRIPS || rp < 0)
return;
if (lp < 0)
lp = 0;
if (rp >= NUM_STRIPS)
rp = NUM_STRIPS - 1;
while (lp <= rp) {
if (top < vs->tdirty[lp])
vs->tdirty[lp] = top;
if (bottom > vs->bdirty[lp])
vs->bdirty[lp] = bottom;
lp++;
}
}
VirtScreen *Scumm::findVirtScreen(int y)
{
VirtScreen *vs = virtscr;
int i;
for (i = 0; i < 3; i++, vs++) {
if (y >= vs->topline && y < vs->topline + vs->height) {
return _curVirtScreen = vs;
}
}
return _curVirtScreen = NULL;
}
void Scumm::unkScreenEffect1()
{
/* XXX: not implemented */
warning("stub unkScreenEffect1()");
}
void Scumm::unkScreenEffect2()
{
/* XXX: not implemented */
warning("stub unkScreenEffect2()");
}
void Scumm::unkScreenEffect3()
{
/* XXX: not implemented */
warning("stub unkScreenEffect3()");
}
void Scumm::unkScreenEffect4()
{
/* XXX: not implemented */
warning("stub unkScreenEffect4()");
}
/* *INDENT-OFF* */
static const int8 screen_eff7_table1[4][16] = {
{ 1, 1, -1, 1, -1, 1, -1, -1,
1, -1, -1, -1, 1, 1, 1, -1},
{ 0, 1, 2, 1, 2, 0, 2, 1,
2, 0, 2, 1, 0, 0, 0, 0},
{-2, -1, 0, -1, -2, -1, -2, 0, -2, -1, -2, 0, 0, 0, 0, 0},
{ 0, -1, -2, -1, -2, 0, -2, -1, -2, 0, -2, -1, 0, 0, 0, 0}
};
static const byte screen_eff7_table2[4][16] = {
{ 0, 0, 39, 0, 39, 0, 39, 24,
0, 24, 39, 24, 0, 0, 0, 24},
{ 0, 0, 0, 0, 0, 0, 0, 0,
1, 0, 1, 0, 255, 0, 0, 0},
{39, 24, 39, 24, 39, 24, 39, 24,
38, 24, 38, 24, 255, 0, 0, 0},
{ 0, 24, 39, 24, 39, 0, 39, 24,
38, 0, 38, 24, 255, 0, 0, 0}
};
static const byte transition_num_of_iterations[4] = {
13, 25, 25, 25
};
/* *INDENT-ON* */
/* Transition effect. There are four different effects possible,
* indicated by the value of a:
* 0: Iris effect
* 1: ?
* 2: ?
* 3: ?
* All effects basically operate on 8x8 blocks of the screen. These blocks
* are updated in a certain order; the exact order determines how the
* effect appears to the user.
*/
void Scumm::transitionEffect(int a)
{
int delta[16]; // Offset applied during each iteration
int tab_2[16];
int i, j;
int bottom;
int l, t, r, b;
for (i = 0; i < 16; i++) {
delta[i] = screen_eff7_table1[a][i];
j = screen_eff7_table2[a][i];
if (j == 24)
j = (virtscr[0].height >> 3) - 1;
tab_2[i] = j;
}
bottom = virtscr[0].height >> 3;
for (j = 0; j < transition_num_of_iterations[a]; j++) {
for (i = 0; i < 4; i++) {
l = tab_2[i * 4];
t = tab_2[i * 4 + 1];
r = tab_2[i * 4 + 2];
b = tab_2[i * 4 + 3];
if (t == b) {
while (l <= r) {
if (l >= 0 && l < NUM_STRIPS && (uint) t < (uint) bottom) {
virtscr[0].tdirty[l] = t << 3;
virtscr[0].bdirty[l] = (t + 1) << 3;
}
l++;
}
} else {
if (l < 0 || l >= NUM_STRIPS || b <= t)
continue;
if (b > bottom)
b = bottom;
virtscr[0].tdirty[l] = t << 3;
virtscr[0].bdirty[l] = (b + 1) << 3;
}
updateDirtyScreen(0);
}
for (i = 0; i < 16; i++)
tab_2[i] += delta[i];
// Draw the current state to the screen and wait half a sec so the user
// can watch the effect taking place.
updatePalette();
_system->update_screen();
waitForTimer(30);
}
}
// Update width x height areas of the screen, in random order, until the whole
// screen has been updated. For instance:
//
// dissolveEffect(1, 1) produces a pixel-by-pixel dissolve
// dissolveEffect(8, 8) produces a square-by-square dissolve
// dissolveEffect(virtsrc[0].width, 1) produces a line-by-line dissolve
void Scumm::dissolveEffect(int width, int height) {
VirtScreen *vs = &virtscr[0];
int *offsets;
int blits_before_refresh, blits;
int x, y;
int w, h;
int i;
// There's probably some less memory-hungry way of doing this. But
// since we're only dealing with relatively small images, it shouldn't
// be too bad.
w = vs->width / width;
h = vs->height / height;
// When used used correctly, vs->width % width and vs->height % height
// should both be zero, but just to be safe...
if (vs->width % width)
w++;
if (vs->height % height)
h++;
offsets = (int *) malloc(w * h * sizeof(int));
if (offsets == NULL) {
warning("dissolveEffect: out of memory");
return;
}
// Create a permutation of offsets into the frame buffer
if (width == 1 && height == 1) {
// Optimized case for pixel-by-pixel dissolve
for (i = 0; i < vs->size; i++)
offsets[i] = i;
for (i = 1; i < w * h; i++) {
int j;
j = getRandomNumber(i - 1);
offsets[i] = offsets[j];
offsets[j] = i;
}
} else {
int *offsets2;
for (i = 0, x = 0; x < vs->width; x += width)
for (y = 0; y < vs->height; y += height)
offsets[i++] = y * vs->width + x;
offsets2 = (int *) malloc(w * h * sizeof(int));
if (offsets2 == NULL) {
warning("dissolveEffect: out of memory");
free(offsets);
return;
}
memcpy(offsets2, offsets, w * h * sizeof(int));
for (i = 1; i < w * h; i++) {
int j;
j = getRandomNumber(i - 1);
offsets[i] = offsets[j];
offsets[j] = offsets2[i];
}
free(offsets2);
}
// Blit the image piece by piece to the screen. The idea here is that
// the whole update should take about a quarter of a second, assuming
// most of the time is spent in waitForTimer(). It looks good to me,
// but might still need some tuning.
updatePalette();
blits = 0;
blits_before_refresh = (3 * w * h) / 25;
for (i = 0; i < w * h; i++) {
x = offsets[i] % vs->width;
y = offsets[i] / vs->width;
_system->copy_rect(vs->screenPtr + vs->xstart + y * vs->width + x, vs->width, x, y + vs->topline, width, height);
if (++blits >= blits_before_refresh) {
blits = 0;
_system->update_screen();
waitForTimer(30);
}
}
free(offsets);
if (blits != 0) {
_system->update_screen();
waitForTimer(30);
}
}
void Scumm::scrollEffect(int dir) {
VirtScreen *vs = &virtscr[0];
int x, y;
int step;
if ((dir == 0) || (dir == 1))
step = vs->height;
else
step = vs->width;
step = (step * kPictureDelay) / kScrolltime;
switch (dir) {
case 0:
//up
y = 1 + step;
while (y < vs->height) {
_system->move_screen(0, -step, vs->height);
_system->copy_rect(vs->screenPtr + vs->xstart + (y - step) * vs->width,
vs->width,
0, vs->height - step,
vs->width, step);
_system->update_screen();
waitForTimer(kPictureDelay);
y += step;
}
break;
case 1:
// down
y = 1 + step;
while (y < vs->height) {
_system->move_screen(0, step, vs->height);
_system->copy_rect(vs->screenPtr + vs->xstart + vs->width * (vs->height-y),
vs->width,
0, 0,
vs->width, step);
_system->update_screen();
waitForTimer(kPictureDelay);
y += step;
}
break;
case 2:
// left
x = 1 + step;
while (x < vs->width) {
_system->move_screen(-step, 0, vs->height);
_system->copy_rect(vs->screenPtr + vs->xstart + x - step,
vs->width,
vs->width - step, 0,
step, vs->height);
_system->update_screen();
waitForTimer(kPictureDelay);
x += step;
}
break;
case 3:
// right
x = 1 + step;
while (x < vs->width) {
_system->move_screen(step, 0, vs->height);
_system->copy_rect(vs->screenPtr + vs->xstart + vs->width - x,
vs->width,
0, 0,
step, vs->height);
_system->update_screen();
waitForTimer(kPictureDelay);
x += step;
}
break;
}
}
void Scumm::unkScreenEffect6() {
if (_gameId == GID_LOOM256)
dissolveEffect(1, 1);
else
dissolveEffect(8, 4);
}
void Scumm::unkScreenEffect5(int a) {
// unkScreenEffect5(0), which is used by FOA during the opening
// cutscene when Indy opens the small statue, has been replaced by
// dissolveEffect(1, 1).
//
// I still don't know what unkScreenEffect5(1) is supposed to do.
/* XXX: not implemented */
warning("stub unkScreenEffect(%d)", a);
}
void Scumm::setShake(int mode)
{
if (_shakeEnabled != (mode != 0))
_fullRedraw = true;
_shakeEnabled = mode != 0;
_shakeFrame = 0;
_system->set_shake_pos(0);
}
void Gdi::clearUpperMask()
{
memset(_vm->getResourceAddress(rtBuffer, 9), 0, _imgBufOffs[1] - _imgBufOffs[0]
);
}
void Scumm::clampCameraPos(ScummPoint *pt)
{
if (pt->x < _vars[VAR_CAMERA_MIN_X])
pt->x = _vars[VAR_CAMERA_MIN_X];
if (pt->x > _vars[VAR_CAMERA_MAX_X])
pt->x = _vars[VAR_CAMERA_MAX_X];
if (pt->y < _vars[VAR_CAMERA_MIN_Y])
pt->y = _vars[VAR_CAMERA_MIN_Y];
if (pt->y > _vars[VAR_CAMERA_MAX_Y])
pt->y = _vars[VAR_CAMERA_MAX_Y];
}
void Scumm::moveCamera()
{
if (_features & GF_AFTER_V7) {
ScummPoint old = camera._cur;
Actor *a = NULL;
if (camera._follows) {
a = derefActorSafe(camera._follows, "moveCamera");
if (abs(camera._cur.x - a->x) > _vars[VAR_CAMERA_THRESHOLD_X] ||
abs(camera._cur.y - a->y) > _vars[VAR_CAMERA_THRESHOLD_Y]) {
camera._movingToActor = true;
if (_vars[VAR_CAMERA_THRESHOLD_X] == 0)
camera._cur.x = a->x;
if (_vars[VAR_CAMERA_THRESHOLD_Y] == 0)
camera._cur.y = a->y;
clampCameraPos(&camera._cur);
}
} else {
camera._movingToActor = false;
}
if (camera._movingToActor) {
camera._dest.x = a->x;
camera._dest.y = a->y;
}
assert(camera._cur.x >= (_realWidth / 2) && camera._cur.y >= (_realHeight / 2));
clampCameraPos(&camera._dest);
if (camera._cur.x < camera._dest.x) {
camera._cur.x += _vars[VAR_CAMERA_SPEED_X];
if (camera._cur.x > camera._dest.x)
camera._cur.x = camera._dest.x;
}
if (camera._cur.x > camera._dest.x) {
camera._cur.x -= _vars[VAR_CAMERA_SPEED_X];
if (camera._cur.x < camera._dest.x)
camera._cur.x = camera._dest.x;
}
if (camera._cur.y < camera._dest.y) {
camera._cur.y += _vars[VAR_CAMERA_SPEED_Y];
if (camera._cur.y > camera._dest.y)
camera._cur.y = camera._dest.y;
}
if (camera._cur.y > camera._dest.y) {
camera._cur.y -= _vars[VAR_CAMERA_SPEED_Y];
if (camera._cur.y < camera._dest.y)
camera._cur.y = camera._dest.y;
}
if (camera._cur.x == camera._dest.x && camera._cur.y == camera._dest.y) {
camera._movingToActor = false;
camera._accel.x = camera._accel.y = 0;
_vars[VAR_CAMERA_SPEED_X] = _vars[VAR_CAMERA_SPEED_Y] = 0;
} else {
camera._accel.x += _vars[VAR_CAMERA_ACCEL_X];
camera._accel.y += _vars[VAR_CAMERA_ACCEL_Y];
_vars[VAR_CAMERA_SPEED_X] += camera._accel.x / 100;
_vars[VAR_CAMERA_SPEED_Y] += camera._accel.y / 100;
if (_vars[VAR_CAMERA_SPEED_X] < 8)
_vars[VAR_CAMERA_SPEED_X] = 8;
if (_vars[VAR_CAMERA_SPEED_Y] < 8)
_vars[VAR_CAMERA_SPEED_Y] = 8;
}
cameraMoved();
if (camera._cur.x != old.x || camera._cur.y != old.y) {
_vars[VAR_CAMERA_POS_X] = camera._cur.x;
_vars[VAR_CAMERA_POS_Y] = camera._cur.y;
_vars[VAR_CAMERA_DEST_X] = camera._dest.x;
_vars[VAR_CAMERA_DEST_Y] = camera._dest.y;
_vars[VAR_CAMERA_FOLLOWED_ACTOR] = camera._follows;
if (_vars[VAR_SCROLL_SCRIPT])
runScript(_vars[VAR_SCROLL_SCRIPT], 0, 0, 0);
}
} else {
int pos = camera._cur.x;
int actorx, t;
Actor *a = NULL;
camera._cur.x &= 0xFFF8;
if (camera._cur.x < _vars[VAR_CAMERA_MIN_X]) {
if (_vars[VAR_CAMERA_FAST_X])
camera._cur.x = _vars[VAR_CAMERA_MIN_X];
else
camera._cur.x += 8;
cameraMoved();
return;
}
if (camera._cur.x > _vars[VAR_CAMERA_MAX_X]) {
if (_vars[VAR_CAMERA_FAST_X])
camera._cur.x = _vars[VAR_CAMERA_MAX_X];
else
camera._cur.x -= 8;
cameraMoved();
return;
}
if (camera._mode == CM_FOLLOW_ACTOR) {
a = derefActorSafe(camera._follows, "moveCamera");
actorx = a->x;
t = (actorx >> 3) - _screenStartStrip;
if (t < camera._leftTrigger || t > camera._rightTrigger) {
if (_vars[VAR_CAMERA_FAST_X]) {
if (t > 35)
camera._dest.x = actorx + 80;
if (t < 5)
camera._dest.x = actorx - 80;
} else
camera._movingToActor = 1;
}
}
if (camera._movingToActor) {
a = derefActorSafe(camera._follows, "moveCamera(2)");
camera._dest.x = a->x;
}
if (camera._dest.x < _vars[VAR_CAMERA_MIN_X])
camera._dest.x = _vars[VAR_CAMERA_MIN_X];
if (camera._dest.x > _vars[VAR_CAMERA_MAX_X])
camera._dest.x = _vars[VAR_CAMERA_MAX_X];
if (_vars[VAR_CAMERA_FAST_X]) {
camera._cur.x = camera._dest.x;
} else {
if (camera._cur.x < camera._dest.x)
camera._cur.x += 8;
if (camera._cur.x > camera._dest.x)
camera._cur.x -= 8;
}
/* a is set a bit above */
if (camera._movingToActor && camera._cur.x >> 3 == a->x >> 3) {
camera._movingToActor = 0;
}
cameraMoved();
if (pos != camera._cur.x && _vars[VAR_SCROLL_SCRIPT]) {
_vars[VAR_CAMERA_POS_X] = camera._cur.x;
runScript(_vars[VAR_SCROLL_SCRIPT], 0, 0, 0);
}
}
}
void Scumm::cameraMoved()
{
if (_features & GF_AFTER_V7) {
assert(camera._cur.x >= (_realWidth / 2) && camera._cur.y >= (_realHeight / 2));
_screenStartStrip = (camera._cur.x - (_realWidth / 2)) >> 3;
_screenEndStrip = _screenStartStrip + NUM_STRIPS - 1;
virtscr[0].xstart = _screenStartStrip << 3;
_screenLeft = camera._cur.x - (_realWidth / 2);
_screenTop = camera._cur.y - (_realHeight / 2);
} else {
if (camera._cur.x < (_realWidth / 2)) {
camera._cur.x = (_realWidth / 2);
} else if (camera._cur.x + (_realWidth / 2) >= _scrWidth) {
camera._cur.x = _scrWidth - (_realWidth / 2);
}
_screenStartStrip = (camera._cur.x >> 3) - 20;
_screenEndStrip = _screenStartStrip + NUM_STRIPS - 1;
virtscr[0].xstart = _screenStartStrip << 3;
}
}
void Scumm::panCameraTo(int x, int y)
{
if (_features & GF_AFTER_V7) {
camera._follows = 0;
camera._dest.x = x;
camera._dest.y = y;
} else {
camera._dest.x = x;
camera._mode = CM_PANNING;
camera._movingToActor = 0;
}
}
void Scumm::actorFollowCamera(int act)
{
if (!(_features & GF_AFTER_V7)) {
int old;
/* mi1 compatibilty */
if (act == 0) {
camera._mode = CM_NORMAL;
camera._follows = 0;
camera._movingToActor = 0;
return;
}
old = camera._follows;
setCameraFollows(derefActorSafe(act, "actorFollowCamera"));
if (camera._follows != old)
runHook(0);
camera._movingToActor = 0;
}
}
void Scumm::setCameraAtEx(int at)
{
if (!(_features & GF_AFTER_V7)) {
camera._mode = CM_NORMAL;
camera._cur.x = at;
setCameraAt(at, 0);
camera._movingToActor = 0;
}
}
void Scumm::palManipulateInit(int start, int end, int string_id, int time)
{
_palManipStart = start;
_palManipEnd = end;
_palManipCounter = 0;
byte *startptr = getResourceAddress(rtTemp, 4);
if (startptr)
nukeResource(rtTemp, 4);
startptr = createResource(rtTemp, 4, 256 * 6);
if (!startptr) {
warning("palManipulateInit(%d,%d,%d,%d): Cannot create rtTemp resource index 4\n", start, end, string_id, time);
return;
}
startptr += _palManipStart * 6;
byte *endptr = getResourceAddress(rtTemp, 5);
if (endptr)
nukeResource(rtTemp, 5);
endptr = createResource(rtTemp, 5, 256 * 6);
if (!endptr) {
warning("palManipulateInit(%d,%d,%d,%d): Cannot create rtTemp resource index 5\n", start, end, string_id, time);
return;
}
endptr += _palManipStart * 6;
byte *curptr = _currentPalette + _palManipStart * 3;
byte *string1ptr = getStringAddress(string_id) + _palManipStart;
byte *string2ptr = getStringAddress(string_id + 1) + _palManipStart;
byte *string3ptr = getStringAddress(string_id + 2) + _palManipStart;
if (!string1ptr || !string2ptr || !string3ptr) {
warning("palManipulateInit(%d,%d,%d,%d): Cannot obtain string resources %d, %d and %d\n",
start, end, string_id, time, string_id, string_id + 1, string_id + 2);
return;
}
int i;
for (i = _palManipStart; i <= _palManipEnd; ++i) {
*((uint16 *)startptr) = ((uint16) *curptr++) << 8;
*((uint16 *)endptr) = ((uint16) *string1ptr++) << 8;
startptr += 2;
endptr += 2;
*((uint16 *)startptr) = ((uint16) *curptr++) << 8;
*((uint16 *)endptr) = ((uint16) *string2ptr++) << 8;
startptr += 2;
endptr += 2;
*((uint16 *)startptr) = ((uint16) *curptr++) << 8;
*((uint16 *)endptr) = ((uint16) *string3ptr++) << 8;
startptr += 2;
endptr += 2;
}
_palManipCounter = time;
}
void Scumm::palManipulate()
{
byte *srcptr, *destptr;
byte *pal;
int i, j;
if (!_palManipCounter)
return;
srcptr = getResourceAddress(rtTemp, 4) + _palManipStart * 6;
destptr = getResourceAddress(rtTemp, 5) + _palManipStart * 6;
if (!srcptr || !destptr)
return;
pal = _currentPalette + _palManipStart * 3;
i = _palManipStart;
while (i < _palManipEnd) {
j = (*((uint16 *)srcptr) += (*(uint16 *)destptr - *((uint16 *)srcptr)) / _palManipCounter);
*pal++ = j >> 8;
srcptr += 2;
destptr += 2;
j = (*((uint16 *)srcptr) += (*(uint16 *)destptr - *((uint16 *)srcptr)) / _palManipCounter);
*pal++ = j >> 8;
srcptr += 2;
destptr += 2;
j = (*((uint16 *)srcptr) += (*(uint16 *)destptr - *((uint16 *)srcptr)) / _palManipCounter);
*pal++ = j >> 8;
srcptr += 2;
destptr += 2;
i++;
}
setDirtyColors(_palManipStart, _palManipEnd);
_palManipCounter--;
if (!_palManipCounter) {
nukeResource(rtTemp, 4);
nukeResource(rtTemp, 5);
}
}
void Scumm::unkRoomFunc3(int palstart, int palend, int rfact, int gfact, int bfact)
{
byte *basepal = getPalettePtr();
byte *pal = basepal;
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++ * rfact) >> 8;
int g = (int) (*pal++ * gfact) >> 8;
int b = (int) (*pal++ * bfact) >> 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, diff, bestsum, bestitem = 0;
compareptr = basepal + palstart * 3;
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 (j = palstart; j <= palend; 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;
}
diff = ar - r;
sum = diff * diff * 3;
diff = ag - g;
sum += diff * diff * 6;
diff = ab - b;
sum += diff * diff * 2;
if (sum < bestsum) {
bestsum = sum;
bestitem = j;
}
}
*table++ = bestitem;
}
}
void Scumm::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, b);
}
void Gdi::resetBackground(int top, int bottom, int strip)
{
VirtScreen *vs = &_vm->virtscr[0];
int offs;
if (top < vs->tdirty[strip])
vs->tdirty[strip] = top;
if (bottom > vs->bdirty[strip])
vs->bdirty[strip] = bottom;
offs = (top * NUM_STRIPS + _vm->_screenStartStrip + strip);
_mask_ptr = _vm->getResourceAddress(rtBuffer, 9) + offs;
_bgbak_ptr = _vm->getResourceAddress(rtBuffer, 5) + (offs << 3);
_backbuff_ptr = vs->screenPtr + (offs << 3);
_numLinesToProcess = bottom - top;
if (_numLinesToProcess) {
if ((_vm->_features & GF_AFTER_V6) || (_vm->_vars[_vm->VAR_CURRENT_LIGHTS] & LIGHTMODE_screen)) {
if (_vm->hasCharsetMask(strip << 3, top, (strip + 1) << 3, bottom))
draw8ColWithMasking();
else
_vm->blit(_backbuff_ptr, _bgbak_ptr, 8, _numLinesToProcess);
} else {
clear8Col();
}
}
}
void Scumm::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 Scumm::setCursorHotspot2(int x, int y)
{
_cursorHotspotX = x;
_cursorHotspotY = y;
}
byte Scumm::isMaskActiveAt(int l, int t, int r, int b, byte *mem)
{
int w, h, i;
l >>= 3;
if (l < 0)
l = 0;
if (t < 0)
t = 0;
r >>= 3;
if (r > NUM_STRIPS-1)
r = NUM_STRIPS-1;
mem += l + t * NUM_STRIPS;
w = r - l;
h = b - t + 1;
do {
for (i = 0; i <= w; i++)
if (mem[i]) {
return true;
}
mem += NUM_STRIPS;
} while (--h);
return false;
}
void Scumm::setPalette(int palindex)
{
byte *pals;
_curPalIndex = palindex;
pals = getPalettePtr();
if (pals == NULL)
error("invalid palette %d", palindex);
setPaletteFromPtr(pals);
}
byte *Scumm::findPalInPals(byte *pal, int idx)
{
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) >> 2;
if ((uint32)idx >= (uint32)size)
return NULL;
return offs + READ_LE_UINT32(offs + idx * sizeof(uint32));
}
byte *Scumm::getPalettePtr()
{
byte *cptr;
cptr = getResourceAddress(rtRoom, _roomResource);
if (_CLUT_offs) {
cptr += _CLUT_offs;
} else {
cptr = findPalInPals(cptr + _PALS_offs, _curPalIndex);
}
return cptr;
}
void Scumm::darkenPalette(int startColor, int endColor, int redScale, int greenScale, int blueScale)
{
if (startColor <= endColor) {
byte *cptr, *cur;
int num;
int color;
cptr = getPalettePtr() + startColor * 3;
cur = _currentPalette + startColor * 3;
num = endColor - startColor + 1;
do {
color = *cptr++;
if (redScale != 0xFF)
color = color * redScale / 0xFF;
if (color > 255)
color = 255;
*cur++ = color;
color = *cptr++;
if (greenScale != 0xFF)
color = color * greenScale / 0xFF;
if (color > 255)
color = 255;
*cur++ = color;
color = *cptr++;
if (blueScale != 0xFF)
color = color * blueScale / 0xFF;
if (color > 255)
color = 255;
*cur++ = color;
} while (--num);
setDirtyColors(startColor, endColor);
}
}
void Scumm::desaturatePalette()
{
// FIXME: Should this be made to take a range of colors instead?
byte *cur;
int i;
cur = _currentPalette;
for (i = 0; i <= 255; i++)
{
int max, min;
int brightness;
// An algorithm that is good enough for The GIMP should be
// good enough for us...
max = (cur[0] > cur[1]) ? cur[0] : cur[1];
if (cur[2] > max)
max = cur[2];
min = (cur[0] < cur[1]) ? cur[0] : cur[1];
if (cur[2] < min)
min = cur[2];
brightness = (min + max) / 2;
*cur++ = brightness;
*cur++ = brightness;
*cur++ = brightness;
}
setDirtyColors(0, 255);
}
void Scumm::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) * _realWidth + x, w, h);
}
void Scumm::decompressBomp(byte *dst, byte *src, int w, int h)
{
int len, num;
byte code, color;
src += 8;
do {
len = w;
src += 2;
while (len) {
code = *src++;
num = (code >> 1) + 1;
if (num > len)
num = len;
len -= num;
if (code & 1) {
color = *src++;
do
*dst++ = color;
while (--num);
} else {
do
*dst++ = *src++;
while (--num);
}
}
} while (--h);
}
void Scumm::grabCursor(byte *ptr, int width, int height)
{
uint size;
byte *dst;
size = width * height;
if (size > sizeof(_grabbedCursor))
error("grabCursor: grabbed cursor too big");
_cursorWidth = width;
_cursorHeight = height;
_cursorAnimate = 0;
dst = _grabbedCursor;
for (; height; height--) {
memcpy(dst, ptr, width);
dst += width;
ptr += _realWidth;
}
updateCursor();
}
void Scumm::useIm01Cursor(byte *im, int w, int h)
{
VirtScreen *vs = &virtscr[0];
w <<= 3;
h <<= 3;
drawBox(0, 0, w - 1, h - 1, 0xFF);
vs->alloctwobuffers = false;
gdi._disable_zbuffer = true;
gdi.drawBitmap(im, vs, _screenStartStrip, 0, h, 0, w >> 3, 0);
vs->alloctwobuffers = true;
gdi._disable_zbuffer = false;
grabCursor(vs->screenPtr + vs->xstart, w, h);
blit(vs->screenPtr + vs->xstart, getResourceAddress(rtBuffer, 5) + vs->xstart, w, h);
}
void Scumm::updateCursor()
{
_system->set_mouse_cursor(_grabbedCursor, _cursorWidth, _cursorHeight,
_cursorHotspotX, _cursorHotspotY);
}
void Scumm::animateCursor()
{
if (_cursorAnimate) {
if (!(_cursorAnimateIndex & 0x3)) {
decompressDefaultCursor((_cursorAnimateIndex >> 2) & 3);
}
_cursorAnimateIndex++;
}
}
void Scumm::useBompCursor(byte *im, int width, int height)
{
uint size;
width <<= 3;
height <<= 3;
size = width * height;
if (size > sizeof(_grabbedCursor))
error("useBompCursor: cursor too big");
_cursorWidth = width;
_cursorHeight = height;
_cursorAnimate = 0;
decompressBomp(_grabbedCursor, im + 10, width, height);
updateCursor();
}
static const byte default_cursor_colors[4] = {
15, 15, 7, 8
};
void Scumm::decompressDefaultCursor(int idx)
{
int i;
byte color;
memset(_grabbedCursor, 0xFF, sizeof(_grabbedCursor));
_cursorWidth = 16;
_cursorHeight = 16;
_cursorHotspotX = 8;
_cursorHotspotY = 8;
color = default_cursor_colors[idx];
for (i = 0; i < 16; i++) {
if ((i < 7) || (i > 9)) {
_grabbedCursor[16 * 8 + i] = color;
_grabbedCursor[16 * i + 8] = color;
}
}
updateCursor();
}
int Scumm::remapPaletteColor(int r, int g, int b, uint threshold)
{
int i;
int ar, ag, ab;
uint sum, j, 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;
j = ar - r;
sum = j * j * 3;
j = ag - g;
sum += j * j * 6;
j = ab - b;
sum += j * j * 2;
if (sum < bestsum) {
bestsum = sum;
bestitem = i;
}
}
if (threshold != (uint) - 1 && bestsum > threshold * threshold * (2 + 3 + 6)) {
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;
}
static int blend_cache[3][256];
static void clear_blend_cache()
{
int i, j;
for (i = 0; i < 3; i++)
for (j = 0; j < 256; j++)
blend_cache[i][j] = -1;
}
static byte blend(byte *pal, byte method, int dest_color)
{
int val = 0;
int cache = 0;
// FIXME: Check if this gives the correct blending for the Dig
// inventory box and conversation menus. For now, I have deliberately
// selected them so that the subsequent multiplication and shift could
// be replaced by just a shift.
switch (method) {
case 1:
cache = 0;
val = 128;
break;
case 2:
cache = 1;
val = 64;
break;
case 3:
cache = 2;
val = 256;
break;
case 255:
return dest_color;
default:
return method;
}
if (blend_cache[cache][dest_color] == -1) {
byte r = *(pal + 3 * dest_color + 0);
byte g = *(pal + 3 * dest_color + 1);
byte b = *(pal + 3 * dest_color + 2);
int new_r = (val * r) >> 8;
int new_g = (val * g) >> 8;
int new_b = (val * b) >> 8;
if (new_r > 255)
new_r = 255;
if (new_g > 255)
new_g = 255;
if (new_b > 255)
new_g = 255;
blend_cache[cache][dest_color] = RGBMatch(pal, new_r, new_g, new_b);
}
return blend_cache[cache][dest_color];
}
// param3= clipping
// param2= mirror
// param1= never used ?
void Scumm::drawBomp(BompDrawData *bd, int param1, byte *dataPtr, int param2, int param3)
{
byte *scale_rows = NULL;
byte *scale_cols = NULL;
byte *dest = bd->out + bd->y * bd->outwidth, *src;
int src_x, src_y, dst_x, dst_y;
uint scaled_width, scaled_height;
int h = bd->srcheight;
uint i;
if (h == 0 || bd->srcwidth == 0)
return;
if (bd->scale_x != 255) {
scale_rows = (byte *) calloc(bd->srcheight, 1);
if (scale_rows == NULL) {
warning("drawBomp: out of memory");
return;
}
}
if (bd->scale_y != 255) {
scale_cols = (byte *) calloc(bd->srcwidth, 1);
if (scale_cols == NULL) {
warning("drawBomp: out of memory");
if (scale_rows)
free(scale_rows);
return;
}
}
// Select which rows and columns from the original to show in the
// scaled version of the image. This is a pretty stupid way of scaling
// images, but it will have to do for now.
if (bd->scale_x < 255) {
scaled_width = (bd->srcwidth * bd->scale_x) / 255;
for (i = 0; i < scaled_width; i++)
scale_cols[(i * 255) / bd->scale_x] = 1;
}
if (bd->scale_y < 255) {
scaled_height = (bd->srcheight * bd->scale_y) / 255;
for (i = 0; i < scaled_height; i++)
scale_rows[(i * 255) / bd->scale_y] = 1;
}
// FIXME: Be more intelligent about clearing the blend cache. It
// should be possible to clear it only for the parts of the palette
// that have changed since the last time.
clear_blend_cache();
dest += bd->x;
src = bd->dataptr;
for (src_y = 0, dst_y = bd->y; src_y < bd->srcheight; src_y++) {
byte code, color;
uint len, num;
byte *d = dest;
if ((dst_y < 0 || dst_y >= bd->outheight) || (bd->scale_y != 255 && !scale_rows[src_y])) {
src += READ_LE_UINT16(src) + 2;
continue;
}
len = bd->srcwidth;
src_x = 0;
dst_x = bd->x;
src += 2;
while (src_x < bd->srcwidth) {
code = *src++;
num = (code >> 1) + 1;
if (num > len)
num = len;
len -= num;
if (code & 1) {
color = *src++;
for (i = 0; i < num; i++) {
if (bd->scale_x == 255 || scale_cols[src_x]) {
if (dst_x >= 0 && dst_x < bd->outwidth)
*d = blend(_currentPalette, color, *d);
d++;
dst_x++;
}
src_x++;
}
} else {
for (i = 0; i < num; i++) {
if (bd->scale_x == 255 || scale_cols[src_x]) {
if (dst_x >= 0 && dst_x < bd->outwidth)
*d = blend(_currentPalette, src[i], *d);
d++;
dst_x++;
}
src_x++;
}
src += num;
}
}
dest += bd->outwidth;
dst_y++;
}
if (scale_rows)
free(scale_rows);
if (scale_cols)
free(scale_cols);
CHECK_HEAP;
}
/* Yazoo: This function create the specialPalette used for semi-transparency in SamnMax */
void Scumm::createSpecialPalette(int16 a, int16 b, int16 c, int16 d, int16 e, int16 colorMin,
int16 colorMax)
{
byte *palPtr;
byte *curPtr;
byte *searchPtr;
byte readComp1;
byte readComp2;
byte readComp3;
int colorComp1;
int colorComp2;
int colorComp3;
int searchComp1;
int searchComp2;
int searchComp3;
short int bestResult;
short int currentResult;
byte currentIndex;
int i;
int j;
palPtr = getPalettePtr();
for (i = 0; i < 256; i++)
_proc_special_palette[i] = i;
curPtr = palPtr + colorMin * 3;
for (i = colorMin; i < colorMax; i++) {
readComp1 = *(curPtr++);
readComp2 = *(curPtr++);
readComp3 = *(curPtr++);
colorComp1 = ((readComp1) * c) >> 8;
colorComp2 = ((readComp2) * d) >> 8;
colorComp3 = ((readComp3) * e) >> 8;
searchPtr = palPtr;
bestResult = 32000;
currentIndex = 0;
for (j = a; j < b; j++) {
searchComp1 = (*searchPtr++);
searchComp2 = (*searchPtr++);
searchComp3 = (*searchPtr++);
currentResult =
abs(searchComp1 - colorComp1) + abs(searchComp2 - colorComp2) + abs(searchComp3 - colorComp3);
if (currentResult < bestResult) {
_proc_special_palette[i] = currentIndex;
bestResult = currentResult;
}
currentIndex++;
}
}
}
Reference in New Issue View Git Blame Copy Permalink