Removed automake stuff from "inert" subdirs. And there was much rejoicing.
[btb/d2x.git] / video / dos_gr.c
1 /*
2  * $Source: /cvs/cvsroot/d2x/video/dos_gr.c,v $
3  * $Revision: 1.2 $
4  * $Author: bradleyb $
5  * $Date: 2001-01-29 13:47:51 $
6  *
7  * Graphics functions for DOS.
8  *
9  * $Log: not supported by cvs2svn $
10  */
11
12 #ifdef HAVE_CONFIG_H
13 #include <conf.h>
14 #endif
15
16 #include <stdio.h>
17 #include <string.h>
18 #include <io.h>
19 #include <dos.h>
20 #include <dpmi.h>
21 #include "gr.h"
22 #include "grdef.h"
23 #include "palette.h"
24 #include "maths.h"
25 #include "u_mem.h"
26 #include "u_dpmi.h"
27 #include "vesa.h"
28 #include "modex.h"
29 #include "error.h"
30
31 #ifdef __DJGPP__
32 #include <sys/nearptr.h>
33 #endif
34
35 static int last_r=0, last_g=0, last_b=0;
36
37 /* old gr.c stuff */
38 unsigned char * gr_video_memory = (unsigned char *)0xa0000;
39
40 char gr_pal_default[768];
41
42 int gr_installed = 0;
43
44 volatile ubyte * pVideoMode =  (volatile ubyte *)0x449;
45 volatile ushort * pNumColumns = (volatile ushort *)0x44a;
46 volatile ubyte * pNumRows = (volatile ubyte *)0x484;
47 volatile ushort * pCharHeight = (volatile ushort *)0x485;
48 volatile ushort * pCursorPos = (volatile ushort *)0x450;
49 volatile ushort * pCursorType = (volatile ushort *)0x460;
50 volatile ushort * pTextMemory = (volatile ushort *)0xb8000;
51
52 typedef struct screen_save {
53         ubyte   video_mode;
54         ubyte   is_graphics;
55         ushort  char_height;
56         ubyte           width;
57         ubyte           height;
58         ubyte           cursor_x, cursor_y;
59         ubyte           cursor_sline, cursor_eline;
60         ushort * video_memory;
61 } screen_save;
62
63 screen_save gr_saved_screen;
64
65 int gr_show_screen_info = 0;
66 extern int VGA_current_mode;
67
68 void gr_set_cellheight( ubyte height )
69 {
70         ubyte temp;
71
72    outp( 0x3d4, 9 );
73         temp = inp( 0x3d5 );
74    temp &= 0xE0;
75         temp |= height;
76         outp( 0x3d5, temp );
77 }
78
79 void gr_set_linear()
80 {
81         outpw( 0x3c4, 0xE04 );            // enable chain4 mode
82         outpw( 0x3d4, 0x4014 );           // turn on dword mode
83         outpw( 0x3d4, 0xa317 );           // turn off byte mode
84 }
85
86 void gr_16_to_256()
87 {
88         outpw( 0x3ce, 0x4005 );         // set Shift reg to 1
89
90         inp( 0x3da );                                   // dummy input
91
92         outp( 0x3c0, 0x30 );
93         outp( 0x3c0, 0x61 );               // turns on PCS & PCC
94
95         inp( 0x3da );                                   // dummy input
96
97         outp( 0x3c0, 0x33 );
98         outp( 0x3c0, 0 );
99 }
100
101 void gr_turn_screen_off()
102 {
103         ubyte temp;
104         temp = inp( 0x3da );
105         outp( 0x3c0, 0 );
106 }
107
108 void gr_turn_screen_on()
109 {
110         ubyte temp;
111         temp = inp( 0x3da );
112         outp( 0x3c0, 0x20 );
113 }
114
115 void gr_set_misc_mode( uint mode )
116 {
117         union REGS regs;
118
119         memset( &regs, 0, sizeof(regs) );
120         regs.w.ax = mode;
121         int386( 0x10, &regs, &regs );
122
123 }
124
125 void gr_set_3dbios_mode( uint mode )
126 {
127         union REGS regs;
128         memset( &regs, 0, sizeof(regs) );
129         regs.w.ax = 0x4fd0;
130         regs.w.bx = 0x3d00 | (mode & 0xff);
131         int386( 0x10, &regs, &regs );
132 }
133
134
135
136 void gr_set_text_25()
137 {
138         union REGS regs;
139
140         regs.w.ax = 3;
141         int386( 0x10, &regs, &regs );
142
143 }
144
145 void gr_set_text_43()
146 {
147         union REGS regs;
148
149         regs.w.ax = 0x1201;
150         regs.w.bx = 0x30;
151         int386( 0x10, &regs, &regs );
152
153         regs.w.ax = 3;
154         int386( 0x10, &regs, &regs );
155
156         regs.w.ax = 0x1112;
157         regs.w.bx = 0x0;
158         int386( 0x10, &regs, &regs );
159 }
160
161 void gr_set_text_50()
162 {
163         union REGS regs;
164
165         regs.w.ax = 0x1202;
166         regs.w.bx = 0x30;
167         int386( 0x10, &regs, &regs );
168
169         regs.w.ax = 3;
170         int386( 0x10, &regs, &regs );
171
172         regs.w.ax = 0x1112;
173         regs.w.bx = 0x0;
174         int386( 0x10, &regs, &regs );
175 }
176
177 ubyte is_graphics_mode()
178 {
179         byte tmp;
180         tmp = inp( 0x3DA );             // Reset flip-flip
181         outp( 0x3C0, 0x30 );            // Select attr register 10
182         tmp = inp( 0x3C1 );     // Get graphics/text bit
183         return tmp & 1;
184 }
185
186 void gr_setcursor(ubyte x, ubyte y, ubyte sline, ubyte eline)
187 {
188         union REGS regs;
189
190         memset( &regs, 0, sizeof(regs) );
191         regs.w.ax = 0x0200;
192         regs.w.bx = 0;
193         regs.h.dh = y;
194         regs.h.dl = x;
195         int386( 0x10, &regs, &regs );
196
197         memset( &regs, 0, sizeof(regs) );
198         regs.w.ax = 0x0100;
199         regs.h.ch = sline & 0xf;
200         regs.h.cl = eline & 0xf;
201         int386( 0x10, &regs, &regs );
202 }
203
204 void gr_getcursor(ubyte *x, ubyte *y, ubyte * sline, ubyte * eline)
205 {
206         union REGS regs;
207
208         memset( &regs, 0, sizeof(regs) );
209         regs.w.ax = 0x0300;
210         regs.w.bx = 0;
211         int386( 0x10, &regs, &regs );
212         *y = regs.h.dh;
213         *x = regs.h.dl;
214         *sline = regs.h.ch;
215         *eline = regs.h.cl;
216 }
217
218
219 int gr_save_mode()
220 {
221         int i;
222
223         gr_saved_screen.is_graphics = is_graphics_mode();
224         gr_saved_screen.video_mode = *pVideoMode;
225         
226         if (!gr_saved_screen.is_graphics)       {
227                 gr_saved_screen.width = *pNumColumns;
228                 gr_saved_screen.height = *pNumRows+1;
229                 gr_saved_screen.char_height = *pCharHeight;
230                 gr_getcursor(&gr_saved_screen.cursor_x, &gr_saved_screen.cursor_y, &gr_saved_screen.cursor_sline, &gr_saved_screen.cursor_eline );
231                 MALLOC(gr_saved_screen.video_memory,ushort, gr_saved_screen.width*gr_saved_screen.height );
232                 for (i=0; i < gr_saved_screen.width*gr_saved_screen.height; i++ )
233                         gr_saved_screen.video_memory[i] = pTextMemory[i];
234         }
235
236         if (gr_show_screen_info )       {
237                 printf( "Current video mode 0x%x:\n",  gr_saved_screen.video_mode );
238                 if (gr_saved_screen.is_graphics)
239                         printf( "Graphics mode\n" );
240                 else    {
241                         printf( "Text mode\n" );
242                         printf( "( %d columns by %d rows)\n", gr_saved_screen.width, gr_saved_screen.height );
243                         printf( "Char height is %d pixel rows\n", gr_saved_screen.char_height );
244                         printf( "Cursor of type 0x%x,0x%x is at (%d, %d)\n", gr_saved_screen.cursor_sline, gr_saved_screen.cursor_eline,gr_saved_screen.cursor_x, gr_saved_screen.cursor_y );
245                 }
246         }
247
248         return 0;
249 }
250
251 int isvga()
252 {
253         union REGS regs;
254
255         memset( &regs, 0, sizeof(regs) );
256         regs.w.ax = 0x1a00;
257         int386( 0x10, &regs, &regs );
258
259         if ( regs.h.al == 0x1a )
260                  return 1;
261
262         return 0;
263 }
264
265 void gr_restore_mode()
266 {
267         int i;
268
269         //gr_set_text_25(); 
270
271 #ifndef NOGRAPH
272         gr_palette_fade_out( gr_palette, 32, 0 );
273         gr_palette_set_gamma(0);
274         if ( gr_saved_screen.video_mode == 3 )  {
275                 switch( gr_saved_screen.height )          {
276                 case 43:        gr_set_text_43(); break;
277                 case 50:        gr_set_text_50(); break;
278                 default:        gr_set_text_25(); break;
279                 }
280         } else {
281                 gr_set_misc_mode(gr_saved_screen.video_mode);   
282         }
283         if (gr_saved_screen.is_graphics==0)     {
284                 gr_sync_display();
285                 gr_sync_display();
286                 gr_palette_read( gr_pal_default );
287                 gr_palette_clear();
288                 for (i=0; i < gr_saved_screen.width*gr_saved_screen.height; i++ )
289                         pTextMemory[i]=gr_saved_screen.video_memory[i];
290                 gr_setcursor( gr_saved_screen.cursor_x, gr_saved_screen.cursor_y, gr_saved_screen.cursor_sline, gr_saved_screen.cursor_eline );
291                 gr_palette_faded_out = 1;
292                 gr_palette_fade_in( gr_pal_default, 32, 0 );
293         }
294 #endif
295
296 }
297
298 void gr_close()
299 {
300         if (gr_installed==1)
301         {
302                 gr_installed = 0;
303                 gr_restore_mode();
304                 free(grd_curscreen);
305                 if( gr_saved_screen.video_memory ) {
306                         free(gr_saved_screen.video_memory);
307                         gr_saved_screen.video_memory = NULL;
308                 }
309         }
310 }
311
312 #ifndef __DJGPP__
313 int gr_vesa_setmode( int mode )
314 {
315         int retcode;
316
317         retcode=gr_vesa_checkmode( mode );
318         if ( retcode ) return retcode;
319
320         return gr_vesa_setmodea( mode );
321 }
322 #endif
323
324
325 int gr_set_mode(u_int32_t mode)
326 {
327         int retcode;
328         unsigned int w,h,t,data, r;
329
330         //JOHNgr_disable_default_palette_loading();
331 #ifdef NOGRAPH
332 return 0;
333 #endif
334         switch(mode)
335         {
336         case SM_ORIGINAL:
337                 return 0;
338         case SM(320,200)://0:
339                 if (!isvga()) return 1;
340                 gr_set_misc_mode(0x13);
341                 w = 320; r = 320; h = 200; t=BM_LINEAR; data = (int)gr_video_memory;
342                 break;
343         case SM(640,400)://SM_640x400V:
344                 retcode = gr_vesa_setmode( 0x100 ); 
345                 if (retcode !=0 ) return retcode;
346                 w = 640; r = 640; h = 400; t=BM_SVGA; data = 0;
347                 break;
348         case SM(640,480)://SM_640x480V:
349                 retcode = gr_vesa_setmode( 0x101 ); 
350                 if (retcode !=0 ) return retcode;
351                 w = 640; r = 640; h = 480; t=BM_SVGA; data = 0;
352                 break;
353         case SM(800,600)://SM_800x600V:
354                 retcode = gr_vesa_setmode( 0x103 ); 
355                 if (retcode !=0 ) return retcode;
356                 w = 800; r = 800; h = 600; t=BM_SVGA; data = 0;
357                 break;
358         case SM(1024,768)://SM_1024x768V:
359                 retcode = gr_vesa_setmode( 0x105 ); 
360                 if (retcode !=0 ) return retcode;
361                 w = 1024; r = 1024; h = 768; t=BM_SVGA; data = 0;
362                 break;
363 /*      case SM_640x480V15:
364                 retcode = gr_vesa_setmode( 0x110 ); 
365                 if (retcode !=0 ) return retcode;
366                 w = 640; r = 640*2; h=480; t=BM_SVGA15; data = 0;
367                 break;
368         case SM_800x600V15:
369                 retcode = gr_vesa_setmode( 0x113 ); 
370                 if (retcode !=0 ) return retcode;
371                 w = 800; r = 800*2; h=600; t=BM_SVGA15; data = 0;
372                 break;*/
373 //      case 19:
374         case SM(320,100):
375                 if (!isvga()) return 1;
376                 gr_set_misc_mode(0x13); 
377 //              {
378 //                      ubyte x;
379 //                      x = inp( 0x3c5 );
380 //                      x |= 8;
381 //                      outp( 0x3c5, x );
382 //              }
383                 gr_set_cellheight( 3 );
384
385                 w = 320; r = 320; h = 100; t=BM_LINEAR; data = (int)gr_video_memory;
386                 break;
387 /*      case 20:
388                 retcode = gr_vesa_setmode( 0x102 ); 
389                 //gr_enable_default_palette_loading();
390                 if (retcode !=0 ) return retcode;
391                 gr_16_to_256();
392                 gr_set_linear();
393                 //gr_set_cellheight( 1 );
394                 gr_vesa_setlogical( 400 );
395                 w = 400; r = 400; h = 600; t=BM_SVGA; data = 0;
396                 break;
397         case 21:
398                 if (!isvga()) return 1;
399                 gr_set_misc_mode(0xd);  
400                 gr_16_to_256();
401                 gr_set_linear();
402                 gr_set_cellheight( 3 );
403                 w = 160; r = 160; h = 100; t=BM_LINEAR; data = (int)gr_video_memory;
404                 break;
405         case //22:                      // 3dmax 320x400
406                 if (!isvga()) return 1;
407                 gr_set_3dbios_mode(0x31);
408                 //w = 320; r = 320/4; h = 400; t=BM_MODEX; data = 0;
409                 w = 320; r = 320; h = 400; t=BM_SVGA; data = 0;
410                 break;*/
411         default:
412                 if (!isvga()) return 1;
413                 if (mode==SM(320,240))
414                         w = gr_modex_setmode( 2 );
415                 else if (mode==SM(320,400))
416                         w = gr_modex_setmode( 6 );
417                 else
418                         Error("unhandled vid mode\n");
419                 //gr_enable_default_palette_loading();
420                 h = w & 0xffff; w = w >> 16; r = w / 4;t = BM_MODEX; data = 0;
421                 break;
422         }
423         gr_palette_clear();
424
425         memset( grd_curscreen, 0, sizeof(grs_screen));
426         grd_curscreen->sc_mode = mode;
427         grd_curscreen->sc_w = w;
428         grd_curscreen->sc_h = h;
429         grd_curscreen->sc_aspect = fixdiv(grd_curscreen->sc_w*3,grd_curscreen->sc_h*4);
430         grd_curscreen->sc_canvas.cv_bitmap.bm_x = 0;
431         grd_curscreen->sc_canvas.cv_bitmap.bm_y = 0;
432         grd_curscreen->sc_canvas.cv_bitmap.bm_w = w;
433         grd_curscreen->sc_canvas.cv_bitmap.bm_h = h;
434         grd_curscreen->sc_canvas.cv_bitmap.bm_rowsize = r;
435         grd_curscreen->sc_canvas.cv_bitmap.bm_type = t;
436         grd_curscreen->sc_canvas.cv_bitmap.bm_data = (unsigned char *)data;
437         VGA_current_mode = mode;
438         gr_set_current_canvas(NULL);
439
440         //gr_enable_default_palette_loading();
441 //        gamefont_choose_game_font(w,h);
442
443         return 0;
444 }
445
446 int gr_init(void)
447 {
448         int org_gamma;
449         int retcode;
450         int mode = SM(320,200);
451
452         // Only do this function once!
453         if (gr_installed==1)
454                 return 3;
455
456 #ifdef __DJGPP__
457         if (!__djgpp_nearptr_enable()) {
458                 printf("nearptr enable=%x\n", __dpmi_error);
459                 return 10;
460         }
461 #ifndef SAVEGR
462         gr_video_memory = (unsigned char *)(__djgpp_conventional_base + 0xa0000);
463 #else
464         gr_video_memory=(unsigned char *)-1;
465 #endif
466         pVideoMode =  (volatile ubyte *)(__djgpp_conventional_base+0x449);
467         pNumColumns = (volatile ushort *)(__djgpp_conventional_base+0x44a);
468         pNumRows = (volatile ubyte *)(__djgpp_conventional_base+0x484);
469         pCharHeight = (volatile ushort *)(__djgpp_conventional_base+0x485);
470         pCursorPos = (volatile ushort *)(__djgpp_conventional_base+0x450);
471         pCursorType = (volatile ushort *)(__djgpp_conventional_base+0x460);
472         pTextMemory = (volatile ushort *)(__djgpp_conventional_base+0xb8000);
473 #endif
474 #ifndef __DJGPP__
475         if (gr_init_A0000())
476                 return 10;
477 #endif
478
479         // Save the current text screen mode
480         if (gr_save_mode()==1)
481                 return 2;
482
483 #ifndef NOGRAPH
484         // Save the current palette, and fade it out to black.
485         gr_palette_read( gr_pal_default );
486         gr_palette_faded_out = 0;
487         org_gamma = gr_palette_get_gamma();
488         gr_palette_set_gamma( 0 );
489         gr_palette_fade_out( gr_pal_default, 32, 0 );
490         gr_palette_clear();
491         gr_palette_set_gamma( org_gamma );
492         gr_sync_display();
493         gr_sync_display();
494 #endif
495
496 #ifdef __DJGPP__
497 #ifdef SAVEGR
498         __djgpp_nearptr_disable();
499 #endif
500 #endif
501
502         MALLOC( grd_curscreen,grs_screen,1 );
503         memset( grd_curscreen, 0, sizeof(grs_screen));
504
505         // Set the mode.
506         if ((retcode=gr_set_mode(mode)))
507         {
508                 gr_restore_mode();
509                 return retcode;
510         }
511         //JOHNgr_disable_default_palette_loading();
512
513         // Set all the screen, canvas, and bitmap variables that
514         // aren't set by the gr_set_mode call:
515         grd_curscreen->sc_canvas.cv_color = 0;
516         grd_curscreen->sc_canvas.cv_drawmode = 0;
517         grd_curscreen->sc_canvas.cv_font = NULL;
518         grd_curscreen->sc_canvas.cv_font_fg_color = 0;
519         grd_curscreen->sc_canvas.cv_font_bg_color = 0;
520         gr_set_current_canvas( &grd_curscreen->sc_canvas );
521
522 #if 0
523         if (!dpmi_allocate_selector( &gr_fade_table, 256*GR_FADE_LEVELS, &gr_fade_table_selector ))
524                 Error( "Error allocating fade table selector!" );
525
526         if (!dpmi_allocate_selector( &gr_palette, 256*3, &gr_palette_selector ))
527                 Error( "Error allocating palette selector!" );
528 #endif
529
530 //      if (!dpmi_allocate_selector( &gr_inverse_table, 32*32*32, &gr_inverse_table_selector ))
531 //              Error( "Error allocating inverse table selector!" );
532
533
534         // Set flags indicating that this is installed.
535         gr_installed = 1;
536 #ifdef __GNUC__
537
538         atexit((void (*)) gr_close);
539 #else
540         atexit(gr_close);
541 #endif
542         return 0;
543 }
544
545 int gr_mode13_checkmode()
546 {
547         if (isvga()) 
548                 return 0;
549         else
550                 return 1;
551 }
552
553 //  0=Mode set OK
554 //  1=No VGA adapter installed
555 //  2=Program doesn't support this VESA granularity
556 //  3=Monitor doesn't support that VESA mode.:
557 //  4=Video card doesn't support that VESA mode.
558 //  5=No VESA driver found.
559 //  6=Bad Status after VESA call/
560 //  7=Not enough DOS memory to call VESA functions.
561 //  8=Error using DPMI.
562 //  9=Error setting logical line width.
563 // 10=Error allocating selector for A0000h
564 // 11=Not a valid mode support by gr.lib
565
566 int gr_check_mode(u_int32_t mode)
567 {
568         switch(mode)
569         {
570         case SM(320,100)://19:
571         case SM(320,200):
572         case SM(320,240):
573         case SM(360,200):
574         case SM(360,240):
575         case SM(376,282):
576         case SM(320,400):
577         case SM(320,480):
578         case SM(360,400):
579         case SM(360,480):
580         case SM(360,360):
581         case SM(376,308):
582         case SM(376,564):               return gr_mode13_checkmode();
583         case SM(640,400):               return gr_vesa_checkmode( 0x100 ); 
584         case SM(640,480):       return gr_vesa_checkmode( 0x101 ); 
585         case SM(800,600):       return gr_vesa_checkmode( 0x103 ); 
586         case SM(1024,768):      return gr_vesa_setmode( 0x105 ); 
587 //      case SM_640x480V15:     return gr_vesa_setmode( 0x110 ); 
588 //      case SM_800x600V15:     return gr_vesa_setmode( 0x113 ); 
589         }
590         return 11;
591 }
592
593 /* Palette Stuff Starts Here... */
594
595 void gr_palette_step_up( int r, int g, int b )
596 {
597         int i;
598         ubyte *p;
599         int temp;
600
601         if (gr_palette_faded_out) return;
602
603         if ( (r==last_r) && (g==last_g) && (b==last_b) ) return;
604
605         last_r = r; last_g = g; last_b = b;
606
607         outp( 0x3c6, 0xff );
608         outp( 0x3c8, 0 );
609         p=gr_palette;
610
611         for (i=0; i<256; i++ )  {
612                 temp = (int)(*p++) + r + gr_palette_gamma;
613                 if (temp<0) temp=0;
614                 else if (temp>63) temp=63;
615                 outp( 0x3c9, temp );
616                 temp = (int)(*p++) + g + gr_palette_gamma;
617                 if (temp<0) temp=0;
618                 else if (temp>63) temp=63;
619                 outp( 0x3c9, temp );
620                 temp = (int)(*p++) + b + gr_palette_gamma;
621                 if (temp<0) temp=0;
622                 else if (temp>63) temp=63;
623                 outp( 0x3c9, temp );
624         }
625 }
626
627
628 void gr_palette_clear()
629 {
630         int i;
631         outp( 0x3c6, 0xff );
632         outp( 0x3c8, 0 );
633         for (i=0; i<768; i++ )  {
634                 outp( 0x3c9, 0 );
635         }
636         gr_palette_faded_out = 1;
637 }
638
639 void gr_palette_load( ubyte * pal )
640 {
641         int i;
642         ubyte c;
643         outp( 0x3c6, 0xff );
644         outp( 0x3c8, 0 );
645         for (i=0; i<768; i++ )  {
646                 c = pal[i] + gr_palette_gamma;
647                 if ( c > 63 ) c = 63;
648                 outp( 0x3c9,c);
649                 gr_current_pal[i] = pal[i];
650         }
651         gr_palette_faded_out = 0;
652
653         init_computed_colors();
654 }
655
656
657 int gr_palette_fade_out(ubyte *pal, int nsteps, int allow_keys )
658 {
659         ubyte c;
660         int i,j;
661         fix fade_palette[768];
662         fix fade_palette_delta[768];
663
664         if (gr_palette_faded_out) return 0;
665
666         if (!pal)
667                 pal = gr_current_pal;
668
669         for (i=0; i<768; i++ )  {
670                 fade_palette[i] = i2f(pal[i]+gr_palette_gamma);
671                 fade_palette_delta[i] = fade_palette[i] / nsteps;
672         }
673
674         for (j=0; j<nsteps; j++ )       {
675                 gr_sync_display();
676                 outp( 0x3c6, 0xff );
677                 outp( 0x3c8, 0 );
678                 for (i=0; i<768; i++ )  {
679                         fade_palette[i] -= fade_palette_delta[i];
680                         if (fade_palette[i] < 0 )
681                                 fade_palette[i] = 0;
682                         c = f2i(fade_palette[i]);
683                         if ( c > 63 ) c = 63;
684                         outp( 0x3c9, c );
685                 }
686         }
687         gr_palette_faded_out = 1;
688         return 0;
689 }
690
691 int gr_palette_fade_in(ubyte *pal, int nsteps, int allow_keys)
692 {
693         int i,j;
694         ubyte c;
695         fix fade_palette[768];
696         fix fade_palette_delta[768];
697
698
699         if (!gr_palette_faded_out) return 0;
700
701         for (i=0; i<768; i++ )  {
702                 gr_current_pal[i] = pal[i];
703                 fade_palette[i] = 0;
704                 fade_palette_delta[i] = i2f(pal[i]+gr_palette_gamma) / nsteps;
705         }
706
707         for (j=0; j<nsteps; j++ )       {
708                 gr_sync_display();
709                 outp( 0x3c6, 0xff );
710                 outp( 0x3c8, 0 );
711                 for (i=0; i<768; i++ )  {
712                         fade_palette[i] += fade_palette_delta[i];
713                         if (fade_palette[i] > i2f(pal[i]+gr_palette_gamma) )
714                                 fade_palette[i] = i2f(pal[i]+gr_palette_gamma);
715                         c = f2i(fade_palette[i]);
716                         if ( c > 63 ) c = 63;
717                         outp( 0x3c9, c );
718                 }
719         }
720         gr_palette_faded_out = 0;
721         return 0;
722 }
723
724 void gr_palette_read(ubyte * palette)
725 {
726         int i;
727         outp( 0x3c6, 0xff );
728         outp( 0x3c7, 0 );
729         for (i=0; i<768; i++ )  {
730                 *palette++ = inp( 0x3c9 );
731         }
732 }
733
734 void gr_update(void)
735 { }