2d/palette.c

   1 /* $Id: palette.c,v 1.12 2004-08-28 23:17:45 schaffner Exp $ */
   2 /*
   3 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   4 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   5 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   6 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   7 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   8 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   9 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
  10 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  11 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  12 COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  13 */
  14
  15 /*
  16  * Graphical routines for setting the palette
  17  *
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include <conf.h>
  22 #endif
  23
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <string.h>
  27
  28 #include "pstypes.h"
  29 #include "u_mem.h"
  30 #include "gr.h"
  31 #include "grdef.h"
  32 #include "cfile.h"
  33 #include "error.h"
  34 #include "mono.h"
  35 #include "fix.h"
  36 //added/remove by dph on 1/9/99
  37 //#include "key.h"
  38 //end remove
  39
  40 #include "palette.h"
  41
  42 extern int gr_installed;
  43
  44 #define SQUARE(x) ((x)*(x))
  45
  46 #define MAX_COMPUTED_COLORS     32
  47
  48 int     Num_computed_colors=0;
  49
  50 typedef struct {
  51         ubyte   r,g,b,color_num;
  52 } color_record;
  53
  54 color_record Computed_colors[MAX_COMPUTED_COLORS];
  55
  56 ubyte gr_palette[256*3];
  57 ubyte gr_current_pal[256*3];
  58 ubyte gr_fade_table[256*34];
  59
  60 ubyte gr_palette_gamma = 0;
  61 int gr_palette_gamma_param = 0;
  62 ubyte gr_palette_faded_out = 1;
  63
  64 int grd_fades_disabled=0;   // Used to skip fading for development
  65
  66 void gr_palette_set_gamma( int gamma )
  67 {
  68         if ( gamma < 0 ) gamma = 0;
  69 //added/changed on 10/27/98 by Victor Rachels to increase brightness slider
  70         if ( gamma > 16 ) gamma = 16;      //was 8
  71 //end this section change - Victor Rachels
  72
  73         if (gr_palette_gamma_param != gamma )   {
  74                 gr_palette_gamma_param = gamma;
  75                 gr_palette_gamma = gamma;
  76                 if (!gr_palette_faded_out)
  77                         gr_palette_load( gr_palette );
  78         }
  79 }
  80
  81 int gr_palette_get_gamma()
  82 {
  83         return gr_palette_gamma_param;
  84 }
  85
  86
  87 void gr_copy_palette(ubyte *gr_palette, ubyte *pal, int size)
  88 {
  89                 memcpy(gr_palette, pal, size);
  90
  91                 Num_computed_colors = 0;
  92 }
  93
  94
  95 void gr_use_palette_table( char * filename )
  96 {
  97         CFILE *fp;
  98         int i,fsize;
  99 #ifdef SWAP_0_255
 100         ubyte c;
 101 #endif
 102
 103         fp = cfopen( filename, "rb" );
 104
 105         // the following is a hack to enable the loading of d2 levels
 106         // even if only the d2 mac shareware datafiles are present.
 107         // However, if the pig file is present but the palette file isn't,
 108         // the textures in the level will look wierd...
 109         if ( fp==NULL)
 110                 fp = cfopen( DEFAULT_LEVEL_PALETTE, "rb" );
 111         if ( fp==NULL)
 112                 Error("Can open neither palette file <%s> "
 113                       "nor default palette file <"
 114                       DEFAULT_LEVEL_PALETTE
 115                       ">.\n",
 116                       filename);
 117
 118         fsize   = cfilelength( fp );
 119         Assert( fsize == 9472 );
 120         cfread( gr_palette, 256*3, 1, fp );
 121         cfread( gr_fade_table, 256*34, 1, fp );
 122         cfclose(fp);
 123
 124         // This is the TRANSPARENCY COLOR
 125         for (i=0; i<GR_FADE_LEVELS; i++ )       {
 126                 gr_fade_table[i*256+255] = 255;
 127         }
 128
 129         Num_computed_colors = 0;        //      Flush palette cache.
 130 #if defined(POLY_ACC)
 131         pa_update_clut(gr_palette, 0, 256, 0);
 132 #endif
 133
 134 // swap colors 0 and 255 of the palette along with fade table entries
 135
 136 #ifdef SWAP_0_255
 137         for (i = 0; i < 3; i++) {
 138                 c = gr_palette[i];
 139                 gr_palette[i] = gr_palette[765+i];
 140                 gr_palette[765+i] = c;
 141         }
 142
 143         for (i = 0; i < GR_FADE_LEVELS * 256; i++) {
 144                 if (gr_fade_table[i] == 0)
 145                         gr_fade_table[i] = 255;
 146         }
 147         for (i=0; i<GR_FADE_LEVELS; i++)
 148                 gr_fade_table[i*256] = TRANSPARENCY_COLOR;
 149 #endif
 150 }
 151
 152 //      Add a computed color (by gr_find_closest_color) to list of computed colors in Computed_colors.
 153 //      If list wasn't full already, increment Num_computed_colors.
 154 //      If was full, replace a random one.
 155 void add_computed_color(int r, int g, int b, int color_num)
 156 {
 157         int     add_index;
 158
 159         if (Num_computed_colors < MAX_COMPUTED_COLORS) {
 160                 add_index = Num_computed_colors;
 161                 Num_computed_colors++;
 162         } else
 163                 add_index = (d_rand() * MAX_COMPUTED_COLORS) >> 15;
 164
 165         Computed_colors[add_index].r = r;
 166         Computed_colors[add_index].g = g;
 167         Computed_colors[add_index].b = b;
 168         Computed_colors[add_index].color_num = color_num;
 169 }
 170
 171 void init_computed_colors(void)
 172 {
 173         int     i;
 174
 175         for (i=0; i<MAX_COMPUTED_COLORS; i++)
 176                 Computed_colors[i].r = 255;             //      Make impossible to match.
 177 }
 178
 179 int gr_find_closest_color( int r, int g, int b )
 180 {
 181         int i, j;
 182         int best_value, best_index, value;
 183
 184         if (Num_computed_colors == 0)
 185                 init_computed_colors();
 186
 187         //      If we've already computed this color, return it!
 188         for (i=0; i<Num_computed_colors; i++)
 189                 if (r == Computed_colors[i].r)
 190                         if (g == Computed_colors[i].g)
 191                                 if (b == Computed_colors[i].b) {
 192                                         if (i > 4) {
 193                                                 color_record    trec;
 194                                                 trec = Computed_colors[i-1];
 195                                                 Computed_colors[i-1] = Computed_colors[i];
 196                                                 Computed_colors[i] = trec;
 197                                                 return Computed_colors[i-1].color_num;
 198                                         }
 199                                         return Computed_colors[i].color_num;
 200                                 }
 201
 202 //      r &= 63;
 203 //      g &= 63;
 204 //      b &= 63;
 205
 206         best_value = SQUARE(r-gr_palette[0])+SQUARE(g-gr_palette[1])+SQUARE(b-gr_palette[2]);
 207         best_index = 0;
 208         if (best_value==0) {
 209                 add_computed_color(r, g, b, best_index);
 210                 return best_index;
 211         }
 212         j=0;
 213         // only go to 255, 'cause we dont want to check the transparent color.
 214         for (i=1; i<254; i++ )  {
 215                 j += 3;
 216                 value = SQUARE(r-gr_palette[j])+SQUARE(g-gr_palette[j+1])+SQUARE(b-gr_palette[j+2]);
 217                 if ( value < best_value )       {
 218                         if (value==0) {
 219                                 add_computed_color(r, g, b, i);
 220                                 return i;
 221                         }
 222                         best_value = value;
 223                         best_index = i;
 224                 }
 225         }
 226         add_computed_color(r, g, b, best_index);
 227         return best_index;
 228 }
 229
 230 int gr_find_closest_color_15bpp( int rgb )
 231 {
 232         return gr_find_closest_color( ((rgb>>10)&31)*2, ((rgb>>5)&31)*2, (rgb&31)*2 );
 233 }
 234
 235
 236 int gr_find_closest_color_current( int r, int g, int b )
 237 {
 238         int i, j;
 239         int best_value, best_index, value;
 240
 241 //      r &= 63;
 242 //      g &= 63;
 243 //      b &= 63;
 244
 245         best_value = SQUARE(r-gr_current_pal[0])+SQUARE(g-gr_current_pal[1])+SQUARE(b-gr_current_pal[2]);
 246         best_index = 0;
 247         if (best_value==0)
 248                 return best_index;
 249
 250         j=0;
 251         // only go to 255, 'cause we dont want to check the transparent color.
 252         for (i=1; i<254; i++ )  {
 253                 j += 3;
 254                 value = SQUARE(r-gr_current_pal[j])+SQUARE(g-gr_current_pal[j+1])+SQUARE(b-gr_current_pal[j+2]);
 255                 if ( value < best_value )       {
 256                         if (value==0)
 257                                 return i;
 258                         best_value = value;
 259                         best_index = i;
 260                 }
 261         }
 262         return best_index;
 263 }
 264
 265 void gr_make_cthru_table(ubyte * table, ubyte r, ubyte g, ubyte b )
 266 {
 267         int i;
 268         ubyte r1, g1, b1;
 269
 270         for (i=0; i<256; i++ )  {
 271                 r1 = gr_palette[i*3+0] + r;
 272                 if ( r1 > 63 ) r1 = 63;
 273                 g1 = gr_palette[i*3+1] + g;
 274                 if ( g1 > 63 ) g1 = 63;
 275                 b1 = gr_palette[i*3+2] + b;
 276                 if ( b1 > 63 ) b1 = 63;
 277                 table[i] = gr_find_closest_color( r1, g1, b1 );
 278         }
 279 }
 280
 281 void gr_make_blend_table(ubyte *blend_table, ubyte r, ubyte g, ubyte b)
 282 {
 283         int i, j;
 284         float alpha;
 285         ubyte r1, g1, b1;
 286
 287         for (j = 0; j < GR_FADE_LEVELS; j++)
 288         {
 289                 alpha = 1.0 - (float)j / ((float)GR_FADE_LEVELS - 1);
 290                 for (i = 0; i < 255; i++)
 291                 {
 292                         r1 = (ubyte)((1.0 - alpha) * (float)gr_palette[i * 3 + 0] + (alpha * (float)r));
 293                         g1 = (ubyte)((1.0 - alpha) * (float)gr_palette[i * 3 + 1] + (alpha * (float)g));
 294                         b1 = (ubyte)((1.0 - alpha) * (float)gr_palette[i * 3 + 2] + (alpha * (float)b));
 295                         blend_table[i + j * 256] = gr_find_closest_color(r1, g1, b1);
 296                 }
 297                 blend_table[i + j * 256] = 255; // leave white alone
 298         }
 299 }