mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-24 02:36:27 +00:00
983 lines
20 KiB
C++
983 lines
20 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* $URL$
|
|
* $Id$
|
|
*
|
|
*/
|
|
|
|
#ifdef ENABLE_LOL
|
|
|
|
#include "kyra/screen_lol.h"
|
|
#include "kyra/lol.h"
|
|
#include "kyra/resource.h"
|
|
|
|
namespace Kyra {
|
|
|
|
Screen_LoL::Screen_LoL(LoLEngine *vm, OSystem *system) : Screen_v2(vm, system), _vm(vm) {
|
|
_paletteOverlay1 = new uint8[0x100];
|
|
_paletteOverlay2 = new uint8[0x100];
|
|
_grayOverlay = new uint8[0x100];
|
|
memset(_paletteOverlay1, 0, 0x100);
|
|
memset(_paletteOverlay2, 0, 0x100);
|
|
memset(_grayOverlay, 0, 0x100);
|
|
|
|
for (int i = 0; i < 8; i++)
|
|
_levelOverlays[i] = new uint8[256];
|
|
|
|
_fadeFlag = 2;
|
|
_curDimIndex = 0;
|
|
}
|
|
|
|
Screen_LoL::~Screen_LoL() {
|
|
for (int i = 0; i < _screenDimTableCount; i++)
|
|
delete _customDimTable[i];
|
|
delete[] _customDimTable;
|
|
|
|
for (int i = 0; i < 8; i++)
|
|
delete[] _levelOverlays[i];
|
|
|
|
delete[] _paletteOverlay1;
|
|
delete[] _paletteOverlay2;
|
|
delete[] _grayOverlay;
|
|
}
|
|
|
|
bool Screen_LoL::init() {
|
|
if (Screen::init()) {
|
|
_screenDimTable = _use16ColorMode ? _screenDimTable16C : _screenDimTable256C;
|
|
_customDimTable = new ScreenDim*[_screenDimTableCount];
|
|
memset(_customDimTable, 0, sizeof(ScreenDim *)* _screenDimTableCount);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
void Screen_LoL::setScreenDim(int dim) {
|
|
assert(dim < _screenDimTableCount);
|
|
_curDim = _customDimTable[dim] ? (const ScreenDim *)_customDimTable[dim] : &_screenDimTable[dim];
|
|
_curDimIndex = dim;
|
|
}
|
|
|
|
const ScreenDim *Screen_LoL::getScreenDim(int dim) {
|
|
assert(dim < _screenDimTableCount);
|
|
return _customDimTable[dim] ? (const ScreenDim *)_customDimTable[dim] : &_screenDimTable[dim];
|
|
}
|
|
|
|
void Screen_LoL::modifyScreenDim(int dim, int x, int y, int w, int h) {
|
|
delete _customDimTable[dim];
|
|
_customDimTable[dim] = new ScreenDim;
|
|
memcpy(_customDimTable[dim], &_screenDimTable[dim], sizeof(ScreenDim));
|
|
_customDimTable[dim]->sx = x;
|
|
_customDimTable[dim]->sy = y;
|
|
_customDimTable[dim]->w = w;
|
|
_customDimTable[dim]->h = h;
|
|
setScreenDim(dim);
|
|
}
|
|
|
|
void Screen_LoL::fprintString(const char *format, int x, int y, uint8 col1, uint8 col2, uint16 flags, ...) {
|
|
if (!format)
|
|
return;
|
|
|
|
char string[240];
|
|
va_list vaList;
|
|
va_start(vaList, flags);
|
|
vsnprintf(string, sizeof(string), format, vaList);
|
|
va_end(vaList);
|
|
|
|
if (flags & 1)
|
|
x -= (getTextWidth(string) >> 1);
|
|
|
|
if (flags & 2)
|
|
x -= getTextWidth(string);
|
|
|
|
if (flags & 4) {
|
|
printText(string, x - 1, y, 1, col2);
|
|
printText(string, x, y + 1, 1, col2);
|
|
}
|
|
|
|
if (flags & 8) {
|
|
printText(string, x - 1, y, 227, col2);
|
|
printText(string, x, y + 1, 227, col2);
|
|
}
|
|
|
|
printText(string, x, y, col1, col2);
|
|
}
|
|
|
|
void Screen_LoL::fprintStringIntro(const char *format, int x, int y, uint8 c1, uint8 c2, uint8 c3, uint16 flags, ...) {
|
|
char buffer[400];
|
|
|
|
va_list args;
|
|
va_start(args, flags);
|
|
vsnprintf(buffer, sizeof(buffer), format, args);
|
|
va_end(args);
|
|
|
|
if ((flags & 0x0F00) == 0x100)
|
|
x -= getTextWidth(buffer) >> 1;
|
|
if ((flags & 0x0F00) == 0x200)
|
|
x -= getTextWidth(buffer);
|
|
|
|
if ((flags & 0x00F0) == 0x20) {
|
|
printText(buffer, x-1, y, c3, c2);
|
|
printText(buffer, x, y+1, c3, c2);
|
|
}
|
|
|
|
printText(buffer, x, y, c1, c2);
|
|
}
|
|
|
|
void Screen_LoL::generateGrayOverlay(const Palette &srcPal, uint8 *grayOverlay, int factor, int addR, int addG, int addB, int lastColor, bool skipSpecialColors) {
|
|
Palette tmpPal(lastColor);
|
|
|
|
for (int i = 0; i != lastColor; i++) {
|
|
int v = (((srcPal[3 * i] & 0x3f) * factor) / 0x40) + addR;
|
|
tmpPal[3 * i] = (v > 0x3f) ? 0x3f : v & 0xff;
|
|
v = (((srcPal[3 * i + 1] & 0x3f) * factor) / 0x40) + addG;
|
|
tmpPal[3 * i + 1] = (v > 0x3f) ? 0x3f : v & 0xff;
|
|
v = (((srcPal[3 * i + 2] & 0x3f) * factor) / 0x40) + addB;
|
|
tmpPal[3 * i + 2] = (v > 0x3f) ? 0x3f : v & 0xff;
|
|
}
|
|
|
|
for (int i = 0; i < lastColor; i++)
|
|
grayOverlay[i] = findLeastDifferentColor(tmpPal.getData() + 3 * i, srcPal, 0, lastColor, skipSpecialColors);
|
|
}
|
|
|
|
uint8 *Screen_LoL::generateLevelOverlay(const Palette &srcPal, uint8 *ovl, int opColor, int weight) {
|
|
if (!ovl)
|
|
return ovl;
|
|
|
|
if (weight > 255)
|
|
weight = 255;
|
|
|
|
uint16 r = srcPal[opColor * 3];
|
|
uint16 g = srcPal[opColor * 3 + 1];
|
|
uint16 b = srcPal[opColor * 3 + 2];
|
|
|
|
uint8 *d = ovl;
|
|
*d++ = 0;
|
|
|
|
for (int i = 1; i != 255; i++) {
|
|
uint16 a = srcPal[i * 3];
|
|
uint8 dr = a - ((((a - r) * (weight >> 1)) << 1) >> 8);
|
|
a = srcPal[i * 3 + 1];
|
|
uint8 dg = a - ((((a - g) * (weight >> 1)) << 1) >> 8);
|
|
a = srcPal[i * 3 + 2];
|
|
uint8 db = a - ((((a - b) * (weight >> 1)) << 1) >> 8);
|
|
|
|
int l = opColor;
|
|
int m = 0x7fff;
|
|
int ii = 127;
|
|
int x = 1;
|
|
const uint8 *s = srcPal.getData() + 3;
|
|
|
|
do {
|
|
if (i == x) {
|
|
s += 3;
|
|
} else {
|
|
int t = *s++ - dr;
|
|
int c = t * t;
|
|
t = *s++ - dg;
|
|
c += (t * t);
|
|
t = *s++ - db;
|
|
c += (t * t);
|
|
|
|
if (!c) {
|
|
l = x;
|
|
break;
|
|
}
|
|
|
|
if (c <= m) {
|
|
m = c;
|
|
l = x;
|
|
}
|
|
}
|
|
x++;
|
|
} while (--ii);
|
|
|
|
*d++ = l & 0xff;
|
|
}
|
|
|
|
return ovl;
|
|
}
|
|
|
|
void Screen_LoL::generateTruelightTables(const uint8 *shp, int a, const Palette &fxPal, const Palette &screenPal, uint8 *outTable1, uint8 *outTable2, int b) {
|
|
memset(outTable1, 0xff, 256);
|
|
|
|
for (int i = 0; i < a; i++)
|
|
outTable1[shp[i]] = i;
|
|
|
|
for (int i = 0; i < a; i++) {
|
|
if (shp[i]) {
|
|
uint8 tcol[3];
|
|
uint16 fcol[3];
|
|
uint16 scol[3];
|
|
|
|
int t1 = (b << 6) / 100;
|
|
int t2 = 64 - t1;
|
|
|
|
uint8 c = shp[i];
|
|
fcol[0] = fxPal[3 * c];
|
|
fcol[1] = fxPal[3 * c + 1];
|
|
fcol[2] = fxPal[3 * c + 2];
|
|
|
|
uint8 *o = &outTable2[i << 8];
|
|
|
|
for (int ii = 0; ii < 256; ii++) {
|
|
scol[0] = screenPal[3 * ii];
|
|
scol[1] = screenPal[3 * ii + 1];
|
|
scol[2] = screenPal[3 * ii + 2];
|
|
|
|
tcol[0] = CLIP(((fcol[0] * t2) >> 6) + ((scol[0] * t1) >> 6), 0, 63);
|
|
tcol[1] = CLIP(((fcol[1] * t2) >> 6) + ((scol[1] * t1) >> 6), 0, 63);
|
|
tcol[2] = CLIP(((fcol[2] * t2) >> 6) + ((scol[2] * t1) >> 6), 0, 63);
|
|
|
|
o[ii] = findLeastDifferentColor(tcol, screenPal, 0, 255);
|
|
}
|
|
|
|
} else {
|
|
for (int ii = 0; ii < 256; ii++)
|
|
outTable2[(i << 8) + ii] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Screen_LoL::drawGridBox(int x, int y, int w, int h, int col) {
|
|
if (w <= 0 || x >= 320 || h <= 0 || y >= 200)
|
|
return;
|
|
|
|
if (x < 0) {
|
|
x += w;
|
|
if (x <= 0)
|
|
return;
|
|
w = x;
|
|
x = 0;
|
|
}
|
|
|
|
int tmp = x + w;
|
|
if (tmp >= 320) {
|
|
w = 320 - x;
|
|
}
|
|
|
|
int pitch = 320 - w;
|
|
|
|
if (y < 0) {
|
|
y += h;
|
|
if (y <= 0)
|
|
return;
|
|
h = y;
|
|
y = 0;
|
|
}
|
|
|
|
tmp = y + h;
|
|
if (tmp >= 200) {
|
|
h = 200 - y;
|
|
}
|
|
|
|
tmp = (y + x) & 1;
|
|
uint8 *p = getPagePtr(_curPage) + y * 320 + x;
|
|
uint8 s = (tmp >> 8) & 1;
|
|
|
|
w >>= 1;
|
|
int w2 = w;
|
|
|
|
while (h--) {
|
|
if (w) {
|
|
while (w--) {
|
|
*(p + tmp) = col;
|
|
p += 2;
|
|
}
|
|
} else {
|
|
w = 1;
|
|
}
|
|
|
|
if (s == 1) {
|
|
if (tmp == 0)
|
|
*p = col;
|
|
p++;
|
|
}
|
|
tmp ^= 1;
|
|
p += pitch;
|
|
w = w2;
|
|
}
|
|
}
|
|
|
|
void Screen_LoL::fadeClearSceneWindow(int delay) {
|
|
if (_fadeFlag == 1)
|
|
return;
|
|
|
|
Palette tpal(getPalette(0).getNumColors());
|
|
tpal.copy(getPalette(0), 128);
|
|
|
|
loadSpecialColors(tpal);
|
|
fadePalette(tpal, delay);
|
|
|
|
fillRect(112, 0, 288, 120, 0);
|
|
|
|
_fadeFlag = 1;
|
|
}
|
|
|
|
void Screen_LoL::backupSceneWindow(int srcPageNum, int dstPageNum) {
|
|
uint8 *src = getPagePtr(srcPageNum) + 112;
|
|
uint8 *dst = getPagePtr(dstPageNum) + 0xa500;
|
|
|
|
for (int h = 0; h < 120; h++) {
|
|
for (int w = 0; w < 176; w++)
|
|
*dst++ = *src++;
|
|
src += 144;
|
|
}
|
|
}
|
|
|
|
void Screen_LoL::restoreSceneWindow(int srcPageNum, int dstPageNum) {
|
|
uint8 *src = getPagePtr(srcPageNum) + 0xa500;
|
|
uint8 *dst = getPagePtr(dstPageNum) + 112;
|
|
|
|
for (int h = 0; h < 120; h++) {
|
|
memcpy(dst, src, 176);
|
|
src += 176;
|
|
dst += 320;
|
|
}
|
|
|
|
if (!dstPageNum)
|
|
addDirtyRect(112, 0, 176, 120);
|
|
}
|
|
|
|
void Screen_LoL::clearGuiShapeMemory(int pageNum) {
|
|
uint8 *dst = getPagePtr(pageNum) + 0x79b0;
|
|
for (int i = 0; i < 23; i++) {
|
|
memset(dst, 0, 176);
|
|
dst += 320;
|
|
}
|
|
}
|
|
|
|
void Screen_LoL::copyGuiShapeFromSceneBackupBuffer(int srcPageNum, int dstPageNum) {
|
|
uint8 *src = getPagePtr(srcPageNum) + 0x79c3;
|
|
uint8 *dst = getPagePtr(dstPageNum);
|
|
|
|
for (int i = 0; i < 23; i++) {
|
|
uint8 len = 0;
|
|
uint8 v = 0;
|
|
|
|
do {
|
|
v = *src++;
|
|
len++;
|
|
} while (!v);
|
|
|
|
*dst++ = len;
|
|
|
|
len = 69 - len;
|
|
memcpy(dst, src, len);
|
|
src += (len + 251);
|
|
dst += len;
|
|
}
|
|
}
|
|
|
|
void Screen_LoL::copyGuiShapeToSurface(int srcPageNum, int dstPageNum) {
|
|
uint8 *src = getPagePtr(srcPageNum);
|
|
uint8 *dst = getPagePtr(dstPageNum) + 0xe7c3;
|
|
|
|
for (int i = 0; i < 23; i++) {
|
|
uint8 v = *src++;
|
|
uint8 len = 69 - v;
|
|
dst += v;
|
|
memcpy(dst, src, len);
|
|
src += (len - 1);
|
|
dst += len;
|
|
|
|
for (int ii = 0; ii < len; ii++)
|
|
*dst++ = *src--;
|
|
|
|
src += (len + 1);
|
|
dst += (v + 38);
|
|
}
|
|
}
|
|
|
|
void Screen_LoL::smoothScrollZoomStepTop(int srcPageNum, int dstPageNum, int x, int y) {
|
|
uint8 *src = getPagePtr(srcPageNum) + 0xa500 + y * 176 + x;
|
|
uint8 *dst = getPagePtr(dstPageNum) + 0xa500;
|
|
|
|
x <<= 1;
|
|
uint16 width = 176 - x;
|
|
uint16 scaleX = (((x + 1) << 8) / width + 0x100);
|
|
uint16 cntW = scaleX >> 8;
|
|
scaleX <<= 8;
|
|
width--;
|
|
uint16 widthCnt = width;
|
|
|
|
uint16 height = 46 - y;
|
|
uint16 scaleY = (((y + 1) << 8) / height + 0x100);
|
|
scaleY <<= 8;
|
|
|
|
uint32 scaleYc = 0;
|
|
while (height) {
|
|
uint32 scaleXc = 0;
|
|
do {
|
|
scaleXc += scaleX;
|
|
int numbytes = cntW + (scaleXc >> 16);
|
|
scaleXc &= 0xffff;
|
|
memset(dst, *src++, numbytes);
|
|
dst += numbytes;
|
|
} while (--widthCnt);
|
|
|
|
*dst++ = *src++;
|
|
widthCnt = width;
|
|
|
|
src += x;
|
|
scaleYc += scaleY;
|
|
|
|
if (scaleYc >> 16) {
|
|
scaleYc = 0;
|
|
src -= 176;
|
|
continue;
|
|
}
|
|
|
|
height--;
|
|
}
|
|
}
|
|
|
|
void Screen_LoL::smoothScrollZoomStepBottom(int srcPageNum, int dstPageNum, int x, int y) {
|
|
uint8 *src = getPagePtr(srcPageNum) + 0xc4a0 + x;
|
|
uint8 *dst = getPagePtr(dstPageNum) + 0xc4a0;
|
|
|
|
x <<= 1;
|
|
uint16 width = 176 - x;
|
|
uint16 scaleX = (((x + 1) << 8) / width + 0x100);
|
|
uint16 cntW = scaleX >> 8;
|
|
scaleX <<= 8;
|
|
width--;
|
|
uint16 widthCnt = width;
|
|
|
|
uint16 height = 74 - y;
|
|
uint16 scaleY = (((y + 1) << 8) / height + 0x100);
|
|
scaleY <<= 8;
|
|
|
|
uint32 scaleYc = 0;
|
|
while (height) {
|
|
uint32 scaleXc = 0;
|
|
do {
|
|
scaleXc += scaleX;
|
|
int numbytes = cntW + (scaleXc >> 16);
|
|
scaleXc &= 0xffff;
|
|
memset(dst, *src++, numbytes);
|
|
dst += numbytes;
|
|
} while (--widthCnt);
|
|
|
|
*dst++ = *src++;
|
|
widthCnt = width;
|
|
|
|
src += x;
|
|
scaleYc += scaleY;
|
|
|
|
if (scaleYc >> 16) {
|
|
scaleYc = 0;
|
|
src -= 176;
|
|
continue;
|
|
}
|
|
|
|
height--;
|
|
}
|
|
}
|
|
|
|
void Screen_LoL::smoothScrollHorizontalStep(int pageNum, int srcX, int dstX, int w) {
|
|
uint8 *d = getPagePtr(pageNum);
|
|
uint8 *s = d + 112 + srcX;
|
|
|
|
int w2 = srcX + w - dstX;
|
|
int pitchS = 320 + w2 - (w << 1);
|
|
|
|
int pitchD = 320 - w;
|
|
int h = 120;
|
|
|
|
while (h--) {
|
|
for (int i = 0; i < w; i++)
|
|
*d++ = *s++;
|
|
d -= w;
|
|
s -= w2;
|
|
|
|
for (int i = 0; i < w; i++)
|
|
*s++ = *d++;
|
|
|
|
s += pitchS;
|
|
d += pitchD;
|
|
}
|
|
}
|
|
|
|
void Screen_LoL::smoothScrollTurnStep1(int srcPage1Num, int srcPage2Num, int dstPageNum) {
|
|
uint8 *s = getPagePtr(srcPage1Num) + 273;
|
|
uint8 *d = getPagePtr(dstPageNum) + 0xa500;
|
|
|
|
for (int i = 0; i < 120; i++) {
|
|
uint8 a = *s++;
|
|
*d++ = a;
|
|
*d++ = a;
|
|
|
|
for (int ii = 0; ii < 14; ii++) {
|
|
a = *s++;
|
|
*d++ = a;
|
|
*d++ = a;
|
|
*d++ = a;
|
|
}
|
|
|
|
s += 305;
|
|
d += 132;
|
|
}
|
|
|
|
s = getPagePtr(srcPage2Num) + 112;
|
|
d = getPagePtr(dstPageNum) + 0xa52c;
|
|
|
|
for (int i = 0; i < 120; i++) {
|
|
for (int ii = 0; ii < 33; ii++) {
|
|
*d++ = *s++;
|
|
*d++ = *s++;
|
|
uint8 a = *s++;
|
|
*d++ = a;
|
|
*d++ = a;
|
|
}
|
|
|
|
s += 221;
|
|
d += 44;
|
|
}
|
|
}
|
|
|
|
void Screen_LoL::smoothScrollTurnStep2(int srcPage1Num, int srcPage2Num, int dstPageNum) {
|
|
uint8 *s = getPagePtr(srcPage1Num) + 244;
|
|
uint8 *d = getPagePtr(dstPageNum) + 0xa500;
|
|
|
|
for (int k = 0; k < 2; k++) {
|
|
for (int i = 0; i < 120; i++) {
|
|
for (int ii = 0; ii < 44; ii++) {
|
|
uint8 a = *s++;
|
|
*d++ = a;
|
|
*d++ = a;
|
|
}
|
|
|
|
s += 276;
|
|
d += 88;
|
|
}
|
|
|
|
s = getPagePtr(srcPage2Num) + 112;
|
|
d = getPagePtr(dstPageNum) + 0xa558;
|
|
}
|
|
}
|
|
|
|
void Screen_LoL::smoothScrollTurnStep3(int srcPage1Num, int srcPage2Num, int dstPageNum) {
|
|
uint8 *s = getPagePtr(srcPage1Num) + 189;
|
|
uint8 *d = getPagePtr(dstPageNum) + 0xa500;
|
|
|
|
for (int i = 0; i < 120; i++) {
|
|
for (int ii = 0; ii < 33; ii++) {
|
|
*d++ = *s++;
|
|
*d++ = *s++;
|
|
uint8 a = *s++;
|
|
*d++ = a;
|
|
*d++ = a;
|
|
}
|
|
|
|
s += 221;
|
|
d += 44;
|
|
}
|
|
|
|
s = getPagePtr(srcPage2Num) + 112;
|
|
d = getPagePtr(dstPageNum) + 0xa584;
|
|
|
|
for (int i = 0; i < 120; i++) {
|
|
for (int ii = 0; ii < 14; ii++) {
|
|
uint8 a = *s++;
|
|
*d++ = a;
|
|
*d++ = a;
|
|
*d++ = a;
|
|
}
|
|
|
|
uint8 a = *s++;
|
|
*d++ = a;
|
|
*d++ = a;
|
|
|
|
s += 305;
|
|
d += 132;
|
|
}
|
|
}
|
|
|
|
void Screen_LoL::copyRegionSpecial(int page1, int w1, int h1, int x1, int y1, int page2, int w2, int h2, int x2, int y2, int w3, int h3, int mode, ...) {
|
|
if (!w3 || !h3)
|
|
return;
|
|
|
|
uint8 *table1 = 0;
|
|
uint8 *table2 = 0;
|
|
|
|
if (mode == 2) {
|
|
va_list args;
|
|
va_start(args, mode);
|
|
table1 = va_arg(args, uint8*);
|
|
table2 = va_arg(args, uint8*);
|
|
va_end(args);
|
|
}
|
|
|
|
int na = 0, nb = 0, nc = w3;
|
|
if (!calcBounds(w1, h1, x1, y1, w3, h3, na, nb, nc))
|
|
return;
|
|
|
|
int iu5_1 = na;
|
|
int iu6_1 = nb;
|
|
int ibw_1 = w3;
|
|
int dx_1 = x1;
|
|
int dy_1 = y1;
|
|
|
|
if (!calcBounds(w2, h2, x2, y2, w3, h3, na, nb, nc))
|
|
return;
|
|
|
|
int iu5_2 = na;
|
|
int iu6_2 = nb;
|
|
int ibw_2 = w3;
|
|
int ibh_2 = h3;
|
|
int dx_2 = x2;
|
|
int dy_2 = y2;
|
|
|
|
uint8 *src = getPagePtr(page1) + (dy_1 + iu6_2) * w1;
|
|
uint8 *dst = getPagePtr(page2) + (dy_2 + iu6_1) * w2;
|
|
|
|
for (int i = 0; i < ibh_2; i++) {
|
|
uint8 *s = src + iu5_2 + dx_1;
|
|
uint8 *d = dst + iu5_1 + dx_2;
|
|
|
|
if (mode == 0) {
|
|
memcpy(d, s, ibw_2);
|
|
|
|
} else if (mode == 1) {
|
|
if (!(i & 1)) {
|
|
s++;
|
|
d++;
|
|
}
|
|
|
|
for (int ii = (i & 1) ^ 1; ii < ibw_2; ii += 2 ) {
|
|
*d = *s;
|
|
d += 2;
|
|
s += 2;
|
|
}
|
|
|
|
} else if (mode == 2) {
|
|
for (int ii = 0; ii < ibw_2; ii++) {
|
|
uint8 cmd = *s++;
|
|
uint8 offs = table1[cmd];
|
|
if (!(offs & 0x80))
|
|
cmd = table2[(offs << 8) | *d];
|
|
*d++ = cmd;
|
|
}
|
|
|
|
} else if (mode == 3) {
|
|
s = s - iu5_2 + ibw_1;
|
|
s = s - iu5_2 - 1;
|
|
for (int ii = 0; ii < ibw_2; ii++)
|
|
*d++ = *s--;
|
|
}
|
|
|
|
dst += w2;
|
|
src += w1;
|
|
}
|
|
|
|
if (!page2)
|
|
addDirtyRect(x2, y2, w2, h2);
|
|
}
|
|
|
|
void Screen_LoL::copyBlockAndApplyOverlay(int page1, int x1, int y1, int page2, int x2, int y2, int w, int h, int dim, uint8 *ovl) {
|
|
if (!w || !h || !ovl)
|
|
return;
|
|
|
|
const ScreenDim *cdim = getScreenDim(dim);
|
|
int ix = cdim->sx << 3;
|
|
int iy = cdim->sy;
|
|
int iw = cdim->w << 3;
|
|
int ih = cdim->h;
|
|
|
|
int na = 0, nb = 0, nc = w;
|
|
if (!calcBounds(iw, ih, x2, y2, w, h, na, nb, nc))
|
|
return;
|
|
|
|
uint8 *src = getPagePtr(page1) + y1 * 320 + x1;
|
|
uint8 *dst = getPagePtr(page2) + (y2 + iy) * 320;
|
|
|
|
for (int i = 0; i < h; i++) {
|
|
uint8 *s = src + na;
|
|
uint8 *d = dst + (x2 + ix);
|
|
|
|
for (int ii = 0; ii < w; ii++) {
|
|
uint8 p = ovl[*s++];
|
|
if (p)
|
|
*d = p;
|
|
d++;
|
|
}
|
|
|
|
dst += 320;
|
|
src += 320;
|
|
}
|
|
|
|
if (!page2)
|
|
addDirtyRect(x2 + ix, y2 + iy, w, h);
|
|
}
|
|
|
|
void Screen_LoL::applyOverlaySpecial(int page1, int x1, int y1, int page2, int x2, int y2, int w, int h, int dim, int flag, uint8 *ovl) {
|
|
if (!w || !h || !ovl)
|
|
return;
|
|
|
|
const ScreenDim *cdim = getScreenDim(dim);
|
|
int ix = cdim->sx << 3;
|
|
int iy = cdim->sy;
|
|
int iw = cdim->w << 3;
|
|
int ih = cdim->h;
|
|
|
|
int na = 0, nb = 0, nc = w;
|
|
if (!calcBounds(iw, ih, x2, y2, w, h, na, nb, nc))
|
|
return;
|
|
|
|
uint8 *src = getPagePtr(page1) + y1 * 320 + x1;
|
|
uint8 *dst = getPagePtr(page2) + (y2 + iy) * 320;
|
|
|
|
for (int i = 0; i < h; i++) {
|
|
uint8 *s = src + na;
|
|
uint8 *d = dst + (x2 + ix);
|
|
|
|
if (flag)
|
|
d += (i >> 1);
|
|
|
|
for (int ii = 0; ii < w; ii++) {
|
|
if (*s++)
|
|
*d = ovl[*d];
|
|
d++;
|
|
}
|
|
|
|
dst += 320;
|
|
src += 320;
|
|
}
|
|
|
|
if (!page2)
|
|
addDirtyRect(x2 + ix, y2 + iy, w, h);
|
|
}
|
|
|
|
void Screen_LoL::copyBlockAndApplyOverlayOutro(int srcPage, int dstPage, const uint8 *ovl) {
|
|
if (!ovl)
|
|
return;
|
|
|
|
const byte *src = getCPagePtr(srcPage);
|
|
byte *dst = getPagePtr(dstPage);
|
|
|
|
for (int y = 0; y < 200; ++y) {
|
|
for (int x = 0; x < 80; ++x) {
|
|
uint32 srcData = READ_LE_UINT32(src); src += 4;
|
|
uint32 dstData = READ_LE_UINT32(dst);
|
|
uint16 offset = 0;
|
|
|
|
offset = ((srcData & 0xFF) << 8) + (dstData & 0xFF);
|
|
*dst++ = ovl[offset];
|
|
|
|
offset = (srcData & 0xFF00) + ((dstData & 0xFF00) >> 8);
|
|
*dst++ = ovl[offset];
|
|
|
|
srcData >>= 16;
|
|
dstData >>= 16;
|
|
|
|
offset = ((srcData & 0xFF) << 8) + (dstData & 0xFF);
|
|
*dst++ = ovl[offset];
|
|
|
|
offset = (srcData & 0xFF00) + ((dstData & 0xFF00) >> 8);
|
|
*dst++ = ovl[offset];
|
|
}
|
|
}
|
|
}
|
|
|
|
void Screen_LoL::fadeToBlack(int delay, const UpdateFunctor *upFunc) {
|
|
Screen::fadeToBlack(delay, upFunc);
|
|
_fadeFlag = 2;
|
|
}
|
|
|
|
void Screen_LoL::fadeToPalette1(int delay) {
|
|
loadSpecialColors(getPalette(1));
|
|
fadePalette(getPalette(1), delay);
|
|
_fadeFlag = 0;
|
|
}
|
|
|
|
void Screen_LoL::loadSpecialColors(Palette &dst) {
|
|
dst.copy(*_screenPalette, 192, 4);
|
|
}
|
|
|
|
void Screen_LoL::copyColor(int dstColorIndex, int srcColorIndex) {
|
|
uint8 *s = _screenPalette->getData() + srcColorIndex * 3;
|
|
uint8 *d = _screenPalette->getData() + dstColorIndex * 3;
|
|
memcpy(d, s, 3);
|
|
|
|
uint8 ci[4];
|
|
ci[0] = (d[0] << 2) | (d[0] & 3);
|
|
ci[1] = (d[1] << 2) | (d[1] & 3);
|
|
ci[2] = (d[2] << 2) | (d[2] & 3);
|
|
ci[3] = 0;
|
|
|
|
_system->setPalette(ci, dstColorIndex, 1);
|
|
}
|
|
|
|
bool Screen_LoL::fadeColor(int dstColorIndex, int srcColorIndex, uint32 elapsedTime, uint32 targetTime) {
|
|
const uint8 *dst = _screenPalette->getData() + 3 * dstColorIndex;
|
|
const uint8 *src = _screenPalette->getData() + 3 * srcColorIndex;
|
|
uint8 *p = getPalette(1).getData() + 3 * dstColorIndex;
|
|
|
|
bool res = false;
|
|
|
|
int16 t1 = 0;
|
|
int16 t2 = 0;
|
|
int32 t3 = 0;
|
|
|
|
uint8 tmpPalEntry[3];
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
if (elapsedTime < targetTime) {
|
|
t1 = *src & 0x3f;
|
|
t2 = *dst & 0x3f;
|
|
|
|
t3 = t1 - t2;
|
|
if (t3)
|
|
res = true;
|
|
|
|
t3 = (((t3 << 8) / (int)targetTime) * (int)elapsedTime) >> 8;
|
|
t3 = t2 + t3;
|
|
} else {
|
|
t1 = *dst & 0x3f;
|
|
*p = t3 = t1;
|
|
res = false;
|
|
}
|
|
|
|
tmpPalEntry[i] = t3 & 0xff;
|
|
src++;
|
|
dst++;
|
|
p++;
|
|
}
|
|
|
|
_internFadePalette->copy(*_screenPalette);
|
|
_internFadePalette->copy(tmpPalEntry, 0, 1, dstColorIndex);
|
|
setScreenPalette(*_internFadePalette);
|
|
updateScreen();
|
|
|
|
return res;
|
|
}
|
|
|
|
bool Screen_LoL::fadePaletteStep(uint8 *pal1, uint8 *pal2, uint32 elapsedTime, uint32 targetTime) {
|
|
Palette &p1 = getPalette(1);
|
|
|
|
bool res = false;
|
|
for (int i = 0; i < 768; i++) {
|
|
uint8 out = 0;
|
|
|
|
if (elapsedTime < targetTime) {
|
|
int32 d = ((pal2[i] & 0x3f) - (pal1[i] & 0x3f));
|
|
if (d)
|
|
res = true;
|
|
|
|
int32 val = ((((d << 8) / (int32)targetTime) * (int32)elapsedTime) >> 8);
|
|
out = ((pal1[i] & 0x3f) + (int8)val);
|
|
} else {
|
|
out = p1[i] = (pal2[i] & 0x3f);
|
|
res = false;
|
|
}
|
|
|
|
(*_internFadePalette)[i] = out;
|
|
}
|
|
|
|
setScreenPalette(*_internFadePalette);
|
|
updateScreen();
|
|
|
|
return res;
|
|
}
|
|
|
|
uint8 *Screen_LoL::generateFadeTable(uint8 *dst, uint8 *src1, uint8 *src2, int numTabs) {
|
|
if (!src1)
|
|
src1 = _screenPalette->getData();
|
|
|
|
uint8 *p1 = dst;
|
|
uint8 *p2 = src1;
|
|
uint8 *p3 = src2;
|
|
|
|
for (int i = 0; i < 768; i++) {
|
|
int8 val = (int8)*p3++ - (int8)*p2++;
|
|
*dst++ = (uint8)val;
|
|
}
|
|
|
|
int16 t = 0;
|
|
int16 d = 256 / numTabs;
|
|
|
|
for (int i = 1; i < numTabs - 1; i++) {
|
|
p2 = src1;
|
|
p3 = p1;
|
|
t += d;
|
|
|
|
for (int ii = 0; ii < 768; ii++) {
|
|
int16 val = (((int8)*p3++ * t) >> 8) + (int8)*p2++;
|
|
*dst++ = (uint8)val;
|
|
}
|
|
}
|
|
|
|
memcpy(p1, src1, 768);
|
|
memcpy(dst, src2, 768);
|
|
|
|
dst += 768;
|
|
return dst;
|
|
}
|
|
|
|
uint8 Screen_LoL::getShapePaletteSize(const uint8 *shp) {
|
|
return shp[10];
|
|
}
|
|
|
|
void Screen_LoL::mergeOverlay(int x, int y, int w, int h) {
|
|
// For now we convert to 16 colors on overlay merging. If that gives
|
|
// any problems, like Screen functionallity not prepared for the
|
|
// format PC98 16 color uses, we'll need to think of a better way.
|
|
//
|
|
// We must do this before merging the overlay, else the font colors
|
|
// will be wrong.
|
|
if (_use16ColorMode)
|
|
convertPC98Gfx(_sjisOverlayPtrs[0] + y * 640 + x, w, h, 640);
|
|
|
|
Screen_v2::mergeOverlay(x, y, w, h);
|
|
}
|
|
|
|
void Screen_LoL::convertPC98Gfx(uint8 *data, int w, int h, int pitch) {
|
|
while (h--) {
|
|
for (int i = 0; i < w; ++i) {
|
|
*data = (*data >> 4) & (*data & 0x0F);
|
|
++data;
|
|
}
|
|
|
|
data += pitch - w;
|
|
}
|
|
}
|
|
|
|
void Screen_LoL::postProcessCursor(uint8 *data, int w, int h, int pitch) {
|
|
if (!_use16ColorMode)
|
|
return;
|
|
|
|
while (h--) {
|
|
for (int i = 0; i < w; ++i) {
|
|
if (*data != _cursorColorKey)
|
|
*data = (*data >> 4) & (*data & 0x0F);
|
|
++data;
|
|
}
|
|
|
|
data += pitch - w;
|
|
}
|
|
}
|
|
|
|
} // end of namespace Kyra
|
|
|
|
#endif // ENABLE_LOL
|
|
|