Initial commit

engines/dgds/game_palettes.cpp

@@ -0,0 +1,190 @@
+/* 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/system.h"
+#include "common/debug.h"
+#include "graphics/paletteman.h"
+
+#include "dgds/game_palettes.h"
+#include "dgds/includes.h"
+#include "dgds/resource.h"
+
+namespace Dgds {
+
+static const byte EGA_COLORS[16][3] = {
+	{ 0x00, 0x00, 0x00 }, { 0x00, 0x00, 0xAA }, { 0x00, 0xAA, 0x00 },
+	{ 0x00, 0xAA, 0xAA }, { 0xAA, 0x00, 0x00 }, { 0xAA, 0x00, 0xAA },
+	{ 0xAA, 0x55, 0x00 }, { 0xAA, 0xAA, 0xAA }, { 0x55, 0x55, 0x55 },
+	{ 0x55, 0x55, 0xFF }, { 0x55, 0xFF, 0x55 }, { 0x55, 0xFF, 0xFF },
+	{ 0xFF, 0x55, 0x55 }, { 0xFF, 0x55, 0xFF }, { 0xFF, 0xFF, 0x55 },
+	{ 0xFF, 0xFF, 0xFF },
+};
+
+DgdsPal::DgdsPal() : Palette(256) {
+}
+
+GamePalettes::GamePalettes(ResourceManager *resourceMan, Decompressor *decompressor) : _curPalNum(0),
+_resourceMan(resourceMan), _decompressor(decompressor) {
+}
+
+void GamePalettes::reset() {
+	_palettes.resize(1);
+	selectPalNum(0);
+}
+
+int GamePalettes::loadPalette(const Common::String &filename) {
+	Common::SeekableReadStream *fileStream = _resourceMan->getResource(filename);
+	if (!fileStream) {
+		// Happens in the Amiga version of Dragon and CDS scripts
+		warning("Couldn't load palette resource %s", filename.c_str());
+		return _curPalNum;
+	}
+
+	_palettes.resize(_palettes.size() + 1);
+
+	DgdsPal &pal = _palettes.back();
+
+	DgdsChunkReader chunk(fileStream);
+	while (chunk.readNextHeader(EX_PAL, filename)) {
+		chunk.readContent(_decompressor);
+		Common::SeekableReadStream *chunkStream = chunk.getContent();
+		if (chunk.isSection(ID_PAL)) {
+			assert(chunk.isContainer());
+		} else if (chunk.isSection(ID_VGA)) {
+			if (chunk.getSize() != 768)
+				error("VGA palette in %s should be 768 bytes long, got %d", filename.c_str(), chunk.getSize());
+			for (uint k = 0; k < 256; k++) {
+				byte r = chunkStream->readByte() << 2;
+				byte g = chunkStream->readByte() << 2;
+				byte b = chunkStream->readByte() << 2;
+				pal.set(k, r, g, b);
+			}
+			break;
+		} else if (chunk.isSection(ID_EGA)) {
+			if (chunk.getSize() > 20) {
+				// Dragon style EGA palette
+				for (uint k = 0; k < chunk.getSize() / 2; k++) {
+					byte egaCol = (chunkStream->readUint16LE() & 0xF);
+					byte r = EGA_COLORS[egaCol][0];
+					byte g = EGA_COLORS[egaCol][1];
+					byte b = EGA_COLORS[egaCol][2];
+					pal.set(k, r, g, b);
+				}
+			} else {
+				// HoC style EGA palette
+				for (uint k = 0; k < MIN(chunk.getSize(), (uint32)16); k++) {
+					byte egaCol = (chunkStream->readByte());
+					// For some reason bit 5 means bit 4 as
+					// offset into the palette
+					if (egaCol & 0x10)
+						egaCol -= 8;
+					byte r = EGA_COLORS[egaCol % 16][0];
+					byte g = EGA_COLORS[egaCol % 16][1];
+					byte b = EGA_COLORS[egaCol % 16][2];
+					pal.set(k, r, g, b);
+				}
+			}
+			break;
+		} else if (chunk.isSection(ID_CGA)) {
+			debug(1, "Skipping CGA palette data");
+		} else {
+			error("Unknown Palette chunk in %s: %s size %d", filename.c_str(), chunk.getIdStr(), chunk.getSize());
+		}
+	}
+	pal.setName(filename);
+
+	delete fileStream;
+	selectPalNum(_palettes.size() - 1);
+
+	return _palettes.size() - 1;
+}
+
+void GamePalettes::selectPalNum(int num) {
+	_curPalNum = num;
+	setPalette();
+}
+
+void GamePalettes::setPalette() {
+	if (_curPalNum >= _palettes.size())
+		error("request to set pal %d but only have %d pals", _curPalNum, _palettes.size());
+
+	_curPal = _palettes[_curPalNum];
+	g_system->getPaletteManager()->setPalette(_curPal.data(), 0, 256);
+}
+
+void GamePalettes::clearPalette() {
+	_curPal = DgdsPal();
+	g_system->getPaletteManager()->setPalette(_curPal.data(), 0, 256);
+}
+
+void GamePalettes::setFade(int col, int ncols, int targetcol, int fade) {
+	if (_curPalNum >= _palettes.size())
+		error("GamePalettes::setFade: invalid curPalNum %d, only have %d pals", _curPalNum, _palettes.size());
+
+	if (col + ncols > 256)
+		error("GamePalettes::setFade: request to fade past the end of the palette");
+
+	const DgdsPal &pal = _palettes[_curPalNum];
+
+	byte r2, b2, g2;
+	pal.get(targetcol, r2, g2, b2);
+
+	for (int c = col; c < col + ncols; c++) {
+		byte r, g, b;
+		pal.get(c, r, g, b);
+
+		_curPal.set(c,
+			(r2 * fade + r * (255 - fade)) / 255,
+			(g2 * fade + g * (255 - fade)) / 255,
+			(b2 * fade + b * (255 - fade)) / 255);
+	}
+	g_system->getPaletteManager()->setPalette(_curPal.data(), 0, 256);
+}
+
+Common::Error GamePalettes::syncState(Common::Serializer &s) {
+	s.syncAsUint16LE(_curPalNum);
+	uint npals = _palettes.size();
+	s.syncAsUint16LE(npals);
+
+	if (s.isLoading()) {
+		if (npals > 100)
+			error("Too many palettes to load, save is probably corrupt");
+		for (uint i = 0; i < npals; i++) {
+			Common::String name;
+			s.syncString(name);
+			loadPalette(name);
+		}
+		if (_curPalNum >= _palettes.size())
+			error("Current palette number %d greater than available palettes %d",
+					_curPalNum, _palettes.size());
+
+		setPalette();
+	} else {
+		for (uint i = 0; i < npals; i++) {
+			Common::String name = _palettes[i].getName();
+			s.syncString(name);
+		}
+	}
+
+	return Common::kNoError;
+}
+
+} // end namespace Dgds