/* 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. * */ /* * This code is based on original Sfinx source code * Copyright (c) 1994-1997 Janus B. Wisniewski and L.K. Avalon */ #include "common/array.h" #include "common/config-manager.h" #include "common/rect.h" #include "graphics/palette.h" #include "cge2/general.h" #include "cge2/vga13h.h" #include "cge2/bitmap.h" #include "cge2/text.h" #include "cge2/cge2_main.h" #include "cge2/cge2.h" #include "cge2/vga13h.h" namespace CGE2 { void V3D::sync(Common::Serializer &s) { _x.sync(s); _y.sync(s); _z.sync(s); } FXP FXP::operator*(const FXP& x) const { FXP y; int32 t1 = (v >> 8) * x.v; int32 t2 = ((v & 0xFF) * x.v) >> 8; y.v = t1 + t2; return y; } FXP FXP::operator/(const FXP& x) const { FXP y; if (x.v != 0) { int32 v1 = this->v; int32 v2 = x.v; bool negFlag = false; if (v1 < 0) { v1 = -v1; negFlag = true; } if (v2 < 0) { v2 = -v2; negFlag ^= true; } int32 v3 = v1 / v2; v1 -= v3 * v2; v3 <<= 8; if (v1 < 0xFFFFFF) v1 <<= 8; else v2 >>= 8; v3 += v1 / v2; if (negFlag) v3 = -v3; y.v = v3; } return y; } void FXP::sync(Common::Serializer &s) { s.syncAsSint32LE(v); } Seq *getConstantSeq(bool seqFlag) { const Seq seq1[] = { { 0, 0, 0, 0, 0, 0 } }; const Seq seq2[] = { { 0, 1, 0, 0, 0, 0 }, { 1, 0, 0, 0, 0, 0 } }; Seq *seq; if (seqFlag) { seq = (Seq *)malloc(1 * sizeof(Seq)); *seq = seq1[0]; } else { seq = (Seq *)malloc(2 * sizeof(Seq)); seq[0] = seq2[0]; seq[1] = seq2[1]; } return seq; } byte Sprite::_constY = 0; byte Sprite::_follow = 0; Seq Sprite::_stdSeq8[] = { { 0, 0, 0, 0, 0, 0 }, { 1, 1, 0, 0, 0, 0 }, { 2, 2, 0, 0, 0, 0 }, { 3, 3, 0, 0, 0, 0 }, { 4, 4, 0, 0, 0, 0 }, { 5, 5, 0, 0, 0, 0 }, { 6, 6, 0, 0, 0, 0 }, { 7, 7, 0, 0, 0, 0 }, }; SprExt::SprExt(CGE2Engine *vm) : _p0(vm, 0, 0), _p1(vm, 0, 0), _b0(nullptr), _b1(nullptr), _shpList(nullptr), _location(0), _seq(nullptr), _name(nullptr) { for (int i = 0; i < kActions; i++) _actions[i] = nullptr; } Sprite::Sprite(CGE2Engine *vm) : _siz(_vm, 0, 0), _seqPtr(kNoSeq), _seqCnt(0), _shpCnt(0), _next(nullptr), _prev(nullptr), _time(0), _ext(nullptr), _ref(-1), _scene(0), _vm(vm), _pos2D(_vm, kScrWidth >> 1, 0), _pos3D(kScrWidth >> 1, 0, 0) { memset(_actionCtrl, 0, sizeof(_actionCtrl)); memset(_file, 0, sizeof(_file)); memset(&_flags, 0, sizeof(_flags)); _flags._frnt = true; } Sprite::Sprite(CGE2Engine *vm, BitmapPtr shpP, int cnt) : _siz(_vm, 0, 0), _seqPtr(kNoSeq), _seqCnt(0), _shpCnt(0), _next(nullptr), _prev(nullptr), _time(0), _ext(nullptr), _ref(-1), _scene(0), _vm(vm), _pos2D(_vm, kScrWidth >> 1, 0), _pos3D(kScrWidth >> 1, 0, 0) { memset(_actionCtrl, 0, sizeof(_actionCtrl)); memset(_file, 0, sizeof(_file)); memset(&_flags, 0, sizeof(_flags)); _flags._frnt = true; setShapeList(shpP, cnt); } Sprite::~Sprite() { contract(); } BitmapPtr Sprite::getShp() { SprExt *e = _ext; if (!e || !e->_seq) return nullptr; int i = e->_seq[_seqPtr]._now; if (i >= _shpCnt) error("Invalid PHASE in SPRITE::Shp() %s - %d", _file, i); return e->_shpList + i; } void Sprite::setShapeList(BitmapPtr shp, int cnt) { _shpCnt = cnt; _siz.x = 0; _siz.y = 0; if (shp) { for (int i = 0; i < cnt; i++) { BitmapPtr p = shp + i; if (p->_w > _siz.x) _siz.x = p->_w; if (p->_h > _siz.y) _siz.y = p->_h; } expand(); _ext->_shpList = shp; if (!_ext->_seq) { setSeq(_stdSeq8); _seqCnt = (cnt < ARRAYSIZE(_stdSeq8)) ? cnt : ARRAYSIZE(_stdSeq8); } } } Seq *Sprite::setSeq(Seq *seq) { expand(); Seq *s = _ext->_seq; _ext->_seq = seq; if (_seqPtr == kNoSeq) step(0); else if (_time == 0) step(_seqPtr); return s; } bool Sprite::seqTest(int n) { if (n >= 0) return (_seqPtr == n); if (_ext) return (_ext->_seq[_seqPtr]._next == _seqPtr); return true; } void Sprite::setName(char *newName) { if (!_ext) return; if (_ext->_name) { delete[] _ext->_name; _ext->_name = nullptr; } if (newName) { _ext->_name = new char[strlen(newName) + 1]; strcpy(_ext->_name, newName); } } int Sprite::labVal(Action snq, int lab) { int lv = -1; if (active()) { int count = _actionCtrl[snq]._cnt; CommandHandler::Command *com = snList(snq); int i = 0; for (; i < count; i++) { if (com[i]._lab == lab) break; } if (i < count) return i; } else { char tmpStr[kLineMax + 1]; _vm->mergeExt(tmpStr, _file, kSprExt); if (_vm->_resman->exist(tmpStr)) { // sprite description file exist EncryptedStream sprf(_vm, tmpStr); if (sprf.err()) error("Bad SPR [%s]", tmpStr); int cnt = 0; ID section = kIdPhase; ID id; Common::String line; while (lv == -1 && !sprf.eos()) { line = sprf.readLine(); if (line.empty()) continue; Common::strlcpy(tmpStr, line.c_str(), sizeof(tmpStr)); char *p; p = _vm->token(tmpStr); if (*p == '@') { if ((int)section == (int)snq && atoi(p + 1) == lab) lv = cnt; } else { id = _vm->ident(p); switch (id) { case kIdMTake: case kIdFTake: case kIdNear: case kIdPhase: case kIdSeq: section = id; break; default: if (id < 0 && (int)section == (int)snq) ++cnt; break; } } } } } return lv; } CommandHandler::Command *Sprite::snList(Action type) { SprExt *e = _ext; return (e) ? e->_actions[type] : nullptr; } Sprite *Sprite::expand() { if (_ext) return this; if (_vm->_spriteNotify != nullptr) (_vm->*_vm->_spriteNotify)(); char fname[kPathMax]; _vm->mergeExt(fname, _file, kSprExt); if (_ext != nullptr) delete _ext; _ext = new SprExt(_vm); if (!*_file) return this; BitmapPtr shplist = new Bitmap[_shpCnt]; int cnt[kActions], shpcnt = 0, seqcnt = 0, maxnow = 0, maxnxt = 0; for (int i = 0; i < kActions; i++) cnt[i] = 0; for (int i = 0; i < kActions; i++){ byte n = _actionCtrl[i]._cnt; if (n) _ext->_actions[i] = new CommandHandler::Command[n]; else _ext->_actions[i] = nullptr; } Seq *curSeq = nullptr; if (_seqCnt) curSeq = new Seq[_seqCnt]; if (_vm->_resman->exist(fname)) { // sprite description file exist EncryptedStream sprf(_vm, fname); if (sprf.err()) error("Bad SPR [%s]", fname); int label = kNoByte; ID section = kIdPhase; ID id; Common::String line; char tmpStr[kLineMax + 1]; for (line = sprf.readLine(); !sprf.eos(); line = sprf.readLine()) { if (line.empty()) continue; Common::strlcpy(tmpStr, line.c_str(), sizeof(tmpStr)); char *p = _vm->token(tmpStr); if (*p == '@') { label = atoi(p + 1); continue; } id = _vm->ident(p); switch (id) { case kIdType: break; case kIdNear: case kIdMTake: case kIdFTake: case kIdPhase: case kIdSeq: section = id; break; case kIdName: Common::strlcpy(tmpStr, line.c_str(), sizeof(tmpStr)); for (p = tmpStr; *p != '='; p++) // We search for the = ; setName(_vm->tail(p)); break; default: if (id >= kIdNear) break; Seq *s; switch (section) { case kIdNear: case kIdMTake: case kIdFTake: id = (ID)_vm->_commandHandler->getComId(p); if (_actionCtrl[section]._cnt) { CommandHandler::Command *c = &_ext->_actions[section][cnt[section]++]; c->_commandType = CommandType(id); c->_lab = label; c->_ref = _vm->number(nullptr); c->_val = _vm->number(nullptr); c->_spritePtr = nullptr; } break; case kIdSeq: s = &curSeq[seqcnt++]; s->_now = atoi(p); if (s->_now > maxnow) maxnow = s->_now; s->_next = _vm->number(nullptr); switch (s->_next) { case 0xFF: s->_next = seqcnt; break; case 0xFE: s->_next = seqcnt - 1; break; } if (s->_next > maxnxt) maxnxt = s->_next; s->_dx = _vm->number(nullptr); s->_dy = _vm->number(nullptr); s->_dz = _vm->number(nullptr); s->_dly = _vm->number(nullptr); break; case kIdPhase: shplist[shpcnt] = Bitmap(_vm, p); shpcnt++; break; default: break; } break; } label = kNoByte; } if (!shpcnt) error("No shapes - %s", fname); } else // no sprite description: try to read immediately from .BMP shplist[shpcnt++] = Bitmap(_vm, _file); if (curSeq) { if (maxnow >= shpcnt) error("Bad PHASE in SEQ %s", fname); if (maxnxt && (maxnxt >= seqcnt)) error("Bad JUMP in SEQ %s", fname); setSeq(curSeq); } else { setSeq(_stdSeq8); _seqCnt = (shpcnt < ARRAYSIZE(_stdSeq8)) ? shpcnt : ARRAYSIZE(_stdSeq8); } setShapeList(shplist, shpcnt); if (_file[2] == '~') { // FLY-type sprite Seq *nextSeq = _ext->_seq; int x = (nextSeq + 1)->_dx, y = (nextSeq + 1)->_dy, z = (nextSeq + 1)->_dz; // random position nextSeq->_dx = _vm->newRandom(x + x) - x; nextSeq->_dy = _vm->newRandom(y + y) - y; nextSeq->_dz = _vm->newRandom(z + z) - z; gotoxyz(_pos3D + V3D(nextSeq->_dx, nextSeq->_dy, nextSeq->_dz)); } return this; } Sprite *Sprite::contract() { SprExt *e = _ext; if (!e) return this; if (_file[2] == '~') { // FLY-type sprite Seq *curSeq = _ext->_seq; // return to middle gotoxyz(_pos3D - V3D(curSeq->_dx, curSeq->_dy, curSeq->_dz)); curSeq->_dx = curSeq->_dy = curSeq->_dz = 0; } if (_vm->_spriteNotify != nullptr) (_vm->*_vm->_spriteNotify)(); if (e->_name) { delete[] e->_name; e->_name = nullptr; } if (e->_shpList) { for (int i = 0; i < _shpCnt; i++) e->_shpList[i].release(); delete[] e->_shpList; e->_shpList = nullptr; } if (e->_seq) { if (e->_seq == _stdSeq8) _seqCnt = 0; else { delete[] e->_seq; e->_seq = nullptr; } } for (int i = 0; i < kActions; i++) { if (e->_actions[i]) { delete[] e->_actions[i]; e->_actions[i] = nullptr; } } delete _ext; _ext = nullptr; return this; } void Sprite::backShow() { expand(); show(2); show(1); _vm->_spare->dispose(this); } void Sprite::step(int nr) { if (nr >= 0) _seqPtr = nr; if (_ext && _ext->_seq) { V3D p = _pos3D; Seq *seq = nullptr; if (nr < 0) _seqPtr = _ext->_seq[_seqPtr]._next; if (_file[2] == '~') { // FLY-type sprite seq = _ext->_seq; // return to middle p._x -= seq->_dx; p._y -= seq->_dy; p._z -= seq->_dz; // generate motion if (_vm->newRandom(10) < 5) { if ((seq + 1)->_dx) seq->_dx += _vm->newRandom(3) - 1; if ((seq + 1)->_dy) seq->_dy += _vm->newRandom(3) - 1; if ((seq + 1)->_dz) seq->_dz += _vm->newRandom(3) - 1; } if (seq->_dx < -(seq + 1)->_dx) seq->_dx += 2; if (seq->_dx >= (seq + 1)->_dx) seq->_dx -= 2; if (seq->_dy < -(seq + 1)->_dy) seq->_dy += 2; if (seq->_dy >= (seq + 1)->_dy) seq->_dy -= 2; if (seq->_dz < -(seq + 1)->_dz) seq->_dz += 2; if (seq->_dz >= (seq + 1)->_dz) seq->_dz -= 2; p._x += seq->_dx; p._y += seq->_dy; p._z += seq->_dz; gotoxyz(p); } else { seq = _ext->_seq + _seqPtr; if (seq) { if (seq->_dz == 127 && seq->_dx != 0) { _vm->_commandHandlerTurbo->addCommand(kCmdSound, -1, 256 * seq->_dy + seq->_dx, this); } else { p._x += seq->_dx; p._y += seq->_dy; p._z += seq->_dz; gotoxyz(p); } } } if (seq && (seq->_dly >= 0)) _time = seq->_dly; } else if (_vm->_waitRef && _vm->_waitRef == _ref) _vm->_waitRef = 0; } void Sprite::tick() { step(); } void Sprite::setScene(int c) { _scene = c; } void Sprite::gotoxyz(int x, int y, int z) { gotoxyz(V3D(x, y, z)); } void Sprite::gotoxyz() { gotoxyz(_pos3D); } void Sprite::gotoxyz(V2D pos) { V2D o = _pos2D; int ctr = _siz.x >> 1; int rem = _siz.x - ctr; byte trim = 0; if (_ref / 10 == 14) { // HERO int z = _pos3D._z.trunc(); ctr = (ctr * _vm->_eye->_z.trunc()) / (_vm->_eye->_z.trunc() - z); rem = (rem * _vm->_eye->_z.trunc()) / (_vm->_eye->_z.trunc() - z); ctr = (ctr * 3) / 4; rem = (rem * 3) / 4; } if (pos.x - ctr < 0) { pos.x = ctr; ++trim; } if (pos.x + rem > kScrWidth) { pos.x = kScrWidth - rem; ++trim; } _pos2D.x = pos.x; if (pos.y < -kPanHeight) { pos.y = -kPanHeight; ++trim; } if (pos.y + _siz.y > kWorldHeight) { pos.y = kWorldHeight - _siz.y; ++trim; } _pos2D.y = pos.y; _flags._trim = (trim != 0); if (!_follow) { FXP m = _vm->_eye->_z / (_pos3D._z - _vm->_eye->_z); _pos3D._x = (_vm->_eye->_x + (_vm->_eye->_x - _pos2D.x) / m); _pos3D._x = _pos3D._x.round(); if (!_constY) { _pos3D._y = _vm->_eye->_y + (_vm->_eye->_y - _pos2D.y) / m; _pos3D._y = _pos3D._y.round(); } } if (_next && _next->_flags._slav) _next->gotoxyz(_next->_pos2D - o + _pos2D); if (_flags._shad) _prev->gotoxyz(_prev->_pos2D - o + _pos2D); } void Sprite::gotoxyz_(V2D pos) { _constY++; gotoxyz(pos); --_constY; } void Sprite::gotoxyz(V3D pos) { _follow++; if (pos._z != _pos3D._z) _flags._zmov = true; gotoxyz(V2D(_vm, _pos3D = pos)); --_follow; } void Sprite::center() { gotoxyz(kScrWidth >> 1, (kWorldHeight - _siz.y) >> 1, 0); } void Sprite::show() { SprExt *e = _ext; if (e) { e->_p0 = e->_p1; e->_b0 = e->_b1; e->_p1 = _pos2D; e->_b1 = getShp(); if (!_flags._hide) e->_b1->show(e->_p1); } } void Sprite::show(uint16 pg) { assert(pg < 4); Graphics::Surface *a = _vm->_vga->_page[1]; _vm->_vga->_page[1] = _vm->_vga->_page[pg]; getShp()->show(_pos2D); _vm->_vga->_page[1] = a; } void Sprite::hide() { SprExt *e = _ext; if (e->_b0) e->_b0->hide(e->_p0); } BitmapPtr Sprite::ghost() { SprExt *e = _ext; if (!e->_b1) return nullptr; BitmapPtr bmp = new Bitmap(_vm, 0, 0, (uint8 *)nullptr); bmp->_w = e->_b1->_w; bmp->_h = e->_b1->_h; bmp->_b = new HideDesc[bmp->_h]; memcpy(bmp->_b, e->_b1->_b, sizeof(HideDesc)* bmp->_h); uint8 *v = new uint8[1]; *v = (e->_p1.y << 16) + e->_p1.x; bmp->_v = v; bmp->_map = (e->_p1.y << 16) + e->_p1.x; return bmp; } void Sprite::sync(Common::Serializer &s) { s.syncAsUint16LE(_ref); s.syncAsByte(_scene); // bitfield in-memory storage is unpredictable, so to avoid // any issues, pack/unpack everything manually uint16 flags = 0; if (s.isLoading()) { s.syncAsUint16LE(flags); _flags._hide = flags & 0x0001; _flags._drag = flags & 0x0002; _flags._hold = flags & 0x0004; _flags._trim = flags & 0x0008; _flags._slav = flags & 0x0010; _flags._kill = flags & 0x0020; _flags._xlat = flags & 0x0040; _flags._port = flags & 0x0080; _flags._kept = flags & 0x0100; _flags._frnt = flags & 0x0200; _flags._east = flags & 0x0400; _flags._near = flags & 0x0800; _flags._shad = flags & 0x1000; _flags._back = flags & 0x2000; _flags._zmov = flags & 0x4000; _flags._tran = flags & 0x8000; } else { flags = (flags << 1) | (_flags._tran ? 1 : 0); flags = (flags << 1) | (_flags._zmov ? 1 : 0); flags = (flags << 1) | (_flags._back ? 1 : 0); flags = (flags << 1) | (_flags._shad ? 1 : 0); flags = (flags << 1) | (_flags._near ? 1 : 0); flags = (flags << 1) | (_flags._east ? 1 : 0); flags = (flags << 1) | (_flags._frnt ? 1 : 0); flags = (flags << 1) | (_flags._kept ? 1 : 0); flags = (flags << 1) | (_flags._port ? 1 : 0); flags = (flags << 1) | (_flags._xlat ? 1 : 0); flags = (flags << 1) | (_flags._kill ? 1 : 0); flags = (flags << 1) | (_flags._slav ? 1 : 0); flags = (flags << 1) | (_flags._trim ? 1 : 0); flags = (flags << 1) | (_flags._hold ? 1 : 0); flags = (flags << 1) | (_flags._drag ? 1 : 0); flags = (flags << 1) | (_flags._hide ? 1 : 0); s.syncAsUint16LE(flags); } s.syncAsSint16LE(_pos2D.x); s.syncAsSint16LE(_pos2D.y); _pos3D.sync(s); s.syncAsSint16LE(_siz.x); s.syncAsSint16LE(_siz.y); s.syncAsUint16LE(_time); for (int i = 0; i < kActions; i++){ s.syncAsByte(_actionCtrl[i]._ptr); s.syncAsByte(_actionCtrl[i]._cnt); } s.syncAsSint16LE(_seqPtr); s.syncAsSint16LE(_seqCnt); s.syncAsUint16LE(_shpCnt); s.syncBytes((byte *)&_file[0], 9); _file[8] = '\0'; } Queue::Queue(bool show) : _head(nullptr), _tail(nullptr) { } void Queue::append(Sprite *spr) { if (spr->_flags._back) spr->backShow(); else { spr->expand(); if (_tail) { spr->_prev = _tail; _tail->_next = spr; } else _head = spr; _tail = spr; } } void Queue::insert(Sprite *spr, Sprite *nxt) { if (spr->_flags._back) spr->backShow(); else { spr->expand(); if (nxt == _head) { spr->_next = _head; _head = spr; if (!_tail) _tail = spr; } else { spr->_next = nxt; spr->_prev = nxt->_prev; if (spr->_prev) spr->_prev->_next = spr; } if (spr->_next) spr->_next->_prev = spr; } } void Queue::insert(Sprite *spr) { if (locate(spr)) return; // We only queue it if it's not already queued. Sprite *s; for (s = _head; s; s = s->_next) { if (s->_pos3D._z < spr->_pos3D._z) break; } if (s) insert(spr, s); else append(spr); } Sprite *Queue::remove(Sprite *spr) { if (spr == _head) _head = spr->_next; if (spr == _tail) _tail = spr->_prev; if (spr->_next) spr->_next->_prev = spr->_prev; if (spr->_prev) spr->_prev->_next = spr->_next; spr->_prev = nullptr; spr->_next = nullptr; return spr; } Sprite *Queue::locate(int ref) { for (Sprite *spr = _head; spr; spr = spr->_next) { if (spr->_ref == ref) return spr; } return nullptr; } bool Queue::locate(Sprite *spr) { Sprite *s; for (s = _head; s; s = s->_next) { if (s == spr) return true; } return false; } Vga::Vga(CGE2Engine *vm) : _frmCnt(0), _msg(nullptr), _name(nullptr), _setPal(false), _vm(vm) { _rot._org = 1; _rot._len = 0; _rot._cnt = 0; _rot._dly = 1; _oldColors = nullptr; _newColors = nullptr; _showQ = new Queue(true); _sysPal = new Dac[kPalCount]; for (int idx = 0; idx < 4; idx++) { _page[idx] = new Graphics::Surface(); _page[idx]->create(kScrWidth, kScrHeight, Graphics::PixelFormat::createFormatCLUT8()); } _mono = ConfMan.getBool("enable_color_blind"); _oldColors = (Dac *)malloc(sizeof(Dac) * kPalCount); _newColors = (Dac *)malloc(sizeof(Dac) * kPalCount); getColors(_oldColors); sunset(); setColors(); clear(0); } Vga::~Vga() { Common::String buffer = ""; free(_oldColors); free(_newColors); if (_msg) buffer = Common::String(_msg); if (_name) buffer = buffer + " [" + _name + "]"; debugN("%s", buffer.c_str()); delete _showQ; delete[] _sysPal; for (int idx = 0; idx < 4; idx++) { _page[idx]->free(); delete _page[idx]; } } void Vga::waitVR() { // Since some of the game parts rely on using vertical sync as a delay mechanism, // we're introducing a short delay to simulate it g_system->delayMillis(5); } void Vga::getColors(Dac *tab) { byte palData[kPalSize]; g_system->getPaletteManager()->grabPalette(palData, 0, kPalCount); palToDac(palData, tab); } uint8 Vga::closest(Dac *pal, const uint8 colR, const uint8 colG, const uint8 colB) { #define f(col, lum) ((((uint16)(col)) << 8) / lum) uint16 i, dif = 0xFFFF, found = 0; uint16 L = colR + colG + colB; if (!L) L++; uint16 R = f(colR, L), G = f(colG, L), B = f(colB, L); for (i = 0; i < 256; i++) { uint16 l = pal[i]._r + pal[i]._g + pal[i]._b; if (!l) l++; int r = f(pal[i]._r, l), g = f(pal[i]._g, l), b = f(pal[i]._b, l); uint16 D = ((r > R) ? (r - R) : (R - r)) + ((g > G) ? (g - G) : (G - g)) + ((b > B) ? (b - B) : (B - b)) + ((l > L) ? (l - L) : (L - l)) * 10 ; if (D < dif) { found = i; dif = D; if (D == 0) break; // exact! } } return found; #undef f } uint8 Vga::closest(Dac *pal, Dac x) { int exp = (sizeof(long) * 8 - 1); long D = (1 << exp) - 1; // Maximum value of long. long R = x._r; long G = x._g; long B = x._b; int idx = 255; for (int n = 0; n < 256; n++) { long dR = R - pal[n]._r; long dG = G - pal[n]._g; long dB = B - pal[n]._b, d = dR * dR + dG * dG + dB * dB; if (d < D) { idx = n; D = d; if (!d) break; } } return idx; } uint8 *Vga::glass(Dac *pal, const uint8 colR, const uint8 colG, const uint8 colB) { uint8 *x = (uint8 *)malloc(256); if (x) { for (uint16 i = 0; i < 256; i++) { x[i] = closest(pal, ((uint16)(pal[i]._r) * colR) / 255, ((uint16)(pal[i]._g) * colG) / 255, ((uint16)(pal[i]._b) * colB) / 255); } } return x; } void Vga::palToDac(const byte *palData, Dac *tab) { const byte *colP = palData; for (int idx = 0; idx < kPalCount; idx++, colP += 3) { tab[idx]._r = *colP >> 2; tab[idx]._g = *(colP + 1) >> 2; tab[idx]._b = *(colP + 2) >> 2; } } void Vga::dacToPal(const Dac *tab, byte *palData) { for (int idx = 0; idx < kPalCount; idx++, palData += 3) { *palData = tab[idx]._r << 2; *(palData + 1) = tab[idx]._g << 2; *(palData + 2) = tab[idx]._b << 2; } } void Vga::setColors(Dac *tab, int lum) { Dac *palP = tab, *destP = _newColors; for (int idx = 0; idx < kPalCount; idx++, palP++, destP++) { destP->_r = (palP->_r * lum) >> 6; destP->_g = (palP->_g * lum) >> 6; destP->_b = (palP->_b * lum) >> 6; } if (_mono) { destP = _newColors; for (int idx = 0; idx < kPalCount; idx++, destP++) { // Form a grayscale color from 30% R, 59% G, 11% B uint8 intensity = (((int)destP->_r * 77) + ((int)destP->_g * 151) + ((int)destP->_b * 28)) >> 8; destP->_r = intensity; destP->_g = intensity; destP->_b = intensity; } } _setPal = true; } void Vga::setColors() { memset(_newColors, 0, kPalSize); updateColors(); } void Vga::sunrise(Dac *tab) { for (int i = 0; i <= 64; i += kFadeStep) { setColors(tab, i); waitVR(); updateColors(); g_system->updateScreen(); } } void Vga::sunset() { Dac tab[256]; getColors(tab); for (int i = 64; i >= 0; i -= kFadeStep) { setColors(tab, i); waitVR(); updateColors(); g_system->updateScreen(); } } void Vga::show() { _vm->_infoLine->update(); for (Sprite *spr = _showQ->first(); spr; spr = spr->_next) { spr->show(); } _vm->_mouse->show(); update(); rotate(); for (Sprite *spr = _showQ->first(); spr; spr = spr->_next) { spr->hide(); if (spr->_flags._zmov) { Sprite *s = nullptr; Sprite *p = spr->_prev; Sprite *n = spr->_next; if (spr->_flags._shad) { s = p; p = s->_prev; } if ((p && spr->_pos3D._z > p->_pos3D._z) || (n && spr->_pos3D._z < n->_pos3D._z)) { _showQ->insert(_showQ->remove(spr)); } spr->_flags._zmov = false; } } _vm->_mouse->hide(); } void Vga::updateColors() { byte palData[kPalSize]; dacToPal(_newColors, palData); g_system->getPaletteManager()->setPalette(palData, 0, 256); } void Vga::update() { SWAP(Vga::_page[0], Vga::_page[1]); if (_setPal) { updateColors(); _setPal = false; } g_system->copyRectToScreen(Vga::_page[0]->getPixels(), kScrWidth, 0, 0, kScrWidth, kScrHeight); g_system->updateScreen(); } void Vga::rotate() { if (_rot._len) { Dac c; getColors(_newColors); c = _newColors[_rot._org]; memmove(_newColors + _rot._org, _newColors + _rot._org + 1, (_rot._len - 1) * sizeof(Dac)); _newColors[_rot._org + _rot._len - 1] = c; _setPal = true; } } void Vga::clear(uint8 color) { for (int paneNum = 0; paneNum < 4; paneNum++) _page[paneNum]->fillRect(Common::Rect(0, 0, kScrWidth, kScrHeight), color); } void Vga::copyPage(uint16 d, uint16 s) { _page[d]->copyFrom(*_page[s]); } void Bitmap::show(V2D pos) { xLatPos(pos); const byte *srcP = (const byte *)_v; byte *screenStartP = (byte *)_vm->_vga->_page[1]->getPixels(); byte *screenEndP = (byte *)_vm->_vga->_page[1]->getBasePtr(0, kScrHeight); // Loop through processing data for each plane. The game originally ran in plane mapped mode, where a // given plane holds each fourth pixel sequentially. So to handle an entire picture, each plane's data // must be decompressed and inserted into the surface for (int planeCtr = 0; planeCtr < 4; planeCtr++) { byte *destP = (byte *)_vm->_vga->_page[1]->getBasePtr(pos.x + planeCtr, pos.y); for (;;) { uint16 v = READ_LE_UINT16(srcP); srcP += 2; int cmd = v >> 14; int count = v & 0x3FFF; if (cmd == 0) { // End of image break; } // Handle a set of pixels while (count-- > 0) { // Transfer operation switch (cmd) { case 1: // SKIP break; case 2: // REPEAT if (destP >= screenStartP && destP < screenEndP) *destP = *srcP; break; case 3: // COPY if (destP >= screenStartP && destP < screenEndP) *destP = *srcP; srcP++; break; } // Move to next dest position destP += 4; } if (cmd == 2) srcP++; } } } void Bitmap::hide(V2D pos) { xLatPos(pos); // Perform clipping to screen int w = MIN<int>(_w, kScrWidth - pos.x); int h = MIN<int>(_h, kScrHeight - pos.y); if (pos.x < 0) { w -= -pos.x; pos.x = 0; if (w < 0) return; } if (pos.y < 0) { h -= -pos.y; pos.y = 0; if (h < 0) return; } // Perform copying of screen section for (int yp = pos.y; yp < pos.y + h; yp++) { if (yp >= 0 && yp < kScrHeight) { const byte *srcP = (const byte *)_vm->_vga->_page[2]->getBasePtr(pos.x, yp); byte *destP = (byte *)_vm->_vga->_page[1]->getBasePtr(pos.x, yp); Common::copy(srcP, srcP + w, destP); } } } Speaker::Speaker(CGE2Engine *vm): Sprite(vm), _vm(vm) { // Set the sprite list BitmapPtr SP = new Bitmap[2]; uint8 *map = Bitmap::makeSpeechBubbleTail(0, _vm->_font->_colorSet); SP[0] = Bitmap(_vm, 15, 16, map); delete[] map; map = Bitmap::makeSpeechBubbleTail(1, _vm->_font->_colorSet); SP[1] = Bitmap(_vm, 15, 16, map); delete[] map; setShapeList(SP, 2); } } // End of namespace CGE2