mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-21 01:08:25 +00:00
809 lines
21 KiB
C++
809 lines
21 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.
|
|
*
|
|
*
|
|
*/
|
|
|
|
#include "graphics/cursorman.h"
|
|
|
|
#include "toltecs/toltecs.h"
|
|
#include "toltecs/palette.h"
|
|
#include "toltecs/render.h"
|
|
#include "toltecs/resource.h"
|
|
#include "toltecs/screen.h"
|
|
#include "toltecs/script.h"
|
|
|
|
namespace Toltecs {
|
|
|
|
Screen::Screen(ToltecsEngine *vm) : _vm(vm) {
|
|
|
|
_frontScreen = new byte[268800];
|
|
_backScreen = new byte[870400];
|
|
|
|
memset(_fontResIndexArray, 0, sizeof(_fontResIndexArray));
|
|
_fontColor1 = 0;
|
|
_fontColor2 = 0;
|
|
|
|
// Screen shaking
|
|
_shakeActive = false;
|
|
_shakeCounterInit = 0;
|
|
_shakeCounter = 0;
|
|
_shakePos = 0;
|
|
|
|
// Verb line
|
|
_verbLineNum = 0;
|
|
memset(_verbLineItems, 0, sizeof(_verbLineItems));
|
|
_verbLineX = 160;
|
|
_verbLineY = 2;
|
|
_verbLineWidth = 20;
|
|
_verbLineCount = 0;
|
|
|
|
// Talk text
|
|
_talkTextItemNum = 0;
|
|
memset(_talkTextItems, 0, sizeof(_talkTextItems));
|
|
_talkTextX = 0;
|
|
_talkTextY = 0;
|
|
_talkTextFontColor = 0;
|
|
_talkTextMaxWidth = 520;
|
|
|
|
_renderQueue = new RenderQueue(_vm);
|
|
_fullRefresh = false;
|
|
_guiRefresh = false;
|
|
|
|
}
|
|
|
|
Screen::~Screen() {
|
|
|
|
delete[] _frontScreen;
|
|
delete[] _backScreen;
|
|
|
|
delete _renderQueue;
|
|
|
|
}
|
|
|
|
void Screen::unpackRle(byte *source, byte *dest, uint16 width, uint16 height) {
|
|
int32 size = width * height;
|
|
while (size > 0) {
|
|
byte a = *source++;
|
|
byte b = *source++;
|
|
if (a == 0) {
|
|
dest += b;
|
|
size -= b;
|
|
} else {
|
|
b = ((b << 4) & 0xF0) | ((b >> 4) & 0x0F);
|
|
memset(dest, b, a);
|
|
dest += a;
|
|
size -= a;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Screen::loadMouseCursor(uint resIndex) {
|
|
byte mouseCursor[16 * 16], *mouseCursorP = mouseCursor;
|
|
byte *cursorData = _vm->_res->load(resIndex)->data;
|
|
for (int i = 0; i < 32; i++) {
|
|
byte pixel;
|
|
byte mask1 = *cursorData++;
|
|
byte mask2 = *cursorData++;
|
|
for (int j = 0; j < 8; j++) {
|
|
pixel = 0xE5;
|
|
if ((mask2 & 0x80) == 0)
|
|
pixel = 0xE0;
|
|
mask2 <<= 1;
|
|
if ((mask1 & 0x80) == 0)
|
|
pixel = 0;
|
|
mask1 <<= 1;
|
|
*mouseCursorP++ = pixel;
|
|
}
|
|
}
|
|
// FIXME: Where's the cursor hotspot? Using 8, 8 seems good enough for now.
|
|
CursorMan.replaceCursor(mouseCursor, 16, 16, 8, 8, 0);
|
|
}
|
|
|
|
void Screen::drawGuiImage(int16 x, int16 y, uint resIndex) {
|
|
|
|
byte *imageData = _vm->_res->load(resIndex)->data;
|
|
int16 headerSize = READ_LE_UINT16(imageData);
|
|
int16 width = imageData[2];
|
|
int16 height = imageData[3];
|
|
int16 workWidth = width, workHeight = height;
|
|
imageData += headerSize;
|
|
|
|
byte *dest = _frontScreen + x + (y + _vm->_cameraHeight) * 640;
|
|
|
|
//debug(0, "Screen::drawGuiImage() x = %d; y = %d; w = %d; h = %d; resIndex = %d", x, y, width, height, resIndex);
|
|
|
|
while (workHeight > 0) {
|
|
int count = 1;
|
|
byte pixel = *imageData++;
|
|
if (pixel & 0x80) {
|
|
pixel &= 0x7F;
|
|
count = *imageData++;
|
|
count += 2;
|
|
}
|
|
pixel = pixel + 0xE0;
|
|
while (count-- && workHeight > 0) {
|
|
*dest++ = pixel;
|
|
workWidth--;
|
|
if (workWidth == 0) {
|
|
workHeight--;
|
|
dest += 640 - width;
|
|
workWidth = width;
|
|
}
|
|
}
|
|
}
|
|
|
|
_guiRefresh = true;
|
|
|
|
}
|
|
|
|
void Screen::startShakeScreen(int16 shakeCounter) {
|
|
_shakeActive = true;
|
|
_shakeCounterInit = shakeCounter;
|
|
_shakeCounter = shakeCounter;
|
|
_shakePos = 0;
|
|
}
|
|
|
|
void Screen::stopShakeScreen() {
|
|
_shakeActive = false;
|
|
_vm->_system->setShakePos(0);
|
|
}
|
|
|
|
void Screen::updateShakeScreen() {
|
|
if (_shakeActive) {
|
|
_shakeCounter--;
|
|
if (_shakeCounter == 0) {
|
|
_shakeCounter = _shakeCounterInit;
|
|
_shakePos ^= 8;
|
|
_vm->_system->setShakePos(_shakePos);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Screen::addStaticSprite(byte *spriteItem) {
|
|
|
|
DrawRequest drawRequest;
|
|
memset(&drawRequest, 0, sizeof(drawRequest));
|
|
|
|
drawRequest.y = READ_LE_UINT16(spriteItem + 0);
|
|
drawRequest.x = READ_LE_UINT16(spriteItem + 2);
|
|
int16 fragmentId = READ_LE_UINT16(spriteItem + 4);
|
|
drawRequest.baseColor = _vm->_palette->findFragment(fragmentId) & 0xFF;
|
|
drawRequest.resIndex = READ_LE_UINT16(spriteItem + 6);
|
|
drawRequest.flags = READ_LE_UINT16(spriteItem + 8);
|
|
drawRequest.scaling = 0;
|
|
|
|
debug(0, "Screen::addStaticSprite() x = %d; y = %d; baseColor = %d; resIndex = %d; flags = %04X", drawRequest.x, drawRequest.y, drawRequest.baseColor, drawRequest.resIndex, drawRequest.flags);
|
|
|
|
addDrawRequest(drawRequest);
|
|
|
|
}
|
|
|
|
void Screen::addAnimatedSprite(int16 x, int16 y, int16 fragmentId, byte *data, int16 *spriteArray, bool loop, int mode) {
|
|
|
|
//debug(0, "Screen::addAnimatedSprite(%d, %d, %d)", x, y, fragmentId);
|
|
|
|
DrawRequest drawRequest;
|
|
memset(&drawRequest, 0, sizeof(drawRequest));
|
|
|
|
drawRequest.x = x;
|
|
drawRequest.y = y;
|
|
drawRequest.baseColor = _vm->_palette->findFragment(fragmentId) & 0xFF;
|
|
|
|
if (mode == 1) {
|
|
drawRequest.scaling = _vm->_segmap->getScalingAtPoint(drawRequest.x, drawRequest.y);
|
|
} else if (mode == 2) {
|
|
drawRequest.scaling = 0;
|
|
}
|
|
|
|
int16 count = FROM_LE_16(spriteArray[0]);
|
|
|
|
//debug(0, "count = %d", count);
|
|
|
|
for (int16 index = 1; index <= count; index++) {
|
|
|
|
byte *spriteItem = data + FROM_LE_16(spriteArray[index]);
|
|
|
|
uint16 loopNum = READ_LE_UINT16(spriteItem + 0) & 0x7FFF;
|
|
uint16 loopCount = READ_LE_UINT16(spriteItem + 2);
|
|
uint16 frameNum = READ_LE_UINT16(spriteItem + 4);
|
|
uint16 frameCount = READ_LE_UINT16(spriteItem + 6);
|
|
drawRequest.resIndex = READ_LE_UINT16(spriteItem + 8);
|
|
drawRequest.flags = READ_LE_UINT16(spriteItem + 10 + loopNum * 2);
|
|
|
|
debug(0, "Screen::addAnimatedSprite(%d of %d) loopNum = %d; loopCount = %d; frameNum = %d; frameCount = %d; resIndex = %d; flags = %04X, mode = %d",
|
|
index, count, loopNum, loopCount, frameNum, frameCount, drawRequest.resIndex, drawRequest.flags, mode);
|
|
|
|
addDrawRequest(drawRequest);
|
|
|
|
frameNum++;
|
|
if (frameNum == frameCount) {
|
|
frameNum = 0;
|
|
loopNum++;
|
|
if (loopNum == loopCount) {
|
|
if (loop) {
|
|
loopNum = 0;
|
|
} else {
|
|
loopNum--;
|
|
}
|
|
}
|
|
} else {
|
|
loopNum |= 0x8000;
|
|
}
|
|
|
|
WRITE_LE_UINT16(spriteItem + 0, loopNum);
|
|
WRITE_LE_UINT16(spriteItem + 4, frameNum);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void Screen::clearSprites() {
|
|
|
|
}
|
|
|
|
void Screen::blastSprite(int16 x, int16 y, int16 fragmentId, int16 resIndex, uint16 flags) {
|
|
|
|
DrawRequest drawRequest;
|
|
SpriteDrawItem sprite;
|
|
|
|
drawRequest.x = x;
|
|
drawRequest.y = y;
|
|
drawRequest.baseColor = _vm->_palette->findFragment(fragmentId) & 0xFF;
|
|
drawRequest.resIndex = resIndex;
|
|
drawRequest.flags = flags;
|
|
drawRequest.scaling = 0;
|
|
|
|
if (createSpriteDrawItem(drawRequest, sprite)) {
|
|
sprite.x -= _vm->_cameraX;
|
|
sprite.y -= _vm->_cameraY;
|
|
drawSprite(sprite);
|
|
}
|
|
|
|
}
|
|
|
|
void Screen::updateVerbLine(int16 slotIndex, int16 slotOffset) {
|
|
|
|
debug(0, "Screen::updateVerbLine() _verbLineNum = %d; _verbLineX = %d; _verbLineY = %d; _verbLineWidth = %d; _verbLineCount = %d",
|
|
_verbLineNum, _verbLineX, _verbLineY, _verbLineWidth, _verbLineCount);
|
|
|
|
Font font(_vm->_res->load(_fontResIndexArray[0])->data);
|
|
|
|
_verbLineItems[_verbLineNum].slotIndex = slotIndex;
|
|
_verbLineItems[_verbLineNum].slotOffset = slotOffset;
|
|
|
|
// First clear the line
|
|
int16 y = _verbLineY;
|
|
for (int16 i = 0; i < _verbLineCount; i++) {
|
|
byte *dest = _frontScreen + _verbLineX - _verbLineWidth / 2 + (y - 1 + _vm->_cameraHeight) * 640;
|
|
for (int16 j = 0; j < 20; j++) {
|
|
memset(dest, 0xE0, _verbLineWidth);
|
|
dest += 640;
|
|
}
|
|
y += 18;
|
|
}
|
|
|
|
GuiTextWrapState wrapState;
|
|
int16 len = 0;
|
|
wrapState.width = 0;
|
|
wrapState.destString = wrapState.textBuffer;
|
|
wrapState.len1 = 0;
|
|
wrapState.len2 = 0;
|
|
|
|
y = _verbLineY;
|
|
|
|
memset(wrapState.textBuffer, 0, sizeof(wrapState.textBuffer));
|
|
|
|
for (int16 i = 0; i <= _verbLineNum; i++) {
|
|
wrapState.sourceString = _vm->_script->getSlotData(_verbLineItems[i].slotIndex) + _verbLineItems[i].slotOffset;
|
|
len = wrapGuiText(_fontResIndexArray[0], _verbLineWidth, wrapState);
|
|
wrapState.len1 += len;
|
|
}
|
|
|
|
if (_verbLineCount != 1) {
|
|
int16 charWidth = 0;
|
|
if (*wrapState.sourceString < 0xF0) {
|
|
while (*wrapState.sourceString > 0x20 && *wrapState.sourceString < 0xF0 && len > 0) {
|
|
byte ch = *wrapState.sourceString--;
|
|
wrapState.len1--;
|
|
len--;
|
|
charWidth = font.getCharWidth(ch) + font.getSpacing() - 1;
|
|
wrapState.width -= charWidth;
|
|
}
|
|
wrapState.width += charWidth;
|
|
wrapState.sourceString++;
|
|
wrapState.len1 -= len;
|
|
wrapState.len2 = len + 1;
|
|
|
|
drawGuiText(_verbLineX - 1 - (wrapState.width / 2), y, 0xF9, 0xFF, _fontResIndexArray[0], wrapState);
|
|
|
|
wrapState.destString = wrapState.textBuffer;
|
|
wrapState.width = 0;
|
|
len = wrapGuiText(_fontResIndexArray[0], _verbLineWidth, wrapState);
|
|
wrapState.len1 += len;
|
|
|
|
y += 9;
|
|
}
|
|
y += 9;
|
|
}
|
|
|
|
wrapState.len1 -= len;
|
|
wrapState.len2 = len;
|
|
|
|
drawGuiText(_verbLineX - 1 - (wrapState.width / 2), y, 0xF9, 0xFF, _fontResIndexArray[0], wrapState);
|
|
|
|
_guiRefresh = true;
|
|
|
|
}
|
|
|
|
void Screen::updateTalkText(int16 slotIndex, int16 slotOffset) {
|
|
|
|
int16 x, y, maxWidth, width, length;
|
|
byte durationModifier = 1;
|
|
byte *textData = _vm->_script->getSlotData(slotIndex) + slotOffset;
|
|
|
|
TalkTextItem *item = &_talkTextItems[_talkTextItemNum];
|
|
|
|
item->fontNum = 0;
|
|
item->color = _talkTextFontColor;
|
|
|
|
x = CLIP<int16>(_talkTextX - _vm->_cameraX, 120, _talkTextMaxWidth);
|
|
y = CLIP<int16>(_talkTextY - _vm->_cameraY, 4, _vm->_cameraHeight - 16);
|
|
|
|
maxWidth = 624 - ABS(x - 320) * 2;
|
|
|
|
while (1) {
|
|
if (*textData == 0x0A) {
|
|
x = CLIP<int16>(READ_LE_UINT16(&textData[3]), 120, _talkTextMaxWidth);
|
|
y = CLIP<int16>(READ_LE_UINT16(&textData[1]), 4, _vm->_cameraHeight - 16);
|
|
maxWidth = 624 - ABS(x - 320) * 2;
|
|
textData += 4;
|
|
} else if (*textData == 0x14) {
|
|
item->color = ((textData[1] << 4) & 0xF0) | ((textData[1] >> 4) & 0x0F);
|
|
textData += 2;
|
|
} else if (*textData == 0x19) {
|
|
durationModifier = textData[1];
|
|
textData += 2;
|
|
} else if (*textData < 0x0A) {
|
|
item->fontNum = textData[0];
|
|
// FIXME: Some texts request a font which isn't registered so we change it to a font that is
|
|
if (_fontResIndexArray[item->fontNum] == 0)
|
|
item->fontNum = 0;
|
|
textData += 1;
|
|
} else
|
|
break;
|
|
}
|
|
|
|
item->slotIndex = slotIndex;
|
|
item->slotOffset = textData - _vm->_script->getSlotData(slotIndex);
|
|
|
|
width = 0;
|
|
length = 0;
|
|
|
|
item->duration = 0;
|
|
item->lineCount = 0;
|
|
|
|
Font font(_vm->_res->load(_fontResIndexArray[item->fontNum])->data);
|
|
int16 wordLength, wordWidth;
|
|
|
|
while (*textData < 0xF0) {
|
|
if (*textData == 0x1E) {
|
|
textData++;
|
|
addTalkTextRect(font, x, y, length, width, item);
|
|
width = 0;
|
|
length = 0;
|
|
} else {
|
|
wordLength = 0;
|
|
wordWidth = 0;
|
|
while (*textData >= 0x20 && *textData < 0xF0) {
|
|
byte ch = *textData++;
|
|
wordLength++;
|
|
if (ch == 0x20) {
|
|
wordWidth += font.getWidth();
|
|
break;
|
|
} else {
|
|
wordWidth += font.getCharWidth(ch) + font.getSpacing() - 1;
|
|
}
|
|
}
|
|
if (width + wordWidth > maxWidth + font.getWidth()) {
|
|
addTalkTextRect(font, x, y, length, width, item);
|
|
width = wordWidth;
|
|
length = wordLength;
|
|
} else {
|
|
width += wordWidth;
|
|
length += wordLength;
|
|
}
|
|
}
|
|
}
|
|
|
|
addTalkTextRect(font, x, y, length, width, item);
|
|
|
|
if (item->lineCount > 0) {
|
|
int16 ysub = (font.getHeight() - 1) * item->lineCount;
|
|
if (item->lines[0].y - 4 < ysub)
|
|
ysub = item->lines[0].y - 4;
|
|
for (int16 l = 0; l < item->lineCount; l++)
|
|
item->lines[l].y -= ysub;
|
|
}
|
|
|
|
int16 textDurationMultiplier = item->duration + 8;
|
|
if (_vm->_doSpeech && *textData == 0xFE) {
|
|
textDurationMultiplier += 100;
|
|
}
|
|
item->duration = 4 * textDurationMultiplier * durationModifier;
|
|
|
|
}
|
|
|
|
void Screen::addTalkTextRect(Font &font, int16 x, int16 &y, int16 length, int16 width, TalkTextItem *item) {
|
|
|
|
if (width > 0) {
|
|
TextRect *textRect = &item->lines[item->lineCount];
|
|
width = width + 1 - font.getSpacing();
|
|
textRect->width = width;
|
|
item->duration += length;
|
|
textRect->length = length;
|
|
textRect->y = y;
|
|
textRect->x = CLIP<int16>(x - width / 2, 0, 640);
|
|
item->lineCount++;
|
|
}
|
|
|
|
y += font.getHeight() - 1;
|
|
|
|
}
|
|
|
|
void Screen::addTalkTextItemsToRenderQueue() {
|
|
|
|
for (int16 i = 0; i <= _talkTextItemNum; i++) {
|
|
TalkTextItem *item = &_talkTextItems[i];
|
|
byte *text = _vm->_script->getSlotData(item->slotIndex) + item->slotOffset;
|
|
|
|
if (item->fontNum == -1 || item->duration == 0)
|
|
continue;
|
|
|
|
//item->duration -= _vm->_counter01;
|
|
item->duration--;
|
|
if (item->duration < 0)
|
|
item->duration = 0;
|
|
|
|
for (byte j = 0; j < item->lineCount; j++) {
|
|
_renderQueue->addText(item->lines[j].x, item->lines[j].y, item->color, _fontResIndexArray[item->fontNum],
|
|
text, item->lines[j].length);
|
|
text += item->lines[j].length;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
int16 Screen::getTalkTextDuration() {
|
|
return _talkTextItems[_talkTextItemNum].duration;
|
|
}
|
|
|
|
void Screen::finishTalkTextItems() {
|
|
for (int16 i = 0; i <= _talkTextItemNum; i++) {
|
|
_talkTextItems[i].duration = 0;
|
|
}
|
|
}
|
|
|
|
void Screen::keepTalkTextItemsAlive() {
|
|
for (int16 i = 0; i <= _talkTextItemNum; i++) {
|
|
TalkTextItem *item = &_talkTextItems[i];
|
|
if (item->fontNum == -1)
|
|
item->duration = 0;
|
|
else if (item->duration > 0)
|
|
item->duration = 2;
|
|
}
|
|
}
|
|
|
|
void Screen::registerFont(uint fontIndex, uint resIndex) {
|
|
_fontResIndexArray[fontIndex] = resIndex;
|
|
}
|
|
|
|
void Screen::drawGuiTextMulti(byte *textData) {
|
|
|
|
int16 x = 0, y = 0;
|
|
|
|
// Really strange stuff.
|
|
for (int i = 30; i >= 0; i--) {
|
|
if (textData[i] >= 0xF0)
|
|
break;
|
|
if (i == 0)
|
|
return;
|
|
}
|
|
|
|
GuiTextWrapState wrapState;
|
|
wrapState.sourceString = textData;
|
|
|
|
do {
|
|
if (*wrapState.sourceString == 0x0A) {
|
|
// Set text position
|
|
y = wrapState.sourceString[1];
|
|
x = READ_LE_UINT32(wrapState.sourceString + 2);
|
|
wrapState.sourceString += 4;
|
|
} else if (*wrapState.sourceString == 0x0B) {
|
|
// Inc text position
|
|
y += wrapState.sourceString[1];
|
|
x += wrapState.sourceString[2];
|
|
wrapState.sourceString += 3;
|
|
} else {
|
|
wrapState.destString = wrapState.textBuffer;
|
|
wrapState.width = 0;
|
|
wrapState.len1 = 0;
|
|
wrapState.len2 = wrapGuiText(_fontResIndexArray[1], 640, wrapState);
|
|
drawGuiText(x - wrapState.width / 2, y, _fontColor1, _fontColor2, _fontResIndexArray[1], wrapState);
|
|
}
|
|
} while (*wrapState.sourceString != 0xFF);
|
|
|
|
_guiRefresh = true;
|
|
|
|
}
|
|
|
|
int16 Screen::wrapGuiText(uint fontResIndex, int maxWidth, GuiTextWrapState &wrapState) {
|
|
|
|
Font font(_vm->_res->load(fontResIndex)->data);
|
|
int16 len = 0;
|
|
|
|
while (*wrapState.sourceString >= 0x20 && *wrapState.sourceString < 0xF0) {
|
|
byte ch = *wrapState.sourceString;
|
|
byte charWidth;
|
|
if (ch <= 0x20)
|
|
charWidth = font.getWidth();
|
|
else
|
|
charWidth = font.getCharWidth(ch) + font.getSpacing() - 1;
|
|
if (wrapState.width + charWidth >= maxWidth)
|
|
break;
|
|
len++;
|
|
wrapState.width += charWidth;
|
|
*wrapState.destString++ = *wrapState.sourceString++;
|
|
}
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
void Screen::drawGuiText(int16 x, int16 y, byte fontColor1, byte fontColor2, uint fontResIndex, GuiTextWrapState &wrapState) {
|
|
|
|
debug(0, "Screen::drawGuiText(%d, %d, %d, %d, %d) wrapState.len1 = %d; wrapState.len2 = %d", x, y, fontColor1, fontColor2, fontResIndex, wrapState.len1, wrapState.len2);
|
|
|
|
int16 ywobble = 1;
|
|
|
|
x = drawString(x + 1, y + _vm->_cameraHeight, fontColor1, fontResIndex, wrapState.textBuffer, wrapState.len1, &ywobble, false);
|
|
x = drawString(x, y + _vm->_cameraHeight, fontColor2, fontResIndex, wrapState.textBuffer + wrapState.len1, wrapState.len2, &ywobble, false);
|
|
|
|
}
|
|
|
|
int16 Screen::drawString(int16 x, int16 y, byte color, uint fontResIndex, const byte *text, int len, int16 *ywobble, bool outline) {
|
|
|
|
//debug(0, "Screen::drawString(%d, %d, %d, %d)", x, y, color, fontResIndex);
|
|
|
|
Font font(_vm->_res->load(fontResIndex)->data);
|
|
|
|
if (len == -1)
|
|
len = strlen((const char*)text);
|
|
|
|
int16 yadd = 0;
|
|
if (ywobble)
|
|
yadd = *ywobble;
|
|
|
|
while (len--) {
|
|
byte ch = *text++;
|
|
if (ch <= 0x20) {
|
|
x += font.getWidth();
|
|
} else {
|
|
drawChar(font, _frontScreen, x, y - yadd, ch, color, outline);
|
|
x += font.getCharWidth(ch) + font.getSpacing() - 1;
|
|
yadd = -yadd;
|
|
}
|
|
}
|
|
|
|
if (ywobble)
|
|
*ywobble = yadd;
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
void Screen::drawChar(const Font &font, byte *dest, int16 x, int16 y, byte ch, byte color, bool outline) {
|
|
|
|
int16 charWidth, charHeight;
|
|
byte *charData;
|
|
|
|
dest += x + y * 640;
|
|
|
|
charWidth = font.getCharWidth(ch);
|
|
//charHeight = font.getHeight() - 2;//Why was this here?!
|
|
charHeight = font.getHeight();
|
|
charData = font.getCharData(ch);
|
|
|
|
while (charHeight--) {
|
|
byte lineWidth = charWidth;
|
|
while (lineWidth > 0) {
|
|
byte count = charData[0] & 0x0F;
|
|
byte flags = charData[0] & 0xF0;
|
|
charData++;
|
|
if ((flags & 0x80) == 0) {
|
|
if (flags & 0x10) {
|
|
memset(dest, color, count);
|
|
} else if (outline) {
|
|
memset(dest, 0, count);
|
|
}
|
|
}
|
|
dest += count;
|
|
lineWidth -= count;
|
|
}
|
|
dest += 640 - charWidth;
|
|
}
|
|
|
|
}
|
|
|
|
void Screen::drawSurface(int16 x, int16 y, Graphics::Surface *surface) {
|
|
|
|
int16 skipX = 0;
|
|
int16 width = surface->w;
|
|
int16 height = surface->h;
|
|
byte *surfacePixels = (byte *)surface->getBasePtr(0, 0);
|
|
byte *frontScreen;
|
|
|
|
// Not on screen, skip
|
|
if (x + width < 0 || y + height < 0 || x >= 640 || y >= _vm->_cameraHeight)
|
|
return;
|
|
|
|
if (x < 0) {
|
|
skipX = -x;
|
|
x = 0;
|
|
width -= skipX;
|
|
}
|
|
|
|
if (y < 0) {
|
|
int16 skipY = -y;
|
|
surfacePixels += surface->w * skipY;
|
|
y = 0;
|
|
height -= skipY;
|
|
}
|
|
|
|
if (x + width >= 640) {
|
|
width -= x + width - 640;
|
|
}
|
|
|
|
if (y + height >= _vm->_cameraHeight) {
|
|
height -= y + height - _vm->_cameraHeight;
|
|
}
|
|
|
|
frontScreen = _vm->_screen->_frontScreen + x + (y * 640);
|
|
|
|
for (int16 h = 0; h < height; h++) {
|
|
surfacePixels += skipX;
|
|
for (int16 w = 0; w < width; w++) {
|
|
if (*surfacePixels != 0xFF)
|
|
*frontScreen = *surfacePixels;
|
|
frontScreen++;
|
|
surfacePixels++;
|
|
}
|
|
frontScreen += 640 - width;
|
|
surfacePixels += surface->w - width - skipX;
|
|
}
|
|
|
|
}
|
|
|
|
void Screen::saveState(Common::WriteStream *out) {
|
|
|
|
// Save verb line
|
|
out->writeUint16LE(_verbLineNum);
|
|
out->writeUint16LE(_verbLineX);
|
|
out->writeUint16LE(_verbLineY);
|
|
out->writeUint16LE(_verbLineWidth);
|
|
out->writeUint16LE(_verbLineCount);
|
|
for (int i = 0; i < 8; i++) {
|
|
out->writeUint16LE(_verbLineItems[i].slotIndex);
|
|
out->writeUint16LE(_verbLineItems[i].slotOffset);
|
|
}
|
|
|
|
// Save talk text items
|
|
out->writeUint16LE(_talkTextX);
|
|
out->writeUint16LE(_talkTextY);
|
|
out->writeUint16LE(_talkTextMaxWidth);
|
|
out->writeByte(_talkTextFontColor);
|
|
out->writeUint16LE(_talkTextItemNum);
|
|
for (int i = 0; i < 5; i++) {
|
|
out->writeUint16LE(_talkTextItems[i].duration);
|
|
out->writeUint16LE(_talkTextItems[i].slotIndex);
|
|
out->writeUint16LE(_talkTextItems[i].slotOffset);
|
|
out->writeUint16LE(_talkTextItems[i].fontNum);
|
|
out->writeByte(_talkTextItems[i].color);
|
|
out->writeByte(_talkTextItems[i].lineCount);
|
|
for (int j = 0; j < _talkTextItems[i].lineCount; j++) {
|
|
out->writeUint16LE(_talkTextItems[i].lines[j].x);
|
|
out->writeUint16LE(_talkTextItems[i].lines[j].y);
|
|
out->writeUint16LE(_talkTextItems[i].lines[j].width);
|
|
out->writeUint16LE(_talkTextItems[i].lines[j].length);
|
|
}
|
|
}
|
|
|
|
// Save GUI bitmap
|
|
{
|
|
byte *gui = _frontScreen + _vm->_cameraHeight * 640;
|
|
for (int i = 0; i < _vm->_guiHeight; i++) {
|
|
out->write(gui, 640);
|
|
gui += 640;
|
|
}
|
|
}
|
|
|
|
// Save fonts
|
|
for (int i = 0; i < 10; i++)
|
|
out->writeUint32LE(_fontResIndexArray[i]);
|
|
out->writeByte(_fontColor1);
|
|
out->writeByte(_fontColor2);
|
|
|
|
}
|
|
|
|
void Screen::loadState(Common::ReadStream *in) {
|
|
|
|
// Load verb line
|
|
_verbLineNum = in->readUint16LE();
|
|
_verbLineX = in->readUint16LE();
|
|
_verbLineY = in->readUint16LE();
|
|
_verbLineWidth = in->readUint16LE();
|
|
_verbLineCount = in->readUint16LE();
|
|
for (int i = 0; i < 8; i++) {
|
|
_verbLineItems[i].slotIndex = in->readUint16LE();
|
|
_verbLineItems[i].slotOffset = in->readUint16LE();
|
|
}
|
|
|
|
// Load talk text items
|
|
_talkTextX = in->readUint16LE();
|
|
_talkTextY = in->readUint16LE();
|
|
_talkTextMaxWidth = in->readUint16LE();
|
|
_talkTextFontColor = in->readByte();
|
|
_talkTextItemNum = in->readUint16LE();
|
|
for (int i = 0; i < 5; i++) {
|
|
_talkTextItems[i].duration = in->readUint16LE();
|
|
_talkTextItems[i].slotIndex = in->readUint16LE();
|
|
_talkTextItems[i].slotOffset = in->readUint16LE();
|
|
_talkTextItems[i].fontNum = in->readUint16LE();
|
|
_talkTextItems[i].color = in->readByte();
|
|
_talkTextItems[i].lineCount = in->readByte();
|
|
for (int j = 0; j < _talkTextItems[i].lineCount; j++) {
|
|
_talkTextItems[i].lines[j].x = in->readUint16LE();
|
|
_talkTextItems[i].lines[j].y = in->readUint16LE();
|
|
_talkTextItems[i].lines[j].width = in->readUint16LE();
|
|
_talkTextItems[i].lines[j].length = in->readUint16LE();
|
|
}
|
|
}
|
|
|
|
// Load GUI bitmap
|
|
{
|
|
byte *gui = _frontScreen + _vm->_cameraHeight * 640;
|
|
for (int i = 0; i < _vm->_guiHeight; i++) {
|
|
in->read(gui, 640);
|
|
gui += 640;
|
|
}
|
|
_guiRefresh = true;
|
|
}
|
|
|
|
// Load fonts
|
|
for (int i = 0; i < 10; i++)
|
|
_fontResIndexArray[i] = in->readUint32LE();
|
|
_fontColor1 = in->readByte();
|
|
_fontColor2 = in->readByte();
|
|
|
|
}
|
|
|
|
} // End of namespace Toltecs
|