/*
* Portions of this file are copyright Rebirth contributors and licensed as
* described in COPYING.txt.
* Portions of this file are copyright Parallax Software and licensed
* according to the Parallax license below.
* See COPYING.txt for license details.
THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
SOFTWARE CORPORATION ("PARALLAX"). PARALLAX, IN DISTRIBUTING THE CODE TO
END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
IN USING, DISPLAYING, AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
FREE PURPOSES. IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES. THE END-USER UNDERSTANDS
AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION. ALL RIGHTS RESERVED.
*/
/*
*
* Graphical routines for setting the palette
*
*/
#include <algorithm>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "physfsx.h"
#include "pstypes.h"
#include "u_mem.h"
#include "gr.h"
#include "grdef.h"
#include "dxxerror.h"
#include "maths.h"
#include "palette.h"
#include "dxxsconf.h"
#include "dsx-ns.h"
#include "compiler-range_for.h"
#include <array>
namespace dcx {
#define SQUARE(x) ((x)*(x))
#define MAX_COMPUTED_COLORS 32
static unsigned Num_computed_colors;
struct color_record {
ubyte r,g,b;
color_palette_index color_num;
};
static std::array<color_record, MAX_COMPUTED_COLORS> Computed_colors;
palette_array_t gr_palette;
palette_array_t gr_current_pal;
gft_array1 gr_fade_table;
ubyte gr_palette_gamma = 0;
int gr_palette_gamma_param = 0;
void copy_bound_palette(palette_array_t &d, const palette_array_t &s)
{
auto a = [](rgb_t c) {
const ubyte bound = 63;
c.r = std::min(c.r, bound);
c.g = std::min(c.g, bound);
c.b = std::min(c.b, bound);
return c;
};
std::transform(s.begin(), s.end(), d.begin(), a);
}
}
namespace dcx {
static void diminish_entry(rgb_t &c)
{
c.r >>= 2;
c.g >>= 2;
c.b >>= 2;
}
void diminish_palette(palette_array_t &palette)
{
range_for (rgb_t &c, palette)
diminish_entry(c);
}
void gr_palette_set_gamma( int gamma )
{
if ( gamma < 0 ) gamma = 0;
if ( gamma > 16 ) gamma = 16; //was 8
if (gr_palette_gamma_param != gamma ) {
gr_palette_gamma_param = gamma;
gr_palette_gamma = gamma;
gr_palette_load( gr_palette );
}
}
int gr_palette_get_gamma()
{
return gr_palette_gamma_param;
}
}
namespace dsx {
#if defined(DXX_BUILD_DESCENT_I)
void copy_diminish_palette(palette_array_t &palette, const uint8_t *p)
{
range_for (auto &i, palette)
{
i.r = *p++ >> 2;
i.g = *p++ >> 2;
i.b = *p++ >> 2;
}
}
#endif
#if defined(DXX_BUILD_DESCENT_II)
void gr_copy_palette(palette_array_t &gr_palette, const palette_array_t &pal)
{
gr_palette = pal;
Num_computed_colors = 0;
}
#endif
void gr_use_palette_table(const char * filename )
{
int fsize;
auto fp = PHYSFSX_openReadBuffered(filename);
#if defined(DXX_BUILD_DESCENT_I)
#define FAILURE_FORMAT "Can't open palette file <%s>"
#elif defined(DXX_BUILD_DESCENT_II)
#define FAILURE_FORMAT "Can open neither palette file <%s> nor default palette file <" DEFAULT_LEVEL_PALETTE ">"
// the following is a hack to enable the loading of d2 levels
// even if only the d2 mac shareware datafiles are present.
// However, if the pig file is present but the palette file isn't,
// the textures in the level will look wierd...
if (!fp)
fp = PHYSFSX_openReadBuffered( DEFAULT_LEVEL_PALETTE );
#endif
if (!fp)
Error(FAILURE_FORMAT,
filename);
fsize = PHYSFS_fileLength( fp );
Assert( fsize == 9472 );
(void)fsize;
PHYSFS_read( fp, &gr_palette[0], sizeof(gr_palette[0]), gr_palette.size() );
PHYSFS_read( fp, gr_fade_table, 256*34, 1 );
fp.reset();
// This is the TRANSPARENCY COLOR
range_for (auto &i, gr_fade_table)
i[255] = 255;
#if defined(DXX_BUILD_DESCENT_II)
Num_computed_colors = 0; // Flush palette cache.
// swap colors 0 and 255 of the palette along with fade table entries
#ifdef SWAP_0_255
for (i = 0; i < 3; i++) {
ubyte c;
c = gr_palette[i];
gr_palette[i] = gr_palette[765+i];
gr_palette[765+i] = c;
}
for (i = 0; i < GR_FADE_LEVELS * 256; i++) {
if (gr_fade_table[i] == 0)
gr_fade_table[i] = 255;
}
for (i=0; i<GR_FADE_LEVELS; i++)
gr_fade_table[i*256] = TRANSPARENCY_COLOR;
#endif
#endif
}
}
namespace dcx {
// Add a computed color (by gr_find_closest_color) to list of computed colors in Computed_colors.
// If list wasn't full already, increment Num_computed_colors.
// If was full, replace a random one.
static void add_computed_color(int r, int g, int b, color_t color_num)
{
int add_index;
if (Num_computed_colors < MAX_COMPUTED_COLORS) {
add_index = Num_computed_colors;
Num_computed_colors++;
} else
add_index = (d_rand() * MAX_COMPUTED_COLORS) >> 15;
Computed_colors[add_index].r = r;
Computed_colors[add_index].g = g;
Computed_colors[add_index].b = b;
Computed_colors[add_index].color_num = color_num;
}
void init_computed_colors(void)
{
range_for (auto &i, Computed_colors)
i.r = 255; // Make impossible to match.
}
color_palette_index gr_find_closest_color(const int r, const int g, const int b)
{
int j;
int best_value, value;
if (Num_computed_colors == 0)
init_computed_colors();
// If we've already computed this color, return it!
for (unsigned i=0; i<Num_computed_colors; i++)
{
auto &c = Computed_colors[i];
if (r == c.r && g == c.g && b == c.b)
{
const auto color_num = c.color_num;
if (i > 4) {
std::swap(Computed_colors[i-1], c);
}
return color_num;
}
}
// r &= 63;
// g &= 63;
// b &= 63;
best_value = SQUARE(r-gr_palette[0].r)+SQUARE(g-gr_palette[0].g)+SQUARE(b-gr_palette[0].b);
color_palette_index best_index = 0;
if (best_value==0) {
add_computed_color(r, g, b, best_index);
return best_index;
}
j=0;
// only go to 255, 'cause we dont want to check the transparent color.
for (color_palette_index i{1}; i < 254; ++i)
{
++j;
value = SQUARE(r-gr_palette[j].r)+SQUARE(g-gr_palette[j].g)+SQUARE(b-gr_palette[j].b);
if ( value < best_value ) {
if (value==0) {
add_computed_color(r, g, b, i);
return i;
}
best_value = value;
best_index = i;
}
}
add_computed_color(r, g, b, best_index);
return best_index;
}
color_palette_index gr_find_closest_color_15bpp( int rgb )
{
return gr_find_closest_color( ((rgb>>10)&31)*2, ((rgb>>5)&31)*2, (rgb&31)*2 );
}
color_palette_index gr_find_closest_color_current( int r, int g, int b )
{
int j;
int best_value, value;
// r &= 63;
// g &= 63;
// b &= 63;
best_value = SQUARE(r-gr_current_pal[0].r)+SQUARE(g-gr_current_pal[0].g)+SQUARE(b-gr_current_pal[0].b);
color_t best_index = 0;
if (best_value==0)
return best_index;
j=0;
// only go to 255, 'cause we dont want to check the transparent color.
for (color_t i=1; i < 254; i++ ) {
++j;
value = SQUARE(r-gr_current_pal[j].r)+SQUARE(g-gr_current_pal[j].g)+SQUARE(b-gr_current_pal[j].b);
if ( value < best_value ) {
if (value==0)
return i;
best_value = value;
best_index = i;
}
}
return best_index;
}
}