src/lib/modex16.c

   1 /* Project 16 Source Code~\r
   2  * Copyright (C) 2012-2016 sparky4 & pngwen & andrius4669\r
   3  *\r
   4  * This file is part of Project 16.\r
   5  *\r
   6  * Project 16 is free software; you can redistribute it and/or modify\r
   7  * it under the terms of the GNU General Public License as published by\r
   8  * the Free Software Foundation; either verson 3 of the License, or\r
   9  * (at your option) any later version.\r
  10  *\r
  11  * Project 16 is distributed in the hope that it will be useful,\r
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  14  * GNU General Public License for more details.\r
  15  *\r
  16  * You should have received a copy of the GNU General Public License\r
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>, or\r
  18  * write to the Free Software Foundation, Inc., 51 Franklin Street,\r
  19  * Fifth Floor, Boston, MA 02110-1301 USA.\r
  20  *\r
  21  */\r
  22 \r
  23 #include <conio.h>\r
  24 #include <stdio.h>\r
  25 #include <stdlib.h>\r
  26 #include "src/lib/modex16.h"\r
  27 \r
  28 byte far* VGA=(byte far*) 0xA0000000;   /* this points to video memory. */\r
  29 \r
  30 static void fadePalette(sbyte fade, sbyte start, word iter, byte *palette);\r
  31 static byte tmppal[PAL_SIZE];\r
  32 \r
  33 /////////////////////////////////////////////////////////////////////////////\r
  34 //                                                                                                                                                                                                                                              //\r
  35 // setvideo() - This function Manages the video modes                                                                                           //\r
  36 //                                                                                                                                                                                                                                              //\r
  37 /////////////////////////////////////////////////////////////////////////////\r
  38 void VGAmodeX(sword vq, boolean cmem, global_game_variables_t *gv)\r
  39 {\r
  40         union REGS in, out;\r
  41 \r
  42         switch (vq)\r
  43         {\r
  44                 case 0: // deinit the video\r
  45                         // change to the video mode we were in before we switched to mode 13h\r
  46                         modexLeave();\r
  47                         in.h.ah = 0x00;\r
  48                         in.h.al = gv->video.old_mode;\r
  49                         int86(0x10, &in, &out);\r
  50                 break;\r
  51                 default: // init the video\r
  52                         // get old video mode\r
  53                         //in.h.ah = 0xf;\r
  54                         //int86(0x10, &in, &out);\r
  55                         gv->video.old_mode = vgaGetMode();//out.h.al;\r
  56                         // enter mode\r
  57                         modexEnter(vq, cmem, gv);\r
  58                 break;\r
  59         }\r
  60 }\r
  61 \r
  62 static void\r
  63 vgaSetMode(byte mode)\r
  64 {\r
  65   int10_setmode(mode);\r
  66 }\r
  67 \r
  68 //---------------------------------------------------\r
  69 //\r
  70 // Use the bios to get the current video mode\r
  71 //\r
  72 \r
  73 byte/*FIXME: why long? "long" is 32-bit datatype, VGA modes are 8-bit numbers. */\r
  74 vgaGetMode()\r
  75 {\r
  76     return int10_getmode();\r
  77 }\r
  78 \r
  79 /* -========================= Entry  Points ==========================- */\r
  80 void modexEnter(sword vq, boolean cmem, global_game_variables_t *gv)\r
  81 {\r
  82         word i;\r
  83         struct vga_mode_params cm;\r
  84         int CRTParmCount;\r
  85 \r
  86         vgaSetMode(VGA_256_COLOR_MODE);\r
  87         vga_enable_256color_modex();\r
  88         /* reprogram the CRT controller */\r
  89 //      outp(CRTC_INDEX, 0x11); /* VSync End reg contains register write prot */\r
  90 //      outp(CRTC_DATA, 0x7f);  /* get current write protect on varios regs */\r
  91         update_state_from_vga();\r
  92         vga_read_crtc_mode(&cm);\r
  93 \r
  94         switch(vq)\r
  95         {\r
  96                 case 1:\r
  97                         //CRTParmCount = sizeof(ModeX_320x240regs) / sizeof(ModeX_320x240regs[0]);\r
  98                         /*for(i=0; i<CRTParmCount; i++) {\r
  99                                 outpw(CRTC_INDEX, ModeX_320x240regs[i]);\r
 100                         }*/\r
 101                         /* width and height */\r
 102                         gv->video.page[0].sw = vga_state.vga_width = 320; // VGA lib currently does not update this\r
 103                         gv->video.page[0].sh = vga_state.vga_height = 240; // VGA lib currently does not update this\r
 104                         /* virtual width and height. match screen, at first */\r
 105                         gv->video.page[0].height = gv->video.page[0].sh;\r
 106                         gv->video.page[0].width = gv->video.page[0].sw;\r
 107 \r
 108                         // mode X BYTE mode\r
 109                         cm.word_mode = 0;\r
 110                         cm.dword_mode = 0;\r
 111                         // 320x240 mode 60Hz\r
 112                         cm.horizontal_total=0x5f + 5; /* CRTC[0]             -5 */\r
 113                         cm.horizontal_display_end=0x4f + 1; /* CRTC[1]       -1 */\r
 114                         cm.horizontal_blank_start=0x50 + 1; /* CRTC[2] */\r
 115                         cm.horizontal_blank_end=0x82 + 1;   /* CRTC[3] bit 0-4 & CRTC[5] bit 7 */\r
 116                         cm.horizontal_start_retrace=0x54;/* CRTC[4] */\r
 117                         cm.horizontal_end_retrace=0x80; /* CRTC[5] bit 0-4 */\r
 118                         //cm.horizontal_start_delay_after_total=0x3e; /* CRTC[3] bit 5-6 */\r
 119                         //cm.horizontal_start_delay_after_retrace=0x41; /* CRTC[5] bit 5-6 */\r
 120                         cm.vertical_total = 0x20D + 2;\r
 121                         cm.vertical_start_retrace = 0x1EA;\r
 122                         cm.vertical_end_retrace = 0x1EC;\r
 123                         cm.vertical_display_end = 480;\r
 124                         cm.vertical_blank_start = 0x1E7 + 1;\r
 125                         cm.vertical_blank_end = 0x206 + 1;\r
 126                         cm.clock_select = 1; /* misc register = 0xE3  25MHz */\r
 127                         cm.vsync_neg = 1;\r
 128                         cm.hsync_neg = 1;\r
 129                         cm.offset = (vga_state.vga_width / (4 * 2)); // 320 wide (40 x 4 pixel groups x 2)\r
 130                         break;\r
 131                 case 2: // TODO: 160x120 according to ModeX_160x120regs\r
 132                         return;\r
 133                 case 3: // TODO: 160x120 according to ModeX_320x200regs\r
 134                         return;\r
 135                 case 4: // TODO: 160x120 according to ModeX_192x144regs\r
 136                         return;\r
 137                 case 5: // TODO: 160x120 according to ModeX_256x192regs\r
 138                         return;\r
 139                 default:\r
 140                         return;\r
 141         }\r
 142 \r
 143         vga_state.vga_stride = cm.offset * 2;\r
 144         vga_write_crtc_mode(&cm,0);\r
 145 \r
 146         /* clear video memory */\r
 147         switch (cmem)\r
 148         {\r
 149                 case 1: {\r
 150                         /* clear video memory */\r
 151                         dword far*ptr=(dword far*)vga_state.vga_graphics_ram;//VGA;      /* used for faster screen clearing */\r
 152                         vga_write_sequencer(2/*map mask register*/,0xf/*all 4 planes*/);\r
 153                         for(i = 0;i < 0x4000; i++) ptr[i] = 0x0000; // 0x4000 x dword = 64KB\r
 154                 }\r
 155                 break;\r
 156         }\r
 157 \r
 158 //      gv->video.page[0].tw = gv->video.page[0].sw/TILEWH;\r
 159 //      gv->video.page[0].th = gv->video.page[0].sh/TILEWH;\r
 160 \r
 161         //TODO MAKE FLEXIBLE~\r
 162 //      gv->video.page[0].tilemidposscreenx = gv->video.page[0].tilesw;\r
 163 //      gv->video.page[0].tilemidposscreeny = (gv->video.page[0].tilesh/2)+1;\r
 164 }\r
 165 \r
 166 void\r
 167 modexLeave() {\r
 168         /* VGAmodeX restores original mode and palette */\r
 169         vgaSetMode(TEXT_MODE);\r
 170 }\r
 171 \r
 172 page_t\r
 173 modexDefaultPage(page_t *p)\r
 174 {\r
 175     page_t page;\r
 176 \r
 177     /* default page values */\r
 178         //page.data = VGA;\r
 179         //page.data = (byte far *)(vga_state.vga_graphics_ram);\r
 180         page.data = (vga_state.vga_graphics_ram);\r
 181     page.dx = 0;\r
 182     page.dy = 0;\r
 183         page.sw = p->sw;\r
 184         page.sh = p->sh;\r
 185         page.width = p->sw+TILEWHD;\r
 186         page.height = p->sh+TILEWHD;\r
 187         page.tw = page.sw/TILEWH;\r
 188         page.th = page.sh/TILEWH;\r
 189         page.tilesw=page.width/TILEWH;\r
 190         page.tilesh=page.height/TILEWH;\r
 191         page.tilemidposscreenx = page.tw/2;\r
 192         page.tilemidposscreeny = (page.th/2)+1;\r
 193         page.stridew=page.width/4;\r
 194         page.pagesize = (word)(page.width/4)*page.height;\r
 195         page.id = 0;\r
 196 \r
 197     return page;\r
 198 }\r
 199 \r
 200 /* returns the next page in contiguous memory\r
 201  * the next page will be the same size as p, by default\r
 202  */\r
 203 page_t\r
 204 modexNextPage(page_t *p) {\r
 205     page_t result;\r
 206 \r
 207     result.data = p->data + (p->pagesize);\r
 208     result.dx = 0;\r
 209     result.dy = 0;\r
 210         result.sw = p->sw;\r
 211         result.sh = p->sh;\r
 212     result.width = p->width;\r
 213     result.height = p->height;\r
 214         result.tw = p->tw;\r
 215         result.th = p->th;\r
 216         result.tilesw = p->tilesw;\r
 217         result.tilesh = p->tilesh;\r
 218         result.id = p->id+1;\r
 219         result.stridew=p->stridew;\r
 220         result.pagesize = p->pagesize;\r
 221 \r
 222         return result;\r
 223 }\r
 224 \r
 225 //next page with defined dimentions~\r
 226 page_t\r
 227 modexNextPageFlexibleSize(page_t *p, word x, word y)\r
 228 {\r
 229         page_t result;\r
 230 \r
 231         result.data = p->data + (p->pagesize);  /* compute the offset */\r
 232         result.dx = 0;\r
 233         result.dy = 0;\r
 234         result.sw = x;\r
 235         result.sh = y;\r
 236         result.width = x;\r
 237         result.height = y;\r
 238         result.tw = result.sw/TILEWH;\r
 239         result.th = result.sh/TILEWH;\r
 240         result.tilesw=result.width/TILEWH;\r
 241         result.tilesh=result.height/TILEWH;\r
 242         result.id = p->id+1;\r
 243         result.stridew=result.width/4;\r
 244         result.pagesize = (word)(result.width/4)*result.height;\r
 245 \r
 246         return result;\r
 247 }\r
 248 \r
 249 void modexCalcVmemRemain(video_t *video)\r
 250 {\r
 251         byte i;\r
 252         //printf("\n\n  1st vmem_remain=%u\n", video->vmem_remain);\r
 253         for(i=0; i<video->num_of_pages; i++)\r
 254         {\r
 255                 video->vmem_remain-=video->page[i].pagesize;\r
 256                 //printf("              [%u], video->page[%u].pagesize=%u\n", i, i, video->page[i].pagesize);\r
 257                 //printf("              [%u], vmem_remain=%u\n", i, video->vmem_remain);\r
 258         }\r
 259 }\r
 260 \r
 261 void modexHiganbanaPageSetup(video_t *video)\r
 262 {\r
 263         video->vmem_remain=65535U;\r
 264         video->num_of_pages=0;\r
 265         (video->page[0]) = modexDefaultPage(&(video->page[0])); video->num_of_pages++;  //video->page[0].width += (TILEWHD); video->page[0].height += (TILEWHD);\r
 266         (video->page[1]) = modexNextPage(&(video->page[0]));    video->num_of_pages++;\r
 267         (video->page[2]) = modexNextPageFlexibleSize(&(video->page[1]), TILEWH*4, TILEWH*4);            video->num_of_pages++;\r
 268         (video->page[3]) = modexNextPageFlexibleSize(&(video->page[2]), video->page[0].sw, 208);        video->num_of_pages++;\r
 269 //      (video->page[2]) = modexNextPageFlexibleSize(&(video->page[1]), video->page[0].width, 172);     video->num_of_pages++;\r
 270 //      (video->page[3]) = modexNextPageFlexibleSize(&(video->page[2]), 72, 128);               video->num_of_pages++;\r
 271         modexCalcVmemRemain(video);\r
 272         video->p=0;\r
 273         video->r=1;\r
 274 }\r
 275 \r
 276 void\r
 277 modexShowPage(page_t *page) {\r
 278     word high_address;\r
 279     word low_address;\r
 280     word offset;\r
 281     byte crtcOffset;\r
 282 \r
 283     /* calculate offset */\r
 284     offset = (word) page->data;\r
 285     offset += page->dy * (page->width >> 2 );\r
 286     offset += page->dx >> 2;\r
 287 \r
 288     /* calculate crtcOffset according to virtual width */\r
 289     crtcOffset = page->width >> 3;\r
 290 \r
 291     high_address = HIGH_ADDRESS | (offset & 0xff00);\r
 292     low_address  = LOW_ADDRESS  | (offset << 8);\r
 293 \r
 294     /* wait for appropriate timing and then program CRTC */\r
 295     while ((inp(INPUT_STATUS_1) & DISPLAY_ENABLE));\r
 296     outpw(CRTC_INDEX, high_address);\r
 297     outpw(CRTC_INDEX, low_address);\r
 298     outp(CRTC_INDEX, 0x13);\r
 299     outp(CRTC_DATA, crtcOffset);\r
 300 \r
 301     /*  wait for one retrace */\r
 302     while (!(inp(INPUT_STATUS_1) & VRETRACE));\r
 303 \r
 304     /* do PEL panning here */\r
 305     outp(AC_INDEX, 0x33);\r
 306     outp(AC_INDEX, (page->dx & 0x03) << 1);\r
 307 }\r
 308 \r
 309 void\r
 310 modexPanPage(page_t *page, int dx, int dy) {\r
 311     page->dx = dx;\r
 312     page->dy = dy;\r
 313 }\r
 314 \r
 315 void\r
 316 modexSelectPlane(byte plane) {\r
 317     outp(SC_INDEX, MAP_MASK);     /* select plane */\r
 318     outp(SC_DATA,  plane);\r
 319 }\r
 320 \r
 321 void\r
 322 modexClearRegion(page_t *page, int x, int y, int w, int h, byte  color) {\r
 323     word pageOff = (word) page->data;\r
 324     word xoff=x/4;       /* xoffset that begins each row */\r
 325     word scanCount=w/4;  /* number of iterations per row (excluding right clip)*/\r
 326     word poffset = pageOff + y*(page->stridew) + xoff; /* starting offset */\r
 327     word nextRow = page->stridew-scanCount-1;  /* loc of next row */\r
 328     byte lclip[] = {0x0f, 0x0e, 0x0c, 0x08};  /* clips for rectangles not on 4s */\r
 329     byte rclip[] = {0x00, 0x01, 0x03, 0x07};\r
 330     byte left = lclip[x&0x03];\r
 331     byte right = rclip[(x+w)&0x03];\r
 332 \r
 333     /* handle the case which requires an extra group */\r
 334     if((x & 0x03) && !((x+w) & 0x03)) {\r
 335       right=0x0f;\r
 336     }\r
 337 \r
 338     __asm {\r
 339             PUSHF\r
 340             PUSH ES\r
 341             PUSH AX\r
 342             PUSH BX\r
 343             PUSH CX\r
 344             PUSH DX\r
 345             PUSH SI\r
 346             PUSH DI\r
 347                 MOV AX, SCREEN_SEG      ; go to the VGA memory\r
 348                 MOV ES, AX\r
 349                 MOV DI, poffset  ; go to the first pixel\r
 350                 MOV DX, SC_INDEX        ; point to the map mask\r
 351                 MOV AL, MAP_MASK\r
 352                 OUT DX, AL\r
 353                 INC DX\r
 354                 MOV AL, color      ; get ready to write colors\r
 355         SCAN_START:\r
 356                 MOV CX, scanCount       ; count the line\r
 357                 MOV BL, AL            ; remember color\r
 358                 MOV AL, left        ; do the left clip\r
 359                 OUT DX, AL            ; set the left clip\r
 360                 MOV AL, BL            ; restore color\r
 361                 STOSB              ; write the color\r
 362                 DEC CX\r
 363                 JZ SCAN_DONE        ; handle 1 group stuff\r
 364 \r
 365                 ;-- write the main body of the scanline\r
 366                 MOV BL, AL            ; remember color\r
 367                 MOV AL, 0x0f        ; write to all pixels\r
 368                 OUT DX, AL\r
 369                 MOV AL, BL            ; restore color\r
 370                 REP STOSB              ; write the color\r
 371         SCAN_DONE:\r
 372                 MOV BL, AL            ; remeber color\r
 373                 MOV AL, right\r
 374                 OUT DX, AL            ; do the right clip\r
 375                 MOV AL, BL            ; restore color\r
 376                 STOSB              ; write pixel\r
 377                 ADD DI, nextRow  ; go to the next row\r
 378                 DEC h\r
 379                 JNZ SCAN_START\r
 380             POP DI\r
 381             POP SI\r
 382             POP DX\r
 383             POP CX\r
 384             POP BX\r
 385             POP AX\r
 386             POP ES\r
 387             POPF\r
 388     }\r
 389 }\r
 390 \r
 391 /* moved to src/lib/modex16/16render.c */\r
 392 \r
 393 /* copy a region of video memory from one page to another.\r
 394  * It assumes that the left edge of the tile is the same on both\r
 395  * regions and the memory areas do not overlap.\r
 396  */\r
 397 void\r
 398 modexCopyPageRegion(page_t *dest, page_t *src,\r
 399                     word sx, word sy,\r
 400                     word dx, word dy,\r
 401                     word width, word height)\r
 402 {\r
 403     word doffset = (word)dest->data + dy*(dest->stridew) + dx/4;\r
 404     word soffset = (word)src->data + sy*(src->stridew) + sx/4;\r
 405     word scans   = vga_state.vga_stride;\r
 406     word nextSrcRow = src->stridew - scans - 1;\r
 407     word nextDestRow = dest->stridew - scans - 1;\r
 408     byte lclip[] = {0x0f, 0x0e, 0x0c, 0x08};  /* clips for rectangles not on 4s */\r
 409     byte rclip[] = {0x0f, 0x01, 0x03, 0x07};\r
 410     byte left = lclip[sx&0x03];\r
 411     byte right = rclip[(sx+width)&0x03];\r
 412 \r
 413     __asm {\r
 414             PUSHF\r
 415             PUSH ES\r
 416             PUSH AX\r
 417             PUSH BX\r
 418             PUSH CX\r
 419             PUSH DX\r
 420             PUSH SI\r
 421             PUSH DI\r
 422 \r
 423                 MOV AX, SCREEN_SEG      ; work in the vga space\r
 424                 MOV ES, AX            ;\r
 425                 MOV DI, doffset  ;\r
 426                 MOV SI, soffset  ;\r
 427 \r
 428                 MOV DX, GC_INDEX        ; turn off cpu bits\r
 429                 MOV AX, 0008h      ;\r
 430                 OUT DX, AX\r
 431 \r
 432                 MOV AX, SC_INDEX        ; point to the mask register\r
 433                 MOV DX, AX            ;\r
 434                 MOV AL, MAP_MASK        ;\r
 435                 OUT DX, AL            ;\r
 436                 INC DX            ;\r
 437 \r
 438         ROW_START:\r
 439                 PUSH DS\r
 440                 MOV AX, ES\r
 441                 MOV DS, AX\r
 442                 MOV CX, scans      ; the number of latches\r
 443 \r
 444                 MOV AL, left        ; do the left column\r
 445                 OUT DX, AL            ;\r
 446                 MOVSB              ;\r
 447                 DEC CX            ;\r
 448 \r
 449                 MOV AL, 0fh          ; do the inner columns\r
 450                 OUT DX, AL\r
 451                 REP MOVSB              ; copy the pixels\r
 452 \r
 453                 MOV AL, right      ; do the right column\r
 454                 OUT DX, AL\r
 455                 MOVSB\r
 456                 POP DS\r
 457 \r
 458                 MOV AX, SI            ; go the start of the next row\r
 459                 ADD AX, nextSrcRow      ;\r
 460                 MOV SI, AX            ;\r
 461                 MOV AX, DI            ;\r
 462                 ADD AX, nextDestRow     ;\r
 463                 MOV DI, AX            ;\r
 464 \r
 465                 DEC height            ; do the rest of the actions\r
 466                 JNZ ROW_START      ;\r
 467 \r
 468                 MOV DX, GC_INDEX+1      ; go back to CPU data\r
 469                 MOV AL, 0ffh        ; none from latches\r
 470                 OUT DX, AL            ;\r
 471 \r
 472             POP DI\r
 473             POP SI\r
 474             POP DX\r
 475             POP CX\r
 476             POP BX\r
 477             POP AX\r
 478             POP ES\r
 479             POPF\r
 480     }\r
 481 }\r
 482 \r
 483 \r
 484 /* fade and flash */\r
 485 void\r
 486 modexFadeOn(word fade, byte *palette) {\r
 487     fadePalette(-fade, 64, 64/fade+1, palette);\r
 488 }\r
 489 \r
 490 \r
 491 void\r
 492 modexFadeOff(word fade, byte *palette) {\r
 493     fadePalette(fade, 0, 64/fade+1, palette);\r
 494 }\r
 495 \r
 496 \r
 497 void\r
 498 modexFlashOn(word fade, byte *palette) {\r
 499     fadePalette(fade, -64, 64/fade+1, palette);\r
 500 }\r
 501 \r
 502 \r
 503 void\r
 504 modexFlashOff(word fade, byte *palette) {\r
 505     fadePalette(-fade, 0, 64/fade+1, palette);\r
 506 }\r
 507 \r
 508 \r
 509 static void\r
 510 fadePalette(sbyte fade, sbyte start, word iter, byte *palette) {\r
 511     word i;\r
 512     byte dim = start;\r
 513 \r
 514     /* handle the case where we just update */\r
 515     if(iter == 0) {\r
 516         modexPalUpdate1(palette);\r
 517         return;\r
 518     }\r
 519 \r
 520     while(iter > 0) {  /* FadeLoop */\r
 521         for(i=0; i<PAL_SIZE; i++) { /* loadpal_loop */\r
 522             tmppal[i] = palette[i] - dim;\r
 523             if(tmppal[i] > 127) {\r
 524                 tmppal[i] = 0;\r
 525             } else if(tmppal[i] > 63) {\r
 526                 tmppal[i] = 63;\r
 527             }\r
 528         }\r
 529         modexPalUpdate1(tmppal);\r
 530         iter--;\r
 531         dim += fade;\r
 532     }\r
 533 }\r
 534 \r
 535 \r
 536 /* save and load */\r
 537 void\r
 538 modexPalSave(byte *palette) {\r
 539     int  i;\r
 540 \r
 541     outp(PAL_READ_REG, 0);      /* start at palette entry 0 */\r
 542     for(i=0; i<PAL_SIZE; i++) {\r
 543         palette[i] = inp(PAL_DATA_REG); /* read the palette data */\r
 544     }\r
 545 }\r
 546 \r
 547 \r
 548 byte *\r
 549 modexNewPal() {\r
 550     byte *ptr;\r
 551     ptr = malloc(PAL_SIZE);\r
 552 \r
 553     /* handle errors */\r
 554     if(!ptr) {\r
 555         printf("Could not allocate palette.\n");\r
 556         exit(-1);\r
 557     }\r
 558 \r
 559     return ptr;\r
 560 }\r
 561 \r
 562 \r
 563 void\r
 564 modexLoadPalFile(byte *filename, byte **palette) {\r
 565     FILE *file;\r
 566     byte *ptr;\r
 567 \r
 568     /* free the palette if it exists */\r
 569     if(*palette) {\r
 570         free(*palette);\r
 571     }\r
 572 \r
 573     /* allocate the new palette */\r
 574     *palette = modexNewPal();\r
 575 \r
 576     /* open the file */\r
 577     file = fopen(filename, "rb");\r
 578     if(!file) {\r
 579         printf("Could not open palette file: %s\n", filename);\r
 580         exit(-2);\r
 581     }\r
 582 \r
 583     /* read the file */\r
 584     ptr = *palette;\r
 585     while(!feof(file)) {\r
 586         *ptr++ = fgetc(file);\r
 587     }\r
 588 \r
 589     fclose(file);\r
 590 }\r
 591 \r
 592 \r
 593 void\r
 594 modexSavePalFile(char *filename, byte *pal) {\r
 595     unsigned int i;\r
 596     FILE *file;\r
 597 \r
 598     /* open the file for writing */\r
 599     file = fopen(filename, "wb");\r
 600     if(!file) {\r
 601         printf("Could not open %s for writing\n", filename);\r
 602         exit(-2);\r
 603     }\r
 604 \r
 605     /* write the data to the file */\r
 606     fwrite(pal, 1, PAL_SIZE, file);\r
 607     fclose(file);\r
 608 }\r
 609 \r
 610 \r
 611 /* blanking */\r
 612 void\r
 613 modexPalBlack() {\r
 614     fadePalette(-1, 64, 1, tmppal);\r
 615 }\r
 616 \r
 617 \r
 618 void\r
 619 modexPalWhite() {\r
 620     fadePalette(-1, -64, 1, tmppal);\r
 621 }\r
 622 \r
 623 \r
 624 /* utility */\r
 625 void\r
 626 modexPalUpdate(bitmap_t *bmp, word *i, word qp, word aqoffset)\r
 627 {\r
 628         byte *p = bmp->palette;\r
 629         word w=0;\r
 630         word q=0;\r
 631         word qq=0;\r
 632         static word a[PAL_SIZE];        //palette array of change values!\r
 633         word z=0, aq=0, aa=0, pp=0;\r
 634 \r
 635         //modexWaitBorder();\r
 636         vga_wait_for_vsync();\r
 637         if((*i)==0)\r
 638         {\r
 639                 memset(a, -1, sizeof(a));\r
 640                 outp(PAL_WRITE_REG, 0);  /* start at the beginning of palette */\r
 641         }\r
 642         else if(qp==0)\r
 643         {\r
 644                 q=(*i);\r
 645         }\r
 646         else\r
 647         {\r
 648                 q=(*i);\r
 649                 qq=(*i)/3;\r
 650 //            printf("q: %02d\n", (q));\r
 651 //            printf("qq: %02d\n", (qq));\r
 652                 //printf("      (*i)-q=%02d\n", (*i)-q);\r
 653                 outp(PAL_WRITE_REG, qq);  /* start at the beginning of palette */\r
 654         }\r
 655         if((*i)<PAL_SIZE/2 && w==0)\r
 656         {\r
 657                 for(; (*i)<PAL_SIZE/2; (*i)++)\r
 658                 {\r
 659                         //if(i%3==0 && (p[i+5]==p[i+4] && p[i+4]==p[i+3] && p[i+3]==p[i+2] && p[i+2]==p[i+1] && p[i+1]==p[i] && p[i+5]==p[i]))\r
 660 //____            if((qp>0)&&((*i)-q)%3==0 && (p[((*i)-q)]==p[((*i)-q)+3] && p[((*i)-q)+1]==p[((*i)-q)+4] && p[((*i)-q)+2]==p[((*i)-q)+5])) outp(PAL_DATA_REG, p[(*i)-q]); else\r
 661                         if(((((*i)-q)%3==0)) && (p[((*i)-q)]==p[((*i)-q)+3] && p[((*i)-q)+1]==p[((*i)-q)+4] && p[((*i)-q)+2]==p[((*i)-q)+5]))\r
 662                         {\r
 663                                 w++;\r
 664                                 break;\r
 665                         }\r
 666                         else if(qp>0 && (*i)>=(qp) && (*i)<((qp)+3))\r
 667                         {\r
 668                                 //printf("qp=%d\n", qp);\r
 669                                 //printf("            (*i)=%d a[%d]=%d\n", (*i), qp, a[qp]);\r
 670                                 printf("                %d's color=%d\n", (*i), (a[qp])-(bmp->offset*3)+qp);\r
 671                                 //outp(PAL_DATA_REG, p[((a[qp])-(bmp->offset*3)+qp)]);// fix this shit!\r
 672                                 if((*i)+1==(qp)+3){ w++; /*(*i)++;*/ break; }\r
 673                         }\r
 674                         else\r
 675                         {\r
 676                                 if(bmp->offset==0 && (*i)<3 && q==0) outp(PAL_DATA_REG, 0);\r
 677                                 else\r
 678                                 if(qp==0) outp(PAL_DATA_REG, p[(*i)-q]);\r
 679                                 else{ //outp(PAL_DATA_REG, p[((*i)-(bmp->offset*3)+qp)]);\r
 680                                 printf("p[]=%d  qp=%d   p[]-qp=%d\n", ((*i)-(bmp->offset*3)), qp, ((*i)-(bmp->offset*3))+qp); }\r
 681                         }\r
 682                 }\r
 683                 //if(qp>0) printf("qp=%d\n", qp);\r
 684                 //if(qp>0) printf("                                          (*i)=%d\n", (*i)/3);\r
 685         }\r
 686         //modexWaitBorder();      /* waits one retrace -- less flicker */\r
 687         vga_wait_for_vsync();\r
 688         if((*i)>=PAL_SIZE/2 && w==0)\r
 689         {\r
 690                 for(; (*i)<PAL_SIZE; (*i)++)\r
 691                 {\r
 692 //____            if((qp>0)&&((*i)-q)%3==0 && (p[((*i)-q)]==p[((*i)-q)+3] && p[((*i)-q)+1]==p[((*i)-q)+4] && p[((*i)-q)+2]==p[((*i)-q)+5])) outp(PAL_DATA_REG, p[(*i)-q]); else\r
 693                         if(((((*i)-q)%3==0)) && (p[((*i)-q)]==p[((*i)-q)+3] && p[((*i)-q)+1]==p[((*i)-q)+4] && p[((*i)-q)+2]==p[((*i)-q)+5]))\r
 694                         {\r
 695                                 w++;\r
 696                                 break;\r
 697                         }\r
 698                         else if(qp>0 && (*i)>=(qp) && (*i)<((qp)+3))\r
 699                         {\r
 700                                 //printf("qp=%d\n", qp);\r
 701                                 //printf("            (*i)=%d a[%d]=%d\n", (*i), qp, a[qp]);\r
 702                                 printf("                %d's color=%d\n", (*i), (a[qp]-(bmp->offset*3)+qp));\r
 703                                 //outp(PAL_DATA_REG, p[((a[qp])-(bmp->offset*3)+qp)]);// fix this shit!\r
 704                                 if((*i)+1==(qp)+3){ w++; /*(*i)++;*/ break; }\r
 705                         }\r
 706                         else\r
 707                         {\r
 708                                 if(qp==0) outp(PAL_DATA_REG, p[(*i)-q]);\r
 709                                 else{ //outp(PAL_DATA_REG, p[((*i)-(bmp->offset*3)+qp)]);\r
 710                                 printf("p[]=%d  qp=%d   p[]-qp=%d\n", ((*i)-(bmp->offset*3)), qp, ((*i)-(bmp->offset*3))+qp); }\r
 711                         }\r
 712                 }\r
 713                 //printf("                                            (*i)=%d\n", (*i)/3);\r
 714         }\r
 715 \r
 716 printf("\nqqqqqqqq\n\n");\r
 717 \r
 718         //palette checker~\r
 719         if(q>0 && qp==0)\r
 720         {\r
 721                 long lq;\r
 722                 long bufSize = (bmp->width * bmp->height);\r
 723                 pp = q;\r
 724                 //printf("1(*i)=%02d\n", (*i)/3);\r
 725                 //printf("1z=%02d\n", z/3);\r
 726                 modexchkcolor(bmp, &q, &a, &aa, &z, i);\r
 727                 //printf("2(*i)=%02d\n", (*i)/3);\r
 728                 //printf("2z=%02d\n", z/3);\r
 729                 aq=0;\r
 730 aqpee:\r
 731                 while(aq<=aa)\r
 732                 {\r
 733 //                    printf("a[%02d]=(%d)\n", aq, a[aq]);\r
 734                         if(a[aq]==-1) aq++;\r
 735                         else { aqoffset++; break; }\r
 736                 }\r
 737 //update the image data here!\r
 738         for(lq=0; lq<bufSize; lq++)\r
 739         {\r
 740                                 /*\r
 741                                                                         note to self\r
 742                                                                         use a[qp] instead of bmp->offset for this spot!\r
 743                                                                         NO! wwww\r
 744                                 */\r
 745 \r
 746                                 /*\r
 747                                 Facking bloody point the values of the changed palette to correct values.... major confusion! wwww\r
 748                                 */\r
 749 \r
 750                 //(offset/bmp->offset)*bmp->offset\r
 751 \r
 752 \r
 753                 //printf("%02d ",bmp->data[lq]+bmp->offset);\r
 754                 //if(lq > 0 && lq%bmp->width==0) printf("\n");\r
 755                 //printf("%02d_", bmp->data[lq]+bmp->offset);\r
 756                 /*if(bmp->data[lq]+bmp->offset==aq)\r
 757                 {\r
 758                         //printf("%02d", bmp->data[lq]);\r
 759                         //printf("\n%02d\n", bmp->offset);\r
 760                         printf("aq=%02d ", aq);\r
 761                         printf("a[aq]=%02d      ", a[aq]);\r
 762                         printf("a[aq]+aqpp=%02d ", a[aq]+aqpp);\r
 763                         printf("a[aq]-aqpp=%02d\n", a[aq]-aqpp);\r
 764                         //bmp->data[lq]=((bmp->data[lq]+bmp->offset)-a[aq]);\r
 765 //++++            bmp->data[lq]=a[aq]-aqpp;\r
 766 //                    printf("_%d ", bmp->data[lq]);\r
 767                         //if(lq > 0 && lq%bmp->width==0) printf("\n");\r
 768                 }\r
 769                 else if(bmp->data[lq]+bmp->offset < ((*i)/3)-aqpp)\r
 770                 {\r
 771                         if(bmp->data[lq]+bmp->offset >= aq)\r
 772                         {\r
 773                                 bmp->data[lq]=(bmp->data[lq]+bmp->offset)-aqpp;//-((z-(*i))/3);\r
 774                                 //printf("_%d ", bmp->data[lq]+bmp->offset)-aqpp-((z-(*i))/3);\r
 775                         }\r
 776                         else bmp->data[lq]+=(bmp->offset-aqpp);\r
 777                 }*/\r
 778 \r
 779                 //printf("%02d`", bmp->data[lq]);\r
 780                 //if(lq > 0 && lq%bmp->width==0) printf("\n");\r
 781         }\r
 782 \r
 783 //printf("            aq=%02d\n", aq);\r
 784 //printf("            aa=%02d\n", aa);\r
 785 \r
 786         //update the palette~\r
 787         modexPalUpdate(bmp, &pp, aq, aqoffset);\r
 788         (*i)=pp;\r
 789 \r
 790         if(aq<aa){ pp=q; aq++; goto aqpee; }\r
 791         }\r
 792 }\r
 793 \r
 794 void\r
 795 modexPalUpdate1(byte *p)\r
 796 {\r
 797         int i;\r
 798         //modexWaitBorder();\r
 799         vga_wait_for_vsync();\r
 800         outp(PAL_WRITE_REG, 0);  /* start at the beginning of palette */\r
 801         for(i=0; i<PAL_SIZE/2; i++)\r
 802         {\r
 803                 outp(PAL_DATA_REG, p[i]);\r
 804         }\r
 805         //modexWaitBorder();      /* waits one retrace -- less flicker */\r
 806         vga_wait_for_vsync();\r
 807         for(; i<PAL_SIZE; i++)\r
 808         {\r
 809                 outp(PAL_DATA_REG, p[(i)]);\r
 810         }\r
 811 }\r
 812 \r
 813 void\r
 814 modexPalUpdate0(byte *p)\r
 815 {\r
 816         int i;\r
 817         //modexWaitBorder();\r
 818         vga_wait_for_vsync();\r
 819         outp(PAL_WRITE_REG, 0);  /* start at the beginning of palette */\r
 820         for(i=0; i<PAL_SIZE/2; i++)\r
 821         {\r
 822                 outp(PAL_DATA_REG, rand());\r
 823         }\r
 824         //modexWaitBorder();      /* waits one retrace -- less flicker */\r
 825         vga_wait_for_vsync();\r
 826         for(; i<PAL_SIZE; i++)\r
 827         {\r
 828                 outp(PAL_DATA_REG, rand());\r
 829         }\r
 830 }\r
 831 \r
 832 void\r
 833 modexPalOverscan(byte *p, word col)\r
 834 {\r
 835         //modexWaitBorder();\r
 836         vga_wait_for_vsync();\r
 837         outp(PAL_WRITE_REG, 0);  /* start at the beginning of palette */\r
 838         outp(PAL_DATA_REG, col);\r
 839 }\r
 840 \r
 841 //color checker~\r
 842 //i want to make another vesion that checks the palette when the palette is being appened~\r
 843 void modexchkcolor(bitmap_t *bmp, word *q, word *a, word *aa, word *z, word *i/*, word *offset*/)\r
 844 {\r
 845                 byte *pal;\r
 846                 word zz=0;\r
 847                 pal = modexNewPal();\r
 848                 modexPalSave(pal);\r
 849                 //printf("q: %02d\n", (*q));\r
 850                 printf("chkcolor start~\n");\r
 851                 printf("1                              (*z): %d\n", (*z)/3);\r
 852                 printf("1                              (*i): %d\n", (*i)/3);\r
 853 //            printf("1 offset of color in palette    (*q): %d\n", (*q)/3);\r
 854                 printf("wwwwwwwwwwwwwwww\n");\r
 855                 //check palette for dups\r
 856                 for(; (*z)<PAL_SIZE; (*z)+=3)\r
 857                 {\r
 858                         //printf("\n        z: %d\n", (*z));\r
 859                         //printf("            q: %d\n", (*q));\r
 860                         //printf("            z+q: %d\n\n", ((*z)+(*q)));\r
 861                         //if((*z)%3==0)\r
 862                         //{\r
 863 //----                    if(pal[(*z)]==pal[(*z)+3] && pal[(*z)+1]==pal[(*z)+4] && pal[(*z)+2]==pal[(*z)+5])\r
 864                                 if((*z)==(*i))\r
 865                                 {\r
 866 //                                    printf("\n%d    [%02d][%02d][%02d]\n", (*z), pal[(*z)], pal[(*z)+1], pal[(*z)+2]);\r
 867 //                                    printf("%d      [%02d][%02d][%02d]\n\n", (*z)+3, pal[(*z)+3], pal[(*z)+4], pal[(*z)+5]);\r
 868 //0000                            (*z)-=3;\r
 869                                         break;\r
 870                                 }\r
 871                                 else for(zz=0; zz<(*q); zz+=3)\r
 872                                 {\r
 873                                         //printf("zz: %02d\n", zz/3);\r
 874                                         if(zz%3==0)\r
 875                                         {\r
 876                                                 if(pal[((*z)+(*q))]==pal[((*z)+(*q))+3] && pal[((*z)+(*q))+1]==pal[((*z)+(*q))+4] && pal[((*z)+(*q))+2]==pal[((*z)+(*q))+5])    //break if duplicate colors found in palette because it have reached the end of the current data of the palette\r
 877                                                 {\r
 878 //                                                    (*z)-=3;\r
 879 //                                                    (*i)-=3;\r
 880 //                                                    printf("\nzq1:%d[%02d][%02d][%02d]\n", (zz+q), pal[(zz+q)], pal[(zz+q)+1], pal[(zz+q)+2]);\r
 881 //                                                    printf("zq2:%d[%02d][%02d][%02d]\n\n", (zz+q)+3, pal[(zz+q)+3], pal[(zz+q)+4], pal[(zz+q)+5]);\r
 882                                                         break;\r
 883                                                 }\r
 884                                                 else if(pal[zz]==pal[((*z)+(*q))] && pal[zz+1]==pal[((*z)+(*q))+1] && pal[zz+2]==pal[((*z)+(*q))+2])\r
 885                                                 {\r
 886 //                                                    printf("\n\nwwwwwwwwwwwwwwww\n");\r
 887 //                                                    printf("  zq: %d  [%02d][%02d][%02d] value that is needing to be changed~\n", ((*z)+(*q))/3, pal[((*z)+(*q))], pal[((*z)+(*q))+1], pal[((*z)+(*q))+2]);\r
 888 //                                                    printf("  zz: %d  [%02d][%02d][%02d] value that the previous value is going to change to~\n", (zz)/3, pal[zz], pal[zz+1], pal[zz+2]);\r
 889 //                                                    //printf("      zv: %d  [%02d][%02d][%02d] wwww\n", (zz-z+q)/3, pal[(zz-z+q)], pal[(zz-z+q)+1], pal[(zz-z+q)+2]);\r
 890 //                                                    printf("  z : %d  [%02d][%02d][%02d] offset value~\n", (*z)/3, pal[(*z)], pal[(*z)+1], pal[(*z)+2]);\r
 891 //++++                                            (*i)--;\r
 892 //                                                    (*z)--;\r
 893                                                         //expand dong here\r
 894 /*\r
 895 planned features that i plan to implement~\r
 896 image that has values on the pallete list!\r
 897 wwww\r
 898 no... wait.... no wwww\r
 899 */\r
 900                                                         //for(zzii=0; zzii<3; zzii++)\r
 901                                                         //{\r
 902                                                                 //printf("z+q: %d\n\n", ((*z)+(*q)));\r
 903                                                                 a[(((*z)+(*q)))]=zz;\r
 904                                                         //}\r
 905                                                         (*aa)=(((*z)+(*q)));\r
 906                                                         printf("!!                                    a[%02d]: %d\n", (((*z)+(*q))/3), zz/3);\r
 907 //                                                    printf("\n              aa: %d\n\n", (*aa));\r
 908 //                                                    printf("  a[%02d]=(%02d) offset array i think the palette should be updated again~\n", ((*z)+(*q))/3, a[((*z)+(*q))/3]);\r
 909 //                                                    printf("wwwwwwwwwwwwwwww\n\n");\r
 910                                                 }\r
 911                                                 /*else\r
 912                                                 {\r
 913                                                         printf("================\n");\r
 914                                                         printf("zq: %d  [%02d][%02d][%02d]\n", ((*z)+(*q))/3, pal[((*z)+(*q))], pal[((*z)+(*q))+1], pal[((*z)+(*q))+2]);\r
 915                                                         printf("zz: %d  [%02d][%02d][%02d]\n", (zz)/3, pal[zz], pal[zz+1], pal[zz+2]);\r
 916                                                         printf("z : %d  [%02d][%02d][%02d]\n", (*z)/3, pal[(*z)], pal[(*z)+1], pal[(*z)+2]);\r
 917                                                         printf("================\n");\r
 918                                                 }*/\r
 919                                                 //printf("[%d]", (zz+q));\r
 920                                         }\r
 921                                 }\r
 922                 }\r
 923                 printf("wwwwwwwwwwwwwwww\n");\r
 924                 printf("2                              (*z): %d\n", (*z)/3);\r
 925                 printf("2                              (*i): %d\n", (*i)/3);\r
 926 //            printf("2 offset of color in palette    (*q): %d\n", (*q)/3);\r
 927                 printf("chkcolor end~\n");\r
 928                 free(pal);\r
 929 }\r
 930 \r
 931 void modexputPixel(page_t *page, int x, int y, byte color)\r
 932 {\r
 933         word pageOff = (word) page->data;\r
 934         /* Each address accesses four neighboring pixels, so set\r
 935            Write Plane Enable according to which pixel we want\r
 936            to modify.  The plane is determined by the two least\r
 937            significant bits of the x-coordinate: */\r
 938         modexSelectPlane(PLANE(x));\r
 939         //outp(SC_INDEX, 0x02);\r
 940         //outp(SC_DATA, 0x01 << (x & 3));\r
 941 \r
 942         /* The offset of the pixel into the video segment is\r
 943            offset = (width * y + x) / 4, and write the given\r
 944            color to the plane we selected above.  Heed the active\r
 945            page start selection. */\r
 946         VGA[(unsigned)((page->width/4) * y) + (x / 4) + pageOff] = color;\r
 947 \r
 948 }\r
 949 \r
 950 byte modexgetPixel(page_t *page, int x, int y)\r
 951 {\r
 952         word pageOff = (word) page->data;\r
 953         /* Select the plane from which we must read the pixel color: */\r
 954         outpw(GC_INDEX, 0x04);\r
 955         outpw(GC_INDEX+1, x & 3);\r
 956 \r
 957         return VGA[(unsigned)((page->width/4) * y) + (x / 4) + pageOff];\r
 958 \r
 959 }\r
 960 \r
 961 void modexprint(page_t *page, word x, word y, word t, word col, word bgcol, const byte *str)\r
 962 {\r
 963         word s, o, w;\r
 964         word x_draw = x;\r
 965         word addr = (word) romFontsData.l;\r
 966         word addrq = (page->width/4) * y + (x / 4) + ((word)page->data);\r
 967         word addrr = addrq;\r
 968         byte c;\r
 969 \r
 970         s=romFonts[t].seg;\r
 971         o=romFonts[t].off;\r
 972         w=romFonts[t].charSize;\r
 973         romFontsData.chw=0;\r
 974 \r
 975         for(; *str != '\0'; str++)\r
 976         {\r
 977         c = (*str);\r
 978         if(c=='\n')\r
 979         {\r
 980                 x = x_draw;\r
 981                 romFontsData.chw = 0;\r
 982                 addrq += (page->width / 4) * 8;\r
 983                 addrr = addrq;\r
 984                 y += 8;\r
 985                 continue;\r
 986         }\r
 987 \r
 988         // load the character into romFontsData.l\r
 989         // no need for inline assembly!\r
 990         // NTS: It might even be faster to just let the modexDrawChar point directly at ROM font than to copy per char! --J.C.\r
 991                 _fmemcpy(romFontsData.l,MK_FP(s,o+(w*c))/*ROM font location*/,w/*char size*/);\r
 992                 modexDrawChar(page, x_draw/*for mode X planar use*/, t, col, bgcol, addrr);\r
 993                 x_draw += 8; /* track X for edge of screen */\r
 994                 addrr += 2; /* move 8 pixels over (2 x 4 planar pixels per byte) */\r
 995         }\r
 996 }\r
 997 \r
 998 void modexprintbig(page_t *page, word x, word y, word t, word col, word bgcol, const byte *str)\r
 999 {\r
1000         word i, s, o, w, j, xp;\r
1001         byte l[1024];\r
1002         word addr = (word) l;\r
1003         word chw=0;\r
1004         byte c;\r
1005 \r
1006         switch(t)\r
1007         {\r
1008                 case 0:\r
1009                         w=14;\r
1010                 break;\r
1011                 case 1:\r
1012                         w=8;\r
1013                 break;\r
1014                 case 2:\r
1015                         w=8;\r
1016                 break;\r
1017                 case 3:\r
1018                         w=16;\r
1019                 break;\r
1020                 default:\r
1021                         t=3;\r
1022                         w=16;\r
1023                 break;\r
1024         }\r
1025 \r
1026         s=romFonts[t].seg;\r
1027         o=romFonts[t].off;\r
1028 \r
1029         for(; *str != '\0'; str++)\r
1030         {\r
1031         c = (*str);\r
1032         if((c=='\n'/* || c=="\\r
1033 "*/)/* || chw>=page->width*/)\r
1034         {\r
1035                 chw=0;\r
1036                 y+=w;\r
1037                 continue;\r
1038         }\r
1039         //load the letter 'A'\r
1040         __asm {\r
1041             PUSHF\r
1042             PUSH ES\r
1043             PUSH AX\r
1044             PUSH BX\r
1045             PUSH CX\r
1046             PUSH DX\r
1047             PUSH SI\r
1048             PUSH DI\r
1049 \r
1050                 MOV DI, addr\r
1051                 MOV SI, o\r
1052                 MOV ES, s\r
1053                 SUB AH, AH\r
1054                 MOV AL, c       ; the letter\r
1055                 MOV CX, w\r
1056                 MUL CX\r
1057                 ADD SI, AX      ;the address of charcter\r
1058         L1:     MOV AX, ES:SI\r
1059                 MOV DS:DI, AX\r
1060                 INC SI\r
1061                 INC DI\r
1062                 DEC CX\r
1063                 JNZ L1\r
1064 \r
1065             POP DI\r
1066             POP SI\r
1067             POP DX\r
1068             POP CX\r
1069             POP BX\r
1070             POP AX\r
1071             POP ES\r
1072             POPF\r
1073         }\r
1074 \r
1075                 for(i=0; i<w; i++)\r
1076                 {\r
1077                         j=1<<8;\r
1078                         xp=0;\r
1079                         while(j)\r
1080                         {\r
1081                                 //modexputPixel(page, x+xp+chw, y+i, l[i] & j ? col:bgcol);\r
1082                                 modexClearRegion(page, (x+xp+chw)*8, (y+i)*8, 8, 8, l[i] & j ? col:bgcol);\r
1083                                 xp++;\r
1084                                 j>>=1;\r
1085                         }\r
1086                 }\r
1087                 chw += xp;\r
1088         }\r
1089 }\r
1090 \r
1091 /* palette dump on display! */\r
1092 void modexpdump(page_t *pee)\r
1093 {\r
1094         int mult=(QUADWH);\r
1095         int palq=(mult)*TILEWH;\r
1096         int palcol=0;\r
1097         int palx, paly;\r
1098         for(paly=0; paly<palq; paly+=mult){\r
1099                 for(palx=0; palx<palq; palx+=mult){\r
1100                                 modexClearRegion(pee, palx+TILEWH, paly+TILEWH, mult, mult, palcol);\r
1101                         palcol++;\r
1102                 }\r
1103         }\r
1104 }\r
1105 \r
1106 /////////////////////////////////////////////////////////////////////////////\r
1107 //                                                                                                                                               //\r
1108 // cls() - This clears the screen to the specified color, on the VGA or on //\r
1109 //               the Virtual screen.                                                                                     //\r
1110 //                                                                                                                                               //\r
1111 /////////////////////////////////////////////////////////////////////////////\r
1112 void modexcls(page_t *page, byte color, byte *Where)\r
1113 {\r
1114         //modexClearRegion(page, 0, 0, page->width, page->height, color);\r
1115         /* set map mask to all 4 planes */\r
1116         outpw(SC_INDEX, 0xff02);\r
1117         //_fmemset(VGA, color, 16000);\r
1118         _fmemset(Where, color, page->width*(page->height)/4);\r
1119 }\r
1120 \r
1121 void\r
1122 modexWaitBorder() {\r
1123         while(inp(INPUT_STATUS_1)  & 8)  {\r
1124         // spin\r
1125         }\r
1126 \r
1127         while(!(inp(INPUT_STATUS_1)  & 8))  {\r
1128         //spin\r
1129         }\r
1130 }\r
1131 \r
1132 void bios_cls() {\r
1133         VGA_ALPHA_PTR ap;\r
1134         VGA_RAM_PTR rp;\r
1135         unsigned char m;\r
1136 \r
1137         m = int10_getmode();\r
1138         if ((rp=vga_state.vga_graphics_ram) != NULL && !(m <= 3 || m == 7)) {\r
1139                 unsigned int i,im;\r
1140 \r
1141                 im = (FP_SEG(vga_state.vga_graphics_ram_fence) - FP_SEG(vga_state.vga_graphics_ram));\r
1142                 if (im > 0xFFE) im = 0xFFE;\r
1143                 im <<= 4;\r
1144                 for (i=0;i < im;i++) vga_state.vga_graphics_ram[i] = 0;\r
1145         }\r
1146         else if ((ap=vga_state.vga_alpha_ram) != NULL) {\r
1147                 unsigned int i,im;\r
1148 \r
1149                 im = (FP_SEG(vga_state.vga_alpha_ram_fence) - FP_SEG(vga_state.vga_alpha_ram));\r
1150                 if (im > 0x7FE) im = 0x7FE;\r
1151                 im <<= 4 - 1; /* because ptr is type uint16_t */\r
1152                 for (i=0;i < im;i++) vga_state.vga_alpha_ram[i] = 0x0720;\r
1153         }\r
1154         else {\r
1155                 printf("WARNING: bios cls no ptr\n");\r
1156         }\r
1157 }\r
1158 \r
1159 void modexprintmeminfo(video_t *v)\r
1160 {\r
1161         byte i;\r
1162         printf("video memory remaining: %u\n", v->vmem_remain);\r
1163         printf("page ");\r
1164         for(i=0; i<v->num_of_pages;i++)\r
1165         {\r
1166                 printf("        [%u]=", i);\r
1167                 printf("(%Fp)", (v->page[i].data));\r
1168                 printf(" size=%u", v->page[i].pagesize);\r
1169                 printf(" sw=%lu  sh=%lu ", (unsigned long)v->page[i].sw, (unsigned long)v->page[i].sh);\r
1170                 printf(" width=%lu  height=%lu", (unsigned long)v->page[i].width, (unsigned long)v->page[i].height);\r
1171                 printf("\n");\r
1172         }\r
1173 }\r