video/dos_gr.c

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