libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2024-12-25 19:25:20 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
3826c7c8a8
scummvm/scumm/string.cpp
Max Horn 41c2d6fba3 sound system cleanup 
svn-id: r4867
2002-08-29 23:45:15 +00:00

1058 lines
22 KiB
C++
Raw Blame History

/* ScummVM - Scumm Interpreter
* Copyright (C) 2001 Ludvig Strigeus
* Copyright (C) 2001/2002 The ScummVM project
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* $Header$
*
*/
#include "stdafx.h"
#include "scumm.h"
#include "actor.h"
#include "scumm/sound.h"
int CharsetRenderer::getStringWidth(int arg, byte *text, int pos)
{
byte *ptr;
int width, offs, w;
byte chr;
width = 1;
ptr = _vm->getResourceAddress(rtCharset, _curId) + 29;
if (_vm->_features & GF_SMALL_HEADER)
ptr -= 12;
while ((chr = text[pos++]) != 0) {
if (chr == 0xD)
break;
if (chr == '@')
continue;
if (chr == 254)
chr = 255;
if (chr == 255) {
chr = text[pos++];
if (chr == 3)
break;
if (chr == 8) {
if (arg == 1)
break;
while (text[pos] == ' ')
text[pos++] = '@';
continue;
}
if (chr == 10 || chr == 21 || chr == 12 || chr == 13) {
pos += 2;
continue;
}
if (chr == 9 || chr == 1 || chr == 2)
break;
if (chr == 14) {
int set = text[pos] | (text[pos + 1] << 8);
pos += 2;
ptr = _vm->getResourceAddress(rtCharset, set) + 29;
if (_vm->_features & GF_SMALL_HEADER)
ptr -= 12;
continue;
}
}
if (_vm->_features & GF_OLD256) {
width += 8;
} else {
offs = READ_LE_UINT32(ptr + chr * 4 + 4);
if (offs) {
if (ptr[offs + 2] >= 0x80) {
w = ptr[offs + 2] - 0x100;
} else {
w = ptr[offs + 2];
}
width += ptr[offs] + w;
}
}
}
return width;
}
void CharsetRenderer::addLinebreaks(int a, byte *str, int pos, int maxwidth)
{
int lastspace = -1;
int curw = 1;
int offs, w;
byte *ptr;
byte chr;
ptr = _vm->getResourceAddress(rtCharset, _curId) + 29;
if (_vm->_features & GF_SMALL_HEADER)
ptr -= 12;
while ((chr = str[pos++]) != 0) {
if (chr == '@')
continue;
if (chr == 254)
chr = 255;
if (chr == 255) {
chr = str[pos++];
if (chr == 3)
break;
if (chr == 8) {
if (a == 1) {
curw = 1;
} else {
while (str[pos] == ' ')
str[pos++] = '@';
}
continue;
}
if (chr == 10 || chr == 21 || chr == 12 || chr == 13) {
pos += 2;
continue;
}
if (chr == 1) {
curw = 1;
continue;
}
if (chr == 2)
break;
if (chr == 14) {
int set = str[pos] | (str[pos + 1] << 8);
pos += 2;
ptr = _vm->getResourceAddress(rtCharset, set) + 29;
if (_vm->_features & GF_SMALL_HEADER)
ptr -= 12;
continue;
}
}
if (chr == ' ')
lastspace = pos - 1;
if (_vm->_features & GF_OLD256) {
curw += getSpacing(chr);
} else {
offs = READ_LE_UINT32(ptr + chr * 4 + 4);
if (offs) {
if (ptr[offs + 2] >= 0x80) {
w = ptr[offs + 2] - 0x100;
} else {
w = ptr[offs + 2];
}
curw += w + ptr[offs];
}
}
if (lastspace == -1)
continue;
if (curw > maxwidth) {
str[lastspace] = 0xD;
curw = 1;
pos = lastspace + 1;
lastspace = -1;
}
}
}
void Scumm::unkMessage1()
{
byte buffer[100];
_msgPtrToAdd = buffer;
_messagePtr = addMessageToStack(_messagePtr);
if (buffer[0] == 0xFF && buffer[1] == 10) {
uint32 a, b;
a = buffer[2] | (buffer[3] << 8) | (buffer[6] << 16) | (buffer[7] << 24);
b = buffer[10] | (buffer[11] << 8) | (buffer[14] << 16) | (buffer[15] << 24);
// if (_saveSound != 1)
_sound->talkSound(a, b, 1);
}
// warning("unkMessage1(\"%s\")", buffer);
}
void Scumm::unkMessage2()
{
byte buf[100], *tmp;
_msgPtrToAdd = buf;
tmp = _messagePtr = addMessageToStack(_messagePtr);
if (string[3].color == 0)
string[3].color = 4;
warning("unkMessage2(\"%s\")", buf);
_messagePtr = tmp;
}
void Scumm::CHARSET_1()
{
int s, i, t, c;
int frme;
Actor *a;
byte *buffer;
if (!_haveMsg)
return;
// FIXME: This Zak check fixes several hangs (Yak hang, and opening
// 'secret room while walking' hang. It doesn't do the camera check
// when the talk target isn't an actor. The question is, can we make
// this a more general case? Does it really need to be Zak specific?
if (!(_features & GF_AFTER_V7) && !(_gameId==GID_ZAK256 && _vars[VAR_TALK_ACTOR] == 0xFF)) {
if ((camera._dest.x >> 3) != (camera._cur.x >> 3) || camera._cur.x != camera._last.x)
return;
}
a = NULL;
if (_vars[VAR_TALK_ACTOR] != 0xFF)
a = derefActorSafe(_vars[VAR_TALK_ACTOR], "CHARSET_1");
if (a && string[0].overhead != 0) {
if (!(_features & GF_AFTER_V6)) {
string[0].xpos = a->x - camera._cur.x + 160;
if (_vars[VAR_V5_TALK_STRING_Y] < 0) {
s = (a->scaley * (int)_vars[VAR_V5_TALK_STRING_Y]) / 0xFF;
string[0].ypos = ((_vars[VAR_V5_TALK_STRING_Y] - s) >> 1) + s - a->elevation + a->y;
} else {
string[0].ypos = _vars[VAR_V5_TALK_STRING_Y];
}
if (string[0].ypos < 1)
string[0].ypos = 1;
if (string[0].xpos < 80)
string[0].xpos = 80;
if (string[0].xpos > 240)
string[0].xpos = 240;
} else {
s = a->scaley * a->new_1 / 0xFF;
string[0].ypos = ((a->new_1 - s) >> 1) + s - a->elevation + a->y;
if (string[0].ypos < 1)
string[0].ypos = 1;
if (string[0].ypos < camera._cur.y - 100)
string[0].ypos = camera._cur.y - 100;
s = a->scalex * a->new_2 / 0xFF;
string[0].xpos = ((a->new_2 - s) >> 1) + s + a->x - camera._cur.x + 160;
if (string[0].xpos < 80)
string[0].xpos = 80;
if (string[0].xpos > 240)
string[0].xpos = 240;
}
}
charset._top = string[0].ypos;
charset._left = string[0].xpos;
charset._left2 = string[0].xpos;
charset._curId = string[0].charset;
if (a && a->charset)
charset._curId = a->charset;
charset._center = string[0].center;
charset._right = string[0].right;
charset._color = _charsetColor;
_bkColor = 0;
if (!(_features & GF_OLD256)) // FIXME
for (i = 0; i < 4; i++)
if (_features & GF_SMALL_HEADER)
charset._colorMap[i] = _charsetData[charset._curId][i - 12];
else
charset._colorMap[i] = _charsetData[charset._curId][i];
if (_keepText) {
charset._strLeft = gdi._mask_left;
charset._strRight = gdi._mask_right;
charset._strTop = gdi._mask_top;
charset._strBottom = gdi._mask_bottom;
}
if (_talkDelay)
return;
if (_haveMsg != 0xFF && _haveMsg != 0xFE) {
if (_sound->_sfxMode == 0)
stopTalk();
return;
}
if (a && !string[0].no_talk_anim) {
a->startAnimActor(a->talkFrame1);
_useTalkAnims = true;
}
_talkDelay = _defaultTalkDelay;
if (!_keepText) {
if (_features & GF_OLD256) {
gdi._mask_left = string[0].xpos;
gdi._mask_top = string[0].ypos;
gdi._mask_bottom = string[0].ypos + 8;
gdi._mask_right = 320;
if (string[0].ypos <= 16) // If we are cleaning the text line, clean 2 lines.
gdi._mask_bottom = 16;
}
restoreCharsetBg();
charset._xpos2 = string[0].xpos;
charset._ypos2 = string[0].ypos;
}
t = charset._right - string[0].xpos - 1;
if (charset._center) {
if (t > charset._xpos2)
t = charset._xpos2;
t <<= 1;
}
buffer = charset._buffer + charset._bufPos;
charset.addLinebreaks(0, buffer, 0, t);
_lastXstart = virtscr[0].xstart;
if (charset._center) {
charset._xpos2 -= charset.getStringWidth(0, buffer, 0) >> 1;
if (charset._xpos2 < 0)
charset._xpos2 = 0;
}
charset._disableOffsX = charset._unk12 = !_keepText;
do {
c = *buffer++;
if (c == 0) {
// End of text reached, set _haveMsg to 1 so that the text will be
// removed next time CHARSET_1 is called.
_haveMsg = 1;
_keepText = false;
break;
}
if (c == 13) {
newLine:;
if (_features & GF_OLD256) {
charset._ypos2 = 8;
charset._xpos2 = 0;
continue;
} else {
charset._xpos2 = string[0].xpos;
if (charset._center) {
charset._xpos2 -= charset.getStringWidth(0, buffer, 0) >> 1;
}
if (_features & GF_SMALL_HEADER)
charset._ypos2 += getResourceAddress(rtCharset, charset._curId)[18];
else
charset._ypos2 += getResourceAddress(rtCharset, charset._curId)[30];
charset._disableOffsX = 1;
continue;
}
}
if (c == 0xFE)
c = 0xFF;
if (c != 0xFF) {
charset._left = charset._xpos2;
charset._top = charset._ypos2;
if (_features & GF_OLD256)
charset.printCharOld(c);
else if (!(_features & GF_AFTER_V6)) {
// if (!_vars[VAR_V5_CHARFLAG]) { /* FIXME */
if (!(_haveMsg == 0xFE && _noSubtitles))
charset.printChar(c);
// }
} else {
if (!(_haveMsg == 0xFE && _noSubtitles))
charset.printChar(c);
}
charset._xpos2 = charset._left;
charset._ypos2 = charset._top;
_talkDelay += _vars[VAR_CHARINC];
continue;
}
c = *buffer++;
if (c == 3) {
if (_haveMsg != 0xFE)
_haveMsg = 0xFF;
_keepText = false;
break;
} else if (c == 1) {
goto newLine;
} else if (c == 2) {
_haveMsg = 0;
_keepText = true;
break;
} else if (c == 9) {
frme = *buffer++;
frme |= *buffer++ << 8;
if (a)
a->startAnimActor(frme);
} else if (c == 10) {
uint32 tmpA, tmpB;
tmpA = buffer[0] | (buffer[1] << 8) | (buffer[4] << 16) | (buffer[5] << 24);
tmpB = buffer[8] | (buffer[9] << 8) | (buffer[12] << 16) | (buffer[13] << 24);
_sound->talkSound(tmpA, tmpB, 2);
buffer += 14;
// Set flag that speech variant exist of this msg
if (_haveMsg == 0xFF)
_haveMsg = 0xFE;
} else if (c == 14) {
int oldy = getResourceAddress(rtCharset, charset._curId)[30];
charset._curId = *buffer++;
buffer += 2;
for (i = 0; i < 4; i++)
if (_features & GF_SMALL_HEADER)
charset._colorMap[i] = _charsetData[charset._curId][i - 12];
else
charset._colorMap[i] = _charsetData[charset._curId][i];
charset._ypos2 -= getResourceAddress(rtCharset, charset._curId)[30] - oldy;
} else if (c == 12) {
int color;
color = *buffer++;
color |= *buffer++ << 8;
if (color == 0xFF)
charset._color = _charsetColor;
else
charset._color = color;
} else if (c == 13) {
buffer += 2;
} else {
warning("CHARSET_1: invalid code %d", c);
}
} while (1);
charset._bufPos = buffer - charset._buffer;
gdi._mask_left = charset._strLeft;
gdi._mask_right = charset._strRight;
gdi._mask_top = charset._strTop;
gdi._mask_bottom = charset._strBottom;
}
void Scumm::description()
{
int c;
byte *buffer;
buffer = charset._buffer + charset._bufPos;
string[0].ypos = camera._cur.y + 88;
string[0].xpos = 160 - (charset.getStringWidth(0, buffer, 0) >> 1);
if (string[0].xpos < 0)
string[0].xpos = 0;
charset._top = string[0].ypos;
charset._left = string[0].xpos;
charset._left2 = string[0].xpos;
charset._right = 319;
charset._xpos2 = string[0].xpos;
charset._ypos2 = string[0].ypos;
charset._disableOffsX = charset._unk12 = 1;
charset._curId = 3;
charset._center = false;
charset._color = 15;
_bkColor = 0;
_talkDelay = 1;
restoreCharsetBg();
_lastXstart = virtscr[0].xstart;
do {
c = *buffer++;
if (c == 0) {
_haveMsg = 1;
break;
}
if (c != 0xFF) {
charset._left = charset._xpos2;
charset._top = charset._ypos2;
charset.printChar(c);
charset._xpos2 = charset._left;
charset._ypos2 = charset._top;
continue;
}
} while (1);
gdi._mask_left = charset._strLeft;
gdi._mask_right = charset._strRight;
gdi._mask_top = charset._strTop;
gdi._mask_bottom = charset._strBottom;
}
void Scumm::drawString(int a)
{
byte buf[256];
byte *charsetptr, *space;
int i;
byte byte1 = 0, chr;
uint color;
_msgPtrToAdd = buf;
_messagePtr = addMessageToStack(_messagePtr);
charset._left2 = charset._left = string[a].xpos;
charset._top = string[a].ypos;
charset._curId = string[a].charset;
charset._center = string[a].center;
charset._right = string[a].right;
charset._color = string[a].color;
_bkColor = 0;
charset._unk12 = 1;
charset._disableOffsX = 1;
if (!(_features & GF_OLD256)) {
charsetptr = getResourceAddress(rtCharset, charset._curId);
assert(charsetptr);
charsetptr += 29;
if (_features & GF_SMALL_HEADER)
charsetptr -= 12;
for (i = 0; i < 4; i++)
if (_features & GF_SMALL_HEADER)
charset._colorMap[i] = _charsetData[charset._curId][i - 12];
else
charset._colorMap[i] = _charsetData[charset._curId][i];
byte1 = charsetptr[1];
}
_msgPtrToAdd = buf;
/* trim from the right */
space = NULL;
while (*_msgPtrToAdd) {
if (*_msgPtrToAdd == ' ') {
if (!space)
space = _msgPtrToAdd;
} else {
space = NULL;
}
_msgPtrToAdd++;
}
if (space)
*space = '\0';
if (charset._center) {
charset._left -= charset.getStringWidth(a, buf, 0) >> 1;
}
charset._ignoreCharsetMask = 1;
if (!buf[0]) {
buf[0] = ' ';
buf[1] = 0;
}
for (i = 0; (chr = buf[i++]) != 0;) {
if (chr == 254)
chr = 255;
if (chr == 255) {
chr = buf[i++];
switch (chr) {
case 9:
case 10:
case 13:
case 14:
i += 2;
break;
case 1:
case 8:
if (charset._center) {
charset._left = charset._left2 - charset.getStringWidth(a, buf, i);
} else {
charset._left = charset._left2;
}
charset._top += byte1;
break;
case 12:
color = buf[i] + (buf[i + 1] << 8);
i += 2;
if (color == 0xFF)
charset._color = string[a].color;
else
charset._color = color;
break;
}
} else {
if (a == 1 && (_features & GF_AFTER_V6))
if (string[a].no_talk_anim == 0)
charset._blitAlso = true;
if (_features & GF_OLD256)
charset.printCharOld(chr);
else
charset.printChar(chr);
charset._blitAlso = false;
}
}
charset._ignoreCharsetMask = 0;
if (a == 0) {
charset._xpos2 = charset._left;
charset._ypos2 = charset._top;
}
}
byte *Scumm::addMessageToStack(byte *msg)
{
int num, numorg;
byte *ptr, chr;
numorg = num = _numInMsgStack;
ptr = getResourceAddress(rtTemp, 6);
if (ptr == NULL)
error("Message stack not allocated");
if (msg == NULL) {
warning("Bad message in addMessageToStack, ignoring");
return NULL;
}
while ((chr = *msg++) != 0) {
if (num > 500)
error("Message stack overflow");
ptr[num++] = chr;
if (chr == 255) {
ptr[num++] = chr = *msg++;
if (chr != 1 && chr != 2 && chr != 3 && chr != 8) {
ptr[num++] = chr = *msg++;
ptr[num++] = chr = *msg++;
}
}
}
ptr[num++] = 0;
_numInMsgStack = num;
num = numorg;
while (1) {
ptr = getResourceAddress(rtTemp, 6);
chr = ptr[num++];
if (chr == 0)
break;
if (chr == 0xFF) {
chr = ptr[num++];
switch (chr) {
case 4:
unkAddMsgToStack2(READ_LE_UINT16(ptr + num));
num += 2;
break;
case 5:
unkAddMsgToStack3(READ_LE_UINT16(ptr + num));
num += 2;
break;
case 6:
unkAddMsgToStack4(READ_LE_UINT16(ptr + num));
num += 2;
break;
case 7:
unkAddMsgToStack5(READ_LE_UINT16(ptr + num));
num += 2;
break;
case 9:
//#if defined(DOTT)
case 10:
case 12:
case 13:
case 14:
//#endif
*_msgPtrToAdd++ = 0xFF;
*_msgPtrToAdd++ = chr;
*_msgPtrToAdd++ = ptr[num++];
*_msgPtrToAdd++ = ptr[num++];
break;
default:
*_msgPtrToAdd++ = 0xFF;
*_msgPtrToAdd++ = chr;
}
} else {
if (chr != '@') {
*_msgPtrToAdd++ = chr;
}
}
}
*_msgPtrToAdd = 0;
_numInMsgStack = numorg;
return msg;
}
void Scumm::unkAddMsgToStack2(int var)
{
int num, max;
byte flag;
num = readVar(var);
if (num < 0) {
*_msgPtrToAdd++ = '-';
num = -num;
}
flag = 0;
max = 10000;
do {
if (num >= max || flag) {
*_msgPtrToAdd++ = num / max + '0';
num -= (num / max) * max;
flag = 1;
}
max /= 10;
if (max == 1)
flag = 1;
} while (max);
}
void Scumm::unkAddMsgToStack3(int var)
{
int num, i;
num = readVar(var);
if (num) {
for (i = 1; i < _maxVerbs; i++) {
if (num == _verbs[i].verbid && !_verbs[i].type && !_verbs[i].saveid) {
addMessageToStack(getResourceAddress(rtVerb, i));
break;
}
}
} else {
addMessageToStack((byte *)"");
}
}
void Scumm::unkAddMsgToStack4(int var)
{
int num;
num = readVar(var);
if (num) {
addMessageToStack(getObjOrActorName(num));
} else {
addMessageToStack((byte *)"");
}
}
void Scumm::unkAddMsgToStack5(int var)
{
byte *ptr;
if (_features & GF_AFTER_V6 || _gameId == GID_INDY3_256)
var = readVar(var);
if (var) {
ptr = getStringAddress(var);
if (ptr) {
addMessageToStack(ptr);
return;
}
}
addMessageToStack((byte *)"");
}
void Scumm::initCharset(int charsetno)
{
int i;
if (_features & GF_OLD256)
charsetno = !charsetno;
if (_features & GF_SMALL_HEADER)
loadCharset(charsetno);
else if (!getResourceAddress(rtCharset, charsetno))
loadCharset(charsetno);
string[0].t_charset = charsetno;
string[1].t_charset = charsetno;
for (i = 0; i < 0x10; i++)
if (_features & GF_SMALL_HEADER)
charset._colorMap[i] = _charsetData[charset._curId][i - 12];
else
charset._colorMap[i] = _charsetData[charset._curId][i];
}
void CharsetRenderer::printCharOld(int chr)
{ // Loom3 / Zak256
VirtScreen *vs;
byte *char_ptr, *dest_ptr;
unsigned int buffer = 0, mask = 0, x = 0, y = 0;
unsigned char color;
_vm->checkRange(_vm->_maxCharsets - 1, 0, _curId, "Printing with bad charset %d");
if ((vs = _vm->findVirtScreen(_top)) == NULL)
return;
if (chr == '@')
return;
if (_unk12) {
_strLeft = _left;
_strTop = _top;
_strRight = _left;
_strBottom = _top;
_unk12 = 0;
}
char_ptr = _vm->getResourceAddress(rtCharset, _curId) + 224 + (chr + 1) * 8;
dest_ptr = vs->screenPtr + vs->xstart + (_top - vs->topline) * 320 + _left;
_vm->updateDirtyRect(vs->number, _left, _left + 8, _top - vs->topline, _top - vs->topline + 8, 0);
for (y = 0; y < 8; y++) {
for (x = 0; x < 8; x++) {
if ((mask >>= 1) == 0) {
buffer = *char_ptr++;
mask = 0x80;
}
color = ((buffer & mask) != 0);
if (color)
*(dest_ptr + y * 320 + x) = _color;
}
}
_left += getSpacing(chr);
if (_left > _strRight)
_strRight = _left;
if (_top + 8 > _strBottom)
_strBottom = _top + 8;
}
void CharsetRenderer::printChar(int chr)
{
int d, right;
VirtScreen *vs;
_vm->checkRange(_vm->_maxCharsets - 1, 1, _curId, "Printing with bad charset %d");
if ((vs = _vm->findVirtScreen(_top)) == NULL)
return;
if (chr == '@')
return;
_ptr = _vm->getResourceAddress(rtCharset, _curId) + 29;
if (_vm->_features & GF_SMALL_HEADER)
_ptr -= 12;
_bpp = _unk2 = *_ptr;
_invNumBits = 8 - _bpp;
_bitMask = 0xFF << _invNumBits;
_colorMap[1] = _color;
_charOffs = READ_LE_UINT32(_ptr + chr * 4 + 4);
if (!_charOffs)
return;
assert(_charOffs < 0x10000);
_charPtr = _ptr + _charOffs;
_width = _charPtr[0];
_height = _charPtr[1];
if (_unk12) {
_strLeft = 0;
_strTop = 0;
_strRight = 0;
_strBottom = 0;
}
if (_disableOffsX) {
_offsX = 0;
} else {
d = _charPtr[2];
if (d >= 0x80)
d -= 0x100;
_offsX = d;
}
d = _charPtr[3];
if (d >= 0x80)
d -= 0x100;
_offsY = d;
_top += _offsY;
_left += _offsX;
right = _left + _width;
if (right > _right + 1 || _left < 0) {
_left = right;
_top -= _offsY;
return;
}
_disableOffsX = 0;
if (_unk12) {
_strLeft = _left;
_strTop = _top;
_strRight = _left;
_strBottom = _top;
_unk12 = 0;
}
if (_left < _strLeft)
_strLeft = _left;
if (_top < _strTop)
_strTop = _top;
_drawTop = _top - vs->topline;
if (_drawTop < 0)
_drawTop = 0;
_bottom = _drawTop + _height + _offsY;
_vm->updateDirtyRect(vs->number, _left, right, _drawTop, _bottom, 0);
#if defined(OLD)
if (vs->number == 0)
_hasMask = true;
#else
if (vs->number != 0)
_blitAlso = false;
if (vs->number == 0 && _blitAlso == 0)
_hasMask = true;
#endif
_dest_ptr = _backbuff_ptr = vs->screenPtr + vs->xstart + _drawTop * 320 + _left;
#if !defined(OLD)
if (_blitAlso) {
#else
if (1) {
#endif
_dest_ptr = _bgbak_ptr = _vm->getResourceAddress(rtBuffer, vs->number + 5)
+ vs->xstart + _drawTop * 320 + _left;
}
_mask_ptr = _vm->getResourceAddress(rtBuffer, 9)
+ _drawTop * 40 + _left / 8 + _vm->_screenStartStrip;
_revBitMask = revBitMask[_left & 7];
_virtScreenHeight = vs->height;
_charPtr += 4;
drawBits();
#if !defined(OLD)
if (_blitAlso)
blit(_backbuff_ptr, _bgbak_ptr, _width, _height);
#endif
_left += _width;
if (_left > _strRight)
_strRight = _left;
if (_top + _height > _strBottom)
_strBottom = _top + _height;
_top -= _offsY;
}
void CharsetRenderer::drawBits()
{
bool usemask;
byte *dst, *mask, maskmask;
int y, x;
int maskpos;
int color;
byte numbits, bits;
usemask = (_vm->_curVirtScreen->number == 0 && _ignoreCharsetMask == 0);
bits = *_charPtr++;
numbits = 8;
dst = _dest_ptr;
mask = _mask_ptr;
y = 0;
for (y = 0; y < _height && y + _drawTop < _virtScreenHeight;) {
maskmask = _revBitMask;
maskpos = 0;
for (x = 0; x < _width; x++) {
color = (bits & _bitMask) >> _invNumBits;
if (color) {
if (usemask) {
mask[maskpos] |= maskmask;
}
*dst = _colorMap[color];
}
dst++;
bits <<= _bpp;
if ((numbits -= _bpp) == 0) {
bits = *_charPtr++;
numbits = 8;
}
if ((maskmask >>= 1) == 0) {
maskmask = 0x80;
maskpos++;
}
}
dst = (_dest_ptr += 320);
mask += 40;
y++;
}
}
int CharsetRenderer::getSpacing(char chr)
{
int space;
if (_curId == 1) { // do spacing for variable width old-style font
switch (chr) {
case '.':
space = 1;
break;
case 'i':
case '\'':
case 'I':
case '!':
space = 2;
break;
case 'l':
space = 3;
break;
case ' ':
space = 4;
break;
case 'W':
case 'w':
case 'N':
case 'M':
case 'm':
space = 8;
break;
default:
space = 6;
}
} else
space = 7;
return space;
}
Reference in New Issue View Git Blame Copy Permalink