scummvm/engines/cine/gfx.cpp
Eugene Sandulenko 327d30d719 CINE: eliminate global variables
svn-id: r51937
2010-08-09 11:38:01 +00:00

1820 lines
46 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$
*
*/
#include "cine/cine.h"
#include "cine/bg.h"
#include "cine/bg_list.h"
#include "cine/various.h"
#include "cine/pal.h"
#include "common/endian.h"
#include "common/system.h"
#include "common/events.h"
#include "graphics/cursorman.h"
namespace Cine {
byte *collisionPage;
FWRenderer *renderer = NULL;
// Constants related to kLowPalFormat
#define kLowPalBytesPerColor 2
#define kLowPalNumColors 16
#define kLowPalNumBytes ((kLowPalNumColors) * (kLowPalBytesPerColor))
/** Low resolution (9-bit) color format used in Cine's 16-color modes. */
#define kLowPalFormat Graphics::PixelFormat(kLowPalBytesPerColor, 3, 3, 3, 0, 8, 4, 0, 0)
// Constants related to kHighPalFormat
#define kHighPalBytesPerColor 3
#define kHighPalNumColors 256
#define kHighPalNumBytes ((kHighPalNumColors) * (kHighPalBytesPerColor))
/** High resolution (24-bit) color format used in Cine's 256-color modes. */
#define kHighPalFormat Graphics::PixelFormat(kHighPalBytesPerColor, 8, 8, 8, 0, 0, 8, 16, 0)
static const byte mouseCursorNormal[] = {
0x00, 0x00, 0x40, 0x00, 0x60, 0x00, 0x70, 0x00,
0x78, 0x00, 0x7C, 0x00, 0x7E, 0x00, 0x7F, 0x00,
0x7F, 0x80, 0x7C, 0x00, 0x6C, 0x00, 0x46, 0x00,
0x06, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00,
0xC0, 0x00, 0xE0, 0x00, 0xF0, 0x00, 0xF8, 0x00,
0xFC, 0x00, 0xFE, 0x00, 0xFF, 0x00, 0xFF, 0x80,
0xFF, 0xC0, 0xFF, 0xC0, 0xFE, 0x00, 0xFF, 0x00,
0xCF, 0x00, 0x07, 0x80, 0x07, 0x80, 0x03, 0x80
};
static const byte mouseCursorDisk[] = {
0x7F, 0xFC, 0x9F, 0x12, 0x9F, 0x12, 0x9F, 0x12,
0x9F, 0x12, 0x9F, 0xE2, 0x80, 0x02, 0x9F, 0xF2,
0xA0, 0x0A, 0xA0, 0x0A, 0xA0, 0x0A, 0xA0, 0x0A,
0xA0, 0x0A, 0xA0, 0x0A, 0x7F, 0xFC, 0x00, 0x00,
0x7F, 0xFC, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE,
0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE,
0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE,
0xFF, 0xFE, 0xFF, 0xFE, 0x7F, 0xFC, 0x00, 0x00
};
static const byte mouseCursorCross[] = {
0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x7C, 0x7C,
0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80,
0x03, 0x80, 0x03, 0x80, 0xFF, 0xFE, 0xFE, 0xFE,
0xFF, 0xFE, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80,
0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00
};
static const struct MouseCursor {
int hotspotX;
int hotspotY;
const byte *bitmap;
} mouseCursors[] = {
{ 1, 1, mouseCursorNormal },
{ 0, 0, mouseCursorDisk },
{ 7, 7, mouseCursorCross }
};
static const byte cursorPalette[] = {
0, 0, 0, 0xff,
0xff, 0xff, 0xff, 0xff
};
/**
* Initialize renderer
*/
FWRenderer::FWRenderer() : _background(NULL), _backupPal(), _cmd(""),
_cmdY(0), _messageBg(0), _backBuffer(new byte[_screenSize]),
_activePal(), _changePal(0), _showCollisionPage(false) {
assert(_backBuffer);
memset(_backBuffer, 0, _screenSize);
memset(_bgName, 0, sizeof (_bgName));
}
/**
* Destroy renderer
*/
FWRenderer::~FWRenderer() {
delete[] _background;
delete[] _backBuffer;
clearMenuStack();
}
bool FWRenderer::initialize() {
_activePal = Palette(kLowPalFormat, kLowPalNumColors);
return true;
}
/**
* Reset renderer state
*/
void FWRenderer::clear() {
delete[] _background;
_background = NULL;
_backupPal.clear();
_activePal.clear();
memset(_backBuffer, 0, _screenSize);
_cmd = "";
_cmdY = 0;
_messageBg = 0;
_changePal = 0;
_showCollisionPage = false;
}
/**
* Draw 1bpp sprite using selected color
* @param obj Object info
* @param fillColor Sprite color
*/
void FWRenderer::fillSprite(const ObjectStruct &obj, uint8 color) {
const byte *data = g_cine->_animDataTable[obj.frame].data();
int x, y, width, height;
x = obj.x;
y = obj.y;
width = g_cine->_animDataTable[obj.frame]._realWidth;
height = g_cine->_animDataTable[obj.frame]._height;
gfxFillSprite(data, width, height, _backBuffer, x, y, color);
}
/**
* Draw 1bpp sprite using selected color on background
* @param obj Object info
* @param fillColor Sprite color
*/
void FWRenderer::incrustMask(const ObjectStruct &obj, uint8 color) {
const byte *data = g_cine->_animDataTable[obj.frame].data();
int x, y, width, height;
x = obj.x;
y = obj.y;
width = g_cine->_animDataTable[obj.frame]._realWidth;
height = g_cine->_animDataTable[obj.frame]._height;
gfxFillSprite(data, width, height, _background, x, y, color);
}
/**
* Draw color sprite using with external mask
* @param obj Object info
* @param mask External mask
*/
void FWRenderer::drawMaskedSprite(const ObjectStruct &obj, const byte *mask) {
const byte *data = g_cine->_animDataTable[obj.frame].data();
int x, y, width, height;
x = obj.x;
y = obj.y;
width = g_cine->_animDataTable[obj.frame]._realWidth;
height = g_cine->_animDataTable[obj.frame]._height;
assert(mask);
drawSpriteRaw(data, mask, width, height, _backBuffer, x, y);
}
/**
* Draw color sprite
* @param obj Object info
*/
void FWRenderer::drawSprite(const ObjectStruct &obj) {
const byte *mask = g_cine->_animDataTable[obj.frame].mask();
drawMaskedSprite(obj, mask);
}
/**
* Draw color sprite on background
* @param obj Object info
*/
void FWRenderer::incrustSprite(const ObjectStruct &obj) {
const byte *data = g_cine->_animDataTable[obj.frame].data();
const byte *mask = g_cine->_animDataTable[obj.frame].mask();
int x, y, width, height;
x = obj.x;
y = obj.y;
width = g_cine->_animDataTable[obj.frame]._realWidth;
height = g_cine->_animDataTable[obj.frame]._height;
// There was an assert(mask) here before but it made savegame loading
// in Future Wars sometimes fail the assertion (e.g. see bug #2055912).
// Not drawing sprites that have no mask seems to work, but not sure
// if this is really a correct way to fix this.
if (mask) {
drawSpriteRaw(data, mask, width, height, _background, x, y);
} else { // mask == NULL
warning("FWRenderer::incrustSprite: Skipping maskless sprite (frame=%d)", obj.frame);
}
}
/**
* Draw command box on screen
*/
void FWRenderer::drawCommand() {
unsigned int i;
int x = 10, y = _cmdY;
drawPlainBox(x, y, 301, 11, 0);
drawBorder(x - 1, y - 1, 302, 12, 2);
x += 2;
y += 2;
for (i = 0; i < _cmd.size(); i++) {
x = drawChar(_cmd[i], x, y);
}
}
void FWRenderer::drawString(const char *string, byte param) {
int width;
width = getStringWidth(string) + 10;
width = width > 300 ? 300 : width;
drawMessage(string, (320 - width) / 2, 80, width, 4);
blit();
}
/**
* Draw message in a box
* @param str Message to draw
* @param x Top left message box corner coordinate
* @param y Top left message box corner coordinate
* @param width Message box width
* @param color Message box background color (Or if negative draws only the text)
* @note Negative colors are used in Operation Stealth's timed cutscenes
* (e.g. when first meeting The Movement for the Liberation of Santa Paragua).
*/
void FWRenderer::drawMessage(const char *str, int x, int y, int width, int color) {
int i, tx, ty, tw;
int line = 0, words = 0, cw = 0;
int space = 0, extraSpace = 0;
const bool isAmiga = (g_cine->getPlatform() == Common::kPlatformAmiga);
if (color >= 0) {
if (isAmiga)
drawTransparentBox(x, y, width, 4);
else
drawPlainBox(x, y, width, 4, color);
}
tx = x + 4;
ty = str[0] ? y - 5 : y + 4;
tw = width - 8;
for (i = 0; str[i]; i++, line--) {
// Fit line of text into textbox
if (!line) {
while (str[i] == ' ') i++;
line = fitLine(str + i, tw, words, cw);
if ( str[i + line] != '\0' && str[i + line] != 0x7C && words) {
space = (tw - cw) / words;
extraSpace = (tw - cw) % words;
} else {
space = 5;
extraSpace = 0;
}
ty += 9;
if (color >= 0) {
if (isAmiga)
drawTransparentBox(x, ty, width, 9);
else
drawPlainBox(x, ty, width, 9, color);
}
tx = x + 4;
}
// draw characters
if (str[i] == ' ') {
tx += space + extraSpace;
if (extraSpace) {
extraSpace = 0;
}
} else {
tx = drawChar(str[i], tx, ty);
}
}
ty += 9;
if (color >= 0) {
if (isAmiga)
drawTransparentBox(x, ty, width, 4);
else
drawPlainBox(x, ty, width, 4, color);
drawDoubleBorder(x, y, width, ty - y + 4, isAmiga ? 18 : 2);
}
}
/**
* Draw rectangle on screen
* @param x Top left corner coordinate
* @param y Top left corner coordinate
* @param width Rectangle width (Negative values draw the box horizontally flipped)
* @param height Rectangle height (Negative values draw the box vertically flipped)
* @param color Fill color
* @note An on-screen rectangle's drawn width is always at least one.
* @note An on-screen rectangle's drawn height is always at least one.
*/
void FWRenderer::drawPlainBox(int x, int y, int width, int height, byte color) {
// Make width's and height's absolute values at least one
// which forces this function to always draw something if the
// drawing position is inside screen bounds. This fixes at least
// the showing of the oxygen gauge meter in Operation Stealth's
// first arcade sequence where this function is called with a
// height of zero.
if (width == 0) {
width = 1;
}
if (height == 0) {
height = 1;
}
// Handle horizontally flipped boxes
if (width < 0) {
width = ABS(width);
x -= width;
}
// Handle vertically flipped boxes
if (height < 0) {
height = ABS(height);
y -= height;
}
// Clip the rectangle to screen dimensions
Common::Rect boxRect(x, y, x + width, y + height);
Common::Rect screenRect(320, 200);
boxRect.clip(screenRect);
byte *dest = _backBuffer + boxRect.top * 320 + boxRect.left;
for (int i = 0; i < boxRect.height(); i++) {
memset(dest + i * 320, color, boxRect.width());
}
}
void FWRenderer::drawTransparentBox(int x, int y, int width, int height) {
// Handle horizontally flipped boxes
if (width < 0) {
width = ABS(width);
x -= width;
}
// Handle vertically flipped boxes
if (height < 0) {
height = ABS(height);
y -= height;
}
// Clip the rectangle to screen dimensions
Common::Rect boxRect(x, y, x + width, y + height);
Common::Rect screenRect(320, 200);
boxRect.clip(screenRect);
byte *dest = _backBuffer + boxRect.top * 320 + boxRect.left;
const int lineAdd = 320 - boxRect.width();
for (int i = 0; i < boxRect.height(); ++i) {
for (int j = 0; j < boxRect.width(); ++j, ++dest) {
if (*dest < 16)
*dest += 16;
}
dest += lineAdd;
}
}
/**
* Draw empty rectangle
* @param x Top left corner coordinate
* @param y Top left corner coordinate
* @param width Rectangle width
* @param height Rectangle height
* @param color Line color
*/
void FWRenderer::drawBorder(int x, int y, int width, int height, byte color) {
drawLine(x, y, width, 1, color);
drawLine(x, y + height, width, 1, color);
drawLine(x, y, 1, height, color);
drawLine(x + width, y, 1, height + 1, color);
}
/**
* Draw empty 2 color rectangle (inner line color is black)
* @param x Top left corner coordinate
* @param y Top left corner coordinate
* @param width Rectangle width
* @param height Rectangle height
* @param color Outter line color
*/
void FWRenderer::drawDoubleBorder(int x, int y, int width, int height, byte color) {
drawBorder(x + 1, y + 1, width - 2, height - 2, 0);
drawBorder(x, y, width, height, color);
}
/**
* Draw text character on screen
* @param character Character to draw
* @param x Character coordinate
* @param y Character coordinate
*/
int FWRenderer::drawChar(char character, int x, int y) {
int width, idx;
if (character == ' ') {
x += 5;
} else if ((width = g_cine->_textHandler.fontParamTable[(unsigned char)character].characterWidth)) {
idx = g_cine->_textHandler.fontParamTable[(unsigned char)character].characterIdx;
drawSpriteRaw(g_cine->_textHandler.textTable[idx][FONT_DATA], g_cine->_textHandler.textTable[idx][FONT_MASK], FONT_WIDTH, FONT_HEIGHT, _backBuffer, x, y);
x += width + 1;
}
return x;
}
int FWRenderer::getStringWidth(const char *str) {
const char *p = str;
int width = 0;
while (*p) {
if (*p == ' ')
width += 5;
else
width += g_cine->_textHandler.fontParamTable[(unsigned char)*p].characterWidth;
p++;
}
return width;
}
/**
* Draw Line
* @param x Line end coordinate
* @param y Line end coordinate
* @param width Horizontal line length
* @param height Vertical line length
* @param color Line color
* @note Either width or height must be equal to 1
*/
void FWRenderer::drawLine(int x, int y, int width, int height, byte color) {
// this line is a special case of rectangle ;-)
drawPlainBox(x, y, width, height, color);
}
/**
* Hide invisible parts of the sprite
* @param[in,out] mask Mask to be updated
* @param it Overlay info from overlayList
*/
void FWRenderer::remaskSprite(byte *mask, Common::List<overlay>::iterator it) {
AnimData &sprite = g_cine->_animDataTable[g_cine->_objectTable[it->objIdx].frame];
int x, y, width, height, idx;
int mx, my, mw, mh;
x = g_cine->_objectTable[it->objIdx].x;
y = g_cine->_objectTable[it->objIdx].y;
width = sprite._realWidth;
height = sprite._height;
for (++it; it != g_cine->_overlayList.end(); ++it) {
if (it->type != 5) {
continue;
}
idx = ABS(g_cine->_objectTable[it->objIdx].frame);
mx = g_cine->_objectTable[it->objIdx].x;
my = g_cine->_objectTable[it->objIdx].y;
mw = g_cine->_animDataTable[idx]._realWidth;
mh = g_cine->_animDataTable[idx]._height;
gfxUpdateSpriteMask(mask, x, y, width, height, g_cine->_animDataTable[idx].data(), mx, my, mw, mh);
}
}
/**
* Draw background to backbuffer
*/
void FWRenderer::drawBackground() {
assert(_background);
memcpy(_backBuffer, _background, _screenSize);
}
/**
* Draw one overlay
* @param it Overlay info
*/
void FWRenderer::renderOverlay(const Common::List<overlay>::iterator &it) {
int idx, len, width;
ObjectStruct *obj;
AnimData *sprite;
byte *mask;
switch (it->type) {
// color sprite
case 0:
if (g_cine->_objectTable[it->objIdx].frame < 0) {
return;
}
sprite = &g_cine->_animDataTable[g_cine->_objectTable[it->objIdx].frame];
len = sprite->_realWidth * sprite->_height;
mask = new byte[len];
memcpy(mask, sprite->mask(), len);
remaskSprite(mask, it);
drawMaskedSprite(g_cine->_objectTable[it->objIdx], mask);
delete[] mask;
break;
// game message
case 2:
if (it->objIdx >= g_cine->_messageTable.size()) {
return;
}
_messageLen += g_cine->_messageTable[it->objIdx].size();
drawMessage(g_cine->_messageTable[it->objIdx].c_str(), it->x, it->y, it->width, it->color);
waitForPlayerClick = 1;
break;
// action failure message
case 3:
idx = it->objIdx * 4 + g_cine->_rnd.getRandomNumber(3);
len = strlen(failureMessages[idx]);
_messageLen += len;
width = 6 * len + 20;
width = width > 300 ? 300 : width;
drawMessage(failureMessages[idx], (320 - width) / 2, 80, width, 4);
waitForPlayerClick = 1;
break;
// bitmap
case 4:
assert(it->objIdx < NUM_MAX_OBJECT);
obj = &g_cine->_objectTable[it->objIdx];
if (obj->frame < 0) {
return;
}
if (!g_cine->_animDataTable[obj->frame].data()) {
return;
}
fillSprite(*obj);
break;
}
}
/**
* Draw overlays
*/
void FWRenderer::drawOverlays() {
Common::List<overlay>::iterator it;
for (it = g_cine->_overlayList.begin(); it != g_cine->_overlayList.end(); ++it) {
renderOverlay(it);
}
}
/**
* Draw another frame
*/
void FWRenderer::drawFrame() {
drawBackground();
drawOverlays();
if (!_cmd.empty()) {
drawCommand();
}
if (_changePal) {
refreshPalette();
}
const int menus = _menuStack.size();
for (int i = 0; i < menus; ++i)
_menuStack[i]->drawMenu(*this, (i == menus - 1));
blit();
}
/**
* Turn on or off the showing of the collision page.
* If turned on the blitting routine shows the collision page instead of the back buffer.
* @note Useful for debugging collision page related problems.
*/
void FWRenderer::showCollisionPage(bool state) {
_showCollisionPage = state;
}
/**
* Update screen
*/
void FWRenderer::blit() {
// Show the back buffer or the collision page. Normally the back
// buffer but showing the collision page is useful for debugging.
byte *source = (_showCollisionPage ? collisionPage : _backBuffer);
g_system->copyRectToScreen(source, 320, 0, 0, 320, 200);
}
/**
* Set player command string
* @param cmd New command string
*/
void FWRenderer::setCommand(Common::String cmd) {
_cmd = cmd;
}
/**
* Refresh current palette
*/
void FWRenderer::refreshPalette() {
assert(_activePal.isValid() && !_activePal.empty());
_activePal.setGlobalOSystemPalette();
_changePal = 0;
}
/**
* Load palette of current background
*/
void FWRenderer::reloadPalette() {
assert(_backupPal.isValid() && !_backupPal.empty());
_activePal = _backupPal;
_changePal = 1;
}
/**
* Load background into renderer
* @param bg Raw background data
* @todo Combine with OSRenderer's version of loadBg16
*/
void FWRenderer::loadBg16(const byte *bg, const char *name, unsigned int idx) {
assert(idx == 0);
if (!_background) {
_background = new byte[_screenSize];
}
assert(_background);
strcpy(_bgName, name);
// Load the 16 color palette
_backupPal.load(bg, kLowPalNumBytes, kLowPalFormat, kLowPalNumColors, CINE_BIG_ENDIAN);
// Jump over the palette data to the background data
bg += kLowPalNumBytes;
gfxConvertSpriteToRaw(_background, bg, 160, 200);
}
/**
* Placeholder for Operation Stealth implementation
*/
void FWRenderer::loadCt16(const byte *ct, const char *name) {
error("Future Wars renderer doesn't support multiple backgrounds");
}
/**
* Placeholder for Operation Stealth implementation
*/
void FWRenderer::loadBg256(const byte *bg, const char *name, unsigned int idx) {
error("Future Wars renderer doesn't support multiple backgrounds");
}
/**
* Placeholder for Operation Stealth implementation
*/
void FWRenderer::loadCt256(const byte *ct, const char *name) {
error("Future Wars renderer doesn't support multiple backgrounds");
}
/**
* Placeholder for Operation Stealth implementation
*/
void FWRenderer::selectBg(unsigned int idx) {
error("Future Wars renderer doesn't support multiple backgrounds");
}
/**
* Placeholder for Operation Stealth implementation
*/
void FWRenderer::selectScrollBg(unsigned int idx) {
error("Future Wars renderer doesn't support multiple backgrounds");
}
/**
* Placeholder for Operation Stealth implementation
*/
void FWRenderer::setScroll(unsigned int shift) {
error("Future Wars renderer doesn't support multiple backgrounds");
}
/**
* Future Wars has no scrolling backgrounds so scroll value is always zero.
*/
uint FWRenderer::getScroll() const {
return 0;
}
/**
* Placeholder for Operation Stealth implementation
*/
void FWRenderer::removeBg(unsigned int idx) {
error("Future Wars renderer doesn't support multiple backgrounds");
}
void FWRenderer::saveBgNames(Common::OutSaveFile &fHandle) {
fHandle.write(_bgName, 13);
}
const char *FWRenderer::getBgName(uint idx) const {
assert(idx == 0);
return _bgName;
}
/**
* Restore active and backup palette from save
* @param fHandle Savefile open for reading
*/
void FWRenderer::restorePalette(Common::SeekableReadStream &fHandle, int version) {
byte buf[kLowPalNumBytes];
// Load the active 16 color palette from file
fHandle.read(buf, kLowPalNumBytes);
_activePal.load(buf, sizeof(buf), kLowPalFormat, kLowPalNumColors, CINE_BIG_ENDIAN);
// Load the backup 16 color palette from file
fHandle.read(buf, kLowPalNumBytes);
_backupPal.load(buf, sizeof(buf), kLowPalFormat, kLowPalNumColors, CINE_BIG_ENDIAN);
_changePal = 1;
}
/**
* Write active and backup palette to save
* @param fHandle Savefile open for writing
*/
void FWRenderer::savePalette(Common::OutSaveFile &fHandle) {
byte buf[kLowPalNumBytes];
// Make sure the active palette has the correct format and color count
assert(_activePal.colorFormat() == kLowPalFormat);
assert(_activePal.colorCount() == kLowPalNumColors);
// Make sure the backup palette has the correct format and color count
assert(_backupPal.colorFormat() == kLowPalFormat);
assert(_backupPal.colorCount() == kLowPalNumColors);
// Write the active palette to the file
_activePal.save(buf, sizeof(buf), CINE_BIG_ENDIAN);
fHandle.write(buf, kLowPalNumBytes);
// Write the backup palette to the file
_backupPal.save(buf, sizeof(buf), CINE_BIG_ENDIAN);
fHandle.write(buf, kLowPalNumBytes);
}
/**
* Write active and backup palette to save
* @param fHandle Savefile open for writing
* @todo Add support for saving the palette in the 16 color version of Operation Stealth.
* Possibly combine with FWRenderer's savePalette-method?
*/
void OSRenderer::savePalette(Common::OutSaveFile &fHandle) {
byte buf[kHighPalNumBytes];
// We can have 16 color palette in many cases
fHandle.writeUint16LE(_activePal.colorCount());
// Write the active 256 color palette.
_activePal.save(buf, sizeof(buf), CINE_LITTLE_ENDIAN);
fHandle.write(buf, kHighPalNumBytes);
// Write the active 256 color palette a second time.
// FIXME: The backup 256 color palette should be saved here instead of the active one.
fHandle.write(buf, kHighPalNumBytes);
}
/**
* Restore active and backup palette from save
* @param fHandle Savefile open for reading
*/
void OSRenderer::restorePalette(Common::SeekableReadStream &fHandle, int version) {
byte buf[kHighPalNumBytes];
uint colorCount = (version > 0) ? fHandle.readUint16LE() : kHighPalNumBytes;
fHandle.read(buf, kHighPalNumBytes);
if (colorCount == kHighPalNumBytes) {
// Load the active 256 color palette from file
_activePal.load(buf, sizeof(buf), kHighPalFormat, kHighPalNumColors, CINE_LITTLE_ENDIAN);
} else {
_activePal.load(buf, sizeof(buf), kLowPalFormat, kLowPalNumColors, CINE_LITTLE_ENDIAN);
}
// Jump over the backup 256 color palette.
// FIXME: Load the backup 256 color palette and use it properly.
fHandle.seek(kHighPalNumBytes, SEEK_CUR);
_changePal = 1;
}
/**
* Rotate active palette
* @param a First color to rotate
* @param b Last color to rotate
* @param c Possibly rotation step, must be 0 or 1 at the moment
*/
void FWRenderer::rotatePalette(int a, int b, int c) {
_activePal.rotateRight(a, b, c);
refreshPalette();
}
/**
* Copy part of backup palette to active palette and transform
* @param first First color to transform
* @param last Last color to transform
* @param r Red channel transformation
* @param g Green channel transformation
* @param b Blue channel transformation
*/
void FWRenderer::transformPalette(int first, int last, int r, int g, int b) {
if (!_activePal.isValid() || _activePal.empty()) {
_activePal = Cine::Palette(kLowPalFormat, kLowPalNumColors);
}
_backupPal.saturatedAddColor(_activePal, first, last, r, g, b);
refreshPalette();
}
/**
* Fade to black
* \bug Operation Stealth sometimes seems to fade to black using
* transformPalette resulting in double fadeout
*/
void FWRenderer::fadeToBlack() {
assert(_activePal.isValid() && !_activePal.empty());
for (int i = 0; i < 8; i++) {
// Fade out the whole palette by 1/7th
// (Operation Stealth used 36 / 252, which is 1 / 7. Future Wars used 1 / 7 directly).
_activePal.saturatedAddNormalizedGray(_activePal, 0, _activePal.colorCount() - 1, -1, 7);
refreshPalette();
g_system->updateScreen();
g_system->delayMillis(50);
}
}
// Menu implementation
void FWRenderer::pushMenu(Menu *menu) {
_menuStack.push(menu);
}
Menu *FWRenderer::popMenu() {
if (_menuStack.empty())
return 0;
Menu *menu = _menuStack.top();
_menuStack.pop();
return menu;
}
void FWRenderer::clearMenuStack() {
Menu *menu = 0;
while ((menu = popMenu()) != 0)
delete menu;
}
SelectionMenu::SelectionMenu(Common::Point p, int width, Common::StringArray elements)
: Menu(kSelectionMenu), _pos(p), _width(width), _elements(elements), _selection(-1) {
}
void SelectionMenu::setSelection(int selection) {
if (selection >= getElementCount() || selection < -1) {
warning("Invalid selection %d", selection);
selection = -1;
}
_selection = selection;
}
void SelectionMenu::drawMenu(FWRenderer &r, bool top) {
const int height = getElementCount() * 9 + 10;
int x = _pos.x;
int y = _pos.y;
if (x + _width > 319)
x = 319 - _width;
if (y + height > 199)
y = 199 - height;
const bool isAmiga = (g_cine->getPlatform() == Common::kPlatformAmiga);
if (isAmiga) {
r.drawTransparentBox(x, y, _width, height);
r.drawDoubleBorder(x, y, _width, height, 18);
} else {
r.drawPlainBox(x, y, _width, height, r._messageBg);
r.drawDoubleBorder(x, y, _width, height, 2);
}
int lineY = y + 4;
int charX;
const int elemCount = getElementCount();
for (int i = 0; i < elemCount; ++i, lineY += 9) {
charX = x + 4;
if (i == _selection) {
if (isAmiga) {
// The original Amiga version is using a different highlight color here,
// but with our current code it is not possible to change the text color,
// thus we can not use the Amiga's color, since otherwise the text
// wouldn't be visible anymore.
r.drawPlainBox(charX, lineY, _width - 8, FONT_HEIGHT, top ? r._messageBg/*2*/ : 18);
} else {
r.drawPlainBox(charX, lineY, _width - 8, 9, 0);
}
}
const int size = _elements[i].size();
for (int j = 0; j < size; ++j)
charX = r.drawChar(_elements[i][j], charX, lineY);
}
}
TextInputMenu::TextInputMenu(Common::Point p, int width, const char *info)
: Menu(kTextInputMenu), _pos(p), _width(width), _info(info), _input(), _cursor(0) {
}
void TextInputMenu::setInput(const char *input, int cursor) {
_input = input;
_cursor = cursor;
}
void TextInputMenu::drawMenu(FWRenderer &r, bool top) {
const int x = _pos.x;
const int y = _pos.y;
int i, tx, ty, tw;
int line = 0, words = 0, cw = 0;
int space = 0, extraSpace = 0;
const bool isAmiga = (g_cine->getPlatform() == Common::kPlatformAmiga);
if (isAmiga)
r.drawTransparentBox(x, y, _width, 4);
else
r.drawPlainBox(x, y, _width, 4, r._messageBg);
tx = x + 4;
ty = _info[0] ? y - 5 : y + 4;
tw = _width - 8;
const int infoSize = _info.size();
// input box info message
for (i = 0; i < infoSize; i++, line--) {
// fit line of text
if (!line) {
line = fitLine(_info.c_str() + i, tw, words, cw);
if (i + line < infoSize && words) {
space = (tw - cw) / words;
extraSpace = (tw - cw) % words;
} else {
space = 5;
extraSpace = 0;
}
ty += 9;
if (isAmiga)
r.drawTransparentBox(x, ty, _width, 9);
else
r.drawPlainBox(x, ty, _width, 9, r._messageBg);
tx = x + 4;
}
// draw characters
if (_info[i] == ' ') {
tx += space + extraSpace;
if (extraSpace) {
extraSpace = 0;
}
} else {
tx = r.drawChar(_info[i], tx, ty);
}
}
// input area background
ty += 9;
if (isAmiga)
r.drawTransparentBox(x, ty, _width, 9);
else
r.drawPlainBox(x, ty, _width, 9, r._messageBg);
r.drawPlainBox(x + 16, ty - 1, _width - 32, 9, 0);
tx = x + 20;
// text in input area
const int inputSize = _input.size();
for (i = 0; i < inputSize; i++) {
tx = r.drawChar(_input[i], tx, ty);
if (_cursor == i + 2) {
r.drawLine(tx, ty - 1, 1, 9, 2);
}
}
if (_input.empty() || _cursor == 1) {
r.drawLine(x + 20, ty - 1, 1, 9, 2);
}
ty += 9;
if (isAmiga)
r.drawTransparentBox(x, ty, _width, 4);
else
r.drawPlainBox(x, ty, _width, 4, r._messageBg);
r.drawDoubleBorder(x, y, _width, ty - y + 4, isAmiga ? 18 : 2);
}
// -------------------
/**
* Initialize Operation Stealth renderer
*/
OSRenderer::OSRenderer() : FWRenderer(), _bgTable(), _currentBg(0), _scrollBg(0),
_bgShift(0) {
_bgTable.resize(9); // Resize the background table to its required size
}
/**
* Destroy Operation Stealth renderer
*/
OSRenderer::~OSRenderer() {
for (uint i = 0; i < _bgTable.size(); i++) {
_bgTable[i].clear();
}
}
bool OSRenderer::initialize() {
_activePal = Palette(kHighPalFormat, kHighPalNumColors);
return true;
}
/**
* Reset Operation Stealth renderer state
*/
void OSRenderer::clear() {
for (uint i = 0; i < _bgTable.size(); i++) {
_bgTable[i].clear();
}
_currentBg = 0;
_scrollBg = 0;
_bgShift = 0;
FWRenderer::clear();
}
/**
* Draw 1bpp sprite using selected color on backgrounds
* @param obj Object info
* @param fillColor Sprite color
*/
void OSRenderer::incrustMask(const ObjectStruct &obj, uint8 color) {
const byte *data = g_cine->_animDataTable[obj.frame].data();
int x, y, width, height;
x = obj.x;
y = obj.y;
width = g_cine->_animDataTable[obj.frame]._realWidth;
height = g_cine->_animDataTable[obj.frame]._height;
if (_bgTable[_currentBg].bg) {
gfxFillSprite(data, width, height, _bgTable[_currentBg].bg, x, y, color);
}
}
/**
* Draw color sprite
* @param obj Object info
*/
void OSRenderer::drawSprite(const ObjectStruct &obj) {
const byte *data = g_cine->_animDataTable[obj.frame].data();
int x, y, width, height, transColor;
x = obj.x;
y = obj.y;
transColor = obj.part;
width = g_cine->_animDataTable[obj.frame]._realWidth;
height = g_cine->_animDataTable[obj.frame]._height;
drawSpriteRaw2(data, transColor, width, height, _backBuffer, x, y);
}
/**
* Draw color sprite
* @param obj Object info
*/
void OSRenderer::incrustSprite(const ObjectStruct &obj) {
const byte *data = g_cine->_animDataTable[obj.frame].data();
int x, y, width, height, transColor;
x = obj.x;
y = obj.y;
transColor = obj.part;
width = g_cine->_animDataTable[obj.frame]._realWidth;
height = g_cine->_animDataTable[obj.frame]._height;
if (_bgTable[_currentBg].bg) {
drawSpriteRaw2(data, transColor, width, height, _bgTable[_currentBg].bg, x, y);
}
}
/**
* Draw text character on screen
* @param character Character to draw
* @param x Character coordinate
* @param y Character coordinate
*/
int OSRenderer::drawChar(char character, int x, int y) {
int width, idx;
if (character == ' ') {
x += 5;
} else if ((width = g_cine->_textHandler.fontParamTable[(unsigned char)character].characterWidth)) {
idx = g_cine->_textHandler.fontParamTable[(unsigned char)character].characterIdx;
drawSpriteRaw2(g_cine->_textHandler.textTable[idx][FONT_DATA], 0, FONT_WIDTH, FONT_HEIGHT, _backBuffer, x, y);
x += width + 1;
}
return x;
}
/**
* Draw background to backbuffer
*/
void OSRenderer::drawBackground() {
byte *main;
main = _bgTable[_currentBg].bg;
assert(main);
if (!_bgShift) {
memcpy(_backBuffer, main, _screenSize);
} else {
byte *scroll = _bgTable[_scrollBg].bg;
int mainShift = _bgShift * _screenWidth;
int mainSize = _screenSize - mainShift;
assert(scroll);
if (mainSize > 0) { // Just a precaution
memcpy(_backBuffer, main + mainShift, mainSize);
}
if (mainShift > 0) { // Just a precaution
memcpy(_backBuffer + mainSize, scroll, mainShift);
}
}
}
/**
* Draw one overlay
* @param it Overlay info
* @todo Add handling of type 22 overlays
*/
void OSRenderer::renderOverlay(const Common::List<overlay>::iterator &it) {
int len, idx, width, height;
ObjectStruct *obj;
AnimData *sprite;
byte *mask;
byte color;
switch (it->type) {
// color sprite
case 0:
if (g_cine->_objectTable[it->objIdx].frame < 0) {
break;
}
sprite = &g_cine->_animDataTable[g_cine->_objectTable[it->objIdx].frame];
len = sprite->_realWidth * sprite->_height;
mask = new byte[len];
generateMask(sprite->data(), mask, len, g_cine->_objectTable[it->objIdx].part);
remaskSprite(mask, it);
drawMaskedSprite(g_cine->_objectTable[it->objIdx], mask);
delete[] mask;
break;
// game message
case 2:
if (it->objIdx >= g_cine->_messageTable.size()) {
return;
}
_messageLen += g_cine->_messageTable[it->objIdx].size();
drawMessage(g_cine->_messageTable[it->objIdx].c_str(), it->x, it->y, it->width, it->color);
if (it->color >= 0) { // This test isn't in Future Wars's implementation
waitForPlayerClick = 1;
}
break;
// action failure message
case 3:
idx = it->objIdx * 4 + g_cine->_rnd.getRandomNumber(3);
len = strlen(failureMessages[idx]);
_messageLen += len;
width = 6 * len + 20;
width = width > 300 ? 300 : width;
// The used color here differs from Future Wars
drawMessage(failureMessages[idx], (320 - width) / 2, 80, width, _messageBg);
waitForPlayerClick = 1;
break;
// bitmap
case 4:
if (g_cine->_objectTable[it->objIdx].frame >= 0) {
FWRenderer::renderOverlay(it);
}
break;
// masked background
case 20:
assert(it->objIdx < NUM_MAX_OBJECT);
var5 = it->x; // A global variable updated here!
obj = &g_cine->_objectTable[it->objIdx];
sprite = &g_cine->_animDataTable[obj->frame];
if (obj->frame < 0 || it->x < 0 || it->x > 8 || !_bgTable[it->x].bg || sprite->_bpp != 1) {
break;
}
maskBgOverlay(_bgTable[it->x].bg, sprite->data(), sprite->_realWidth, sprite->_height, _backBuffer, obj->x, obj->y);
break;
// FIXME: Implement correct drawing of type 21 overlays.
// Type 21 overlays aren't just filled rectangles, I found their drawing routine
// from Operation Stealth's drawSprite routine. So they're likely some kind of sprites
// and it's just a coincidence that the oxygen meter during the first arcade sequence
// works even somehow currently. I tried the original under DOSBox and the oxygen gauge
// is a long red bar that gets shorter as the air runs out.
case 21:
// A filled rectangle:
case 22:
// TODO: Check it this implementation really works correctly (Some things might be wrong, needs testing).
assert(it->objIdx < NUM_MAX_OBJECT);
obj = &g_cine->_objectTable[it->objIdx];
color = obj->part & 0x0F;
width = obj->frame;
height = obj->costume;
drawPlainBox(obj->x, obj->y, width, height, color);
debug(5, "renderOverlay: type=%d, x=%d, y=%d, width=%d, height=%d, color=%d",
it->type, obj->x, obj->y, width, height, color);
break;
// something else
default:
FWRenderer::renderOverlay(it);
break;
}
}
/**
* Load palette of current background
*/
void OSRenderer::reloadPalette() {
// selected background in plane takeoff scene has swapped colors 12
// and 14, shift background has it right
palBg *bg = _bgShift ? &_bgTable[_scrollBg] : &_bgTable[_currentBg];
assert(bg->pal.isValid() && !(bg->pal.empty()));
_activePal = bg->pal;
_changePal = 1;
}
/**
* Copy part of backup palette to active palette and transform
* @param first First color to transform
* @param last Last color to transform
* @param r Red channel transformation
* @param g Green channel transformation
* @param b Blue channel transformation
*/
void OSRenderer::transformPalette(int first, int last, int r, int g, int b) {
palBg *bg = _bgShift ? &_bgTable[_scrollBg] : &_bgTable[_currentBg];
// Initialize active palette to current background's palette format and size if they differ
if (_activePal.colorFormat() != bg->pal.colorFormat() || _activePal.colorCount() != bg->pal.colorCount()) {
_activePal = Cine::Palette(bg->pal.colorFormat(), bg->pal.colorCount());
}
bg->pal.saturatedAddColor(_activePal, first, last, r, g, b, kLowPalFormat);
refreshPalette();
}
/**
* Load 16 color background into renderer
* @param bg Raw background data
* @param name Background filename
* @param pos Background index
* @todo Combine with FWRenderer's version of loadBg16
*/
void OSRenderer::loadBg16(const byte *bg, const char *name, unsigned int idx) {
assert(idx < 9);
if (!_bgTable[idx].bg) {
_bgTable[idx].bg = new byte[_screenSize];
}
assert(_bgTable[idx].bg);
strcpy(_bgTable[idx].name, name);
// Load the 16 color palette
_bgTable[idx].pal.load(bg, kLowPalNumBytes, kLowPalFormat, kLowPalNumColors, CINE_BIG_ENDIAN);
// Jump over the palette data to the background data
bg += kLowPalNumBytes;
gfxConvertSpriteToRaw(_bgTable[idx].bg, bg, 160, 200);
}
/**
* Load 16 color CT data as background into renderer
* @param ct Raw CT data
* @param name Background filename
*/
void OSRenderer::loadCt16(const byte *ct, const char *name) {
// Make the 9th background point directly to the collision page
// and load the picture into it.
_bgTable[kCollisionPageBgIdxAlias].bg = collisionPage;
loadBg16(ct, name, kCollisionPageBgIdxAlias);
}
/**
* Load 256 color background into renderer
* @param bg Raw background data
* @param name Background filename
* @param pos Background index
*/
void OSRenderer::loadBg256(const byte *bg, const char *name, unsigned int idx) {
assert(idx < 9);
if (!_bgTable[idx].bg) {
_bgTable[idx].bg = new byte[_screenSize];
}
assert(_bgTable[idx].bg);
strcpy(_bgTable[idx].name, name);
_bgTable[idx].pal.load(bg, kHighPalNumBytes, kHighPalFormat, kHighPalNumColors, CINE_LITTLE_ENDIAN);
memcpy(_bgTable[idx].bg, bg + kHighPalNumBytes, _screenSize);
}
/**
* Load 256 color CT data as background into renderer
* @param ct Raw CT data
* @param name Background filename
*/
void OSRenderer::loadCt256(const byte *ct, const char *name) {
// Make the 9th background point directly to the collision page
// and load the picture into it.
_bgTable[kCollisionPageBgIdxAlias].bg = collisionPage;
loadBg256(ct, name, kCollisionPageBgIdxAlias);
}
/**
* Select active background and load its palette
* @param idx Background index
*/
void OSRenderer::selectBg(unsigned int idx) {
assert(idx < 9 && _bgTable[idx].bg);
assert(_bgTable[idx].pal.isValid() && !(_bgTable[idx].pal.empty()));
_currentBg = idx;
reloadPalette();
}
/**
* Select scroll background
* @param idx Scroll background index
*/
void OSRenderer::selectScrollBg(unsigned int idx) {
assert(idx < 9);
if (_bgTable[idx].bg) {
_scrollBg = idx;
}
reloadPalette();
}
/**
* Set background scroll
* @param shift Background scroll in pixels
*/
void OSRenderer::setScroll(unsigned int shift) {
assert(shift <= 200);
_bgShift = shift;
}
/**
* Get background scroll
* @return Background scroll in pixels
*/
uint OSRenderer::getScroll() const {
return _bgShift;
}
/**
* Unload background from renderer
* @param idx Background to unload
*/
void OSRenderer::removeBg(unsigned int idx) {
assert(idx > 0 && idx < 9);
if (_currentBg == idx) {
_currentBg = 0;
}
if (_scrollBg == idx) {
_scrollBg = 0;
}
_bgTable[idx].clear();
}
void OSRenderer::saveBgNames(Common::OutSaveFile &fHandle) {
for (int i = 0; i < 8; i++) {
fHandle.write(_bgTable[i].name, 13);
}
}
const char *OSRenderer::getBgName(uint idx) const {
assert(idx < 9);
return _bgTable[idx].name;
}
void setMouseCursor(int cursor) {
static int currentMouseCursor = -1;
assert(cursor >= 0 && cursor < 3);
if (currentMouseCursor != cursor) {
byte mouseCursor[16 * 16];
const MouseCursor *mc = &mouseCursors[cursor];
const byte *src = mc->bitmap;
for (int i = 0; i < 32; ++i) {
int offs = i * 8;
for (byte mask = 0x80; mask != 0; mask >>= 1) {
if (src[0] & mask) {
mouseCursor[offs] = 1;
} else if (src[32] & mask) {
mouseCursor[offs] = 0;
} else {
mouseCursor[offs] = 0xFF;
}
++offs;
}
++src;
}
CursorMan.replaceCursor(mouseCursor, 16, 16, mc->hotspotX, mc->hotspotY, 0xFF);
CursorMan.replaceCursorPalette(cursorPalette, 0, 2);
currentMouseCursor = cursor;
}
}
void gfxFillSprite(const byte *spritePtr, uint16 width, uint16 height, byte *page, int16 x, int16 y, uint8 fillColor) {
int16 i, j;
for (i = 0; i < height; i++) {
byte *destPtr = page + x + y * 320;
destPtr += i * 320;
for (j = 0; j < width; j++) {
if (x + j >= 0 && x + j < 320 && i + y >= 0 && i + y < 200 && !*spritePtr) {
*destPtr = fillColor;
}
destPtr++;
spritePtr++;
}
}
}
void gfxDrawMaskedSprite(const byte *spritePtr, const byte *maskPtr, uint16 width, uint16 height, byte *page, int16 x, int16 y) {
int16 i, j;
for (i = 0; i < height; i++) {
byte *destPtr = page + x + y * 320;
destPtr += i * 320;
for (j = 0; j < width; j++) {
if (x + j >= 0 && x + j < 320 && i + y >= 0 && i + y < 200 && *maskPtr == 0) {
*destPtr = *spritePtr;
}
++destPtr;
++spritePtr;
++maskPtr;
}
}
}
void gfxUpdateSpriteMask(byte *destMask, int16 x, int16 y, int16 width, int16 height, const byte *srcMask, int16 xm, int16 ym, int16 maskWidth, int16 maskHeight) {
int16 i, j, d, spritePitch, maskPitch;
spritePitch = width;
maskPitch = maskWidth;
// crop update area to overlapping parts of masks
if (y > ym) {
d = y - ym;
srcMask += d * maskPitch;
maskHeight -= d;
} else if (y < ym) {
d = ym - y;
destMask += d * spritePitch;
height -= d;
}
if (x > xm) {
d = x - xm;
srcMask += d;
maskWidth -= d;
} else if (x < xm) {
d = xm - x;
destMask += d;
width -= d;
}
// update mask
for (j = 0; j < MIN(maskHeight, height); ++j) {
for (i = 0; i < MIN(maskWidth, width); ++i) {
destMask[i] |= srcMask[i] ^ 1;
}
destMask += spritePitch;
srcMask += maskPitch;
}
}
void gfxUpdateIncrustMask(byte *destMask, int16 x, int16 y, int16 width, int16 height, const byte *srcMask, int16 xm, int16 ym, int16 maskWidth, int16 maskHeight) {
int16 i, j, d, spritePitch, maskPitch;
spritePitch = width;
maskPitch = maskWidth;
// crop update area to overlapping parts of masks
if (y > ym) {
d = y - ym;
srcMask += d * maskPitch;
maskHeight -= d;
} else if (y < ym) {
d = ym - y > height ? height : ym - y;
memset(destMask, 1, d * spritePitch);
destMask += d * spritePitch;
height -= d;
}
if (x > xm) {
d = x - xm;
xm = x;
srcMask += d;
maskWidth -= d;
}
d = xm - x;
maskWidth += d;
// update mask
for (j = 0; j < MIN(maskHeight, height); ++j) {
for (i = 0; i < width; ++i) {
destMask[i] |= i < d || i >= maskWidth ? 1 : srcMask[i - d];
}
destMask += spritePitch;
srcMask += maskPitch;
}
if (j < height) {
memset(destMask, 1, (height - j) * spritePitch);
}
}
void gfxDrawLine(int16 x1, int16 y1, int16 x2, int16 y2, byte color, byte *page) {
if (x1 == x2) {
if (y1 > y2) {
SWAP(y1, y2);
}
while (y1 <= y2) {
*(page + (y1 * 320 + x1)) = color;
y1++;
}
} else {
if (x1 > x2) {
SWAP(x1, x2);
}
while (x1 <= x2) {
*(page + (y1 * 320 + x1)) = color;
x1++;
}
}
}
void gfxDrawPlainBoxRaw(int16 x1, int16 y1, int16 x2, int16 y2, byte color, byte *page) {
int16 t;
if (x1 > x2) {
SWAP(x1, x2);
}
if (y1 > y2) {
SWAP(y1, y2);
}
t = x1;
while (y1 <= y2) {
x1 = t;
while (x1 <= x2) {
*(page + y1 * 320 + x1) = color;
x1++;
}
y1++;
}
}
int16 gfxGetBit(int16 x, int16 y, const byte *ptr, int16 width) {
const byte *ptrToData = (ptr) + y * width + x;
if (x > width) {
return 0;
}
if (*ptrToData) {
return 0;
}
return 1;
}
void gfxResetRawPage(byte *pageRaw) {
memset(pageRaw, 0, 320 * 200);
}
void gfxConvertSpriteToRaw(byte *dst, const byte *src, uint16 w, uint16 h) {
// Output is 4 bits per pixel.
// Pixels are in 16 pixel chunks (8 bytes of source per 16 pixels of output).
// The source data is interleaved so that
// 1st big-endian 16-bit value contains all bit position 0 values for 16 pixels,
// 2nd big-endian 16-bit value contains all bit position 1 values for 16 pixels,
// 3rd big-endian 16-bit value contains all bit position 2 values for 16 pixels,
// 4th big-endian 16-bit value contains all bit position 3 values for 16 pixels.
// 1st pixel's bits are in the 16th bits,
// 2nd pixel's bits are in the 15th bits,
// 3rd pixel's bits are in the 14th bits etc.
for (int y = 0; y < h; ++y) {
for (int x = 0; x < w / 8; ++x) {
for (int bit = 0; bit < 16; ++bit) {
uint8 color = 0;
for (int p = 0; p < 4; ++p) {
if (READ_BE_UINT16(src + p * 2) & (1 << (15 - bit))) {
color |= 1 << p;
}
}
*dst++ = color;
}
src += 8;
}
}
}
void drawSpriteRaw(const byte *spritePtr, const byte *maskPtr, int16 width, int16 height, byte *page, int16 x, int16 y) {
int16 i, j;
// FIXME: Is it a bug if maskPtr == NULL?
if (!maskPtr)
warning("drawSpriteRaw: maskPtr == NULL");
for (i = 0; i < height; i++) {
byte *destPtr = page + x + y * 320;
destPtr += i * 320;
for (j = 0; j < width; j++) {
if ((!maskPtr || !(*maskPtr)) && x + j >= 0 && x + j < 320 && i + y >= 0 && i + y < 200) {
*(destPtr++) = *(spritePtr++);
} else {
destPtr++;
spritePtr++;
}
if (maskPtr)
maskPtr++;
}
}
}
void drawSpriteRaw2(const byte *spritePtr, byte transColor, int16 width, int16 height, byte *page, int16 x, int16 y) {
int16 i, j;
for (i = 0; i < height; i++) {
byte *destPtr = page + x + y * 320;
destPtr += i * 320;
for (j = 0; j < width; j++) {
if ((*spritePtr != transColor) && (x + j >= 0 && x + j < 320 && i + y >= 0 && i + y < 200)) {
*destPtr = *spritePtr;
}
destPtr++;
spritePtr++;
}
}
}
void maskBgOverlay(const byte *bgPtr, const byte *maskPtr, int16 width, int16 height,
byte *page, int16 x, int16 y) {
int16 i, j, tmpWidth, tmpHeight;
Common::List<BGIncrust>::iterator it;
byte *mask;
const byte *backup = maskPtr;
// background pass
for (i = 0; i < height; i++) {
byte *destPtr = page + x + y * 320;
const byte *srcPtr = bgPtr + x + y * 320;
destPtr += i * 320;
srcPtr += i * 320;
for (j = 0; j < width; j++) {
if ((!maskPtr || !(*maskPtr)) && (x + j >= 0
&& x + j < 320 && i + y >= 0 && i + y < 200)) {
*destPtr = *srcPtr;
}
destPtr++;
srcPtr++;
maskPtr++;
}
}
maskPtr = backup;
// incrust pass
for (it = g_cine->_bgIncrustList.begin(); it != g_cine->_bgIncrustList.end(); ++it) {
tmpWidth = g_cine->_animDataTable[it->frame]._realWidth;
tmpHeight = g_cine->_animDataTable[it->frame]._height;
mask = (byte*)malloc(tmpWidth * tmpHeight);
if (it->param == 0) {
generateMask(g_cine->_animDataTable[it->frame].data(), mask, tmpWidth * tmpHeight, it->part);
gfxUpdateIncrustMask(mask, it->x, it->y, tmpWidth, tmpHeight, maskPtr, x, y, width, height);
gfxDrawMaskedSprite(g_cine->_animDataTable[it->frame].data(), mask, tmpWidth, tmpHeight, page, it->x, it->y);
} else {
memcpy(mask, g_cine->_animDataTable[it->frame].data(), tmpWidth * tmpHeight);
gfxUpdateIncrustMask(mask, it->x, it->y, tmpWidth, tmpHeight, maskPtr, x, y, width, height);
gfxFillSprite(mask, tmpWidth, tmpHeight, page, it->x, it->y);
}
free(mask);
}
}
} // End of namespace Cine