improved automake config. make dist, VPATH builds, ...
[btb/d2x.git] / unused / vga / palette.c
1 /*
2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.  
11 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
12 */
13
14 char palette_rcsid[] = "$Id: palette.c,v 1.1.1.1 2001-01-19 03:30:15 bradleyb Exp $";
15
16 #include <conio.h>
17 #include <stdlib.h>
18 #include <stdio.h>
19 #include <io.h>
20 #include <string.h>
21
22 #include "pa_enabl.h"                   //$$POLY_ACC
23 #include "types.h"
24 #include "mem.h"
25 #include "gr.h"
26 #include "grdef.h"
27 #include "cfile.h"
28 #include "error.h"
29 #include "mono.h"
30 #include "fix.h"
31 #include "key.h"
32
33 #if defined(POLY_ACC)
34 #include "poly_acc.h"
35 #endif
36
37 extern int gr_installed;
38
39 #define SQUARE(x) ((x)*(x))
40
41 #define MAX_COMPUTED_COLORS     32
42
43 int     Num_computed_colors=0;
44
45 typedef struct {
46         ubyte   r,g,b,color_num;
47 } color_record;
48
49 color_record Computed_colors[MAX_COMPUTED_COLORS];
50
51 ubyte gr_palette[256*3];
52 ubyte gr_current_pal[256*3];
53 ubyte gr_fade_table[256*34];
54
55 // ushort gr_palette_selector;
56 // ushort gr_fade_table_selector;
57
58 ubyte gr_palette_gamma = 0;
59 int gr_palette_gamma_param = 0;
60 ubyte gr_palette_faded_out = 1;
61
62 //to speed up development
63 int grd_fades_disabled=0;
64
65 void gr_palette_set_gamma( int gamma )
66 {
67         if ( gamma < 0 ) gamma = 0;
68         if ( gamma > 8 ) gamma = 8;
69
70         if (gr_palette_gamma_param != gamma )   {
71                 gr_palette_gamma_param = gamma;
72                 gr_palette_gamma = gamma;
73                 if (!gr_palette_faded_out)
74                         gr_palette_load( gr_palette );
75         }       
76 }
77
78 int gr_palette_get_gamma()
79 {
80         return gr_palette_gamma_param;
81 }
82
83
84 void gr_copy_palette(ubyte *gr_palette, ubyte *pal, int size)
85 {
86         memcpy(gr_palette, pal, size);
87
88         Num_computed_colors = 0;
89 }
90
91 void gr_use_palette_table( char * filename )
92 {
93         CFILE *fp;
94         int i,fsize;
95
96         fp = cfopen( filename, "rb" );
97         if ( fp==NULL)
98                 Error("Can't open palette file <%s>",filename);
99
100         fsize   = cfilelength( fp );
101         if ( fsize != 9472)
102                 Error("Palette file <%s> is wrong size",filename);
103         cfread( gr_palette, 256*3, 1, fp );
104         cfread( gr_fade_table, 256*34, 1, fp );
105         cfclose(fp);
106
107         // This is the TRANSPARENCY COLOR
108         for (i=0; i<GR_FADE_LEVELS; i++ )       {
109                 gr_fade_table[i*256+255] = 255;
110         }
111
112         Num_computed_colors = 0;        //      Flush palette cache.
113 #if defined(POLY_ACC)
114     pa_update_clut(gr_palette, 0, 256, 0);
115 #endif
116 }
117
118 //      Add a computed color (by gr_find_closest_color) to list of computed colors in Computed_colors.
119 //      If list wasn't full already, increment Num_computed_colors.
120 //      If was full, replace a random one.
121 void add_computed_color(int r, int g, int b, int color_num)
122 {
123         int     add_index;
124
125         if (Num_computed_colors < MAX_COMPUTED_COLORS) {
126                 add_index = Num_computed_colors;
127                 Num_computed_colors++;
128         } else
129                 add_index = (rand() * MAX_COMPUTED_COLORS) >> 15;
130
131         Computed_colors[add_index].r = r;
132         Computed_colors[add_index].g = g;
133         Computed_colors[add_index].b = b;
134         Computed_colors[add_index].color_num = color_num;
135 }
136
137 void init_computed_colors(void)
138 {
139         int     i;
140
141         for (i=0; i<MAX_COMPUTED_COLORS; i++)
142                 Computed_colors[i].r = 255;             //      Make impossible to match.
143 }
144
145 int gr_find_closest_color( int r, int g, int b )
146 {
147         int i, j;
148         int best_value, best_index, value;
149
150         if (Num_computed_colors == 0)
151                 init_computed_colors();
152
153         //      If we've already computed this color, return it!
154         for (i=0; i<Num_computed_colors; i++)
155                 if (r == Computed_colors[i].r)
156                         if (g == Computed_colors[i].g)
157                                 if (b == Computed_colors[i].b) {
158                                         if (i > 4) {
159                                                 color_record    trec;
160                                                 trec = Computed_colors[i-1];
161                                                 Computed_colors[i-1] = Computed_colors[i];
162                                                 Computed_colors[i] = trec;
163                                                 return Computed_colors[i-1].color_num;
164                                         }
165                                         return Computed_colors[i].color_num;
166                                 }
167
168 //      r &= 63;
169 //      g &= 63;
170 //      b &= 63;
171
172         best_value = SQUARE(r-gr_palette[0])+SQUARE(g-gr_palette[1])+SQUARE(b-gr_palette[2]);
173         best_index = 0;
174         if (best_value==0) {
175                 add_computed_color(r, g, b, best_index);
176                 return best_index;
177         }
178         j=0;
179         // only go to 255, 'cause we dont want to check the transparent color.
180         for (i=1; i<254; i++ )  {
181                 j += 3;
182                 value = SQUARE(r-gr_palette[j])+SQUARE(g-gr_palette[j+1])+SQUARE(b-gr_palette[j+2]);
183                 if ( value < best_value )       {
184                         if (value==0) {
185                                 add_computed_color(r, g, b, i);
186                                 return i;
187                         }
188                         best_value = value;
189                         best_index = i;
190                 }
191         }
192         add_computed_color(r, g, b, best_index);
193         return best_index;
194 }
195
196 int gr_find_closest_color_15bpp( int rgb )
197 {
198         return gr_find_closest_color( ((rgb>>10)&31)*2, ((rgb>>5)&31)*2, (rgb&31)*2 );
199 }
200
201
202 int gr_find_closest_color_current( int r, int g, int b )
203 {
204         int i, j;
205         int best_value, best_index, value;
206
207 //      r &= 63;
208 //      g &= 63;
209 //      b &= 63;
210
211         best_value = SQUARE(r-gr_current_pal[0])+SQUARE(g-gr_current_pal[1])+SQUARE(b-gr_current_pal[2]);
212         best_index = 0;
213         if (best_value==0)
214                 return best_index;
215
216         j=0;
217         // only go to 255, 'cause we dont want to check the transparent color.
218         for (i=1; i<254; i++ )  {
219                 j += 3;
220                 value = SQUARE(r-gr_current_pal[j])+SQUARE(g-gr_current_pal[j+1])+SQUARE(b-gr_current_pal[j+2]);
221                 if ( value < best_value )       {
222                         if (value==0)
223                                 return i;
224                         best_value = value;
225                         best_index = i;
226                 }
227         }
228         return best_index;
229 }
230
231
232 static int last_r=0, last_g=0, last_b=0;
233
234 void gr_palette_step_up( int r, int g, int b )
235 {
236         int i;
237         ubyte *p;
238         int temp;
239
240         if (gr_palette_faded_out) return;
241
242 #if !defined(POLY_ACC)      // need this called always.
243         if ( (r==last_r) && (g==last_g) && (b==last_b) ) return;
244 #endif
245
246         last_r = r;
247         last_g = g;
248         last_b = b;
249 #if defined(POLY_ACC)
250     if ( (r==0) && (g==0) && (b==0) ) return;
251          PA_DFX (pa_set_backbuffer_current());  
252     pa_step_up(r, g, b);
253     return; //POLY_ACC
254 #endif
255
256         outp( 0x3c6, 0xff );
257         outp( 0x3c8, 0 );
258         p=gr_palette;
259         for (i=0; i<256; i++ )  {
260                 temp = (int)(*p++) + r + gr_palette_gamma;
261                 if (temp<0) temp=0;
262                 else if (temp>63) temp=63;
263                 outp( 0x3c9, temp );
264                 temp = (int)(*p++) + g + gr_palette_gamma;
265                 if (temp<0) temp=0;
266                 else if (temp>63) temp=63;
267                 outp( 0x3c9, temp );
268                 temp = (int)(*p++) + b + gr_palette_gamma;
269                 if (temp<0) temp=0;
270                 else if (temp>63) temp=63;
271                 outp( 0x3c9, temp );
272         }
273 }
274
275 // This steps up all gun values, leaving black and white to always be black and white.
276 void gr_palette_step_up_vr( int r, int g, int b, int white_index, int black_index )
277 {
278         int i;
279         ubyte *p;
280         int temp;
281
282         if (gr_palette_faded_out) return;
283
284         if ( (r==last_r) && (g==last_g) && (b==last_b) ) return;
285
286         last_r = r;
287         last_g = g;
288         last_b = b;
289 #if defined(POLY_ACC)
290     return; //POLY_ACC
291 #endif
292
293         outp( 0x3c6, 0xff );
294         outp( 0x3c8, 0 );
295         p=gr_palette;
296         for (i=0; i<256; i++ )  {
297                 temp = (int)(*p++) + r + gr_palette_gamma;
298                 if (temp<0) temp=0;
299                 else if (temp>63) temp=63;
300                 if ( i==white_index )   temp = 63;
301                 else if ( i==black_index ) temp = 0;
302                 outp( 0x3c9, temp );
303                 temp = (int)(*p++) + g + gr_palette_gamma;
304                 if (temp<0) temp=0;
305                 else if (temp>63) temp=63;
306                 if ( i==white_index )   temp = 63;
307                 else if ( i==black_index ) temp = 0;
308                 outp( 0x3c9, temp );
309                 temp = (int)(*p++) + b + gr_palette_gamma;
310                 if (temp<0) temp=0;
311                 else if (temp>63) temp=63;
312                 if ( i==white_index )   temp = 63;
313                 else if ( i==black_index ) temp = 0;
314                 outp( 0x3c9, temp );
315         }
316 }
317
318
319 void gr_palette_clear()
320 {
321         int i;
322 #if !defined(POLY_ACC)
323         outp( 0x3c6, 0xff );
324         outp( 0x3c8, 0 );
325         for (i=0; i<768; i++ )  {
326                 outp( 0x3c9, 0 );
327         }
328 #endif
329         gr_palette_faded_out = 1;
330 }
331
332 void gr_palette_load( ubyte * pal )     
333 {
334         int i;
335         ubyte c;
336 #if !defined(POLY_ACC)
337         outp( 0x3c6, 0xff );
338         outp( 0x3c8, 0 );
339         for (i=0; i<768; i++ )  {
340                 c = pal[i] + gr_palette_gamma;
341                 if ( c > 63 ) c = 63;
342                 outp( 0x3c9,c);
343                 gr_current_pal[i] = pal[i];
344         }
345 #else
346         for (i=0; i<768; i++ )  {
347         c = pal[i] + gr_palette_gamma;
348         if ( c > 63 ) c = 63;
349         gr_current_pal[i] = c;
350         }
351         pa_update_clut(gr_current_pal, 0, 256, 0);
352 #endif
353         gr_palette_faded_out = 0;
354
355 //      init_computed_colors();
356 }
357
358 extern void gr_sync_display(void);
359
360 int gr_palette_fade_out(ubyte *pal, int nsteps, int allow_keys )        
361 {
362         ubyte c;
363         int i,j;
364         fix fade_palette[768];
365         fix fade_palette_delta[768];
366
367         allow_keys  = allow_keys;
368
369         if (gr_palette_faded_out) return 0;
370
371         #ifndef NDEBUG
372         if (grd_fades_disabled) {
373                 gr_palette_clear();
374                 return 0;
375         }
376         #endif
377
378 #if defined(POLY_ACC)
379         return 0;
380 #endif
381
382         for (i=0; i<768; i++ )  {
383                 fade_palette[i] = i2f(pal[i]+gr_palette_gamma);
384                 fade_palette_delta[i] = fade_palette[i] / nsteps;
385         }
386
387         for (j=0; j<nsteps; j++ )       {
388                 gr_sync_display();
389                 outp( 0x3c6, 0xff );
390                 outp( 0x3c8, 0 );
391                 for (i=0; i<768; i++ )  {               
392                         fade_palette[i] -= fade_palette_delta[i];
393                         if (fade_palette[i] < 0 )
394                                 fade_palette[i] = 0;
395                         c = f2i(fade_palette[i]);
396                         if ( c > 63 ) c = 63;
397                         outp( 0x3c9, c );                                                               
398                 }
399         }
400         gr_palette_faded_out = 1;
401         return 0;
402 }
403
404 int gr_palette_fade_in(ubyte *pal, int nsteps, int allow_keys)  
405 {
406         int i,j;
407         ubyte c;
408         fix fade_palette[768];
409         fix fade_palette_delta[768];
410
411         allow_keys  = allow_keys;
412
413         if (!gr_palette_faded_out) return 0;
414
415         #ifndef NDEBUG
416         if (grd_fades_disabled) {
417                 gr_palette_load(pal);
418                 return 0;
419         }
420         #endif
421
422 #if defined(POLY_ACC)
423         gr_palette_load(pal);
424                 return 0;
425 #endif
426
427         for (i=0; i<768; i++ )  {
428                 gr_current_pal[i] = pal[i];
429                 fade_palette[i] = 0;
430                 fade_palette_delta[i] = i2f(pal[i]+gr_palette_gamma) / nsteps;
431         }
432
433         for (j=0; j<nsteps; j++ )       {
434                 gr_sync_display();
435                 outp( 0x3c6, 0xff );
436                 outp( 0x3c8, 0 );
437                 for (i=0; i<768; i++ )  {               
438                         fade_palette[i] += fade_palette_delta[i];
439                         if (fade_palette[i] > i2f(pal[i]+gr_palette_gamma) )
440                                 fade_palette[i] = i2f(pal[i]+gr_palette_gamma);
441                         c = f2i(fade_palette[i]);
442                         if ( c > 63 ) c = 63;
443                         outp( 0x3c9, c );                                                               
444                 }
445         }
446         gr_palette_faded_out = 0;
447         return 0;
448 }
449
450 void gr_make_cthru_table(ubyte * table, ubyte r, ubyte g, ubyte b )
451 {
452         int i;
453         ubyte r1, g1, b1;
454
455         for (i=0; i<256; i++ )  {
456                 r1 = gr_palette[i*3+0] + r;
457                 if ( r1 > 63 ) r1 = 63;
458                 g1 = gr_palette[i*3+1] + g;
459                 if ( g1 > 63 ) g1 = 63;
460                 b1 = gr_palette[i*3+2] + b;
461                 if ( b1 > 63 ) b1 = 63;
462                 table[i] = gr_find_closest_color( r1, g1, b1 );
463         }
464 }
465
466 void gr_palette_read(ubyte * palette)
467 {
468         int i;
469
470 #if defined(POLY_ACC)
471     for(i = 0; i != 256; ++i)
472     {
473         *palette++ = (pa_clut[i] >> 9) & 0x3E;
474         *palette++ = (pa_clut[i] >> 4) & 0x3E;
475         *palette++ = (pa_clut[i] << 1) & 0x3E;
476     }
477 #else
478         outp( 0x3c6, 0xff );
479         outp( 0x3c7, 0 );
480         for (i=0; i<768; i++ )  {
481                 *palette++ = inp( 0x3c9 );
482         }
483 #endif
484
485 }
486