From 09a4a4ac39f0cdaf7f8f78eb35ccadcb2cf1b467 Mon Sep 17 00:00:00 2001 From: Borja Lorente Date: Mon, 18 Jul 2016 19:16:13 +0200 Subject: MACVENTURE: Fix image to allow mask attributes --- engines/macventure/image.cpp | 191 +++++++++++++++++++++++-------------------- engines/macventure/image.h | 31 +++---- engines/macventure/world.cpp | 2 +- 3 files changed, 119 insertions(+), 105 deletions(-) (limited to 'engines/macventure') diff --git a/engines/macventure/image.cpp b/engines/macventure/image.cpp index feb4d2e78b..a4db46ecd4 100644 --- a/engines/macventure/image.cpp +++ b/engines/macventure/image.cpp @@ -64,23 +64,37 @@ ImageAsset::ImageAsset(ObjID original, Container * container) { _id = (original * 2); _mask = (original * 2) + 1; + uint imgRowBytes = 0; + uint imgBitWidth = 0; + uint imgBitHeight = 0; + uint maskRowBytes = 0; + uint maskBitWidth = 0; + uint maskBitHeight = 0; + _container = container; - decodePPIC(_id, _imgData); + decodePPIC(_id, _imgData, imgBitHeight, imgBitWidth, imgRowBytes); + _imgRowBytes = imgRowBytes; + _imgBitWidth = imgBitWidth; + _imgBitHeight = imgBitHeight; - if (_container->getItemByteSize(_mask)) // Has mask - decodePPIC(_mask, _maskData); + if (_container->getItemByteSize(_mask)) { + decodePPIC(_mask, _maskData, maskBitHeight, maskBitWidth, maskRowBytes); + } + _maskRowBytes = maskRowBytes; + _maskBitWidth = maskBitWidth; + _maskBitHeight = maskBitHeight; } ImageAsset::~ImageAsset() { } -void ImageAsset::decodePPIC(ObjID id, Common::Array &data) { +void ImageAsset::decodePPIC(ObjID id, Common::Array &data, uint &bitHeight, uint &bitWidth, uint &rowBytes) { ObjID realID = id; uint32 size = _container->getItemByteSize(id); if (size < 2) { - _rowBytes = 0; - _bitHeight = 0; - _bitHeight = 0; + rowBytes = 0; + bitHeight = 0; + bitWidth = 0; return; } if (size == 2) { @@ -96,37 +110,37 @@ void ImageAsset::decodePPIC(ObjID id, Common::Array &data) { if (stream.getBit()) w = stream.getBits(10); else w = stream.getBits(6); - _rowBytes = ((w + 0xF) >> 3) & 0xFFFE; - _bitWidth = w; - _bitHeight = h; + rowBytes = ((w + 0xF) >> 3) & 0xFFFE; + bitWidth = w; + bitHeight = h; - for (int i = 0; i < _rowBytes * h; i++) { + for (int i = 0; i < rowBytes * h; i++) { data.push_back(0); } switch (mode) { case MacVenture::kPPIC0: - decodePPIC0(stream, data); + decodePPIC0(stream, data, bitHeight, bitWidth, rowBytes); break; case MacVenture::kPPIC1: - decodePPIC1(stream, data); + decodePPIC1(stream, data, bitHeight, bitWidth, rowBytes); break; case MacVenture::kPPIC2: - decodePPIC2(stream, data); + decodePPIC2(stream, data, bitHeight, bitWidth, rowBytes); break; case MacVenture::kPPIC3: - decodePPIC3(stream, data); + decodePPIC3(stream, data, bitHeight, bitWidth, rowBytes); break; } } -void ImageAsset::decodePPIC0(Common::BitStream & stream, Common::Array &data) { - uint words = _bitWidth >> 4; - uint bytes = _bitWidth & 0xF; +void ImageAsset::decodePPIC0(Common::BitStream & stream, Common::Array &data, uint bitHeight, uint bitWidth, uint rowBytes) { + uint words = bitWidth >> 4; + uint bytes = bitWidth & 0xF; uint v = 0; uint p = 0; - for (uint y = 0; y <_bitHeight; y++) { + for (uint y = 0; y < bitHeight; y++) { for (uint x = 0; x < words; x++) { v = stream.peekBits(32); stream.skip(16); @@ -144,15 +158,15 @@ void ImageAsset::decodePPIC0(Common::BitStream & stream, Common::Array &da } -void ImageAsset::decodePPIC1(Common::BitStream & stream, Common::Array &data) { - decodeHuffGraphic(PPIC1Huff, stream, data); +void ImageAsset::decodePPIC1(Common::BitStream & stream, Common::Array &data, uint bitHeight, uint bitWidth, uint rowBytes) { + decodeHuffGraphic(PPIC1Huff, stream, data, bitHeight, bitWidth, rowBytes); } -void ImageAsset::decodePPIC2(Common::BitStream & stream, Common::Array &data) { - decodeHuffGraphic(PPIC2Huff, stream, data); +void ImageAsset::decodePPIC2(Common::BitStream & stream, Common::Array &data, uint bitHeight, uint bitWidth, uint rowBytes) { + decodeHuffGraphic(PPIC2Huff, stream, data, bitHeight, bitWidth, rowBytes); } -void ImageAsset::decodePPIC3(Common::BitStream & stream, Common::Array &data) { +void ImageAsset::decodePPIC3(Common::BitStream & stream, Common::Array &data, uint bitHeight, uint bitWidth, uint rowBytes) { // We need to load the huffman from the PPIC itself PPICHuff huff; uint16 v, bits; @@ -193,20 +207,20 @@ void ImageAsset::decodePPIC3(Common::BitStream & stream, Common::Array &da huff.lens[0xf] = bits; huff.lens[0x10] = bits; - decodeHuffGraphic(huff, stream, data); + decodeHuffGraphic(huff, stream, data, bitHeight, bitWidth, rowBytes); } -void ImageAsset::decodeHuffGraphic(const PPICHuff & huff, Common::BitStream & stream, Common::Array &data) { +void ImageAsset::decodeHuffGraphic(const PPICHuff & huff, Common::BitStream & stream, Common::Array &data, uint bitHeight, uint bitWidth, uint rowBytes) { byte flags = 0; _walkRepeat = 0; _walkLast = 0; - if (_bitWidth & 3) + if (bitWidth & 3) flags = stream.getBits(5); else flags = stream.getBits(4) << 1; byte odd = 0; - byte blank = _bitWidth & 0xf; + byte blank = bitWidth & 0xf; if (blank) { blank >>= 2; odd = blank & 1; @@ -214,9 +228,9 @@ void ImageAsset::decodeHuffGraphic(const PPICHuff & huff, Common::BitStream & st } uint16 pos = 0; - for (uint y = 0; y < _bitHeight; y++) { + for (uint y = 0; y < bitHeight; y++) { uint16 x = 0; - for (; x < _bitWidth >> 3; x++) { + for (; x < bitWidth >> 3; x++) { byte hi = walkHuff(huff, stream) << 4; data[pos++] = walkHuff(huff, stream) | hi; } @@ -226,13 +240,13 @@ void ImageAsset::decodeHuffGraphic(const PPICHuff & huff, Common::BitStream & st pos += blank; } - uint16 edge = _bitWidth & 3; + uint16 edge = bitWidth & 3; if (edge) { - pos = _rowBytes - blank; + pos = rowBytes - blank; uint16 bits = 0; uint16 val = 0; uint16 v; - for (uint y = 0; y < _bitHeight; y++) { + for (uint y = 0; y < bitHeight; y++) { if (flags & 1) { if (bits < edge) { v = walkHuff(huff, stream) << 4; @@ -251,15 +265,15 @@ void ImageAsset::decodeHuffGraphic(const PPICHuff & huff, Common::BitStream & st v >>= 4; data[pos] |= v & 0xff; - pos += _rowBytes; + pos += rowBytes; } } if (flags & 8) { pos = 0; - for (uint y = 0; y < _bitHeight; y++) { + for (uint y = 0; y < bitHeight; y++) { uint16 v = 0; if (flags & 2) { - for (uint x = 0; x < _rowBytes; x++) + for (uint x = 0; x < rowBytes; x++) { data[pos] ^= v; v = data[pos]; @@ -267,7 +281,7 @@ void ImageAsset::decodeHuffGraphic(const PPICHuff & huff, Common::BitStream & st } } else { - for (uint x = 0; x < _rowBytes; x++) { + for (uint x = 0; x < rowBytes; x++) { uint16 val = data[pos] ^ v; val ^= (val >> 4) & 0xf; data[pos] = val; @@ -278,11 +292,11 @@ void ImageAsset::decodeHuffGraphic(const PPICHuff & huff, Common::BitStream & st } } if (flags & 4) { - uint16 delta = _rowBytes * 4; + uint16 delta = rowBytes * 4; if (flags & 2) delta *= 2; pos = 0; uint q = delta; - for (int i = 0; i < _bitHeight * _rowBytes - delta; i++) { + for (int i = 0; i < bitHeight * rowBytes - delta; i++) { data[q] ^= data[pos]; q++; pos++; @@ -331,15 +345,15 @@ byte ImageAsset::walkHuff(const PPICHuff & huff, Common::BitStream & stream) { void ImageAsset::blitInto(Graphics::ManagedSurface *target, uint32 x, uint32 y, BlitMode mode) { if (mode == kBlitDirect) { - blitDirect(target, x, y, _imgData); + blitDirect(target, x, y, _imgData, _imgBitHeight, _imgBitWidth, _imgRowBytes); } else if (mode < kBlitXOR){ if (_container->getItemByteSize(_mask)) { // Has mask switch (mode) { case MacVenture::kBlitBIC: - blitBIC(target, x, y, _maskData); + blitBIC(target, x, y, _maskData, _maskBitHeight, _maskBitWidth, _maskRowBytes); break; case MacVenture::kBlitOR: - blitOR(target, x, y, _maskData); + blitOR(target, x, y, _maskData, _maskBitHeight, _maskBitWidth, _maskRowBytes); break; default: break; @@ -347,10 +361,10 @@ void ImageAsset::blitInto(Graphics::ManagedSurface *target, uint32 x, uint32 y, } else if (_container->getItemByteSize(_id)) { switch (mode) { case MacVenture::kBlitBIC: - target->fillRect(Common::Rect(x, y, x + _bitWidth, y + _bitHeight), kColorWhite); + target->fillRect(Common::Rect(x, y, x + _imgBitWidth, y + _imgBitHeight), kColorWhite); break; case MacVenture::kBlitOR: - target->fillRect(Common::Rect(x, y, x + _bitWidth, y + _bitHeight), kColorBlack); + target->fillRect(Common::Rect(x, y, x + _imgBitWidth, y + _imgBitHeight), kColorBlack); break; default: break; @@ -358,16 +372,16 @@ void ImageAsset::blitInto(Graphics::ManagedSurface *target, uint32 x, uint32 y, } if (_container->getItemByteSize(_id) && mode > 0) { - blitXOR(target, x, y, _imgData); + blitXOR(target, x, y, _imgData, _imgBitHeight, _imgBitWidth, _imgRowBytes); } } } bool ImageAsset::isPointInside(Common::Point point) { - if (point.x >= _bitWidth || point.y >= _bitHeight) return false; + if (point.x >= _maskBitWidth || point.y >= _maskBitHeight) return false; if (_maskData.empty()) return false; // We see if the point lands on the mask. - uint pix = _maskData[(point.y * _rowBytes) + (point.x >> 3)] & (1 << (7 - (point.x & 7))); + uint pix = _maskData[(point.y * _maskRowBytes) + (point.x >> 3)] & (1 << (7 - (point.x & 7))); return pix != 0; } @@ -376,7 +390,7 @@ bool ImageAsset::isRectInside(Common::Rect rect) { if (_maskData.empty()) return (rect.width() > 0 && rect.height() > 0); for (int y = rect.top; y < rect.top + rect.height(); y++) { - uint bmpofs = y * _rowBytes; + uint bmpofs = y * _maskRowBytes; byte pix; for (int x = rect.left; x < rect.left + rect.width(); x++) { pix = _maskData[bmpofs + (x >> 3)] & (1 << (7 - (x & 7))); @@ -388,19 +402,20 @@ bool ImageAsset::isRectInside(Common::Rect rect) { int ImageAsset::getWidth() { if (_imgData.size() == 0) return 0; - return MAX(0, (int)_bitWidth); + return MAX(0, (int)_imgBitWidth); } int ImageAsset::getHeight() { if (_imgData.size() == 0) return 0; - return MAX(0, (int)_bitHeight); + return MAX(0, (int)_imgBitHeight); } -void ImageAsset::blitDirect(Graphics::ManagedSurface * target, uint32 ox, uint32 oy, const Common::Array& data) { - /* - if (_bitWidth == 0 || _bitHeight == 0) return; - uint w = _bitWidth; - uint h = _bitHeight; +void ImageAsset::blitDirect(Graphics::ManagedSurface * target, uint32 ox, uint32 oy, const Common::Array& data, uint bitHeight, uint bitWidth, uint rowBytes) { + +/* + if (bitWidth == 0 || bitHeight == 0) return; + uint w = bitWidth; + uint h = bitHeight; uint sx = 0; uint sy = 0; if (ox<0) { sx = -ox; ox = 0; } @@ -408,12 +423,11 @@ void ImageAsset::blitDirect(Graphics::ManagedSurface * target, uint32 ox, uint32 if (w + ox >= target->w) w = target->w - ox; if (h + oy >= target->h) h = target->h - oy; if (w == 0 || h == 0) return; - */ - - for (uint y = 0; y < _bitHeight; y++) { - uint bmpofs = y * _rowBytes; +*/ + for (uint y = 0; y < bitHeight; y++) { + uint bmpofs = y * rowBytes; byte pix = 0; - for (uint x = 0; x < _bitWidth; x++) { + for (uint x = 0; x < bitWidth; x++) { pix = data[bmpofs + (x >> 3)] & (1 << (7 - (x & 7))); pix = pix ? kColorBlack : kColorWhite; *((byte *)target->getBasePtr(ox + x, oy + y)) = pix; @@ -421,11 +435,11 @@ void ImageAsset::blitDirect(Graphics::ManagedSurface * target, uint32 ox, uint32 } } -void ImageAsset::blitBIC(Graphics::ManagedSurface * target, uint32 ox, uint32 oy, const Common::Array &data) { - /* - if (_bitWidth == 0 || _bitHeight == 0) return; - uint w = _bitWidth; - uint h = _bitHeight; +void ImageAsset::blitBIC(Graphics::ManagedSurface * target, uint32 ox, uint32 oy, const Common::Array &data, uint bitHeight, uint bitWidth, uint rowBytes) { +/* + if (bitWidth == 0 || bitHeight == 0) return; + uint w = bitWidth; + uint h = bitHeight; uint sx = 0; uint sy = 0; if (ox<0) { sx = -ox; ox = 0; } @@ -433,22 +447,22 @@ void ImageAsset::blitBIC(Graphics::ManagedSurface * target, uint32 ox, uint32 oy if (w + ox >= target->w) w = target->w - ox; if (h + oy >= target->h) h = target->h - oy; if (w == 0 || h == 0) return; - */ - for (uint y = 0; y < _bitHeight; y++) { - uint bmpofs = y * _rowBytes; +*/ + for (uint y = 0; y < bitHeight; y++) { + uint bmpofs = y * rowBytes; byte pix = 0; - for (uint x = 0; x < _bitWidth; x++) { + for (uint x = 0; x < bitWidth; x++) { pix = data[bmpofs + (x >> 3)] & (1 << (7 - (x & 7))); if (pix) *((byte *)target->getBasePtr(ox + x, oy + y)) = kColorWhite; } } } -void ImageAsset::blitOR(Graphics::ManagedSurface * target, uint32 ox, uint32 oy, const Common::Array &data) { - /* - if (_bitWidth == 0 || _bitHeight == 0) return; - uint w = _bitWidth; - uint h = _bitHeight; +void ImageAsset::blitOR(Graphics::ManagedSurface * target, uint32 ox, uint32 oy, const Common::Array &data, uint bitHeight, uint bitWidth, uint rowBytes) { +/* + if (bitWidth == 0 || bitHeight == 0) return; + uint w = bitWidth; + uint h = bitHeight; uint sx = 0; uint sy = 0; if (ox<0) { sx = -ox; ox = 0; } @@ -456,23 +470,22 @@ void ImageAsset::blitOR(Graphics::ManagedSurface * target, uint32 ox, uint32 oy, if (w + ox >= target->w) w = target->w - ox; if (h + oy >= target->h) h = target->h - oy; if (w == 0 || h == 0) return; - */ - for (uint y = 0; y < _bitHeight; y++) { - uint bmpofs = y * _rowBytes; +*/ + for (uint y = 0; y < bitHeight; y++) { + uint bmpofs = y * rowBytes; byte pix = 0; - for (uint x = 0; x < _bitWidth; x++) { + for (uint x = 0; x < bitWidth; x++) { pix = data[bmpofs + (x >> 3)] & (1 << (7 - (x & 7))); - if (pix) *((byte *)target->getBasePtr(ox + x, oy + y)) = kColorBlack; } } } -void ImageAsset::blitXOR(Graphics::ManagedSurface * target, uint32 ox, uint32 oy, const Common::Array &data) { - /* - if (_bitWidth == 0 || _bitHeight == 0) return; - uint w = _bitWidth; - uint h = _bitHeight; +void ImageAsset::blitXOR(Graphics::ManagedSurface * target, uint32 ox, uint32 oy, const Common::Array &data, uint bitHeight, uint bitWidth, uint rowBytes) { +/* + if (bitWidth == 0 || bitHeight == 0) return; + uint w = bitWidth; + uint h = bitHeight; uint sx = 0; uint sy = 0; if (ox<0) { sx = -ox; ox = 0; } @@ -480,16 +493,14 @@ void ImageAsset::blitXOR(Graphics::ManagedSurface * target, uint32 ox, uint32 oy if (w + ox >= target->w) w = target->w - ox; if (h + oy >= target->h) h = target->h - oy; if (w == 0 || h == 0) return; - */ - for (uint y = 0;y < _bitHeight; y++) { - uint bmpofs = y * _rowBytes; +*/ + for (uint y = 0; y < bitHeight; y++) { + uint bmpofs = y * rowBytes; byte pix = 0; - for (uint x = 0; x < _bitWidth; x++) { + for (uint x = 0; x < bitWidth; x++) { pix = data[bmpofs + (x >> 3)] & (1 << (7 - (x & 7))); - if (pix) { // We need to xor byte p = *((byte *)target->getBasePtr(ox + x, oy + y)); - *((byte *)target->getBasePtr(ox + x, oy + y)) = (p == kColorWhite) ? kColorBlack : kColorWhite; } diff --git a/engines/macventure/image.h b/engines/macventure/image.h index b529109442..e6b2515f5c 100644 --- a/engines/macventure/image.h +++ b/engines/macventure/image.h @@ -67,20 +67,20 @@ public: int getHeight(); private: - void decodePPIC(ObjID id, Common::Array &data); + void decodePPIC(ObjID id, Common::Array &data, uint &bitHeight, uint &bitWidth, uint &rowBytes); - void decodePPIC0(Common::BitStream &stream, Common::Array &data); - void decodePPIC1(Common::BitStream &stream, Common::Array &data); - void decodePPIC2(Common::BitStream &stream, Common::Array &data); - void decodePPIC3(Common::BitStream &stream, Common::Array &data); + void decodePPIC0(Common::BitStream &stream, Common::Array &data, uint bitHeight, uint bitWidth, uint rowBytes); + void decodePPIC1(Common::BitStream &stream, Common::Array &data, uint bitHeight, uint bitWidth, uint rowBytes); + void decodePPIC2(Common::BitStream &stream, Common::Array &data, uint bitHeight, uint bitWidth, uint rowBytes); + void decodePPIC3(Common::BitStream &stream, Common::Array &data, uint bitHeight, uint bitWidth, uint rowBytes); - void decodeHuffGraphic(const PPICHuff &huff, Common::BitStream &stream, Common::Array &data); + void decodeHuffGraphic(const PPICHuff &huff, Common::BitStream &stream, Common::Array &data, uint bitHeight, uint bitWidth, uint rowBytes); byte walkHuff(const PPICHuff &huff, Common::BitStream &stream); - void blitDirect(Graphics::ManagedSurface * target, uint32 ox, uint32 oy, const Common::Array &data); - void blitBIC(Graphics::ManagedSurface * target, uint32 ox, uint32 oy, const Common::Array &data); - void blitOR(Graphics::ManagedSurface * target, uint32 ox, uint32 oy, const Common::Array &data); - void blitXOR(Graphics::ManagedSurface * target, uint32 ox, uint32 oy, const Common::Array &data); + void blitDirect(Graphics::ManagedSurface * target, uint32 ox, uint32 oy, const Common::Array &data, uint bitHeight, uint bitWidth, uint rowBytes); + void blitBIC(Graphics::ManagedSurface * target, uint32 ox, uint32 oy, const Common::Array &data, uint bitHeight, uint bitWidth, uint rowBytes); + void blitOR(Graphics::ManagedSurface * target, uint32 ox, uint32 oy, const Common::Array &data, uint bitHeight, uint bitWidth, uint rowBytes); + void blitXOR(Graphics::ManagedSurface * target, uint32 ox, uint32 oy, const Common::Array &data, uint bitHeight, uint bitWidth, uint rowBytes); private: ObjID _id; @@ -90,12 +90,15 @@ private: uint16 _walkRepeat; uint16 _walkLast; - uint16 _rowBytes; - uint16 _bitWidth; - uint16 _bitHeight; - Common::Array _imgData; + uint16 _imgRowBytes; + uint16 _imgBitWidth; + uint16 _imgBitHeight; + Common::Array _maskData; + uint16 _maskRowBytes; + uint16 _maskBitWidth; + uint16 _maskBitHeight; }; } // End of namespace MacVenture diff --git a/engines/macventure/world.cpp b/engines/macventure/world.cpp index ab35226aa0..e6efeb5598 100644 --- a/engines/macventure/world.cpp +++ b/engines/macventure/world.cpp @@ -41,7 +41,7 @@ World::~World() { uint32 World::getObjAttr(ObjID objID, uint32 attrID) { - int res; + uint res; uint32 index = _engine->getGlobalSettings().attrIndices[attrID]; // HACK, but if I try to initialize it in the else clause, it goes out of scope and segfaults Common::SeekableReadStream *objStream = _objectConstants->getItem(objID); -- cgit v1.2.3