189 lines
6.2 KiB
C++
189 lines
6.2 KiB
C++
/* 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
|