2001-10-09 14:30:12 +00:00
|
|
|
/* ScummVM - Scumm Interpreter
|
|
|
|
* Copyright (C) 2001 Ludvig Strigeus
|
2002-03-20 17:51:07 +00:00
|
|
|
* Copyright (C) 2001/2002 The ScummVM project
|
2001-10-09 14:30:12 +00:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
2001-11-06 20:00:47 +00:00
|
|
|
* $Header$
|
2001-10-09 14:30:12 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "stdafx.h"
|
|
|
|
#include "scumm.h"
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::getGraphicsPerformance()
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
int i;
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
for (i = 10; i != 0; i--) {
|
2001-10-09 14:30:12 +00:00
|
|
|
initScreens(0, 0, 320, 200);
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
_vars[VAR_PERFORMANCE_1] = 0; //_scummTimer;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
for (i = 10; i != 0; i--) {
|
2001-10-09 14:30:12 +00:00
|
|
|
setDirtyRange(0, 0, 200);
|
2001-11-09 18:54:15 +00:00
|
|
|
drawDirtyScreenParts();
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
_vars[VAR_PERFORMANCE_2] = 0; //_scummTimer;
|
2002-03-06 09:40:21 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if (_gameId == GID_DIG)
|
2002-03-06 09:40:21 +00:00
|
|
|
initScreens(0, 0, 320, 200);
|
|
|
|
else
|
|
|
|
initScreens(0, 16, 320, 144);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::initScreens(int a, int b, int w, int h)
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
int i;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
|
|
// nukeResource(rtBuffer, i+1);
|
|
|
|
nukeResource(rtBuffer, i + 5);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if (!getResourceAddress(rtBuffer, 4)) {
|
2001-10-09 14:30:12 +00:00
|
|
|
initVirtScreen(3, 80, 13, false, false);
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
initVirtScreen(0, b, h - b, true, true);
|
2001-10-09 14:30:12 +00:00
|
|
|
initVirtScreen(1, 0, b, false, false);
|
2002-04-11 17:19:16 +00:00
|
|
|
initVirtScreen(2, h, 200 - h, false, false);
|
2001-10-10 10:02:33 +00:00
|
|
|
|
|
|
|
_screenB = b;
|
|
|
|
_screenH = h;
|
|
|
|
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::initVirtScreen(int slot, int top, int height, bool twobufs,
|
|
|
|
bool fourextra)
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
VirtScreen *vs = &virtscr[slot];
|
|
|
|
int size;
|
2002-03-24 00:27:00 +00:00
|
|
|
int i;
|
|
|
|
byte *ptr;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
assert(height >= 0);
|
|
|
|
assert(slot >= 0 && slot < 4);
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
vs->number = slot;
|
2001-10-09 14:30:12 +00:00
|
|
|
vs->unk1 = 0;
|
|
|
|
vs->width = 320;
|
|
|
|
vs->topline = top;
|
|
|
|
vs->height = height;
|
|
|
|
vs->alloctwobuffers = twobufs;
|
2001-10-17 07:12:37 +00:00
|
|
|
vs->scrollable = fourextra;
|
2001-10-09 14:30:12 +00:00
|
|
|
vs->xstart = 0;
|
|
|
|
size = vs->width * vs->height;
|
|
|
|
vs->size = size;
|
2002-03-20 22:58:41 +00:00
|
|
|
vs->backBuf = NULL;
|
2002-03-14 13:57:28 +00:00
|
|
|
|
2001-10-17 07:12:37 +00:00
|
|
|
if (vs->scrollable)
|
2002-04-11 17:19:16 +00:00
|
|
|
size += 320 * 4;
|
|
|
|
// createResource(rtBuffer, slot+1, size);
|
|
|
|
|
|
|
|
vs->screenPtr = _videoBuffer + 328 * top;
|
2002-03-20 22:58:41 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
ptr = vs->screenPtr;
|
|
|
|
for (i = 0; i < size; i++) // reset background ?
|
|
|
|
*ptr++ = 0;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
|
|
|
if (twobufs) {
|
2002-04-11 17:19:16 +00:00
|
|
|
createResource(rtBuffer, slot + 5, size);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (slot != 3) {
|
|
|
|
setDirtyRange(slot, 0, height);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::setDirtyRange(int slot, int top, int bottom)
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
int i;
|
|
|
|
VirtScreen *vs = &virtscr[slot];
|
2002-04-11 17:19:16 +00:00
|
|
|
for (i = 0; i < 40; i++) {
|
2001-10-09 14:30:12 +00:00
|
|
|
vs->tdirty[i] = top;
|
|
|
|
vs->bdirty[i] = bottom;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-12-28 15:26:28 +00:00
|
|
|
/* power of 2 */
|
|
|
|
#define NUM_SHAKE_POSITIONS 8
|
|
|
|
|
|
|
|
static const int8 shake_positions[NUM_SHAKE_POSITIONS] = {
|
2002-04-11 17:19:16 +00:00
|
|
|
0, 1 * 2, 2 * 2, 1 * 2, 0 * 2, 2 * 2, 3 * 2, 1 * 2
|
2001-12-28 15:26:28 +00:00
|
|
|
};
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::drawDirtyScreenParts()
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
int i;
|
|
|
|
VirtScreen *vs;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
|
|
|
updateDirtyScreen(2);
|
2002-04-11 17:19:16 +00:00
|
|
|
if (_features & GF_OLD256)
|
2002-02-17 18:55:46 +00:00
|
|
|
updateDirtyScreen(1);
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if ((camera._last.x == camera._cur.x &&
|
|
|
|
camera._last.y == camera._cur.y && (_features & GF_AFTER_V7))
|
|
|
|
|| (camera._last.x == camera._cur.x)) {
|
2001-10-09 14:30:12 +00:00
|
|
|
updateDirtyScreen(0);
|
|
|
|
} else {
|
2001-10-26 17:34:50 +00:00
|
|
|
vs = &virtscr[0];
|
|
|
|
|
2002-04-12 21:26:59 +00:00
|
|
|
_system->copy_rect(vs->screenPtr + _screenStartStrip * 8, 320,
|
|
|
|
0, vs->topline, 320, vs->height);
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
for (i = 0; i < 40; i++) {
|
2001-10-26 17:34:50 +00:00
|
|
|
vs->tdirty[i] = (byte)vs->height;
|
|
|
|
vs->bdirty[i] = 0;
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
}
|
2001-12-28 15:26:28 +00:00
|
|
|
|
|
|
|
/* Handle shaking */
|
|
|
|
if (_shakeEnabled) {
|
2002-04-11 17:19:16 +00:00
|
|
|
_shakeFrame = (_shakeFrame + 1) & (NUM_SHAKE_POSITIONS - 1);
|
2002-04-12 21:26:59 +00:00
|
|
|
_system->set_shake_pos(shake_positions[_shakeFrame]);
|
2001-12-28 15:26:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::redrawLines(int from, int to)
|
|
|
|
{
|
2001-12-28 15:26:28 +00:00
|
|
|
VirtScreen *vs = virtscr;
|
2002-04-11 17:19:16 +00:00
|
|
|
int i, j;
|
|
|
|
|
|
|
|
if (to <= from)
|
2001-12-28 15:26:28 +00:00
|
|
|
return;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
for (i = 0; i != ARRAYSIZE(virtscr); i++, vs++) {
|
2001-12-28 15:26:28 +00:00
|
|
|
if (to > vs->topline && from < vs->topline + vs->height) {
|
|
|
|
int min = from - vs->topline;
|
|
|
|
int max = to - vs->topline;
|
2002-04-11 17:19:16 +00:00
|
|
|
if (min < 0)
|
|
|
|
min = 0;
|
|
|
|
if (max > vs->height)
|
|
|
|
max = vs->height;
|
|
|
|
for (j = 0; j != 40; j++) {
|
2001-12-28 15:26:28 +00:00
|
|
|
vs->tdirty[j] = min;
|
|
|
|
vs->bdirty[j] = max;
|
|
|
|
}
|
|
|
|
gdi.updateDirtyScreen(vs);
|
|
|
|
}
|
|
|
|
}
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::updateDirtyScreen(int slot)
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
gdi.updateDirtyScreen(&virtscr[slot]);
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Gdi::updateDirtyScreen(VirtScreen * vs)
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
int i;
|
2002-04-11 17:19:16 +00:00
|
|
|
int start, w, top, bottom;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if (vs->height == 0)
|
2001-10-09 14:30:12 +00:00
|
|
|
return;
|
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
_readOffs = 0;
|
2001-10-17 07:12:37 +00:00
|
|
|
if (vs->scrollable)
|
2001-10-26 17:34:50 +00:00
|
|
|
_readOffs = vs->xstart;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
w = 8;
|
|
|
|
start = 0;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
for (i = 0; i < 40; i++) {
|
2001-10-26 17:34:50 +00:00
|
|
|
bottom = vs->bdirty[i];
|
|
|
|
if (bottom) {
|
|
|
|
top = vs->tdirty[i];
|
|
|
|
vs->tdirty[i] = (byte)vs->height;
|
|
|
|
vs->bdirty[i] = 0;
|
2002-04-11 17:19:16 +00:00
|
|
|
if (i != 39 && vs->bdirty[i + 1] == (byte)bottom
|
|
|
|
&& vs->tdirty[i + 1] == (byte)top) {
|
2001-10-26 17:34:50 +00:00
|
|
|
w += 8;
|
|
|
|
continue;
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
2001-10-26 17:34:50 +00:00
|
|
|
drawStripToScreen(vs, start, w, top, bottom);
|
|
|
|
w = 8;
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
start = i + 1;
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Gdi::drawStripToScreen(VirtScreen * vs, int x, int w, int t, int b)
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
byte *ptr;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
if (b <= t)
|
|
|
|
return;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
if (t > vs->height)
|
|
|
|
t = 0;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
if (b > vs->height)
|
|
|
|
b = vs->height;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
ptr = vs->screenPtr + (t * 40 + x) * 8 + _readOffs;
|
2002-04-12 21:26:59 +00:00
|
|
|
|
|
|
|
_vm->_system->copy_rect(
|
|
|
|
ptr, 320, x * 8, vs->topline + t, w, b - t);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void blit(byte *dst, byte *src, int w, int h)
|
|
|
|
{
|
|
|
|
assert(h > 0);
|
2001-10-09 14:30:12 +00:00
|
|
|
do {
|
|
|
|
memcpy(dst, src, w);
|
|
|
|
dst += 320;
|
|
|
|
src += 320;
|
|
|
|
} while (--h);
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::setCursor(int cursor)
|
|
|
|
{
|
2001-12-27 17:51:58 +00:00
|
|
|
warning("setCursor(%d)", cursor);
|
|
|
|
}
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::setCameraAt(int pos_x, int pos_y)
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if (_features & GF_AFTER_V7) {
|
2002-03-05 23:05:55 +00:00
|
|
|
CameraData *cd = &camera;
|
2002-03-08 17:05:09 +00:00
|
|
|
ScummPoint old;
|
2001-12-27 17:51:58 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
old = cd->_cur;
|
2001-12-27 17:51:58 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
cd->_cur.x = pos_x;
|
|
|
|
cd->_cur.y = pos_y;
|
2001-12-27 17:51:58 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
clampCameraPos(&cd->_cur);
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
cd->_dest = cd->_cur;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
assert(cd->_cur.x >= 160 && cd->_cur.y >= 100);
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if ((cd->_cur.x != old.x || cd->_cur.y != old.y)
|
|
|
|
&& _vars[VAR_SCROLL_SCRIPT]) {
|
2002-03-05 23:05:55 +00:00
|
|
|
_vars[VAR_CAMERA_POS_X] = cd->_cur.x;
|
|
|
|
_vars[VAR_CAMERA_POS_Y] = cd->_cur.y;
|
|
|
|
runScript(_vars[VAR_SCROLL_SCRIPT], 0, 0, 0);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
int t;
|
|
|
|
CameraData *cd = &camera;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if (cd->_mode != CM_FOLLOW_ACTOR || abs(pos_x - cd->_cur.x) > 160) {
|
2002-03-05 23:05:55 +00:00
|
|
|
cd->_cur.x = pos_x;
|
|
|
|
}
|
|
|
|
cd->_dest.x = pos_x;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
t = _vars[VAR_CAMERA_MIN_X];
|
2002-04-11 17:19:16 +00:00
|
|
|
if (cd->_cur.x < t)
|
|
|
|
cd->_cur.x = t;
|
2001-12-27 17:51:58 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
t = _vars[VAR_CAMERA_MAX_X];
|
2002-04-11 17:19:16 +00:00
|
|
|
if (cd->_cur.x > t)
|
|
|
|
cd->_cur.x = t;
|
2001-12-27 17:51:58 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (_vars[VAR_SCROLL_SCRIPT]) {
|
|
|
|
_vars[VAR_CAMERA_POS_X] = cd->_cur.x;
|
|
|
|
runScript(_vars[VAR_SCROLL_SCRIPT], 0, 0, 0);
|
|
|
|
}
|
2001-12-27 17:51:58 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (cd->_cur.x != cd->_last.x && charset._hasMask)
|
|
|
|
stopTalk();
|
2001-12-27 17:51:58 +00:00
|
|
|
}
|
|
|
|
}
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::setCameraFollows(Actor * a)
|
|
|
|
{
|
|
|
|
if (_features & GF_AFTER_V7) {
|
2002-03-05 23:05:55 +00:00
|
|
|
CameraData *cd = &camera;
|
|
|
|
byte oldfollow = cd->_follows;
|
2002-04-11 17:19:16 +00:00
|
|
|
int ax, ay;
|
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
cd->_follows = a->number;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (a->room != _currentRoom) {
|
|
|
|
startScene(a->room, 0, 0);
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
ax = abs(a->x - cd->_cur.x);
|
|
|
|
ay = abs(a->y - cd->_cur.y);
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if (ax > _vars[VAR_CAMERA_THRESHOLD_X] ||
|
|
|
|
ay > _vars[VAR_CAMERA_THRESHOLD_Y] || ax > 160 || ay > 100) {
|
2002-03-05 23:05:55 +00:00
|
|
|
setCameraAt(a->x, a->y);
|
|
|
|
}
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (a->number != oldfollow)
|
|
|
|
runHook(0);
|
|
|
|
} else {
|
2002-04-11 17:19:16 +00:00
|
|
|
int t, i;
|
2002-03-05 23:05:55 +00:00
|
|
|
CameraData *cd = &camera;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
cd->_mode = CM_FOLLOW_ACTOR;
|
|
|
|
cd->_follows = a->number;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (a->room != _currentRoom) {
|
|
|
|
startScene(a->room, 0, 0);
|
|
|
|
cd->_mode = CM_FOLLOW_ACTOR;
|
|
|
|
cd->_cur.x = a->x;
|
|
|
|
setCameraAt(cd->_cur.x, 0);
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
t = (a->x >> 3);
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
if (t - _screenStartStrip < cd->_leftTrigger ||
|
|
|
|
t - _screenStartStrip > cd->_rightTrigger)
|
2002-03-05 23:05:55 +00:00
|
|
|
setCameraAt(a->x, 0);
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
for (i = 1, a = getFirstActor(); ++a, i < NUM_ACTORS; i++) {
|
|
|
|
if (a->room == _currentRoom)
|
2002-03-05 23:05:55 +00:00
|
|
|
a->needRedraw = true;
|
|
|
|
}
|
|
|
|
runHook(0);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::initBGBuffers()
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
byte *ptr;
|
|
|
|
int size, itemsize, i;
|
|
|
|
byte *room;
|
|
|
|
|
2001-11-05 19:21:49 +00:00
|
|
|
room = getResourceAddress(rtRoom, _roomResource);
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if (_features & GF_SMALL_HEADER) {
|
|
|
|
gdi._numZBuffer = 1;
|
|
|
|
} else {
|
|
|
|
ptr = findResource(MKID('RMIH'), findResource(MKID('RMIM'), room));
|
|
|
|
gdi._numZBuffer = READ_LE_UINT16(ptr + 8) + 1;
|
|
|
|
}
|
|
|
|
assert(gdi._numZBuffer >= 1 && gdi._numZBuffer <= 5);
|
|
|
|
|
2001-10-09 14:30:12 +00:00
|
|
|
itemsize = (_scrHeight + 4) * 40;
|
2001-10-26 17:34:50 +00:00
|
|
|
size = itemsize * gdi._numZBuffer;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-11-06 21:29:23 +00:00
|
|
|
createResource(rtBuffer, 9, size);
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
gdi._imgBufOffs[i] = i * itemsize;
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::setPaletteFromPtr(byte *ptr)
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
int i, r, g, b;
|
2002-02-24 17:25:03 +00:00
|
|
|
byte *dest;
|
2001-10-10 10:02:33 +00:00
|
|
|
int numcolor;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
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;
|
|
|
|
}
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-10-10 10:02:33 +00:00
|
|
|
checkRange(256, 0, numcolor, "Too many colors (%d) in Palette");
|
2001-10-09 14:30:12 +00:00
|
|
|
|
|
|
|
dest = _currentPalette;
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
for (i = 0; i < numcolor; i++) {
|
2001-11-09 18:54:15 +00:00
|
|
|
r = *ptr++;
|
|
|
|
g = *ptr++;
|
|
|
|
b = *ptr++;
|
2002-04-11 17:19:16 +00:00
|
|
|
if (i <= 15 || r < 252 || g < 252 || b < 252) {
|
2001-12-11 13:34:15 +00:00
|
|
|
*dest++ = r;
|
|
|
|
*dest++ = g;
|
|
|
|
*dest++ = b;
|
2001-11-09 18:54:15 +00:00
|
|
|
} else {
|
|
|
|
dest += 3;
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
}
|
2001-11-09 18:54:15 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
setDirtyColors(0, numcolor - 1);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::setPaletteFromRes()
|
|
|
|
{
|
2001-10-16 10:01:48 +00:00
|
|
|
byte *ptr;
|
2001-11-05 19:21:49 +00:00
|
|
|
ptr = getResourceAddress(rtRoom, _roomResource) + _CLUT_offs;
|
2001-10-16 10:01:48 +00:00
|
|
|
setPaletteFromPtr(ptr);
|
|
|
|
}
|
|
|
|
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::setDirtyColors(int min, int max)
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
if (_palDirtyMin > min)
|
|
|
|
_palDirtyMin = min;
|
|
|
|
if (_palDirtyMax < max)
|
|
|
|
_palDirtyMax = max;
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::initCycl(byte *ptr)
|
|
|
|
{
|
2002-02-24 17:25:03 +00:00
|
|
|
int j;
|
2001-10-26 17:34:50 +00:00
|
|
|
ColorCycle *cycl;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-11-26 19:57:57 +00:00
|
|
|
memset(_colorCycle, 0, sizeof(_colorCycle));
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
while ((j = *ptr++) != 0) {
|
|
|
|
if (j < 1 || j > 16) {
|
2001-10-26 17:34:50 +00:00
|
|
|
error("Invalid color cycle index %d", j);
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
cycl = &_colorCycle[j - 1];
|
2001-10-26 17:34:50 +00:00
|
|
|
|
2001-10-09 14:30:12 +00:00
|
|
|
ptr += 2;
|
2001-10-26 17:34:50 +00:00
|
|
|
cycl->counter = 0;
|
|
|
|
cycl->delay = 16384 / READ_BE_UINT16_UNALIGNED(ptr);
|
2001-10-09 14:30:12 +00:00
|
|
|
ptr += 2;
|
2001-10-26 17:34:50 +00:00
|
|
|
cycl->flags = READ_BE_UINT16_UNALIGNED(ptr);
|
2001-10-09 14:30:12 +00:00
|
|
|
ptr += 2;
|
2001-10-26 17:34:50 +00:00
|
|
|
cycl->start = *ptr++;
|
|
|
|
cycl->end = *ptr++;
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::stopCycle(int i)
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
ColorCycle *cycl;
|
|
|
|
|
2001-10-09 14:30:12 +00:00
|
|
|
checkRange(16, 0, i, "Stop Cycle %d Out Of Range");
|
2002-04-11 17:19:16 +00:00
|
|
|
if (i != 0) {
|
|
|
|
_colorCycle[i - 1].delay = 0;
|
2001-10-09 14:30:12 +00:00
|
|
|
return;
|
|
|
|
}
|
2001-10-26 17:34:50 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
for (i = 0, cycl = _colorCycle; i < 16; i++, cycl++)
|
2001-10-26 17:34:50 +00:00
|
|
|
cycl->delay = 0;
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::cyclePalette()
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
ColorCycle *cycl;
|
2001-10-09 14:30:12 +00:00
|
|
|
int valueToAdd;
|
|
|
|
int i, num;
|
|
|
|
byte *start, *end;
|
|
|
|
byte tmp[3];
|
|
|
|
|
2001-10-16 10:01:48 +00:00
|
|
|
valueToAdd = _vars[VAR_TIMER];
|
|
|
|
if (valueToAdd < _vars[VAR_TIMER_NEXT])
|
|
|
|
valueToAdd = _vars[VAR_TIMER_NEXT];
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if (!_colorCycle) // FIXME
|
2002-03-24 16:35:17 +00:00
|
|
|
return;
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
for (i = 0, cycl = _colorCycle; i < 16; i++, cycl++) {
|
|
|
|
if (cycl->delay && (cycl->counter += valueToAdd) >= cycl->delay) {
|
2001-10-09 14:30:12 +00:00
|
|
|
do {
|
2001-10-26 17:34:50 +00:00
|
|
|
cycl->counter -= cycl->delay;
|
|
|
|
} while (cycl->delay <= cycl->counter);
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
setDirtyColors(cycl->start, cycl->end);
|
2002-04-11 17:19:16 +00:00
|
|
|
moveMemInPalRes(cycl->start, cycl->end, cycl->flags & 2);
|
|
|
|
start = &_currentPalette[cycl->start * 3];
|
|
|
|
end = &_currentPalette[cycl->end * 3];
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
num = cycl->end - cycl->start;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if (!(cycl->flags & 2)) {
|
2001-10-09 14:30:12 +00:00
|
|
|
memmove(tmp, end, 3);
|
2002-04-11 17:19:16 +00:00
|
|
|
memmove(start + 3, start, num * 3);
|
2001-10-09 14:30:12 +00:00
|
|
|
memmove(start, tmp, 3);
|
|
|
|
} else {
|
|
|
|
memmove(tmp, start, 3);
|
2002-04-11 17:19:16 +00:00
|
|
|
memmove(start, start + 3, num * 3);
|
2001-10-09 14:30:12 +00:00
|
|
|
memmove(end, tmp, 3);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::moveMemInPalRes(int start, int end, byte direction)
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
byte *startptr, *endptr;
|
|
|
|
byte *startptr2, *endptr2;
|
|
|
|
int num;
|
|
|
|
byte tmp[6];
|
|
|
|
byte tmp2[6];
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if (!_palManipCounter)
|
2001-10-09 14:30:12 +00:00
|
|
|
return;
|
|
|
|
|
2001-11-05 19:21:49 +00:00
|
|
|
startptr = getResourceAddress(rtTemp, 4) + start * 6;
|
|
|
|
endptr = getResourceAddress(rtTemp, 4) + end * 6;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-11-05 19:21:49 +00:00
|
|
|
startptr2 = getResourceAddress(rtTemp, 5) + start * 6;
|
|
|
|
endptr2 = getResourceAddress(rtTemp, 5) + end * 6;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
|
|
|
num = end - start;
|
2002-03-24 16:35:17 +00:00
|
|
|
|
|
|
|
if (!endptr) {
|
|
|
|
warning("moveMemInPalRes(%d,%d): Bad end pointer\n", start, end);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2001-10-09 14:30:12 +00:00
|
|
|
if (!direction) {
|
|
|
|
memmove(tmp, endptr, 6);
|
2002-04-11 17:19:16 +00:00
|
|
|
memmove(startptr + 6, startptr, num * 6);
|
2001-10-09 14:30:12 +00:00
|
|
|
memmove(startptr, tmp, 6);
|
|
|
|
memmove(tmp2, endptr2, 6);
|
2002-04-11 17:19:16 +00:00
|
|
|
memmove(startptr2 + 6, startptr2, num * 6);
|
2001-10-09 14:30:12 +00:00
|
|
|
memmove(startptr2, tmp2, 6);
|
|
|
|
} else {
|
|
|
|
memmove(tmp, startptr, 6);
|
2002-04-11 17:19:16 +00:00
|
|
|
memmove(startptr, startptr + 6, num * 6);
|
2001-10-09 14:30:12 +00:00
|
|
|
memmove(endptr, tmp, 6);
|
|
|
|
memmove(tmp2, startptr2, 6);
|
2002-04-11 17:19:16 +00:00
|
|
|
memmove(startptr2, startptr2 + 6, num * 6);
|
2001-10-09 14:30:12 +00:00
|
|
|
memmove(endptr2, tmp2, 6);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::unkVirtScreen4(int a)
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
VirtScreen *vs;
|
|
|
|
|
|
|
|
setDirtyRange(0, 0, 0);
|
2002-04-11 17:19:16 +00:00
|
|
|
if (!(_features & GF_AFTER_V7))
|
2002-03-05 23:05:55 +00:00
|
|
|
camera._last.x = camera._cur.x;
|
2001-10-26 17:34:50 +00:00
|
|
|
if (!_screenEffectFlag)
|
2001-10-09 14:30:12 +00:00
|
|
|
return;
|
2001-10-26 17:34:50 +00:00
|
|
|
_screenEffectFlag = false;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
if (a == 0)
|
2001-10-09 14:30:12 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
vs = &virtscr[0];
|
2002-03-20 22:58:41 +00:00
|
|
|
gdi._backbuff_ptr = vs->screenPtr + vs->xstart;
|
2001-10-26 17:34:50 +00:00
|
|
|
memset(gdi._backbuff_ptr, 0, vs->size);
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
switch (a) {
|
|
|
|
case 1:
|
|
|
|
case 2:
|
|
|
|
case 3:
|
|
|
|
unkScreenEffect7(a - 1);
|
2001-10-09 14:30:12 +00:00
|
|
|
break;
|
|
|
|
case 128:
|
|
|
|
unkScreenEffect6();
|
|
|
|
break;
|
|
|
|
case 129:
|
2002-03-09 00:59:29 +00:00
|
|
|
//setDirtyRange(0, 0, vs->height);
|
|
|
|
//updateDirtyScreen(0);
|
2001-10-09 14:30:12 +00:00
|
|
|
/* XXX: EGA_proc4(0); */
|
2002-04-11 17:19:16 +00:00
|
|
|
warning("EGA_proc4"); /* FIXME */
|
2001-10-09 14:30:12 +00:00
|
|
|
break;
|
|
|
|
case 134:
|
|
|
|
unkScreenEffect5(0);
|
|
|
|
break;
|
|
|
|
case 135:
|
|
|
|
unkScreenEffect5(1);
|
|
|
|
break;
|
2001-10-16 10:01:48 +00:00
|
|
|
default:
|
2002-03-09 00:56:22 +00:00
|
|
|
warning("unkVirtScreen4: default case %d", a);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::redrawBGAreas()
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
int i;
|
|
|
|
int val;
|
|
|
|
CameraData *cd = &camera;
|
2002-03-06 12:24:56 +00:00
|
|
|
int diff;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-03-05 23:41:41 +00:00
|
|
|
if (!(_features & GF_AFTER_V7))
|
2002-04-11 17:19:16 +00:00
|
|
|
if (cd->_cur.x != cd->_last.x && charset._hasMask)
|
2002-03-05 23:41:41 +00:00
|
|
|
stopTalk();
|
2001-10-09 14:30:12 +00:00
|
|
|
|
|
|
|
val = 0;
|
|
|
|
|
2001-11-26 19:57:57 +00:00
|
|
|
if (!_fullRedraw && _BgNeedsRedraw) {
|
2002-04-11 17:19:16 +00:00
|
|
|
for (i = 0; i != 40; i++) {
|
|
|
|
if (gfxUsageBits[_screenStartStrip + i] & 0x80000000) {
|
2001-10-09 14:30:12 +00:00
|
|
|
redrawBGStrip(i, 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if (_features & GF_AFTER_V7) {
|
|
|
|
diff = (cd->_cur.x >> 3) - (cd->_last.x >> 3);
|
|
|
|
if (_fullRedraw == 0 && diff == 1) {
|
2002-03-05 23:41:41 +00:00
|
|
|
val = 2;
|
|
|
|
redrawBGStrip(39, 1);
|
2002-04-11 17:19:16 +00:00
|
|
|
} else if (_fullRedraw == 0 && diff == -1) {
|
2002-03-05 23:41:41 +00:00
|
|
|
val = 1;
|
|
|
|
redrawBGStrip(0, 1);
|
2002-04-11 17:19:16 +00:00
|
|
|
} else if (_fullRedraw != 0 || diff != 0) {
|
2002-03-05 23:41:41 +00:00
|
|
|
_BgNeedsRedraw = false;
|
|
|
|
_fullRedraw = false;
|
|
|
|
redrawBGStrip(0, 40);
|
|
|
|
}
|
|
|
|
} else {
|
2002-04-11 17:19:16 +00:00
|
|
|
if (_fullRedraw == 0 && cd->_cur.x - cd->_last.x == 8) {
|
2002-03-05 23:41:41 +00:00
|
|
|
val = 2;
|
|
|
|
redrawBGStrip(39, 1);
|
2002-04-11 17:19:16 +00:00
|
|
|
} else if (_fullRedraw == 0 && cd->_cur.x - cd->_last.x == -8) {
|
2002-03-05 23:41:41 +00:00
|
|
|
val = 1;
|
|
|
|
redrawBGStrip(0, 1);
|
2002-04-11 17:19:16 +00:00
|
|
|
} else if (_fullRedraw != 0 || cd->_cur.x != cd->_last.x) {
|
2002-03-05 23:41:41 +00:00
|
|
|
_BgNeedsRedraw = false;
|
|
|
|
redrawBGStrip(0, 40);
|
|
|
|
}
|
2001-12-27 17:51:58 +00:00
|
|
|
}
|
|
|
|
|
2001-10-09 14:30:12 +00:00
|
|
|
drawRoomObjects(val);
|
2001-11-26 19:57:57 +00:00
|
|
|
_BgNeedsRedraw = false;
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const uint32 zplane_tags[] = {
|
|
|
|
MKID('ZP00'),
|
|
|
|
MKID('ZP01'),
|
|
|
|
MKID('ZP02'),
|
2001-12-27 17:51:58 +00:00
|
|
|
MKID('ZP03'),
|
|
|
|
MKID('ZP04')
|
2001-10-09 14:30:12 +00:00
|
|
|
};
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
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;
|
2001-10-09 14:30:12 +00:00
|
|
|
int i;
|
|
|
|
byte *zplane_list[4];
|
2001-10-26 17:34:50 +00:00
|
|
|
int bottom;
|
2001-10-09 14:30:12 +00:00
|
|
|
byte twobufs;
|
2001-10-26 17:34:50 +00:00
|
|
|
int numzbuf;
|
|
|
|
int sx;
|
2002-02-12 18:20:37 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
CHECK_HEAP if (_vm->_features & GF_SMALL_HEADER)
|
|
|
|
smap_ptr = _smap_ptr = ptr;
|
|
|
|
else
|
|
|
|
smap_ptr = findResource(MKID('SMAP'), ptr);
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-11-11 16:54:45 +00:00
|
|
|
assert(smap_ptr);
|
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
numzbuf = _disable_zbuffer ? 0 : _numZBuffer;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
for (i = 1; i < numzbuf; i++) {
|
2001-11-26 19:57:57 +00:00
|
|
|
zplane_list[i] = findResource(zplane_tags[i], ptr);
|
2001-10-26 17:34:50 +00:00
|
|
|
}
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
bottom = y + h;
|
|
|
|
if (bottom > vs->height) {
|
2002-04-11 17:19:16 +00:00
|
|
|
error("Gdi::drawBitmap, strip drawn to %d below window bottom %d", bottom,
|
|
|
|
vs->height);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
twobufs = vs->alloctwobuffers;
|
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
_vertStripNextInc = h * 320 - 1;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
_numLinesToProcess = h;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
do {
|
2002-04-11 17:19:16 +00:00
|
|
|
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);
|
2001-10-10 10:02:33 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
CHECK_HEAP sx = x;
|
2001-10-26 17:34:50 +00:00
|
|
|
if (vs->scrollable)
|
2002-04-11 17:19:16 +00:00
|
|
|
sx -= vs->xstart >> 3;
|
|
|
|
|
|
|
|
if ((uint) sx >= 40)
|
2001-10-09 14:30:12 +00:00
|
|
|
return;
|
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
if (y < vs->tdirty[sx])
|
2002-04-11 17:19:16 +00:00
|
|
|
vs->tdirty[sx] = y;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
if (bottom > vs->bdirty[sx])
|
|
|
|
vs->bdirty[sx] = bottom;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
_backbuff_ptr = vs->screenPtr + (y * 40 + x) * 8;
|
|
|
|
_bgbak_ptr =
|
|
|
|
_vm->getResourceAddress(rtBuffer, vs->number + 5) + (y * 40 + x) * 8;
|
2001-10-09 14:30:12 +00:00
|
|
|
if (!twobufs) {
|
2001-10-26 17:34:50 +00:00
|
|
|
_bgbak_ptr = _backbuff_ptr;
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
_mask_ptr = _vm->getResourceAddress(rtBuffer, 9) + (y * 40 + x);
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
where_draw_ptr = _bgbak_ptr;
|
2001-10-09 14:30:12 +00:00
|
|
|
decompressBitmap();
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
CHECK_HEAP if (twobufs) {
|
2001-10-26 17:34:50 +00:00
|
|
|
_bgbak_ptr = where_draw_ptr;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
if (_vm->hasCharsetMask(sx << 3, y, (sx + 1) << 3, bottom)) {
|
|
|
|
if (flag & dbClear)
|
2001-10-09 14:30:12 +00:00
|
|
|
clear8ColWithMasking();
|
|
|
|
else
|
2001-11-26 19:57:57 +00:00
|
|
|
draw8ColWithMasking();
|
|
|
|
} else {
|
2002-04-11 17:19:16 +00:00
|
|
|
if (flag & dbClear)
|
2001-10-09 14:30:12 +00:00
|
|
|
clear8Col();
|
2001-11-26 19:57:57 +00:00
|
|
|
else
|
|
|
|
blit(_backbuff_ptr, _bgbak_ptr, 8, h);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
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 * 40 + x;
|
|
|
|
if (_useOrDecompress && flag & dbAllowMaskOr)
|
2001-11-26 19:57:57 +00:00
|
|
|
decompressMaskImgOr();
|
|
|
|
else
|
|
|
|
decompressMaskImg();
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
for (i = 1; i < numzbuf; i++) {
|
2001-10-09 14:30:12 +00:00
|
|
|
if (!zplane_list[i])
|
|
|
|
continue;
|
2002-04-11 17:19:16 +00:00
|
|
|
_z_plane_ptr =
|
|
|
|
zplane_list[i] + READ_LE_UINT16(zplane_list[i] + stripnr * 2 + 8);
|
|
|
|
_mask_ptr_dest =
|
|
|
|
_vm->getResourceAddress(rtBuffer, 9) + y * 40 + x + _imgBufOffs[i];
|
|
|
|
if (_useOrDecompress && flag & dbAllowMaskOr)
|
2001-10-09 14:30:12 +00:00
|
|
|
decompressMaskImgOr();
|
|
|
|
else
|
|
|
|
decompressMaskImg();
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
CHECK_HEAP x++;
|
2001-10-26 17:34:50 +00:00
|
|
|
stripnr++;
|
|
|
|
} while (--numstrip);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Gdi::decompressBitmap()
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
const byte decompress_table[] = {
|
|
|
|
0x0, 0x1, 0x3, 0x7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x0,
|
|
|
|
};
|
|
|
|
|
2001-11-08 19:59:05 +00:00
|
|
|
_useOrDecompress = false;
|
2001-10-10 10:02:33 +00:00
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
byte code = *_smap_ptr++;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
assert(_numLinesToProcess);
|
2001-10-16 10:01:48 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
switch (code) {
|
2001-10-09 14:30:12 +00:00
|
|
|
case 1:
|
2001-10-26 17:34:50 +00:00
|
|
|
unkDecode7();
|
2001-10-09 14:30:12 +00:00
|
|
|
break;
|
2002-02-12 18:20:37 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
case 2:
|
|
|
|
unkDecode8(); /* Ender - Zak256/Indy256 */
|
|
|
|
break;
|
2002-02-12 18:20:37 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
case 3:
|
|
|
|
unkDecode9(); /* Ender - Zak256/Indy256 */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 4:
|
|
|
|
unkDecode10(); /* Ender - Zak256/Indy256 */
|
|
|
|
break;
|
2002-02-12 18:20:37 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
case 7:
|
|
|
|
unkDecode11(); /* Ender - Zak256/Indy256 */
|
|
|
|
break;
|
2002-02-12 18:20:37 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
case 14:
|
|
|
|
case 15:
|
|
|
|
case 16:
|
|
|
|
case 17:
|
|
|
|
case 18:
|
2001-10-26 17:34:50 +00:00
|
|
|
_decomp_shr = code - 10;
|
|
|
|
_decomp_mask = decompress_table[code - 10];
|
|
|
|
unkDecode6();
|
2001-10-09 14:30:12 +00:00
|
|
|
break;
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
case 24:
|
|
|
|
case 25:
|
|
|
|
case 26:
|
|
|
|
case 27:
|
|
|
|
case 28:
|
2001-10-26 17:34:50 +00:00
|
|
|
_decomp_shr = code - 20;
|
|
|
|
_decomp_mask = decompress_table[code - 20];
|
|
|
|
unkDecode5();
|
2001-10-09 14:30:12 +00:00
|
|
|
break;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
case 34:
|
|
|
|
case 35:
|
|
|
|
case 36:
|
|
|
|
case 37:
|
|
|
|
case 38:
|
2001-11-05 19:21:49 +00:00
|
|
|
_useOrDecompress = true;
|
2001-10-26 17:34:50 +00:00
|
|
|
_decomp_shr = code - 30;
|
2002-04-11 17:19:16 +00:00
|
|
|
_decomp_mask = decompress_table[code - 30];
|
2001-10-26 17:34:50 +00:00
|
|
|
unkDecode4();
|
2001-10-09 14:30:12 +00:00
|
|
|
break;
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
case 44:
|
|
|
|
case 45:
|
|
|
|
case 46:
|
|
|
|
case 47:
|
|
|
|
case 48:
|
2001-11-05 19:21:49 +00:00
|
|
|
_useOrDecompress = true;
|
2001-10-26 17:34:50 +00:00
|
|
|
_decomp_shr = code - 40;
|
|
|
|
_decomp_mask = decompress_table[code - 40];
|
|
|
|
unkDecode2();
|
2001-10-09 14:30:12 +00:00
|
|
|
break;
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
case 64:
|
|
|
|
case 65:
|
|
|
|
case 66:
|
|
|
|
case 67:
|
|
|
|
case 68:
|
2001-10-26 17:34:50 +00:00
|
|
|
_decomp_shr = code - 60;
|
|
|
|
_decomp_mask = decompress_table[code - 60];
|
|
|
|
unkDecode1();
|
2001-10-09 14:30:12 +00:00
|
|
|
break;
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
case 84:
|
|
|
|
case 85:
|
|
|
|
case 86:
|
|
|
|
case 87:
|
|
|
|
case 88:
|
2001-11-05 19:21:49 +00:00
|
|
|
_useOrDecompress = true;
|
2001-10-26 17:34:50 +00:00
|
|
|
_decomp_shr = code - 80;
|
|
|
|
_decomp_mask = decompress_table[code - 80];
|
|
|
|
unkDecode3();
|
2001-10-09 14:30:12 +00:00
|
|
|
break;
|
2001-10-16 10:01:48 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
/* New since version 6 */
|
|
|
|
case 104:
|
|
|
|
case 105:
|
|
|
|
case 106:
|
|
|
|
case 107:
|
|
|
|
case 108:
|
2001-10-26 17:34:50 +00:00
|
|
|
_decomp_shr = code - 100;
|
|
|
|
_decomp_mask = decompress_table[code - 100];
|
|
|
|
unkDecode1();
|
2001-10-16 10:01:48 +00:00
|
|
|
break;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
/* New since version 6 */
|
|
|
|
case 124:
|
|
|
|
case 125:
|
|
|
|
case 126:
|
|
|
|
case 127:
|
|
|
|
case 128:
|
2001-11-05 19:21:49 +00:00
|
|
|
_useOrDecompress = true;
|
2001-10-26 17:34:50 +00:00
|
|
|
_decomp_shr = code - 120;
|
|
|
|
_decomp_mask = decompress_table[code - 120];
|
|
|
|
unkDecode3();
|
2001-10-16 10:01:48 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2001-10-26 17:34:50 +00:00
|
|
|
error("Gdi::decompressBitmap: default case %d", code);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
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)
|
2001-10-09 14:30:12 +00:00
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Gdi::draw8ColWithMasking()
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
int height = _numLinesToProcess;
|
|
|
|
byte *mask = _mask_ptr;
|
|
|
|
byte *dst = _backbuff_ptr;
|
|
|
|
byte *src = _bgbak_ptr;
|
2001-10-09 14:30:12 +00:00
|
|
|
byte maskbits;
|
|
|
|
|
|
|
|
do {
|
|
|
|
maskbits = *mask;
|
|
|
|
if (maskbits) {
|
2002-04-11 17:19:16 +00:00
|
|
|
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];
|
2001-10-09 14:30:12 +00:00
|
|
|
} else {
|
|
|
|
/* alignment safe */
|
2002-04-11 17:19:16 +00:00
|
|
|
((uint32 *)dst)[0] = ((uint32 *)src)[0];
|
|
|
|
((uint32 *)dst)[1] = ((uint32 *)src)[1];
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
src += 320;
|
|
|
|
dst += 320;
|
|
|
|
mask += 40;
|
|
|
|
} while (--height);
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Gdi::clear8ColWithMasking()
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
int height = _numLinesToProcess;
|
|
|
|
byte *mask = _mask_ptr;
|
|
|
|
byte *dst = _backbuff_ptr;
|
2001-10-09 14:30:12 +00:00
|
|
|
byte maskbits;
|
|
|
|
|
|
|
|
do {
|
|
|
|
maskbits = *mask;
|
|
|
|
if (!maskbits) {
|
2002-04-11 17:19:16 +00:00
|
|
|
((uint32 *)dst)[1] = ((uint32 *)dst)[0] = 0;
|
2001-10-09 14:30:12 +00:00
|
|
|
} else {
|
2002-04-11 17:19:16 +00:00
|
|
|
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;
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
dst += 320;
|
|
|
|
mask += 40;
|
|
|
|
} while (--height);
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Gdi::clear8Col()
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
int height = _numLinesToProcess;
|
|
|
|
byte *dst = _backbuff_ptr;
|
2001-10-09 14:30:12 +00:00
|
|
|
do {
|
2002-04-11 17:19:16 +00:00
|
|
|
((uint32 *)dst)[1] = ((uint32 *)dst)[0] = 0;
|
2001-10-09 14:30:12 +00:00
|
|
|
dst += 320;
|
|
|
|
} while (--height);
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Gdi::decompressMaskImg()
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
byte *src = _z_plane_ptr;
|
|
|
|
byte *dst = _mask_ptr_dest;
|
|
|
|
int height = _numLinesToProcess;
|
2001-10-09 14:30:12 +00:00
|
|
|
byte b, c;
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
while (1) {
|
2001-10-09 14:30:12 +00:00
|
|
|
b = *src++;
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if (b & 0x80) {
|
|
|
|
b &= 0x7F;
|
2001-10-09 14:30:12 +00:00
|
|
|
c = *src++;
|
|
|
|
|
|
|
|
do {
|
|
|
|
*dst = c;
|
|
|
|
dst += 40;
|
|
|
|
if (!--height)
|
|
|
|
return;
|
|
|
|
} while (--b);
|
|
|
|
} else {
|
|
|
|
do {
|
|
|
|
*dst = *src++;
|
|
|
|
dst += 40;
|
|
|
|
if (!--height)
|
|
|
|
return;
|
|
|
|
} while (--b);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Gdi::decompressMaskImgOr()
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
byte *src = _z_plane_ptr;
|
|
|
|
byte *dst = _mask_ptr_dest;
|
|
|
|
int height = _numLinesToProcess;
|
2001-10-09 14:30:12 +00:00
|
|
|
byte b, c;
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
while (1) {
|
2001-10-09 14:30:12 +00:00
|
|
|
b = *src++;
|
2002-04-11 17:19:16 +00:00
|
|
|
if (b & 0x80) {
|
|
|
|
b &= 0x7F;
|
2001-10-09 14:30:12 +00:00
|
|
|
c = *src++;
|
|
|
|
|
|
|
|
do {
|
|
|
|
*dst |= c;
|
|
|
|
dst += 40;
|
|
|
|
if (!--height)
|
|
|
|
return;
|
|
|
|
} while (--b);
|
|
|
|
} else {
|
|
|
|
do {
|
|
|
|
*dst |= *src++;
|
|
|
|
dst += 40;
|
|
|
|
if (!--height)
|
|
|
|
return;
|
|
|
|
} while (--b);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::redrawBGStrip(int start, int num)
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
int s = _screenStartStrip + start;
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
assert(s >= 0
|
|
|
|
&& (size_t) s < sizeof(gfxUsageBits) / sizeof(gfxUsageBits[0]));
|
2001-10-17 07:12:37 +00:00
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
_curVirtScreen = &virtscr[0];
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
gfxUsageBits[s] |= 0x80000000;
|
|
|
|
|
|
|
|
/*if (_curVirtScreen->height < _scrHeight) {
|
|
|
|
warning("Screen Y size %d < Room height %d",
|
|
|
|
_curVirtScreen->height,
|
|
|
|
_scrHeight);
|
|
|
|
} */
|
2002-03-09 12:23:56 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
gdi.drawBitmap(getResourceAddress(rtRoom, _roomResource) + _IM00_offs,
|
|
|
|
_curVirtScreen, s, 0, _curVirtScreen->height, s, num, 0);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#define READ_BIT (cl--,bit = bits&1, bits>>=1,bit)
|
|
|
|
#define FILL_BITS if (cl <= 8) { bits |= (*src++ << cl); cl += 8;}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Gdi::unkDecode1()
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
byte *src = _smap_ptr;
|
|
|
|
byte *dst = _bgbak_ptr;
|
2001-10-09 14:30:12 +00:00
|
|
|
byte color = *src++;
|
|
|
|
uint bits = *src++;
|
|
|
|
byte cl = 8;
|
|
|
|
byte bit;
|
2002-04-11 17:19:16 +00:00
|
|
|
byte incm, reps;
|
2001-10-26 17:34:50 +00:00
|
|
|
_tempNumLines = _numLinesToProcess;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
do {
|
2001-10-26 17:34:50 +00:00
|
|
|
_currentX = 8;
|
2001-10-09 14:30:12 +00:00
|
|
|
do {
|
2002-04-11 17:19:16 +00:00
|
|
|
FILL_BITS * dst++ = color;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
againPos:;
|
2001-10-16 10:01:48 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if (!READ_BIT) {
|
|
|
|
} else if (READ_BIT) {
|
|
|
|
incm = (bits & 7) - 4;
|
|
|
|
cl -= 3;
|
|
|
|
bits >>= 3;
|
2001-10-16 10:01:48 +00:00
|
|
|
if (!incm) {
|
2002-04-11 17:19:16 +00:00
|
|
|
FILL_BITS reps = bits & 0xFF;
|
2001-10-16 10:01:48 +00:00
|
|
|
do {
|
2001-10-26 17:34:50 +00:00
|
|
|
if (!--_currentX) {
|
|
|
|
_currentX = 8;
|
2001-10-16 10:01:48 +00:00
|
|
|
dst += 312;
|
2001-10-26 17:34:50 +00:00
|
|
|
if (!--_tempNumLines)
|
2001-10-16 10:01:48 +00:00
|
|
|
return;
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
*dst++ = color;
|
2001-10-16 10:01:48 +00:00
|
|
|
} while (--reps);
|
2002-04-11 17:19:16 +00:00
|
|
|
bits >>= 8;
|
|
|
|
bits |= (*src++) << (cl - 8);
|
2001-10-16 10:01:48 +00:00
|
|
|
goto againPos;
|
|
|
|
} else {
|
|
|
|
color += incm;
|
|
|
|
}
|
2001-10-09 14:30:12 +00:00
|
|
|
} else {
|
2002-04-11 17:19:16 +00:00
|
|
|
FILL_BITS color = bits & _decomp_mask;
|
2001-10-26 17:34:50 +00:00
|
|
|
cl -= _decomp_shr;
|
|
|
|
bits >>= _decomp_shr;
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
2001-10-26 17:34:50 +00:00
|
|
|
} while (--_currentX);
|
2001-10-09 14:30:12 +00:00
|
|
|
dst += 312;
|
2001-10-26 17:34:50 +00:00
|
|
|
} while (--_tempNumLines);
|
2001-10-16 10:01:48 +00:00
|
|
|
}
|
2001-10-23 19:51:50 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Gdi::unkDecode2()
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
byte *src = _smap_ptr;
|
|
|
|
byte *dst = _bgbak_ptr;
|
2001-10-09 14:30:12 +00:00
|
|
|
byte color = *src++;
|
|
|
|
int8 inc = -1;
|
|
|
|
uint bits = *src++;
|
|
|
|
byte cl = 8;
|
|
|
|
byte bit;
|
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
_tempNumLines = _numLinesToProcess;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
do {
|
2001-10-26 17:34:50 +00:00
|
|
|
_currentX = 8;
|
2001-10-09 14:30:12 +00:00
|
|
|
do {
|
2002-04-11 17:19:16 +00:00
|
|
|
FILL_BITS if (color != _transparency)
|
|
|
|
*dst = color;
|
2001-10-09 14:30:12 +00:00
|
|
|
dst++;
|
2002-04-11 17:19:16 +00:00
|
|
|
if (!READ_BIT) {
|
|
|
|
} else if (!READ_BIT) {
|
|
|
|
FILL_BITS color = bits & _decomp_mask;
|
2001-10-26 17:34:50 +00:00
|
|
|
bits >>= _decomp_shr;
|
|
|
|
cl -= _decomp_shr;
|
2001-10-09 14:30:12 +00:00
|
|
|
inc = -1;
|
|
|
|
} else if (!READ_BIT) {
|
|
|
|
color += inc;
|
|
|
|
} else {
|
|
|
|
inc = -inc;
|
|
|
|
color += inc;
|
|
|
|
}
|
2001-10-26 17:34:50 +00:00
|
|
|
} while (--_currentX);
|
2001-10-09 14:30:12 +00:00
|
|
|
dst += 312;
|
2001-10-26 17:34:50 +00:00
|
|
|
} while (--_tempNumLines);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Gdi::unkDecode3()
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
byte *src = _smap_ptr;
|
|
|
|
byte *dst = _bgbak_ptr;
|
2001-10-16 10:01:48 +00:00
|
|
|
byte color = *src++;
|
|
|
|
uint bits = *src++;
|
|
|
|
byte cl = 8;
|
|
|
|
byte bit;
|
2002-04-11 17:19:16 +00:00
|
|
|
byte incm, reps;
|
2001-10-16 10:01:48 +00:00
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
_tempNumLines = _numLinesToProcess;
|
2001-10-16 10:01:48 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
do {
|
2001-10-26 17:34:50 +00:00
|
|
|
_currentX = 8;
|
2001-10-16 10:01:48 +00:00
|
|
|
do {
|
2002-04-11 17:19:16 +00:00
|
|
|
FILL_BITS if (color != _transparency)
|
|
|
|
*dst = color;
|
2001-10-16 10:01:48 +00:00
|
|
|
dst++;
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
againPos:;
|
|
|
|
if (!READ_BIT) {
|
|
|
|
} else if (READ_BIT) {
|
|
|
|
incm = (bits & 7) - 4;
|
|
|
|
|
|
|
|
cl -= 3;
|
|
|
|
bits >>= 3;
|
2001-10-16 10:01:48 +00:00
|
|
|
if (incm) {
|
|
|
|
color += incm;
|
|
|
|
} else {
|
2002-04-11 17:19:16 +00:00
|
|
|
FILL_BITS reps = bits & 0xFF;
|
|
|
|
if (color == _transparency) {
|
2001-10-16 10:01:48 +00:00
|
|
|
do {
|
2001-10-26 17:34:50 +00:00
|
|
|
if (!--_currentX) {
|
|
|
|
_currentX = 8;
|
2001-10-16 10:01:48 +00:00
|
|
|
dst += 312;
|
2001-10-26 17:34:50 +00:00
|
|
|
if (!--_tempNumLines)
|
2001-10-16 10:01:48 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
dst++;
|
|
|
|
} while (--reps);
|
|
|
|
} else {
|
|
|
|
do {
|
2001-10-26 17:34:50 +00:00
|
|
|
if (!--_currentX) {
|
|
|
|
_currentX = 8;
|
2001-10-16 10:01:48 +00:00
|
|
|
dst += 312;
|
2001-10-26 17:34:50 +00:00
|
|
|
if (!--_tempNumLines)
|
2001-10-16 10:01:48 +00:00
|
|
|
return;
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
*dst++ = color;
|
2001-10-16 10:01:48 +00:00
|
|
|
} while (--reps);
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
bits >>= 8;
|
|
|
|
bits |= (*src++) << (cl - 8);
|
2001-10-16 10:01:48 +00:00
|
|
|
goto againPos;
|
|
|
|
}
|
|
|
|
} else {
|
2002-04-11 17:19:16 +00:00
|
|
|
FILL_BITS color = bits & _decomp_mask;
|
2001-10-26 17:34:50 +00:00
|
|
|
cl -= _decomp_shr;
|
|
|
|
bits >>= _decomp_shr;
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
2001-10-26 17:34:50 +00:00
|
|
|
} while (--_currentX);
|
2001-10-09 14:30:12 +00:00
|
|
|
dst += 312;
|
2001-10-26 17:34:50 +00:00
|
|
|
} while (--_tempNumLines);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
2001-10-16 10:01:48 +00:00
|
|
|
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Gdi::unkDecode4()
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
byte *src = _smap_ptr;
|
|
|
|
byte *dst = _bgbak_ptr;
|
2001-10-09 14:30:12 +00:00
|
|
|
byte color = *src++;
|
|
|
|
int8 inc = -1;
|
|
|
|
uint bits = *src++;
|
|
|
|
byte cl = 8;
|
|
|
|
byte bit;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
_currentX = 8;
|
2002-04-11 17:19:16 +00:00
|
|
|
do {
|
2001-10-26 17:34:50 +00:00
|
|
|
_tempNumLines = _numLinesToProcess;
|
2001-10-09 14:30:12 +00:00
|
|
|
do {
|
2002-04-11 17:19:16 +00:00
|
|
|
FILL_BITS if (color != _transparency)
|
|
|
|
*dst = color;
|
|
|
|
dst += 320;
|
|
|
|
if (!READ_BIT) {
|
|
|
|
} else if (!READ_BIT) {
|
|
|
|
FILL_BITS color = bits & _decomp_mask;
|
2001-10-26 17:34:50 +00:00
|
|
|
bits >>= _decomp_shr;
|
|
|
|
cl -= _decomp_shr;
|
2001-10-09 14:30:12 +00:00
|
|
|
inc = -1;
|
|
|
|
} else if (!READ_BIT) {
|
|
|
|
color += inc;
|
|
|
|
} else {
|
|
|
|
inc = -inc;
|
|
|
|
color += inc;
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
} while (--_tempNumLines);
|
2001-10-26 17:34:50 +00:00
|
|
|
dst -= _vertStripNextInc;
|
|
|
|
} while (--_currentX);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Gdi::unkDecode5()
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
byte *src = _smap_ptr;
|
|
|
|
byte *dst = _bgbak_ptr;
|
2001-10-09 14:30:12 +00:00
|
|
|
byte color = *src++;
|
|
|
|
int8 inc = -1;
|
|
|
|
uint bits = *src++;
|
|
|
|
byte cl = 8;
|
|
|
|
byte bit;
|
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
_tempNumLines = _numLinesToProcess;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
do {
|
2001-10-26 17:34:50 +00:00
|
|
|
_currentX = 8;
|
2001-10-09 14:30:12 +00:00
|
|
|
do {
|
2002-04-11 17:19:16 +00:00
|
|
|
FILL_BITS * dst++ = color;
|
|
|
|
if (!READ_BIT) {
|
|
|
|
} else if (!READ_BIT) {
|
|
|
|
FILL_BITS color = bits & _decomp_mask;
|
2001-10-26 17:34:50 +00:00
|
|
|
bits >>= _decomp_shr;
|
|
|
|
cl -= _decomp_shr;
|
2001-10-09 14:30:12 +00:00
|
|
|
inc = -1;
|
|
|
|
} else if (!READ_BIT) {
|
|
|
|
color += inc;
|
|
|
|
} else {
|
|
|
|
inc = -inc;
|
|
|
|
color += inc;
|
|
|
|
}
|
2001-10-26 17:34:50 +00:00
|
|
|
} while (--_currentX);
|
2001-10-09 14:30:12 +00:00
|
|
|
dst += 312;
|
2001-10-26 17:34:50 +00:00
|
|
|
} while (--_tempNumLines);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Gdi::unkDecode6()
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
byte *src = _smap_ptr;
|
|
|
|
byte *dst = _bgbak_ptr;
|
2001-10-09 14:30:12 +00:00
|
|
|
byte color = *src++;
|
|
|
|
int8 inc = -1;
|
|
|
|
uint bits = *src++;
|
|
|
|
byte cl = 8;
|
|
|
|
byte bit;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
_currentX = 8;
|
2002-04-11 17:19:16 +00:00
|
|
|
do {
|
2001-10-26 17:34:50 +00:00
|
|
|
_tempNumLines = _numLinesToProcess;
|
2001-10-09 14:30:12 +00:00
|
|
|
do {
|
2002-04-11 17:19:16 +00:00
|
|
|
FILL_BITS * dst = color;
|
|
|
|
dst += 320;
|
|
|
|
if (!READ_BIT) {
|
|
|
|
} else if (!READ_BIT) {
|
|
|
|
FILL_BITS color = bits & _decomp_mask;
|
2001-10-26 17:34:50 +00:00
|
|
|
bits >>= _decomp_shr;
|
|
|
|
cl -= _decomp_shr;
|
2001-10-09 14:30:12 +00:00
|
|
|
inc = -1;
|
|
|
|
} else if (!READ_BIT) {
|
|
|
|
color += inc;
|
|
|
|
} else {
|
|
|
|
inc = -inc;
|
|
|
|
color += inc;
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
} while (--_tempNumLines);
|
2001-10-26 17:34:50 +00:00
|
|
|
dst -= _vertStripNextInc;
|
|
|
|
} while (--_currentX);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-03-09 09:15:34 +00:00
|
|
|
/* Ender - Zak256/Indy256 decoders */
|
|
|
|
#define READ_256BIT \
|
|
|
|
if ((mask <<= 1) == 256) {buffer = *src++; mask = 1;} \
|
|
|
|
bits = ((buffer & mask) != 0);
|
|
|
|
|
|
|
|
#define NEXT_ROW \
|
|
|
|
dst += 320; \
|
|
|
|
if (--h == 0) { \
|
|
|
|
if (!--_currentX) \
|
|
|
|
return; \
|
|
|
|
dst -= _vertStripNextInc; \
|
|
|
|
h = _numLinesToProcess; \
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Gdi::unkDecode7()
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
byte *src = _smap_ptr;
|
|
|
|
byte *dst = _bgbak_ptr;
|
|
|
|
int height = _numLinesToProcess;
|
2002-03-09 09:15:34 +00:00
|
|
|
uint h = _numLinesToProcess;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
|
|
|
|
if (_vm->_features & GF_OLD256) {
|
|
|
|
_currentX = 8;
|
|
|
|
for (;;) {
|
|
|
|
byte color = *src++;
|
|
|
|
*dst = color;
|
|
|
|
NEXT_ROW}
|
|
|
|
return;
|
2002-03-09 09:15:34 +00:00
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2001-10-09 14:30:12 +00:00
|
|
|
do {
|
|
|
|
/* Endian safe */
|
|
|
|
#if defined(SCUMM_NEED_ALIGNMENT)
|
|
|
|
memcpy(dst, src, 8);
|
|
|
|
#else
|
2002-04-11 17:19:16 +00:00
|
|
|
((uint32 *)dst)[0] = ((uint32 *)src)[0];
|
|
|
|
((uint32 *)dst)[1] = ((uint32 *)src)[1];
|
2001-10-09 14:30:12 +00:00
|
|
|
#endif
|
|
|
|
dst += 320;
|
2001-10-10 12:52:21 +00:00
|
|
|
src += 8;
|
2001-10-09 14:30:12 +00:00
|
|
|
} while (--height);
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
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 += 320;
|
|
|
|
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);
|
2002-02-12 18:20:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#undef NEXT_ROW
|
|
|
|
#undef READ_256BIT
|
2001-10-09 14:30:12 +00:00
|
|
|
#undef READ_BIT
|
|
|
|
#undef FILL_BITS
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::restoreCharsetBg()
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
_bkColor = 0;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2001-11-07 18:10:52 +00:00
|
|
|
if (gdi._mask_left != -1) {
|
2002-04-11 17:19:16 +00:00
|
|
|
restoreBG(gdi._mask_left, gdi._mask_top, gdi._mask_right,
|
|
|
|
gdi._mask_bottom);
|
2001-10-09 14:30:12 +00:00
|
|
|
charset._hasMask = false;
|
2001-11-07 18:10:52 +00:00
|
|
|
gdi._mask_left = -1;
|
2001-10-16 10:01:48 +00:00
|
|
|
charset._strLeft = -1;
|
|
|
|
charset._left = -1;
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2001-11-07 18:10:52 +00:00
|
|
|
charset._xpos2 = string[0].xpos;
|
|
|
|
charset._ypos2 = string[0].ypos;
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::restoreBG(int left, int top, int right, int bottom)
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
VirtScreen *vs;
|
|
|
|
int topline, height, width, widthmod;
|
2002-04-11 17:19:16 +00:00
|
|
|
byte *backbuff, *bgbak, *mask;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if (left == right || top == bottom)
|
2001-10-09 14:30:12 +00:00
|
|
|
return;
|
2002-04-11 17:19:16 +00:00
|
|
|
if (top < 0)
|
|
|
|
top = 0;
|
|
|
|
|
|
|
|
if ((vs = findVirtScreen(top)) == NULL)
|
2001-10-09 14:30:12 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
topline = vs->topline;
|
|
|
|
height = topline + vs->height;
|
2002-04-11 17:19:16 +00:00
|
|
|
if (vs->number == 0) {
|
2001-10-09 14:30:12 +00:00
|
|
|
left += _lastXstart - vs->xstart;
|
|
|
|
right += _lastXstart - vs->xstart;
|
|
|
|
}
|
|
|
|
|
|
|
|
right++;
|
2002-04-11 17:19:16 +00:00
|
|
|
if (left < 0)
|
|
|
|
left = 0;
|
|
|
|
if (right < 0)
|
|
|
|
right = 0;
|
|
|
|
if (left > 320)
|
2001-10-09 14:30:12 +00:00
|
|
|
return;
|
2002-04-11 17:19:16 +00:00
|
|
|
if (right > 320)
|
|
|
|
right = 320;
|
|
|
|
if (bottom >= height)
|
|
|
|
bottom = height;
|
|
|
|
|
|
|
|
updateDirtyRect(vs->number, left, right, top - topline, bottom - topline,
|
|
|
|
0x40000000);
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
height = (top - topline) * 320 + vs->xstart + left;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-03-20 22:58:41 +00:00
|
|
|
backbuff = vs->screenPtr + height;
|
2002-04-11 17:19:16 +00:00
|
|
|
bgbak = getResourceAddress(rtBuffer, vs->number + 5) + height;
|
|
|
|
mask =
|
|
|
|
getResourceAddress(rtBuffer,
|
|
|
|
9) + top * 40 + (left >> 3) + _screenStartStrip;
|
|
|
|
if (vs->number == 0) {
|
2001-10-26 17:34:50 +00:00
|
|
|
mask += vs->topline * 216;
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
height = bottom - top;
|
|
|
|
width = right - left;
|
|
|
|
widthmod = (width >> 2) + 2;
|
2001-10-16 20:31:27 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if (vs->alloctwobuffers
|
|
|
|
&& _currentRoom != 0 /*&& _vars[VAR_V5_DRAWFLAGS]&2 */ ) {
|
2001-10-26 17:34:50 +00:00
|
|
|
blit(backbuff, bgbak, width, height);
|
2002-04-11 17:19:16 +00:00
|
|
|
if (vs->number == 0 && charset._hasMask && height) {
|
2001-10-09 14:30:12 +00:00
|
|
|
do {
|
2001-10-26 17:34:50 +00:00
|
|
|
memset(mask, 0, widthmod);
|
|
|
|
mask += 40;
|
2001-10-09 14:30:12 +00:00
|
|
|
} while (--height);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (height) {
|
|
|
|
do {
|
2001-10-26 17:34:50 +00:00
|
|
|
memset(backbuff, _bkColor, width);
|
2002-04-11 17:19:16 +00:00
|
|
|
backbuff += 320;
|
2001-10-09 14:30:12 +00:00
|
|
|
} while (--height);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::updateDirtyRect(int virt, int left, int right, int top,
|
|
|
|
int bottom, uint32 dirtybits)
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
VirtScreen *vs = &virtscr[virt];
|
2002-04-11 17:19:16 +00:00
|
|
|
int lp, rp;
|
2001-11-26 19:57:57 +00:00
|
|
|
uint32 *sp;
|
2001-10-09 14:30:12 +00:00
|
|
|
int num;
|
|
|
|
|
2001-12-27 17:51:58 +00:00
|
|
|
if (top > vs->height || left > vs->width || right < 0 || bottom < 0)
|
2001-10-09 14:30:12 +00:00
|
|
|
return;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
if (top < 0)
|
|
|
|
top = 0;
|
|
|
|
if (left < 0)
|
|
|
|
left = 0;
|
2001-10-09 14:30:12 +00:00
|
|
|
if (bottom > vs->height)
|
|
|
|
bottom = vs->height;
|
2001-12-27 17:51:58 +00:00
|
|
|
if (right > vs->width)
|
|
|
|
right = vs->width;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if (virt == 0 && dirtybits) {
|
2001-10-09 14:30:12 +00:00
|
|
|
rp = (right >> 3) + _screenStartStrip;
|
|
|
|
lp = (left >> 3) + _screenStartStrip;
|
2002-04-11 17:19:16 +00:00
|
|
|
if (lp < 0)
|
|
|
|
lp = 0;
|
2001-10-16 10:01:48 +00:00
|
|
|
if (rp >= 200)
|
|
|
|
rp = 200;
|
2001-10-09 14:30:12 +00:00
|
|
|
if (lp <= rp) {
|
|
|
|
num = rp - lp + 1;
|
2001-11-26 19:57:57 +00:00
|
|
|
sp = &gfxUsageBits[lp];
|
2001-10-09 14:30:12 +00:00
|
|
|
do {
|
|
|
|
*sp++ |= dirtybits;
|
|
|
|
} while (--num);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-11-09 18:54:15 +00:00
|
|
|
setVirtscreenDirty(vs, left, top, right, bottom);
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::setVirtscreenDirty(VirtScreen * vs, int left, int top, int right,
|
|
|
|
int bottom)
|
|
|
|
{
|
2001-11-09 18:54:15 +00:00
|
|
|
int lp = left >> 3;
|
|
|
|
int rp = right >> 3;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if (lp >= 40 || rp < 0)
|
2001-10-09 14:30:12 +00:00
|
|
|
return;
|
2002-04-11 17:19:16 +00:00
|
|
|
if (lp < 0)
|
|
|
|
lp = 0;
|
|
|
|
if (rp >= 40)
|
|
|
|
rp = 39;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
while (lp <= rp) {
|
2001-10-09 14:30:12 +00:00
|
|
|
if (top < vs->tdirty[lp])
|
|
|
|
vs->tdirty[lp] = top;
|
|
|
|
if (bottom > vs->bdirty[lp])
|
|
|
|
vs->bdirty[lp] = bottom;
|
|
|
|
lp++;
|
2002-04-11 17:19:16 +00:00
|
|
|
}
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
VirtScreen *Scumm::findVirtScreen(int y)
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
VirtScreen *vs = virtscr;
|
|
|
|
int i;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
for (i = 0; i < 3; i++, vs++) {
|
|
|
|
if (y >= vs->topline && y < vs->topline + vs->height) {
|
|
|
|
return _curVirtScreen = vs;
|
|
|
|
}
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
return _curVirtScreen = NULL;
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::unkScreenEffect1()
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
/* XXX: not implemented */
|
2001-10-17 10:07:40 +00:00
|
|
|
warning("stub unkScreenEffect1()");
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::unkScreenEffect2()
|
|
|
|
{
|
2001-10-17 10:07:40 +00:00
|
|
|
/* XXX: not implemented */
|
|
|
|
warning("stub unkScreenEffect2()");
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::unkScreenEffect3()
|
|
|
|
{
|
2001-10-17 10:07:40 +00:00
|
|
|
/* XXX: not implemented */
|
|
|
|
warning("stub unkScreenEffect3()");
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::unkScreenEffect4()
|
|
|
|
{
|
2001-10-17 10:07:40 +00:00
|
|
|
/* XXX: not implemented */
|
|
|
|
warning("stub unkScreenEffect4()");
|
|
|
|
}
|
|
|
|
|
|
|
|
static const int8 screen_eff7_table1[4][16] = {
|
2002-04-11 17:19:16 +00:00
|
|
|
{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}
|
2001-10-17 10:07:40 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const byte screen_eff7_table2[4][16] = {
|
2002-04-11 17:19:16 +00:00
|
|
|
{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}
|
2001-10-17 10:07:40 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const byte screen_eff7_table3[4] = {
|
2002-04-11 17:19:16 +00:00
|
|
|
13, 25, 25, 25
|
2001-10-17 10:07:40 +00:00
|
|
|
};
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::unkScreenEffect7(int a)
|
|
|
|
{
|
2001-10-17 10:07:40 +00:00
|
|
|
int tab_1[16];
|
|
|
|
int tab_2[16];
|
2002-04-11 17:19:16 +00:00
|
|
|
int i, j;
|
2001-10-17 10:07:40 +00:00
|
|
|
int bottom;
|
2002-04-11 17:19:16 +00:00
|
|
|
int l, t, r, b;
|
2001-10-17 10:07:40 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
for (i = 0; i < 16; i++) {
|
2001-10-17 10:07:40 +00:00
|
|
|
tab_1[i] = screen_eff7_table1[a][i];
|
|
|
|
j = screen_eff7_table2[a][i];
|
2002-04-11 17:19:16 +00:00
|
|
|
if (j == 24)
|
|
|
|
j = (virtscr[0].height >> 3) - 1;
|
2001-10-17 10:07:40 +00:00
|
|
|
tab_2[i] = j;
|
|
|
|
}
|
|
|
|
|
|
|
|
bottom = virtscr[0].height >> 3;
|
2002-04-11 17:19:16 +00:00
|
|
|
for (j = 0; j < screen_eff7_table3[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) {
|
2001-10-17 10:07:40 +00:00
|
|
|
while (l <= r) {
|
2002-04-11 17:19:16 +00:00
|
|
|
if (l >= 0 && l < 40 && (uint) t < (uint) bottom) {
|
|
|
|
virtscr[0].tdirty[l] = t << 3;
|
|
|
|
virtscr[0].bdirty[l] = (t + 1) << 3;
|
2001-10-17 10:07:40 +00:00
|
|
|
}
|
|
|
|
l++;
|
|
|
|
}
|
|
|
|
} else {
|
2002-04-11 17:19:16 +00:00
|
|
|
if (l < 0 || l >= 40 || b <= t)
|
2001-10-17 10:07:40 +00:00
|
|
|
continue;
|
2002-04-11 17:19:16 +00:00
|
|
|
if (b > bottom)
|
|
|
|
b = bottom;
|
|
|
|
virtscr[0].tdirty[l] = t << 3;
|
|
|
|
virtscr[0].bdirty[l] = (b + 1) << 3;
|
2001-10-17 10:07:40 +00:00
|
|
|
}
|
|
|
|
updateDirtyScreen(0);
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
for (i = 0; i < 16; i++)
|
2001-10-17 10:07:40 +00:00
|
|
|
tab_2[i] += tab_1[i];
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-04-12 21:26:59 +00:00
|
|
|
updatePalette();
|
|
|
|
_system->update_screen();
|
|
|
|
waitForTimer(30);
|
2001-10-17 10:07:40 +00:00
|
|
|
}
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::unkScreenEffect6()
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
/* XXX: not implemented */
|
|
|
|
warning("stub unkScreenEffect6");
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
void Scumm::unkScreenEffect5(int a)
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
/* XXX: not implemented */
|
2002-04-11 17:19:16 +00:00
|
|
|
warning("stub unkScreenEffect5(%d)", a);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::setShake(int mode)
|
|
|
|
{
|
2001-12-28 15:26:28 +00:00
|
|
|
_shakeEnabled = mode != 0;
|
|
|
|
_shakeFrame = 0;
|
2002-04-12 21:26:59 +00:00
|
|
|
_system->set_shake_pos(0);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Gdi::clearUpperMask()
|
|
|
|
{
|
|
|
|
memset(_vm->getResourceAddress(rtBuffer, 9),
|
|
|
|
0, _imgBufOffs[1] - _imgBufOffs[0]
|
|
|
|
);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::clampCameraPos(ScummPoint * pt)
|
|
|
|
{
|
2001-12-27 17:51:58 +00:00
|
|
|
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];
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::moveCamera()
|
|
|
|
{
|
|
|
|
if (_features & GF_AFTER_V7) {
|
2002-03-05 23:05:55 +00:00
|
|
|
CameraData *cd = &camera;
|
2002-03-08 17:05:09 +00:00
|
|
|
ScummPoint old = cd->_cur;
|
2002-04-11 17:19:16 +00:00
|
|
|
Actor *a = NULL;
|
2002-03-05 23:05:55 +00:00
|
|
|
|
|
|
|
if (cd->_follows) {
|
|
|
|
a = derefActorSafe(cd->_follows, "moveCamera");
|
|
|
|
if (abs(cd->_cur.x - a->x) > _vars[VAR_CAMERA_THRESHOLD_X] ||
|
|
|
|
abs(cd->_cur.y - a->y) > _vars[VAR_CAMERA_THRESHOLD_Y]) {
|
|
|
|
cd->_movingToActor = true;
|
|
|
|
if (_vars[VAR_CAMERA_THRESHOLD_X] == 0)
|
|
|
|
cd->_cur.x = a->x;
|
|
|
|
if (_vars[VAR_CAMERA_THRESHOLD_Y] == 0)
|
|
|
|
cd->_cur.y = a->y;
|
|
|
|
clampCameraPos(&cd->_cur);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
cd->_movingToActor = false;
|
2001-12-27 17:51:58 +00:00
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (cd->_movingToActor) {
|
|
|
|
cd->_dest.x = a->x;
|
|
|
|
cd->_dest.y = a->y;
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
assert(cd->_cur.x >= 160 && cd->_cur.y >= 100);
|
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
clampCameraPos(&cd->_dest);
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (cd->_cur.x < cd->_dest.x) {
|
|
|
|
cd->_cur.x += _vars[VAR_CAMERA_SPEED_X];
|
|
|
|
if (cd->_cur.x > cd->_dest.x)
|
|
|
|
cd->_cur.x = cd->_dest.x;
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (cd->_cur.x > cd->_dest.x) {
|
|
|
|
cd->_cur.x -= _vars[VAR_CAMERA_SPEED_X];
|
|
|
|
if (cd->_cur.x < cd->_dest.x)
|
|
|
|
cd->_cur.x = cd->_dest.x;
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (cd->_cur.y < cd->_dest.y) {
|
|
|
|
cd->_cur.y += _vars[VAR_CAMERA_SPEED_Y];
|
|
|
|
if (cd->_cur.y > cd->_dest.y)
|
|
|
|
cd->_cur.y = cd->_dest.y;
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (cd->_cur.y > cd->_dest.y) {
|
|
|
|
cd->_cur.y -= _vars[VAR_CAMERA_SPEED_Y];
|
|
|
|
if (cd->_cur.y < cd->_dest.y)
|
|
|
|
cd->_cur.y = cd->_dest.y;
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
if (cd->_cur.x == cd->_dest.x && cd->_cur.y == cd->_dest.y) {
|
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
cd->_movingToActor = false;
|
|
|
|
cd->_accel.x = cd->_accel.y = 0;
|
|
|
|
_vars[VAR_CAMERA_SPEED_X] = _vars[VAR_CAMERA_SPEED_Y] = 0;
|
|
|
|
} else {
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
cd->_accel.x += _vars[VAR_CAMERA_ACCEL_X];
|
|
|
|
cd->_accel.y += _vars[VAR_CAMERA_ACCEL_Y];
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
_vars[VAR_CAMERA_SPEED_X] += cd->_accel.x / 100;
|
|
|
|
_vars[VAR_CAMERA_SPEED_Y] += cd->_accel.y / 100;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (_vars[VAR_CAMERA_SPEED_X] < 8)
|
|
|
|
_vars[VAR_CAMERA_SPEED_X] = 8;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (_vars[VAR_CAMERA_SPEED_Y] < 8)
|
|
|
|
_vars[VAR_CAMERA_SPEED_Y] = 8;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2001-10-09 14:30:12 +00:00
|
|
|
cameraMoved();
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (cd->_cur.x != old.x || cd->_cur.y != old.y) {
|
|
|
|
_vars[VAR_CAMERA_POS_X] = cd->_cur.x;
|
|
|
|
_vars[VAR_CAMERA_POS_Y] = cd->_cur.y;
|
|
|
|
runScript(_vars[VAR_SCROLL_SCRIPT], 0, 0, 0);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
CameraData *cd = &camera;
|
|
|
|
int pos = cd->_cur.x;
|
|
|
|
int actorx, t;
|
2002-04-11 17:19:16 +00:00
|
|
|
Actor *a = NULL;
|
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
cd->_cur.x &= 0xFFF8;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (cd->_cur.x < _vars[VAR_CAMERA_MIN_X]) {
|
|
|
|
if (_vars[VAR_CAMERA_FAST_X])
|
2002-04-11 17:19:16 +00:00
|
|
|
cd->_cur.x = _vars[VAR_CAMERA_MIN_X];
|
2002-03-05 23:05:55 +00:00
|
|
|
else
|
2002-04-11 17:19:16 +00:00
|
|
|
cd->_cur.x += 8;
|
2002-03-05 23:05:55 +00:00
|
|
|
cameraMoved();
|
2002-04-11 17:19:16 +00:00
|
|
|
return;
|
2002-03-05 23:05:55 +00:00
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (cd->_cur.x > _vars[VAR_CAMERA_MAX_X]) {
|
|
|
|
if (_vars[VAR_CAMERA_FAST_X])
|
|
|
|
cd->_cur.x = _vars[VAR_CAMERA_MAX_X];
|
|
|
|
else
|
2002-04-11 17:19:16 +00:00
|
|
|
cd->_cur.x -= 8;
|
2002-03-05 23:05:55 +00:00
|
|
|
cameraMoved();
|
|
|
|
return;
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
if (cd->_mode == CM_FOLLOW_ACTOR) {
|
2002-03-05 23:05:55 +00:00
|
|
|
a = derefActorSafe(cd->_follows, "moveCamera");
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
actorx = a->x;
|
2002-04-11 17:19:16 +00:00
|
|
|
t = (actorx >> 3) - _screenStartStrip;
|
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (t < cd->_leftTrigger || t > cd->_rightTrigger) {
|
|
|
|
if (_vars[VAR_CAMERA_FAST_X]) {
|
|
|
|
if (t > 35)
|
|
|
|
cd->_dest.x = actorx + 80;
|
|
|
|
if (t < 5)
|
|
|
|
cd->_dest.x = actorx - 80;
|
2002-04-11 17:19:16 +00:00
|
|
|
} else
|
2002-03-05 23:05:55 +00:00
|
|
|
cd->_movingToActor = 1;
|
|
|
|
}
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (cd->_movingToActor) {
|
|
|
|
a = derefActorSafe(cd->_follows, "moveCamera(2)");
|
|
|
|
cd->_dest.x = a->x;
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (cd->_dest.x < _vars[VAR_CAMERA_MIN_X])
|
|
|
|
cd->_dest.x = _vars[VAR_CAMERA_MIN_X];
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (cd->_dest.x > _vars[VAR_CAMERA_MAX_X])
|
|
|
|
cd->_dest.x = _vars[VAR_CAMERA_MAX_X];
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (_vars[VAR_CAMERA_FAST_X]) {
|
|
|
|
cd->_cur.x = cd->_dest.x;
|
|
|
|
} else {
|
|
|
|
if (cd->_cur.x < cd->_dest.x)
|
2002-04-11 17:19:16 +00:00
|
|
|
cd->_cur.x += 8;
|
2002-03-05 23:05:55 +00:00
|
|
|
if (cd->_cur.x > cd->_dest.x)
|
2002-04-11 17:19:16 +00:00
|
|
|
cd->_cur.x -= 8;
|
2002-03-05 23:05:55 +00:00
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
/* a is set a bit above */
|
2002-04-11 17:19:16 +00:00
|
|
|
if (cd->_movingToActor && cd->_cur.x >> 3 == a->x >> 3) {
|
2002-03-05 23:05:55 +00:00
|
|
|
cd->_movingToActor = 0;
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2001-10-09 14:30:12 +00:00
|
|
|
cameraMoved();
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:05:55 +00:00
|
|
|
if (pos != cd->_cur.x && _vars[VAR_SCROLL_SCRIPT]) {
|
|
|
|
_vars[VAR_CAMERA_POS_X] = cd->_cur.x;
|
|
|
|
runScript(_vars[VAR_SCROLL_SCRIPT], 0, 0, 0);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::cameraMoved()
|
|
|
|
{
|
|
|
|
if (_features & GF_AFTER_V7) {
|
2002-03-05 23:41:41 +00:00
|
|
|
CameraData *cd = &camera;
|
2001-12-27 17:51:58 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
assert(cd->_cur.x >= 160 && cd->_cur.y >= 100);
|
|
|
|
|
|
|
|
_screenStartStrip = (cd->_cur.x - 160) >> 3;
|
2002-03-05 23:41:41 +00:00
|
|
|
_screenEndStrip = _screenStartStrip + 39;
|
|
|
|
virtscr[0].xstart = _screenStartStrip << 3;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:41:41 +00:00
|
|
|
_screenLeft = cd->_cur.x - 160;
|
|
|
|
_screenTop = cd->_cur.y - 100;
|
|
|
|
} else {
|
2001-12-27 17:51:58 +00:00
|
|
|
|
2002-03-05 23:41:41 +00:00
|
|
|
CameraData *cd = &camera;
|
2001-12-27 17:51:58 +00:00
|
|
|
|
2002-03-05 23:41:41 +00:00
|
|
|
if (cd->_cur.x < 160) {
|
|
|
|
cd->_cur.x = 160;
|
|
|
|
} else if (cd->_cur.x + 160 >= _scrWidth) {
|
2002-04-11 17:19:16 +00:00
|
|
|
cd->_cur.x = _scrWidth - 160;
|
2002-03-05 23:41:41 +00:00
|
|
|
}
|
2001-12-27 17:51:58 +00:00
|
|
|
|
2002-03-05 23:41:41 +00:00
|
|
|
_screenStartStrip = (cd->_cur.x >> 3) - 20;
|
|
|
|
_screenEndStrip = _screenStartStrip + 39;
|
|
|
|
virtscr[0].xstart = _screenStartStrip << 3;
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::panCameraTo(int x, int y)
|
|
|
|
{
|
|
|
|
if (_features & GF_AFTER_V7) {
|
2002-03-05 23:41:41 +00:00
|
|
|
CameraData *cd = &camera;
|
|
|
|
cd->_follows = 0;
|
|
|
|
cd->_dest.x = x;
|
|
|
|
cd->_dest.y = y;
|
|
|
|
} else {
|
2001-12-27 17:51:58 +00:00
|
|
|
|
2002-03-05 23:41:41 +00:00
|
|
|
CameraData *cd = &camera;
|
|
|
|
cd->_dest.x = x;
|
|
|
|
cd->_mode = CM_PANNING;
|
|
|
|
cd->_movingToActor = 0;
|
|
|
|
}
|
2001-10-16 10:01:48 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::actorFollowCamera(int act)
|
|
|
|
{
|
|
|
|
if (!(_features & GF_AFTER_V7)) {
|
2002-03-05 23:41:41 +00:00
|
|
|
int old;
|
|
|
|
CameraData *cd = &camera;
|
2001-10-16 10:01:48 +00:00
|
|
|
|
2002-03-05 23:41:41 +00:00
|
|
|
/* mi1 compatibilty */
|
2002-04-11 17:19:16 +00:00
|
|
|
if (act == 0) {
|
2002-03-05 23:41:41 +00:00
|
|
|
cd->_mode = CM_NORMAL;
|
|
|
|
cd->_follows = 0;
|
|
|
|
cd->_movingToActor = 0;
|
|
|
|
return;
|
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-05 23:41:41 +00:00
|
|
|
old = cd->_follows;
|
|
|
|
setCameraFollows(derefActorSafe(act, "actorFollowCamera"));
|
2002-04-11 17:19:16 +00:00
|
|
|
if (cd->_follows != old)
|
2002-03-05 23:41:41 +00:00
|
|
|
runHook(0);
|
2001-10-16 10:01:48 +00:00
|
|
|
|
2002-03-05 23:41:41 +00:00
|
|
|
cd->_movingToActor = 0;
|
|
|
|
}
|
2001-10-16 10:01:48 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::setCameraAtEx(int at)
|
|
|
|
{
|
|
|
|
if (!(_features & GF_AFTER_V7)) {
|
2002-03-05 23:41:41 +00:00
|
|
|
CameraData *cd = &camera;
|
|
|
|
cd->_mode = CM_NORMAL;
|
|
|
|
cd->_cur.x = at;
|
|
|
|
setCameraAt(at, 0);
|
|
|
|
cd->_movingToActor = 0;
|
|
|
|
}
|
2001-10-16 10:01:48 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::palManipulate()
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
byte *srcptr, *destptr;
|
|
|
|
byte *pal;
|
2002-04-11 17:19:16 +00:00
|
|
|
int i, j;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
|
|
|
if (!_palManipCounter)
|
|
|
|
return;
|
2002-04-11 17:19:16 +00:00
|
|
|
srcptr = getResourceAddress(rtTemp, 4) + _palManipStart * 6;
|
|
|
|
destptr = getResourceAddress(rtTemp, 5) + _palManipStart * 6;
|
2001-10-09 14:30:12 +00:00
|
|
|
pal = _currentPalette + _palManipStart * 3;
|
|
|
|
|
|
|
|
i = _palManipStart;
|
|
|
|
while (i < _palManipEnd) {
|
2002-04-11 17:19:16 +00:00
|
|
|
j = (*((uint16 *)srcptr) += *(uint16 *)destptr);
|
|
|
|
*pal++ = j >> 8;
|
2001-10-09 14:30:12 +00:00
|
|
|
srcptr += 2;
|
|
|
|
destptr += 2;
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
j = (*((uint16 *)srcptr) += *(uint16 *)destptr);
|
|
|
|
*pal++ = j >> 8;
|
2001-10-09 14:30:12 +00:00
|
|
|
srcptr += 2;
|
|
|
|
destptr += 2;
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
j = (*((uint16 *)srcptr) += *(uint16 *)destptr);
|
|
|
|
*pal++ = j >> 8;
|
2001-10-09 14:30:12 +00:00
|
|
|
srcptr += 2;
|
|
|
|
destptr += 2;
|
|
|
|
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
setDirtyColors(_palManipStart, _palManipEnd);
|
|
|
|
if (!--_palManipCounter) {
|
2001-11-05 19:21:49 +00:00
|
|
|
nukeResource(rtTemp, 4);
|
|
|
|
nukeResource(rtTemp, 5);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::swapPalColors(int a, int b)
|
|
|
|
{
|
|
|
|
byte *ap, *bp;
|
2001-11-11 16:54:45 +00:00
|
|
|
byte t;
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if ((uint) a >= 256 || (uint) b >= 256)
|
2001-11-11 16:54:45 +00:00
|
|
|
error("swapPalColors: invalid values, %d, %d", a, b);
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
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;
|
2001-11-11 16:54:45 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
setDirtyColors(a, b);
|
2001-11-11 16:54:45 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::screenEffect(int effect)
|
|
|
|
{
|
|
|
|
switch (effect) {
|
2001-10-17 10:07:40 +00:00
|
|
|
case 1:
|
|
|
|
case 2:
|
2002-04-11 17:19:16 +00:00
|
|
|
case 3:
|
|
|
|
unkScreenEffect7(effect - 1);
|
|
|
|
break;
|
|
|
|
case 128:
|
|
|
|
unkScreenEffect6();
|
|
|
|
break;
|
|
|
|
case 130:
|
|
|
|
unkScreenEffect1();
|
|
|
|
break;
|
|
|
|
case 131:
|
|
|
|
unkScreenEffect2();
|
|
|
|
break;
|
|
|
|
case 132:
|
|
|
|
unkScreenEffect3();
|
|
|
|
break;
|
|
|
|
case 133:
|
|
|
|
unkScreenEffect4();
|
|
|
|
break;
|
|
|
|
case 134:
|
|
|
|
unkScreenEffect5(0);
|
|
|
|
break;
|
|
|
|
case 135:
|
|
|
|
unkScreenEffect5(1);
|
|
|
|
break;
|
|
|
|
case 129:
|
|
|
|
break;
|
2001-10-17 10:07:40 +00:00
|
|
|
default:
|
|
|
|
warning("Unknown screen effect, %d", effect);
|
|
|
|
}
|
2001-10-26 17:34:50 +00:00
|
|
|
_screenEffectFlag = true;
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::resetActorBgs()
|
|
|
|
{
|
2001-10-09 14:30:12 +00:00
|
|
|
Actor *a;
|
2001-11-26 19:57:57 +00:00
|
|
|
int i;
|
2002-04-11 17:19:16 +00:00
|
|
|
uint32 onlyActorFlags, bitpos;
|
|
|
|
|
|
|
|
for (i = 0; i < 40; i++) {
|
|
|
|
onlyActorFlags = (gfxUsageBits[_screenStartStrip + i] &= 0x3FFFFFFF);
|
2001-10-09 14:30:12 +00:00
|
|
|
a = getFirstActor();
|
|
|
|
bitpos = 1;
|
|
|
|
|
2001-10-10 10:02:33 +00:00
|
|
|
while (onlyActorFlags) {
|
2002-04-11 17:19:16 +00:00
|
|
|
if (onlyActorFlags & 1 && a->top != 0xFF && a->needBgReset) {
|
2001-11-26 19:57:57 +00:00
|
|
|
gfxUsageBits[_screenStartStrip + i] ^= bitpos;
|
2001-10-26 17:34:50 +00:00
|
|
|
gdi.resetBackground(a->top, a->bottom, i);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
bitpos <<= 1;
|
|
|
|
onlyActorFlags >>= 1;
|
2001-10-09 14:30:12 +00:00
|
|
|
a++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
for (i = 1, a = getFirstActor(); ++a, i < NUM_ACTORS; i++) {
|
2001-10-09 14:30:12 +00:00
|
|
|
a->needBgReset = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Gdi::resetBackground(byte top, byte bottom, int strip)
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
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;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
offs = (top * 40 + _vm->_screenStartStrip + strip);
|
2002-04-11 17:19:16 +00:00
|
|
|
_mask_ptr = _vm->getResourceAddress(rtBuffer, 9) + offs;
|
|
|
|
_bgbak_ptr = _vm->getResourceAddress(rtBuffer, 5) + (offs << 3);
|
|
|
|
_backbuff_ptr = vs->screenPtr + (offs << 3);
|
|
|
|
|
2001-10-26 17:34:50 +00:00
|
|
|
_numLinesToProcess = bottom - top;
|
|
|
|
if (_numLinesToProcess) {
|
2002-04-11 17:19:16 +00:00
|
|
|
if (1 /*_vm->_vars[VAR_V5_DRAWFLAGS]&2*/ ) {
|
|
|
|
if (_vm->hasCharsetMask(strip << 3, top, (strip + 1) << 3, bottom))
|
2001-10-26 17:34:50 +00:00
|
|
|
draw8ColWithMasking();
|
|
|
|
else
|
|
|
|
blit(_backbuff_ptr, _bgbak_ptr, 8, _numLinesToProcess);
|
|
|
|
} else {
|
|
|
|
clear8Col();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
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);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::setCursorHotspot2(int x, int y)
|
|
|
|
{
|
2001-11-06 20:00:47 +00:00
|
|
|
_cursorHotspotX = x;
|
|
|
|
_cursorHotspotY = y;
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
byte Scumm::isMaskActiveAt(int l, int t, int r, int b, byte *mem)
|
|
|
|
{
|
|
|
|
int w, h, i;
|
|
|
|
if (_features & GF_SMALL_HEADER)
|
2002-04-05 16:41:02 +00:00
|
|
|
return 0;
|
2002-04-11 17:19:16 +00:00
|
|
|
l >>= 3;
|
|
|
|
if (l < 0)
|
|
|
|
l = 0;
|
|
|
|
if (t < 0)
|
|
|
|
t = 0;
|
2001-11-06 21:29:23 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
r >>= 3;
|
|
|
|
if (r > 39)
|
|
|
|
r = 39;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
mem += l + t * 40;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
w = r - l;
|
|
|
|
h = b - t + 1;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
|
|
|
do {
|
2002-04-11 17:19:16 +00:00
|
|
|
for (i = 0; i <= w; i++)
|
2001-10-09 14:30:12 +00:00
|
|
|
if (mem[i])
|
|
|
|
return true;
|
2001-11-06 21:29:23 +00:00
|
|
|
mem += 40;
|
2001-10-09 14:30:12 +00:00
|
|
|
} while (--h);
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2001-10-09 14:30:12 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::setPalette(int palindex)
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
byte *pals;
|
|
|
|
|
|
|
|
_curPalIndex = palindex;
|
|
|
|
pals = getPalettePtr();
|
2002-04-11 17:19:16 +00:00
|
|
|
if (pals == NULL)
|
2001-10-26 17:34:50 +00:00
|
|
|
error("invalid palette %d", palindex);
|
|
|
|
setPaletteFromPtr(pals);
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
byte *Scumm::findPalInPals(byte *pal, int idx)
|
|
|
|
{
|
2001-10-16 10:01:48 +00:00
|
|
|
byte *offs;
|
2002-04-11 17:19:16 +00:00
|
|
|
uint32 size;
|
2001-10-16 10:01:48 +00:00
|
|
|
|
2001-11-26 19:57:57 +00:00
|
|
|
pal = findResource(MKID('WRAP'), pal);
|
2002-04-11 17:19:16 +00:00
|
|
|
if (pal == NULL)
|
2001-10-16 10:01:48 +00:00
|
|
|
return NULL;
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
offs = findResourceData(MKID('OFFS'), pal);
|
|
|
|
if (offs == NULL)
|
2001-10-16 10:01:48 +00:00
|
|
|
return NULL;
|
|
|
|
|
2001-12-27 17:51:58 +00:00
|
|
|
size = getResourceDataSize(offs) >> 2;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2002-03-08 08:42:11 +00:00
|
|
|
if ((uint32)idx >= (uint32)size)
|
2001-10-16 10:01:48 +00:00
|
|
|
return NULL;
|
|
|
|
|
2002-03-08 08:42:11 +00:00
|
|
|
return offs + READ_LE_UINT32(offs + idx * sizeof(uint32));
|
2001-10-16 10:01:48 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
byte *Scumm::getPalettePtr()
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
byte *cptr;
|
2001-10-16 10:01:48 +00:00
|
|
|
|
2001-11-05 19:21:49 +00:00
|
|
|
cptr = getResourceAddress(rtRoom, _roomResource);
|
2001-10-26 17:34:50 +00:00
|
|
|
if (_CLUT_offs) {
|
|
|
|
cptr += _CLUT_offs;
|
|
|
|
} else {
|
|
|
|
cptr = findPalInPals(cptr + _PALS_offs, _curPalIndex);
|
|
|
|
}
|
|
|
|
return cptr;
|
2001-10-16 10:01:48 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::darkenPalette(int a, int b, int c, int d, int e)
|
|
|
|
{
|
2001-10-26 17:34:50 +00:00
|
|
|
byte *cptr, *cur;
|
|
|
|
int num;
|
2001-12-11 13:34:15 +00:00
|
|
|
int color;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
cptr = getPalettePtr() + a * 3;
|
|
|
|
cur = _currentPalette + a * 3;
|
2001-11-09 18:54:15 +00:00
|
|
|
if (a <= b) {
|
|
|
|
num = b - a + 1;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-11-09 18:54:15 +00:00
|
|
|
do {
|
2001-12-11 13:34:15 +00:00
|
|
|
color = *cptr++;
|
|
|
|
if (c != 0xFF)
|
|
|
|
color = color * c / 0xFF;
|
2002-04-11 17:19:16 +00:00
|
|
|
if (color > 255)
|
|
|
|
color = 255;
|
|
|
|
*cur++ = color;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-12-11 13:34:15 +00:00
|
|
|
color = *cptr++;
|
|
|
|
if (d != 0xFF)
|
|
|
|
color = color * d / 0xFF;
|
2002-04-11 17:19:16 +00:00
|
|
|
if (color > 255)
|
|
|
|
color = 255;
|
|
|
|
*cur++ = color;
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2001-12-11 13:34:15 +00:00
|
|
|
color = *cptr++;
|
|
|
|
if (e != 0xFF)
|
|
|
|
color = color * e / 0xFF;
|
2002-04-11 17:19:16 +00:00
|
|
|
if (color > 255)
|
|
|
|
color = 255;
|
|
|
|
*cur++ = color;
|
2001-11-09 18:54:15 +00:00
|
|
|
} while (--num);
|
2001-10-26 17:34:50 +00:00
|
|
|
}
|
2002-04-11 17:19:16 +00:00
|
|
|
setDirtyColors(a, b);
|
2001-10-26 17:34:50 +00:00
|
|
|
}
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::grabCursor(int x, int y, int w, int h)
|
|
|
|
{
|
2001-11-06 20:00:47 +00:00
|
|
|
VirtScreen *vs = findVirtScreen(y);
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if (vs == NULL) {
|
2001-11-06 20:00:47 +00:00
|
|
|
warning("grabCursor: invalid Y %d", y);
|
2001-10-26 17:34:50 +00:00
|
|
|
return;
|
|
|
|
}
|
2001-10-09 14:30:12 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
grabCursor(vs->screenPtr + (y - vs->topline) * 320 + x, w, h);
|
2001-11-05 19:21:49 +00:00
|
|
|
|
2001-11-06 20:00:47 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::decompressBomp(byte *dst, byte *src, int w, int h)
|
|
|
|
{
|
|
|
|
int len, num;
|
|
|
|
byte code, color;
|
2001-11-06 20:00:47 +00:00
|
|
|
|
|
|
|
src += 8;
|
|
|
|
|
|
|
|
do {
|
|
|
|
len = w;
|
|
|
|
src += 2;
|
|
|
|
while (len) {
|
|
|
|
code = *src++;
|
2002-04-11 17:19:16 +00:00
|
|
|
num = (code >> 1) + 1;
|
|
|
|
if (num > len)
|
|
|
|
num = len;
|
2001-11-06 20:00:47 +00:00
|
|
|
len -= num;
|
2002-04-11 17:19:16 +00:00
|
|
|
if (code & 1) {
|
2001-11-06 20:00:47 +00:00
|
|
|
color = *src++;
|
2002-04-11 17:19:16 +00:00
|
|
|
do
|
|
|
|
*dst++ = color;
|
|
|
|
while (--num);
|
2001-11-06 20:00:47 +00:00
|
|
|
} else {
|
2002-04-11 17:19:16 +00:00
|
|
|
do
|
|
|
|
*dst++ = *src++;
|
|
|
|
while (--num);
|
2001-11-06 20:00:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} while (--h);
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::grabCursor(byte *ptr, int width, int height)
|
|
|
|
{
|
2001-11-06 20:00:47 +00:00
|
|
|
uint size;
|
|
|
|
byte *dst;
|
2002-04-11 17:19:16 +00:00
|
|
|
|
2001-11-05 19:21:49 +00:00
|
|
|
size = width * height;
|
2001-11-06 20:00:47 +00:00
|
|
|
if (size > sizeof(_grabbedCursor))
|
2001-11-05 19:21:49 +00:00
|
|
|
error("grabCursor: grabbed cursor too big");
|
2001-11-06 20:00:47 +00:00
|
|
|
|
|
|
|
_cursorWidth = width;
|
|
|
|
_cursorHeight = height;
|
2001-11-09 18:54:15 +00:00
|
|
|
_cursorAnimate = 0;
|
2001-11-06 20:00:47 +00:00
|
|
|
|
|
|
|
dst = _grabbedCursor;
|
2002-04-11 17:19:16 +00:00
|
|
|
for (; height; height--) {
|
2001-11-06 20:00:47 +00:00
|
|
|
memcpy(dst, ptr, width);
|
|
|
|
dst += width;
|
|
|
|
ptr += 320;
|
|
|
|
}
|
2002-04-12 21:26:59 +00:00
|
|
|
|
|
|
|
updateCursor();
|
2001-11-06 20:00:47 +00:00
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::useIm01Cursor(byte *im, int w, int h)
|
|
|
|
{
|
2001-11-06 20:00:47 +00:00
|
|
|
VirtScreen *vs = &virtscr[0];
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
w <<= 3;
|
|
|
|
h <<= 3;
|
|
|
|
|
|
|
|
drawBox(0, 0, w - 1, h - 1, 0xFF);
|
2001-11-06 20:00:47 +00:00
|
|
|
|
|
|
|
vs->alloctwobuffers = false;
|
|
|
|
gdi._disable_zbuffer = true;
|
2002-04-11 17:19:16 +00:00
|
|
|
gdi.drawBitmap(im, vs, _screenStartStrip, 0, h, 0, w >> 3, 0);
|
2001-11-06 20:00:47 +00:00
|
|
|
vs->alloctwobuffers = true;
|
|
|
|
gdi._disable_zbuffer = false;
|
|
|
|
|
2002-03-20 22:58:41 +00:00
|
|
|
grabCursor(vs->screenPtr + vs->xstart, w, h);
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
blit(vs->screenPtr + vs->xstart,
|
|
|
|
getResourceAddress(rtBuffer, 5) + vs->xstart, w, h);
|
2001-11-06 20:00:47 +00:00
|
|
|
}
|
|
|
|
|
2002-04-12 21:26:59 +00:00
|
|
|
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++;
|
|
|
|
}
|
|
|
|
|
|
|
|
updateCursor();
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::useBompCursor(byte *im, int width, int height)
|
|
|
|
{
|
2001-11-06 20:00:47 +00:00
|
|
|
uint size;
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
width <<= 3;
|
|
|
|
height <<= 3;
|
|
|
|
|
2001-11-06 20:00:47 +00:00
|
|
|
size = width * height;
|
|
|
|
if (size > sizeof(_grabbedCursor))
|
|
|
|
error("useBompCursor: cursor too big");
|
|
|
|
|
|
|
|
_cursorWidth = width;
|
|
|
|
_cursorHeight = height;
|
2001-11-09 18:54:15 +00:00
|
|
|
_cursorAnimate = 0;
|
2001-11-06 20:00:47 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
decompressBomp(_grabbedCursor, im + 10, width, height);
|
2002-04-12 21:26:59 +00:00
|
|
|
|
|
|
|
updateCursor();
|
2001-11-06 20:00:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const byte default_cursor_colors[4] = {
|
2002-04-11 17:19:16 +00:00
|
|
|
15, 15, 7, 8
|
2001-11-06 20:00:47 +00:00
|
|
|
};
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::decompressDefaultCursor(int idx)
|
|
|
|
{
|
2001-11-06 20:00:47 +00:00
|
|
|
int i;
|
|
|
|
byte color;
|
|
|
|
|
|
|
|
memset(_grabbedCursor, 0xFF, sizeof(_grabbedCursor));
|
|
|
|
_cursorWidth = 16;
|
|
|
|
_cursorHeight = 16;
|
|
|
|
_cursorHotspotX = 8;
|
|
|
|
_cursorHotspotY = 7;
|
|
|
|
|
2002-03-08 08:42:11 +00:00
|
|
|
color = default_cursor_colors[idx];
|
2002-04-11 17:19:16 +00:00
|
|
|
|
|
|
|
for (i = 0; i < 16; i++) {
|
|
|
|
_grabbedCursor[16 * 8 + i] = color;
|
|
|
|
_grabbedCursor[16 * i + 8] = color;
|
2001-11-06 20:00:47 +00:00
|
|
|
}
|
2002-04-12 21:26:59 +00:00
|
|
|
|
|
|
|
updateCursor();
|
2001-10-09 14:30:12 +00:00
|
|
|
}
|
2001-11-26 19:57:57 +00:00
|
|
|
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
int Scumm::remapPaletteColor(int r, int g, int b, uint threshold)
|
|
|
|
{
|
2001-11-26 19:57:57 +00:00
|
|
|
int i;
|
2002-04-11 17:19:16 +00:00
|
|
|
int ar, ag, ab;
|
|
|
|
uint sum, j, bestsum, bestitem = 0;
|
2001-11-26 19:57:57 +00:00
|
|
|
byte *pal = _currentPalette;
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
if (r > 255)
|
|
|
|
r = 255;
|
|
|
|
if (g > 255)
|
|
|
|
g = 255;
|
|
|
|
if (b > 255)
|
|
|
|
b = 255;
|
2001-12-11 13:34:15 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
bestsum = (uint) - 1;
|
2001-11-26 19:57:57 +00:00
|
|
|
|
|
|
|
r &= ~3;
|
|
|
|
g &= ~3;
|
|
|
|
b &= ~3;
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
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)
|
2001-11-26 19:57:57 +00:00
|
|
|
return i;
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
j = abs(ar - r);
|
|
|
|
sum = j * j * 3;
|
|
|
|
j = abs(ag - g);
|
|
|
|
sum += j * j * 6;
|
|
|
|
j = abs(ab - b);
|
|
|
|
sum += j * j * 2;
|
2001-11-26 19:57:57 +00:00
|
|
|
|
|
|
|
if (sum < bestsum) {
|
|
|
|
bestsum = sum;
|
|
|
|
bestitem = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
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) {
|
2001-11-26 19:57:57 +00:00
|
|
|
setPalColor(i, r, g, b);
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return bestitem;
|
|
|
|
}
|
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
void Scumm::drawBomp(BompDrawData * bd)
|
|
|
|
{
|
|
|
|
byte *dest = bd->out + bd->y * bd->outwidth, *src;
|
|
|
|
int h = bd->srcheight;
|
|
|
|
bool inside;
|
|
|
|
|
|
|
|
if (h == 0 || bd->srcwidth == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
inside = (bd->x >= 0) && (bd->y >= 0) &&
|
|
|
|
(bd->x <= bd->outwidth - bd->srcwidth) &&
|
|
|
|
(bd->y <= bd->outheight - bd->srcheight);
|
|
|
|
|
|
|
|
if (1 || bd->scale_x == 255 && bd->scale_y == 255) {
|
|
|
|
/* Routine used when no scaling is needed */
|
|
|
|
if (inside) {
|
|
|
|
dest += bd->x;
|
|
|
|
src = bd->dataptr;
|
|
|
|
do {
|
|
|
|
byte code, color;
|
|
|
|
uint len = bd->srcwidth, num, i;
|
|
|
|
byte *d = dest;
|
|
|
|
src += 2;
|
|
|
|
do {
|
|
|
|
code = *src++;
|
|
|
|
num = (code >> 1) + 1;
|
|
|
|
if (num > len)
|
|
|
|
num = len;
|
|
|
|
len -= num;
|
|
|
|
if (code & 1) {
|
|
|
|
color = *src++;
|
|
|
|
if (color != 255) {
|
|
|
|
do
|
|
|
|
*d++ = color;
|
|
|
|
while (--num);
|
|
|
|
} else {
|
|
|
|
d += num;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (i = 0; i < num; i++)
|
|
|
|
if ((color = src[i]) != 255)
|
|
|
|
d[i] = color;
|
|
|
|
d += num;
|
|
|
|
src += num;
|
|
|
|
}
|
|
|
|
} while (len);
|
|
|
|
dest += bd->outwidth;
|
|
|
|
} while (--h);
|
2001-11-27 17:56:04 +00:00
|
|
|
} else {
|
2002-04-11 17:19:16 +00:00
|
|
|
uint y = bd->y;
|
|
|
|
src = bd->dataptr;
|
2001-11-27 17:56:04 +00:00
|
|
|
|
2002-04-11 17:19:16 +00:00
|
|
|
do {
|
|
|
|
byte color;
|
|
|
|
uint len, num;
|
|
|
|
uint x;
|
|
|
|
if ((uint) y >= (uint) bd->outheight) {
|
|
|
|
src += READ_LE_UINT16(src) + 2;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
len = bd->srcwidth;
|
|
|
|
x = bd->x;
|
|
|
|
|
|
|
|
src += 2;
|
|
|
|
do {
|
|
|
|
byte code = *src++;
|
|
|
|
num = (code >> 1) + 1;
|
|
|
|
if (num > len)
|
|
|
|
num = len;
|
|
|
|
len -= num;
|
|
|
|
if (code & 1) {
|
|
|
|
if ((color = *src++) != 255) {
|
|
|
|
do {
|
|
|
|
if ((uint) x < (uint) bd->outwidth)
|
|
|
|
dest[x] = color;
|
|
|
|
} while (++x, --num);
|
|
|
|
} else {
|
|
|
|
x += num;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
do {
|
|
|
|
if ((color = *src++) != 255 && (uint) x < (uint) bd->outwidth)
|
|
|
|
dest[x] = color;
|
|
|
|
} while (++x, --num);
|
|
|
|
}
|
|
|
|
} while (len);
|
|
|
|
} while (dest += bd->outwidth, y++, --h);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* scaling of bomp images not supported yet */
|
|
|
|
}
|
2001-12-27 17:51:58 +00:00
|
|
|
|
2002-04-12 21:26:59 +00:00
|
|
|
CHECK_HEAP;
|
|
|
|
}
|