Initial commit

engines/mm/shared/xeen/sprites.cpp

@@ -0,0 +1,617 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "common/scummsys.h"
+#include "common/archive.h"
+#include "common/memstream.h"
+#include "common/textconsole.h"
+#include "graphics/paletteman.h"
+#include "image/bmp.h"
+#include "image/png.h"
+#include "mm/shared/xeen/sprites.h"
+#include "mm/mm.h"
+
+namespace MM {
+namespace Shared {
+namespace Xeen {
+
+#define SCREEN_WIDTH 320
+#define SCREEN_HEIGHT 200
+#define PALETTE_COUNT 256
+#define PALETTE_SIZE (256 * 3)
+#define SCENE_CLIP_LEFT 8
+#define SCENE_CLIP_RIGHT 223
+
+int SpriteResource::_clippedBottom;
+
+SpriteResource::SpriteResource() {
+	_filesize = 0;
+	_data = nullptr;
+}
+
+SpriteResource::SpriteResource(const Common::Path &filename) {
+	_data = nullptr;
+	load(filename);
+}
+
+SpriteResource::SpriteResource(const SpriteResource &src) {
+	copy(src);
+}
+
+SpriteResource::~SpriteResource() {
+	clear();
+}
+
+void SpriteResource::copy(const SpriteResource &src) {
+	_filesize = src._filesize;
+	_data = new byte[_filesize];
+	Common::copy(src._data, src._data + _filesize, _data);
+
+	_index.resize(src._index.size());
+	for (uint i = 0; i < src._index.size(); ++i)
+		_index[i] = src._index[i];
+}
+
+SpriteResource &SpriteResource::operator=(const SpriteResource &src) {
+	delete[] _data;
+	_index.clear();
+
+	copy(src);
+
+	return *this;
+}
+
+void SpriteResource::load(const Common::Path &filename) {
+	_filename = filename;
+	Common::File f;
+	if (g_engine->getGameID() == GType_MightAndMagic1 && f.open(filename)) {
+		load(f);
+	} else {
+		File f2(filename);
+		load(f2);
+	}
+}
+
+void SpriteResource::load(Common::SeekableReadStream &f) {
+	// Read in a copy of the file
+	_filesize = f.size();
+	delete[] _data;
+	_data = new byte[_filesize];
+	f.read(_data, _filesize);
+
+	// Read in the index
+	f.seek(0);
+	int count = f.readUint16LE();
+	_index.resize(count);
+
+	for (int i = 0; i < count; ++i) {
+		_index[i]._offset1 = f.readUint16LE();
+		_index[i]._offset2 = f.readUint16LE();
+
+		// Check for any images overriding the default Xeen sprites for M&M1 Enhanced mode
+		const Common::String fnPNG = Common::String::format("gfx/%s/image%.2d.png", _filename.baseName().c_str(), i);
+		const Common::String fnBitmap = Common::String::format("gfx/%s/image%.2d.bmp", _filename.baseName().c_str(), i);
+		Image::PNGDecoder pngDecoder;
+		Image::BitmapDecoder bmpDecoder;
+		Common::File imgFile;
+
+		if (Common::File::exists(fnPNG.c_str()) && imgFile.open(fnPNG.c_str()) && pngDecoder.loadStream(imgFile)) {
+			_index[i]._override.copyFrom(*pngDecoder.getSurface());
+		} else if (Common::File::exists(fnBitmap.c_str()) && imgFile.open(fnBitmap.c_str()) && bmpDecoder.loadStream(imgFile)) {
+			_index[i]._override.copyFrom(*bmpDecoder.getSurface());
+		}
+	}
+}
+
+void SpriteResource::clear() {
+	delete[] _data;
+	_data = nullptr;
+	_filesize = 0;
+	_index.clear();
+}
+
+void SpriteResource::draw(XSurface &dest, int frame, const Common::Point &destPos,
+		uint flags, int scale) const {
+	draw(dest, frame, destPos, Common::Rect(0, 0, dest.w, dest.h), flags, scale);
+}
+
+void SpriteResource::draw(XSurface &dest, int frame, const Common::Point &destPos,
+	const Common::Rect &bounds, uint flags, int scale) const {
+	Common::Rect r = bounds;
+	if (flags & SPRFLAG_BOTTOM_CLIPPED)
+		r.clip(SCREEN_WIDTH, _clippedBottom);
+
+	// Create drawer to handle the rendering
+	SpriteDrawer *drawer;
+	switch (flags & SPRFLAG_MODE_MASK) {
+	case SPRFLAG_DRAWER1:
+		drawer = new SpriteDrawer1(_data, _filesize, flags & 0x1F);
+		break;
+	case SPRFLAG_DRAWER2:
+		drawer = new SpriteDrawer2(_data, _filesize, flags & 0x1F);
+		break;
+	case SPRFLAG_DRAWER3:
+		drawer = new SpriteDrawer3(_data, _filesize, flags & 0x1F);
+		break;
+	case SPRFLAG_DRAWER5:
+		drawer = new SpriteDrawer5(_data, _filesize, flags & 0x1F);
+		break;
+	case SPRFLAG_DRAWER6:
+		drawer = new SpriteDrawer6(_data, _filesize, flags & 0x1F);
+		break;
+	default:
+		drawer = new SpriteDrawer(_data, _filesize);
+		break;
+	}
+
+	// WORKAROUND: Crash clicking Vertigo well in Clouds
+	if (frame < (int)_index.size()) {
+		if (!_index[frame]._override.empty()) {
+			const Graphics::ManagedSurface &src = _index[frame]._override;
+			if (flags & Shared::Xeen::SPRFLAG_RESIZE)
+				dest.create(src.w, src.h);
+			dest.blitFrom(src, destPos);
+		} else {
+			// Sprites can consist of separate background & foreground
+			drawer->draw(dest, _index[frame]._offset1, destPos, r, flags, scale);
+			if (_index[frame]._offset2)
+				drawer->draw(dest, _index[frame]._offset2, destPos, r, flags, scale);
+		}
+	}
+
+	delete drawer;
+}
+
+void SpriteResource::draw(XSurface &dest, int frame) const {
+	draw(dest, frame, Common::Point());
+}
+
+void SpriteResource::draw(Graphics::ManagedSurface *dest, int frame, const Common::Point &destPos) const {
+	XSurface tmp;
+	tmp.w = dest->w;
+	tmp.h = dest->h;
+	tmp.pitch = dest->pitch;
+	tmp.format = dest->format;
+	tmp.setPixels(dest->getPixels());
+
+	draw(tmp, frame, destPos);
+}
+
+
+Common::Point SpriteResource::getFrameSize(int frame) const {
+	Common::MemoryReadStream f(_data, _filesize);
+	Common::Point frameSize;
+
+	for (int idx = 0; idx < (_index[frame]._offset2 ? 2 : 1); ++idx) {
+		f.seek((idx == 0) ? _index[frame]._offset1 : _index[frame]._offset2);
+		int xOffset = f.readUint16LE();
+		int width = f.readUint16LE();
+		int yOffset = f.readUint16LE();
+		int height = f.readUint16LE();
+
+		frameSize.x = MAX((int)frameSize.x, xOffset + width);
+		frameSize.y = MAX((int)frameSize.y, yOffset + height);
+	}
+
+	return frameSize;
+}
+
+/*------------------------------------------------------------------------*/
+
+void SpriteDrawer::draw(XSurface &dest, uint16 offset, const Common::Point &pt,
+	const Common::Rect &clipRect, uint flags, int scale) {
+	static const uint SCALE_TABLE[] = {
+		0xFFFF, 0xFFEF, 0xEFEF, 0xEFEE, 0xEEEE, 0xEEAE, 0xAEAE, 0xAEAA,
+		0xAAAA, 0xAA8A, 0x8A8A, 0x8A88, 0x8888, 0x8880, 0x8080, 0x8000
+	};
+	static const int PATTERN_STEPS[] = { 0, 1, 1, 1, 2, 2, 3, 3, 0, -1, -1, -1, -2, -2, -3, -3 };
+
+	assert((scale & SCALE_MASK) < 16);
+	uint16 scaleMask = SCALE_TABLE[scale & SCALE_MASK];
+	uint16 scaleMaskX = scaleMask, scaleMaskY = scaleMask;
+	bool flipped = (flags & SPRFLAG_HORIZ_FLIPPED) != 0;
+	int xInc = flipped ? -1 : 1;
+	bool enlarge = (scale & SCALE_ENLARGE) != 0;
+
+	_destTop = (byte *)dest.getBasePtr(clipRect.left, clipRect.top);
+	_destBottom = (byte *)dest.getBasePtr(clipRect.right, clipRect.bottom - 1);
+	_pitch = dest.pitch;
+
+	// Get cell header
+	Common::MemoryReadStream f(_data, _filesize);
+	f.seek(offset);
+	int xOffset = f.readUint16LE();
+	int width = f.readUint16LE();
+	int yOffset = f.readUint16LE();
+	int height = f.readUint16LE();
+
+	// Figure out drawing x, y
+	Common::Point destPos;
+	destPos.x = pt.x + getScaledVal(xOffset, scaleMaskX);
+	destPos.x += (width - getScaledVal(width, scaleMaskX)) / 2;
+
+	destPos.y = pt.y + getScaledVal(yOffset, scaleMaskY);
+
+	// If the flags allow the dest surface to be resized, ensure dest surface is big enough
+	Common::Rect bounds = clipRect;
+	if (flags & SPRFLAG_RESIZE) {
+		if (dest.w < (xOffset + width) || dest.h < (yOffset + height))
+			dest.create(xOffset + width, yOffset + height);
+		bounds = Common::Rect(0, 0, dest.w, dest.h);
+	}
+	if (flags & SPRFLAG_SCENE_CLIPPED) {
+		bounds.clip(Common::Rect(8, 8, 223, 141));
+	}
+
+	uint16 scaleMaskXCopy = scaleMaskX;
+	Common::Rect drawBounds;
+	drawBounds.left = SCREEN_WIDTH;
+	drawBounds.top = SCREEN_HEIGHT;
+	drawBounds.right = drawBounds.bottom = 0;
+
+	// Main loop
+	for (int yCtr = height; yCtr > 0; --yCtr) {
+		// The number of bytes in this scan line
+		int lineLength = f.readByte();
+
+		if (lineLength == 0) {
+			// Skip the specified number of scan lines
+			int numLines = f.readByte();
+			destPos.y += getScaledVal(numLines + 1, scaleMaskY);
+			yCtr -= numLines;
+			continue;
+		}
+
+		// Roll the scale mask
+		uint bit = (scaleMaskY >> 15) & 1;
+		scaleMaskY = ((scaleMaskY & 0x7fff) << 1) + bit;
+
+		if (!bit) {
+			// Not a line to be drawn due to scaling down
+			f.skip(lineLength);
+		} else if (destPos.y < bounds.top || destPos.y >= bounds.bottom) {
+			// Skip over the bytes of the line
+			f.skip(lineLength);
+			destPos.y++;
+		} else {
+			scaleMaskX = scaleMaskXCopy;
+			xOffset = f.readByte();
+
+			// Initialize the array to hold the temporary data for the line. We do this to make it simpler
+			// to handle both deciding which pixels to draw in a scaled image, as well as when images
+			// have been horizontally flipped. Note that we allocate an extra line for before and after our
+			// work line, just in case the sprite is screwed up and overruns the line
+			int tempLine[SCREEN_WIDTH * 3];
+			Common::fill(&tempLine[SCREEN_WIDTH], &tempLine[SCREEN_WIDTH * 3], -1);
+			int *lineP = flipped ? &tempLine[SCREEN_WIDTH + width - 1 - xOffset] : &tempLine[SCREEN_WIDTH + xOffset];
+
+			// Build up the line
+			int byteCount, opr1, opr2;
+			int32 pos;
+			for (byteCount = 1; byteCount < lineLength; ) {
+				// The next byte is an opcode that determines what operators are to follow and how to interpret them.
+				int opcode = f.readByte(); ++byteCount;
+
+				// Decode the opcode
+				int len = opcode & 0x1F;
+				int cmd = (opcode & 0xE0) >> 5;
+
+				switch (cmd) {
+				case 0:   // The following len + 1 bytes are stored as indexes into the color table.
+				case 1:   // The following len + 33 bytes are stored as indexes into the color table.
+					for (int i = 0; i < opcode + 1; ++i, ++byteCount) {
+						byte b = f.readByte();
+						*lineP = b;
+						lineP += xInc;
+					}
+					break;
+
+				case 2:   // The following byte is an index into the color table, draw it len + 3 times.
+					opr1 = f.readByte(); ++byteCount;
+					for (int i = 0; i < len + 3; ++i) {
+						*lineP = opr1;
+						lineP += xInc;
+					}
+					break;
+
+				case 3:   // Stream copy command.
+					opr1 = f.readUint16LE(); byteCount += 2;
+					pos = f.pos();
+					f.seek(-opr1, SEEK_CUR);
+
+					for (int i = 0; i < len + 4; ++i) {
+						*lineP = f.readByte();
+						lineP += xInc;
+					}
+
+					f.seek(pos, SEEK_SET);
+					break;
+
+				case 4:   // The following two bytes are indexes into the color table, draw the pair len + 2 times.
+					opr1 = f.readByte(); ++byteCount;
+					opr2 = f.readByte(); ++byteCount;
+					for (int i = 0; i < len + 2; ++i) {
+						*lineP = opr1;
+						lineP += xInc;
+						*lineP = opr2;
+						lineP += xInc;
+					}
+					break;
+
+				case 5:   // Skip len + 1 pixels
+					lineP += (len + 1) * xInc;
+					break;
+
+				case 6:   // Pattern command.
+				case 7:
+					// The pattern command has a different opcode format
+					len = opcode & 0x07;
+					cmd = (opcode >> 2) & 0x0E;
+
+					opr1 = f.readByte(); ++byteCount;
+					for (int i = 0; i < len + 3; ++i) {
+						*lineP = opr1;
+						lineP += xInc;
+						opr1 += PATTERN_STEPS[cmd + (i % 2)];
+					}
+					break;
+
+				default:
+					break;
+				}
+			}
+			assert(byteCount == lineLength);
+
+			drawBounds.top = MIN(drawBounds.top, destPos.y);
+			drawBounds.bottom = MAX((int)drawBounds.bottom, destPos.y + 1);
+
+			// Handle drawing out the line
+			byte *destP = (byte *)dest.getBasePtr(destPos.x, destPos.y);
+			_destLeft = (byte *)dest.getBasePtr(
+				(flags & SPRFLAG_SCENE_CLIPPED) ? SCENE_CLIP_LEFT : clipRect.left, destPos.y);
+			_destRight = (byte *)dest.getBasePtr(
+				(flags & SPRFLAG_SCENE_CLIPPED) ? SCENE_CLIP_RIGHT : clipRect.right, destPos.y);
+			int16 xp = destPos.x;
+			lineP = &tempLine[SCREEN_WIDTH];
+
+			for (int xCtr = 0; xCtr < width; ++xCtr, ++lineP) {
+				bit = (scaleMaskX >> 15) & 1;
+				scaleMaskX = ((scaleMaskX & 0x7fff) << 1) + bit;
+
+				if (bit) {
+					// Check whether there's a pixel to write, and we're within the allowable bounds. Note that for
+					// the SPRFLAG_SCENE_CLIPPED or when enlarging, we also have an extra horizontal bounds check
+					if (*lineP != -1 && xp >= bounds.left && xp < bounds.right) {
+						drawBounds.left = MIN(drawBounds.left, xp);
+						drawBounds.right = MAX((int)drawBounds.right, xp + 1);
+						drawPixel(destP, (byte)*lineP);
+						if (enlarge) {
+							drawPixel(destP + SCREEN_WIDTH, (byte)*lineP);
+							drawPixel(destP + 1, (byte)*lineP);
+							drawPixel(destP + 1 + SCREEN_WIDTH, (byte)*lineP);
+						}
+					}
+
+					++xp;
+					++destP;
+					if (enlarge) {
+						++destP;
+						++xp;
+					}
+				}
+			}
+
+			++destPos.y;
+			if (enlarge)
+				++destPos.y;
+		}
+	}
+
+	if (drawBounds.isValidRect()) {
+		drawBounds.clip(Common::Rect(0, 0, dest.w, dest.h));
+		if (!drawBounds.isEmpty())
+			dest.addDirtyRect(drawBounds);
+	}
+}
+
+uint SpriteDrawer::getScaledVal(int xy, uint16 &scaleMask) {
+	if (!xy)
+		return 0;
+
+	uint result = 0;
+	for (int idx = 0; idx < xy; ++idx) {
+		uint bit = (scaleMask >> 15) & 1;
+		scaleMask = ((scaleMask & 0x7fff) << 1) + bit;
+		result += bit;
+	}
+
+	return result;
+}
+
+void SpriteDrawer::drawPixel(byte *dest, byte pixel) {
+	*dest = pixel;
+}
+
+void SpriteDrawer::rcr(uint16 &val, bool &cf) {
+	bool newCf = (val & 1);
+	val = (val >> 1) | (cf ? 0x8000 : 0);
+	cf = newCf;
+}
+
+/*------------------------------------------------------------------------*/
+
+static const byte DRAWER1_OFFSET[24] = {
+	0x30, 0xC0, 0xB0, 0x10, 0x41, 0x20, 0x40, 0x21, 0x48, 0x46, 0x43, 0x40,
+	0xD0, 0xD3, 0xD6, 0xD8, 0x01, 0x04, 0x07, 0x0A, 0xEA, 0xEE, 0xF2, 0xF6
+};
+
+static const byte DRAWER1_MASK[24] = {
+	0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x07, 0x07, 0x0F, 0x07, 0x07, 0x07, 0x07,
+	0x07, 0x07, 0x07, 0x07, 0x0F, 0x0F, 0x0F, 0x0F, 0x07, 0x07, 0x07, 0x07
+};
+
+SpriteDrawer1::SpriteDrawer1(byte *data, size_t filesize, int index) : SpriteDrawer(data, filesize) {
+	_offset = DRAWER1_OFFSET[index];
+	_mask = DRAWER1_MASK[index];
+}
+
+void SpriteDrawer1::drawPixel(byte *dest, byte pixel) {
+	*dest = (pixel & _mask) + _offset;
+}
+
+/*------------------------------------------------------------------------*/
+
+static const byte DRAWER2_MASK1[32] = {
+	3, 0, 3, 0, 3, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0,
+	1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+static const byte DRAWER2_MASK2[16] = {
+	0x7E, 0x7E, 0x7E, 0x7E, 0x3E, 0x3E, 0x3E, 0x3E,
+	0x1E, 0x1E, 0x1E, 0x1E, 0x0E, 0x0E, 0x0E, 0x0E
+};
+
+static const int8 DRAWER2_DELTA[64] = {
+	-3, 3, 0, 0, 0, 0, 0, 0,
+	-5, 5, 0, 0, 0, 0, 0, 0,
+	-7, 7, 0, 0, 0, 0, 0, 0,
+	-9, 9, 0, 0, 0, 0, 0, 0,
+	-7, 7, 0, 0, 0, 0, 0, 0,
+	-9, 9, 0, 0, 0, 0, 0, 0,
+	-11, 11, 0, 0, 0, 0, 0, 0,
+	-13, 13, 0, 0, 0, 0, 0, 0
+};
+
+SpriteDrawer2::SpriteDrawer2(byte *data, size_t filesize, int index) : SpriteDrawer(data, filesize) {
+	_mask1 = DRAWER2_MASK1[index];
+	_mask2 = DRAWER2_MASK2[index];
+
+	MM::MMEngine *engine = static_cast<MM::MMEngine *>(g_engine);
+	_random1 = engine->getRandomNumber(0xffff);
+	_random2 = engine->getRandomNumber(0xffff);
+}
+
+void SpriteDrawer2::drawPixel(byte *dest, byte pixel) {
+	bool flag = (_random1 & 0x8000) != 0;
+	_random1 = (int)((uint16)_random1 << 1) - _random2 - (flag ? 1 : 0);
+
+	rcr(_random2, flag);
+	rcr(_random2, flag);
+	_random2 ^= _random1;
+
+	dest += DRAWER2_DELTA[(_random2 & _mask1 & _mask2) / 2];
+	if (dest >= _destLeft && dest < _destRight) {
+		dest += _pitch * DRAWER2_DELTA[((_random2 >> 8) &_mask1 &_mask2) / 2];
+
+		if (dest >= _destTop && dest < _destBottom) {
+			*dest = pixel;
+		}
+	}
+}
+
+/*------------------------------------------------------------------------*/
+
+static const uint16 DRAWER3_MASK[4] = { 1, 3, 7, 15 };
+static const uint16 DRAWER3_OFFSET[4] = { 1, 2, 4, 8 };
+
+SpriteDrawer3::SpriteDrawer3(byte *data, size_t filesize, int index) : SpriteDrawer(data, filesize) {
+	_offset = DRAWER3_OFFSET[index];
+	_mask = DRAWER3_MASK[index];
+
+	g_system->getPaletteManager()->grabPalette(_palette, 0, PALETTE_COUNT);
+	_hasPalette = false;
+	for (byte *pal = _palette; pal < _palette + PALETTE_SIZE && !_hasPalette; ++pal)
+		_hasPalette = *pal != 0;
+}
+
+void SpriteDrawer3::drawPixel(byte *dest, byte pixel) {
+	// WORKAROUND: This is slightly different then the original:
+	// 1) The original has bunches of black pixels appearing. This does index increments to avoid such pixels
+	// 2) It also prevents any pixels being drawn in the single initial frame until the palette is set
+	if (_hasPalette) {
+		byte level = (pixel & _mask) - _offset + (*dest & 0xf);
+
+		if (level >= 0x80) {
+			*dest &= 0xf0;
+		} else if (level <= 0xf) {
+			*dest = (*dest & 0xf0) | level;
+		} else {
+			*dest |= 0xf;
+		}
+
+		//
+		while (*dest < 0xff && !_palette[*dest * 3] && !_palette[*dest * 3 + 1] && !_palette[*dest * 3 + 2])
+			++ *dest;
+	}
+}
+
+/*------------------------------------------------------------------------*/
+
+static const byte DRAWER4_THRESHOLD[4] = { 4, 7, 10, 13 };
+
+SpriteDrawer4::SpriteDrawer4(byte *data, size_t filesize, int index) : SpriteDrawer(data, filesize) {
+	_threshold = DRAWER4_THRESHOLD[index];
+}
+
+void SpriteDrawer4::drawPixel(byte *dest, byte pixel) {
+	if ((pixel & 0xf) >= _threshold)
+		*dest = pixel;
+}
+
+/*------------------------------------------------------------------------*/
+
+static const uint16 DRAWER5_THRESHOLD[4] = { 0x3333, 0x6666, 0x999A, 0xCCCD };
+
+SpriteDrawer5::SpriteDrawer5(byte *data, size_t filesize, int index) : SpriteDrawer(data, filesize) {
+	_threshold = DRAWER5_THRESHOLD[index];
+
+	MM::MMEngine *engine = static_cast<MM::MMEngine *>(g_engine);
+	_random1 = engine->getRandomNumber(0xffff);
+	_random2 = engine->getRandomNumber(0xffff);
+}
+
+void SpriteDrawer5::drawPixel(byte *dest, byte pixel) {
+	bool flag = (_random1 & 0x8000) != 0;
+	_random1 = (int)((uint16)_random1 << 1) - _random2 - (flag ? 1 : 0);
+
+	rcr(_random2, flag);
+	rcr(_random2, flag);
+	_random2 ^= _random1;
+
+	if (_random2 > _threshold)
+		*dest = pixel;
+}
+
+/*------------------------------------------------------------------------*/
+
+static const byte DRAWER6_MASK[16] = { 1, 2, 4, 8, 1, 3, 7, 15, 8, 12, 14, 15, 1, 2, 1, 2 };
+
+SpriteDrawer6::SpriteDrawer6(byte *data, size_t filesize, int index) : SpriteDrawer(data, filesize) {
+	_mask = DRAWER6_MASK[index];
+}
+
+void SpriteDrawer6::drawPixel(byte *dest, byte pixel) {
+	*dest = pixel ^ _mask;
+}
+
+} // End of namespace Xeen
+} // End of namespace Shared
+} // End of namespace MM