Initial commit

engines/m4/graphics/gr_pal.cpp

@@ -0,0 +1,188 @@
+/* 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 "graphics/paletteman.h"
+#include "common/textconsole.h"
+#include "m4/graphics/gr_pal.h"
+#include "m4/core/errors.h"
+#include "m4/vars.h"
+
+namespace M4 {
+
+byte EGAcolors[16] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
+
+uint8 gr_pal_get_ega_color(uint8 myColor) {
+	return EGAcolors[myColor];
+}
+
+
+uint8 *gr_color_createInverseTable(RGB8 *pal, uint8 bitDepth, int begin_color, int end_color) {
+	error("gr_color_createInverseTable is not implemented in ScummVM");
+}
+
+void gr_color_create_ipl5(uint8 *inverseColorTable, char *fname, int room_num) {
+	error("gr_color_create_ipl5 is not implemented in ScummVM");
+}
+
+uint8 *gr_color_load_ipl5(const char *filename, uint8 *inverseColors) {
+	error("gr_color_load_ipl5 is not implemented in ScummVM");
+}
+
+void gr_color_set(int32 c) {
+	_G(color) = c;
+}
+
+byte gr_color_get_current() {
+	return _G(color);
+}
+
+void gr_pal_clear(RGB8 *palette) {
+	for (int i = 0; i < 256; i++) {
+		palette[i].r = 0;
+		palette[i].g = 0;
+		palette[i].b = 0;
+	}
+
+	gr_pal_set(palette);
+}
+
+void gr_pal_set(RGB8 *pal) {
+	gr_pal_set_range(pal, 0, 256);
+}
+
+void gr_pal_set_RGB8(RGB8 *entry, int r, int g, int b) {
+	entry->r = (byte)r;
+	entry->g = (byte)g;
+	entry->b = (byte)b;
+}
+
+void gr_pal_set_range(RGB8 *pal, int first_color, int num_colors) {
+	g_system->getPaletteManager()->setPalette((const byte *)pal + first_color * 3,
+		first_color, num_colors);
+}
+
+void gr_pal_set_range(int first_color, int num_colors) {
+	gr_pal_set_range(_G(master_palette), first_color, num_colors);
+}
+
+void  gr_pal_set_entry(int32 index, RGB8 *entry) {
+	g_system->getPaletteManager()->setPalette((const byte *)entry, index, 1);
+}
+
+void gr_pal_clear_range(RGB8 *palette, int first_color, int last_color) {
+	for (int i = first_color; i <= last_color; i++) {
+		palette[i].r = 0;
+		palette[i].g = 0;
+		palette[i].b = 0;
+	}
+
+	gr_pal_set_range(palette, first_color, last_color - first_color);
+}
+
+uint8 gr_pal_find_best_match(RGB8 *pal, uint8 r, uint8 g, uint8 b) {
+	int index = 0;
+	uint32 minDist = 0x7fffffff;
+
+	for (int i = 0; i < 256; ++i) {
+		const int Rdiff = r - pal[i].r;
+		const int Gdiff = g - pal[i].g;
+		const int Bdiff = b - pal[i].b;
+		if (Rdiff * Rdiff + Gdiff * Gdiff + Bdiff * Bdiff < (int)minDist) {
+			minDist = Rdiff * Rdiff + Gdiff * Gdiff + Bdiff * Bdiff;
+			index = i;
+		}
+	}
+
+	return (uint8)index;
+}
+
+void gr_pal_interface(RGB8 *fixpal) {
+	if (_GI().set_interface_palette(fixpal))
+		return;
+
+	// Low intensity
+	gr_pal_set_RGB8(&fixpal[0], 0, 0, 0);		// r0 g0 b0		black
+	gr_pal_set_RGB8(&fixpal[1], 0, 0, 168);		// r0 g0 b2		blue
+	gr_pal_set_RGB8(&fixpal[2], 0, 168, 0);		// r0 g2 b0		green
+	gr_pal_set_RGB8(&fixpal[3], 0, 168, 168);	// r0 g2 b2		cyan
+
+	gr_pal_set_RGB8(&fixpal[4], 168, 0, 0);		// r2 g0 b0		red
+	gr_pal_set_RGB8(&fixpal[5], 168, 0, 168);	// r2 g0 b2		violet
+	gr_pal_set_RGB8(&fixpal[6], 168, 92, 0);	// r2 g1 b0		brown
+	gr_pal_set_RGB8(&fixpal[7], 168, 168, 168);	// r2 g2 b2		light grey
+
+	// high intensity
+	gr_pal_set_RGB8(&fixpal[8], 92, 92, 92);	// r1 g1 b1		dark grey
+	gr_pal_set_RGB8(&fixpal[9], 92, 92, 255);	// r1 g1 b2		light blue
+	gr_pal_set_RGB8(&fixpal[10], 92, 255, 92);	// r1 g2 b1		light green
+	gr_pal_set_RGB8(&fixpal[11], 92, 255, 255); // r1 g2 b2		light cyan
+
+	gr_pal_set_RGB8(&fixpal[12], 255, 92, 92);	// r2 g1 b1		light red
+	gr_pal_set_RGB8(&fixpal[13], 255, 92, 255);	// r2 g1 b2		pink
+	gr_pal_set_RGB8(&fixpal[14], 255, 255, 23);	// r2 g2 b1		yellow
+	gr_pal_set_RGB8(&fixpal[15], 255, 255, 255);// r1 g1 b1		white
+}
+
+void gr_pal_reset_ega_colors(RGB8 *pal) {
+	EGAcolors[0] = gr_pal_find_best_match(pal, 0, 0, 0);		//__BLACK
+	EGAcolors[1] = gr_pal_find_best_match(pal, 0, 0, 255);		//__BLUE
+	EGAcolors[2] = gr_pal_find_best_match(pal, 0, 255, 0);		//__GREEN
+	EGAcolors[3] = gr_pal_find_best_match(pal, 0, 255, 255);	//__CYAN
+	EGAcolors[4] = gr_pal_find_best_match(pal, 255, 0, 0);		//__RED
+	EGAcolors[5] = gr_pal_find_best_match(pal, 255, 0, 255);	//__VIOLET
+	EGAcolors[6] = gr_pal_find_best_match(pal, 168, 84, 84);	//__BROWN
+	EGAcolors[7] = gr_pal_find_best_match(pal, 168, 168, 168);	//__LTGRAY
+	EGAcolors[8] = gr_pal_find_best_match(pal, 84, 84, 84);		//__DKGRAY
+	EGAcolors[9] = gr_pal_find_best_match(pal, 0, 0, 127);		//__LTBLUE
+	EGAcolors[10] = gr_pal_find_best_match(pal, 0, 127, 0);		//__LTGREEN
+	EGAcolors[11] = gr_pal_find_best_match(pal, 0, 127, 127);	//__LTCYAN
+	EGAcolors[12] = gr_pal_find_best_match(pal, 84, 0, 0);		//__LTRED
+	EGAcolors[13] = gr_pal_find_best_match(pal, 84, 0, 0);		//__PINK
+	EGAcolors[14] = gr_pal_find_best_match(pal, 0, 84, 84);		//__YELLOW
+	EGAcolors[15] = gr_pal_find_best_match(pal, 255, 255, 255);	//__WHITE
+}
+
+void gr_backup_palette() {
+	Common::copy(_G(master_palette), _G(master_palette) + 256, _G(backup_palette));
+}
+
+void gr_restore_palette() {
+	Common::copy(_G(backup_palette), _G(backup_palette) + 256, _G(master_palette));
+}
+
+void pal_mirror_colours(int first_color, int last_color, RGB8 *pal) {
+	if (first_color < 0 || last_color > 255 || first_color > last_color)
+		error_show(FL, 'Burg', "pal_mirror_colours index error");
+
+	const int num_colors = last_color - first_color + 1;
+	for (int index = 0; index < num_colors; ++index) {
+		RGB8 *destP = pal + (last_color + num_colors - index);
+		RGB8 *srcP = pal + (first_color + index);
+		*destP = *srcP;
+	}
+}
+
+void pal_mirror_colours(int first_color, int last_color) {
+	pal_mirror_colours(first_color, last_color, _G(master_palette));
+}
+
+} // namespace M4