gr_copy_palette not really a kludge, I think
[btb/d2x.git] / 2d / palette.c
1 /* $Id: palette.c,v 1.9 2003-06-10 07:31:38 btb 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  * Old Log:
19  * Revision 1.41  1995/02/02  14:26:31  john
20  * Made palette fades work better with gamma thingy..
21  *
22  * Revision 1.40  1994/12/08  19:03:46  john
23  * Made functions use cfile.
24  *
25  * Revision 1.39  1994/12/01  11:23:27  john
26  * Limited Gamma from 0-8.
27  *
28  * Revision 1.38  1994/11/28  01:31:08  mike
29  * optimize color lookup function, caching recently used colors.
30  *
31  * Revision 1.37  1994/11/18  22:50:18  john
32  * Changed shorts to ints in parameters.
33  *
34  * Revision 1.36  1994/11/15  17:54:59  john
35  * Made text palette fade in when game over.
36  *
37  * Revision 1.35  1994/11/10  19:53:14  matt
38  * Fixed error handling is gr_use_palette_table()
39  *
40  * Revision 1.34  1994/11/07  13:53:48  john
41  * Added better gamma stufff.
42  *
43  * Revision 1.33  1994/11/07  13:37:56  john
44  * Added gamma correction stuff.
45  *
46  * Revision 1.32  1994/11/05  13:20:14  john
47  * Fixed bug with find_closest_color_current not working.
48  *
49  * Revision 1.31  1994/11/05  13:08:09  john
50  * MAde it return 0 when palette already faded out.
51  *
52  * Revision 1.30  1994/11/05  13:05:34  john
53  * Added back in code to allow keys during fade.
54  *
55  * Revision 1.29  1994/11/05  12:49:50  john
56  * Fixed bug with previous comment..
57  *
58  * Revision 1.28  1994/11/05  12:48:46  john
59  * Made palette only fade in / out when its supposed to.
60  *
61  * Revision 1.27  1994/11/05  12:46:43  john
62  * Changed palette stuff a bit.
63  *
64  * Revision 1.26  1994/11/01  12:59:35  john
65  * Reduced palette.256 size.
66  *
67  * Revision 1.25  1994/10/26  23:55:35  john
68  * Took out roller; Took out inverse table.
69  *
70  * Revision 1.24  1994/10/04  22:03:05  matt
71  * Fixed bug: palette wasn't fading all the way out or in
72  *
73  * Revision 1.23  1994/09/22  16:08:40  john
74  * Fixed some palette stuff.
75  *
76  * Revision 1.22  1994/09/19  11:44:31  john
77  * Changed call to allocate selector to the dpmi module.
78  *
79  * Revision 1.21  1994/09/12  19:28:09  john
80  * Fixed bug with unclipped fonts clipping.
81  *
82  * Revision 1.20  1994/09/12  18:18:39  john
83  * Set 254 and 255 to fade to themselves in fadetable
84  *
85  * Revision 1.19  1994/09/12  14:40:10  john
86  * Neatend.
87  *
88  * Revision 1.18  1994/09/09  09:31:55  john
89  * Made find_closest_color not look at superx spot of 254
90  *
91  * Revision 1.17  1994/08/09  11:27:08  john
92  * Add cthru stuff.
93  *
94  * Revision 1.16  1994/08/01  11:03:51  john
95  * MAde it read in old/new palette.256
96  *
97  * Revision 1.15  1994/07/27  18:30:27  john
98  * Took away the blending table.
99  *
100  * Revision 1.14  1994/06/09  10:39:52  john
101  * In fade out.in functions, returned 1 if key was pressed...
102  *
103  * Revision 1.13  1994/05/31  19:04:16  john
104  * Added key to stop fade if desired.
105  *
106  * Revision 1.12  1994/05/06  12:50:20  john
107  * Added supertransparency; neatend things up; took out warnings.
108  *
109  * Revision 1.11  1994/05/03  19:39:02  john
110  * *** empty log message ***
111  *
112  * Revision 1.10  1994/04/22  11:16:07  john
113  * *** empty log message ***
114  *
115  * Revision 1.9  1994/04/08  16:59:40  john
116  * Add fading poly's; Made palette fade 32 instead of 16.
117  *
118  * Revision 1.8  1994/03/16  17:21:17  john
119  * Added slow palette searching options.
120  *
121  * Revision 1.7  1994/01/07  11:47:33  john
122  * made use cflib
123  *
124  * Revision 1.6  1993/12/21  11:41:04  john
125  * *** empty log message ***
126  *
127  * Revision 1.5  1993/12/09  15:02:47  john
128  * Changed palette stuff majorly
129  *
130  * Revision 1.4  1993/12/07  12:31:41  john
131  * moved bmd_palette to gr_palette
132  *
133  * Revision 1.3  1993/10/15  16:22:23  john
134  * *** empty log message ***
135  *
136  * Revision 1.2  1993/09/26  18:59:46  john
137  * fade stuff
138  *
139  * Revision 1.1  1993/09/08  11:44:03  john
140  * Initial revision
141  *
142  */
143
144 #ifdef HAVE_CONFIG_H
145 #include <conf.h>
146 #endif
147
148 #include <stdlib.h>
149 #include <stdio.h>
150
151 #include "pstypes.h"
152 #include "u_mem.h"
153 #include "gr.h"
154 #include "grdef.h"
155 #include "cfile.h"
156 #include "error.h"
157 #include "mono.h"
158 #include "fix.h"
159 //added/remove by dph on 1/9/99
160 //#include "key.h"
161 //end remove
162
163 #include "palette.h"
164
165 extern int gr_installed;
166
167 ubyte gr_palette[256*3];
168 ubyte gr_current_pal[256*3];
169 ubyte gr_fade_table[256*34];
170
171 ubyte gr_palette_gamma = 0;
172 int gr_palette_gamma_param = 0;
173 ubyte gr_palette_faded_out = 1;
174
175 int grd_fades_disabled=0;   // Used to skip fading for development
176
177 void gr_palette_set_gamma( int gamma )
178 {
179         if ( gamma < 0 ) gamma = 0;
180 //added/changed on 10/27/98 by Victor Rachels to increase brightness slider
181         if ( gamma > 16 ) gamma = 16;      //was 8
182 //end this section change - Victor Rachels
183
184         if (gr_palette_gamma_param != gamma )   {
185                 gr_palette_gamma_param = gamma;
186                 gr_palette_gamma = gamma;
187                 if (!gr_palette_faded_out)
188                         gr_palette_load( gr_palette );
189         }
190 }
191
192 int gr_palette_get_gamma()
193 {
194         return gr_palette_gamma_param;
195 }
196
197
198 void gr_copy_palette(ubyte *gr_palette, ubyte *pal, int size)
199 {
200                 memcpy(gr_palette, pal, size);
201
202                 Num_computed_colors = 0;
203 }
204
205
206 void gr_use_palette_table( char * filename )
207 {
208         CFILE *fp;
209         int i,fsize;
210 #ifdef SWAP_0_255
211         ubyte c;
212 #endif
213
214         fp = cfopen( filename, "rb" );
215
216         // the following is a hack to enable the loading of d2 levels
217         // even if only the d2 mac shareware datafiles are present.
218         // However, if the pig file is present but the palette file isn't,
219         // the textures in the level will look wierd...
220         if ( fp==NULL)
221                 fp = cfopen( DEFAULT_LEVEL_PALETTE, "rb" );
222         if ( fp==NULL)
223                 Error("Can open neither palette file <%s> "
224                       "nor default palette file <"
225                       DEFAULT_LEVEL_PALETTE
226                       ">.\n",
227                       filename);
228
229         fsize   = cfilelength( fp );
230         Assert( fsize == 9472 );
231         cfread( gr_palette, 256*3, 1, fp );
232         cfread( gr_fade_table, 256*34, 1, fp );
233         cfclose(fp);
234
235         // This is the TRANSPARENCY COLOR
236         for (i=0; i<GR_FADE_LEVELS; i++ )       {
237                 gr_fade_table[i*256+255] = 255;
238         }
239
240 // swap colors 0 and 255 of the palette along with fade table entries
241
242 #ifdef SWAP_0_255
243         for (i = 0; i < 3; i++) {
244                 c = gr_palette[i];
245                 gr_palette[i] = gr_palette[765+i];
246                 gr_palette[765+i] = c;
247         }
248
249         for (i = 0; i < GR_FADE_LEVELS * 256; i++) {
250                 if (gr_fade_table[i] == 0)
251                         gr_fade_table[i] = 255;
252         }
253         for (i=0; i<GR_FADE_LEVELS; i++)
254                 gr_fade_table[i*256] = TRANSPARENCY_COLOR;
255 #endif
256 }
257
258 #define SQUARE(x) ((x)*(x))
259
260 #define MAX_COMPUTED_COLORS     32
261
262 int     Num_computed_colors=0;
263
264 typedef struct {
265         ubyte   r,g,b,color_num;
266 } color_record;
267
268 color_record Computed_colors[MAX_COMPUTED_COLORS];
269
270 //      Add a computed color (by gr_find_closest_color) to list of computed colors in Computed_colors.
271 //      If list wasn't full already, increment Num_computed_colors.
272 //      If was full, replace a random one.
273 void add_computed_color(int r, int g, int b, int color_num)
274 {
275         int     add_index;
276
277         if (Num_computed_colors < MAX_COMPUTED_COLORS) {
278                 add_index = Num_computed_colors;
279                 Num_computed_colors++;
280         } else
281                 add_index = (d_rand() * MAX_COMPUTED_COLORS) >> 15;
282
283         Computed_colors[add_index].r = r;
284         Computed_colors[add_index].g = g;
285         Computed_colors[add_index].b = b;
286         Computed_colors[add_index].color_num = color_num;
287 }
288
289 void init_computed_colors(void)
290 {
291         int     i;
292
293         for (i=0; i<MAX_COMPUTED_COLORS; i++)
294                 Computed_colors[i].r = 255;             //      Make impossible to match.
295 }
296
297 int gr_find_closest_color( int r, int g, int b )
298 {
299         int i, j;
300         int best_value, best_index, value;
301
302         if (Num_computed_colors == 0)
303                 init_computed_colors();
304
305         //      If we've already computed this color, return it!
306         for (i=0; i<Num_computed_colors; i++)
307                 if (r == Computed_colors[i].r)
308                         if (g == Computed_colors[i].g)
309                                 if (b == Computed_colors[i].b) {
310                                         if (i > 4) {
311                                                 color_record    trec;
312                                                 trec = Computed_colors[i-1];
313                                                 Computed_colors[i-1] = Computed_colors[i];
314                                                 Computed_colors[i] = trec;
315                                                 return Computed_colors[i-1].color_num;
316                                         }
317                                         return Computed_colors[i].color_num;
318                                 }
319
320 //      r &= 63;
321 //      g &= 63;
322 //      b &= 63;
323
324         best_value = SQUARE(r-gr_palette[0])+SQUARE(g-gr_palette[1])+SQUARE(b-gr_palette[2]);
325         best_index = 0;
326         if (best_value==0) {
327                 add_computed_color(r, g, b, best_index);
328                 return best_index;
329         }
330         j=0;
331         // only go to 255, 'cause we dont want to check the transparent color.
332         for (i=1; i<254; i++ )  {
333                 j += 3;
334                 value = SQUARE(r-gr_palette[j])+SQUARE(g-gr_palette[j+1])+SQUARE(b-gr_palette[j+2]);
335                 if ( value < best_value )       {
336                         if (value==0) {
337                                 add_computed_color(r, g, b, i);
338                                 return i;
339                         }
340                         best_value = value;
341                         best_index = i;
342                 }
343         }
344         add_computed_color(r, g, b, best_index);
345         return best_index;
346 }
347
348 int gr_find_closest_color_15bpp( int rgb )
349 {
350         return gr_find_closest_color( ((rgb>>10)&31)*2, ((rgb>>5)&31)*2, (rgb&31)*2 );
351 }
352
353
354 int gr_find_closest_color_current( int r, int g, int b )
355 {
356         int i, j;
357         int best_value, best_index, value;
358
359 //      r &= 63;
360 //      g &= 63;
361 //      b &= 63;
362
363         best_value = SQUARE(r-gr_current_pal[0])+SQUARE(g-gr_current_pal[1])+SQUARE(b-gr_current_pal[2]);
364         best_index = 0;
365         if (best_value==0)
366                 return best_index;
367
368         j=0;
369         // only go to 255, 'cause we dont want to check the transparent color.
370         for (i=1; i<254; i++ )  {
371                 j += 3;
372                 value = SQUARE(r-gr_current_pal[j])+SQUARE(g-gr_current_pal[j+1])+SQUARE(b-gr_current_pal[j+2]);
373                 if ( value < best_value )       {
374                         if (value==0)
375                                 return i;
376                         best_value = value;
377                         best_index = i;
378                 }
379         }
380         return best_index;
381 }
382
383 void gr_make_cthru_table(ubyte * table, ubyte r, ubyte g, ubyte b )
384 {
385         int i;
386         ubyte r1, g1, b1;
387
388         for (i=0; i<256; i++ )  {
389                 r1 = gr_palette[i*3+0] + r;
390                 if ( r1 > 63 ) r1 = 63;
391                 g1 = gr_palette[i*3+1] + g;
392                 if ( g1 > 63 ) g1 = 63;
393                 b1 = gr_palette[i*3+2] + b;
394                 if ( b1 > 63 ) b1 = 63;
395                 table[i] = gr_find_closest_color( r1, g1, b1 );
396         }
397 }
398