src/lib/modex16.c

   1 #include <dos.h>\r
   2 #include <string.h>\r
   3 #include <mem.h>\r
   4 #include <conio.h>\r
   5 #include <stdio.h>\r
   6 #include <stdlib.h>\r
   7 #include "src\lib\modex16.h"\r
   8 \r
   9 \r
  10 byte far* VGA=(byte far*) 0xA0000000;   /* this points to video memory. */\r
  11 \r
  12 static void fadePalette(sbyte fade, sbyte start, word iter, byte *palette);\r
  13 static byte tmppal[PAL_SIZE];\r
  14 \r
  15 static void\r
  16 vgaSetMode(byte mode)\r
  17 {\r
  18   union REGS regs;\r
  19 \r
  20   regs.h.ah = SET_MODE;\r
  21   regs.h.al = mode;\r
  22   int86(VIDEO_INT, &regs, &regs);\r
  23 }\r
  24 \r
  25 \r
  26 /* -========================= Entry  Points ==========================- */\r
  27 void\r
  28 modexEnter() {\r
  29     word i;\r
  30     dword far*ptr=(dword far*)VGA;      /* used for faster screen clearing */\r
  31     word CRTParms[] = {\r
  32         0x0d06,         /* vertical total */\r
  33         0x3e07,         /* overflow (bit 8 of vertical counts) */\r
  34         0x4109,         /* cell height (2 to double-scan */\r
  35         0xea10,         /* v sync start */\r
  36         0xac11,         /* v sync end and protect cr0-cr7 */\r
  37         0xdf12,         /* vertical displayed */\r
  38         0x0014,         /* turn off dword mode */\r
  39         0xe715,         /* v blank start */\r
  40         0x0616,         /* v blank end */\r
  41         0xe317          /* turn on byte mode */\r
  42     };\r
  43     int CRTParmCount = sizeof(CRTParms) / sizeof(CRTParms[0]);\r
  44 \r
  45     /* TODO save current video mode and palette */\r
  46     vgaSetMode(VGA_256_COLOR_MODE);\r
  47 \r
  48     /* disable chain4 mode */\r
  49     outpw(SC_INDEX, 0x0604);\r
  50 \r
  51     /* synchronous reset while setting Misc Output */\r
  52     outpw(SC_INDEX, 0x0100);\r
  53 \r
  54     /* select 25 MHz dot clock & 60 Hz scanning rate */\r
  55     outp(MISC_OUTPUT, 0xe3);\r
  56 \r
  57     /* undo reset (restart sequencer) */\r
  58     outpw(SC_INDEX, 0x0300);\r
  59 \r
  60     /* reprogram the CRT controller */\r
  61     outp(CRTC_INDEX, 0x11); /* VSync End reg contains register write prot */\r
  62     outp(CRTC_DATA, 0x7f);  /* get current write protect on varios regs */\r
  63 \r
  64     /* send the CRTParms */\r
  65     for(i=0; i<CRTParmCount; i++) {\r
  66         outpw(CRTC_INDEX, CRTParms[i]);\r
  67     }\r
  68 \r
  69     /* clear video memory */\r
  70     outpw(SC_INDEX, 0x0f02);\r
  71     for(i=0; i<0x8000; i++) {\r
  72         ptr[i] = 0x0000;\r
  73     }\r
  74 }\r
  75 \r
  76 \r
  77 void\r
  78 modexLeave() {\r
  79     /* TODO restore original mode and palette */\r
  80     vgaSetMode(TEXT_MODE);\r
  81 }\r
  82 \r
  83 \r
  84 page_t\r
  85 modexDefaultPage() {\r
  86     page_t page;\r
  87 \r
  88     /* default page values */\r
  89     page.data = VGA;\r
  90     page.dx = 0;\r
  91     page.dy = 0;\r
  92     page.width = SCREEN_WIDTH;\r
  93     page.height = SCREEN_HEIGHT;\r
  94 \r
  95     return page;\r
  96 }\r
  97 \r
  98 /* returns the next page in contiguous memory\r
  99  * the next page will be the same size as p, by default\r
 100  */\r
 101 page_t\r
 102 modexNextPage(page_t *p) {\r
 103     page_t result;\r
 104 \r
 105     result.data = p->data + (p->width/4)*p->height;  /* compute the offset */\r
 106     result.dx = 0;\r
 107     result.dy = 0;\r
 108     result.width = p->width;\r
 109     result.height = p->height;\r
 110 \r
 111     return result;\r
 112 }\r
 113 \r
 114 \r
 115 void\r
 116 modexShowPage(page_t *page) {\r
 117     word high_address;\r
 118     word low_address;\r
 119     word offset;\r
 120     byte crtcOffset;\r
 121 \r
 122     /* calculate offset */\r
 123     offset = (word) page->data;\r
 124     offset += page->dy * (page->width >> 2 );\r
 125     offset += page->dx >> 2;\r
 126 \r
 127     /* calculate crtcOffset according to virtual width */\r
 128     crtcOffset = page->width >> 3;\r
 129 \r
 130     high_address = HIGH_ADDRESS | (offset & 0xff00);\r
 131     low_address  = LOW_ADDRESS  | (offset << 8);\r
 132 \r
 133     /* wait for appropriate timing and then program CRTC */\r
 134     while ((inp(INPUT_STATUS_1) & DISPLAY_ENABLE));\r
 135     outpw(CRTC_INDEX, high_address);\r
 136     outpw(CRTC_INDEX, low_address);\r
 137     outp(CRTC_INDEX, 0x13);\r
 138     outp(CRTC_DATA, crtcOffset);\r
 139 \r
 140     /*  wait for one retrace */\r
 141     while (!(inp(INPUT_STATUS_1) & VRETRACE)); \r
 142 \r
 143     /* do PEL panning here */\r
 144     outp(AC_INDEX, 0x33);\r
 145     outp(AC_INDEX, (page->dx & 0x03) << 1);\r
 146 }\r
 147 \r
 148 \r
 149 void\r
 150 modexPanPage(page_t *page, int dx, int dy) {\r
 151     page->dx = dx;\r
 152     page->dy = dy;\r
 153 }\r
 154 \r
 155 \r
 156 void\r
 157 modexSelectPlane(byte plane) {\r
 158     outp(SC_INDEX, MAP_MASK);          /* select plane */\r
 159     outp(SC_DATA,  plane);\r
 160 }\r
 161 \r
 162 \r
 163 void\r
 164 modexClearRegion(page_t *page, int x, int y, int w, int h, byte  color) {\r
 165     word pageOff = (word) page->data;\r
 166     word xoff=x/4;       /* xoffset that begins each row */\r
 167     word scanCount=w/4;  /* number of iterations per row (excluding right clip)*/\r
 168     word poffset = pageOff + y*(page->width/4) + xoff; /* starting offset */\r
 169     word nextRow = page->width/4-scanCount-1;  /* loc of next row */\r
 170     byte lclip[] = {0x0f, 0x0e, 0x0c, 0x08};  /* clips for rectangles not on 4s */\r
 171     byte rclip[] = {0x00, 0x01, 0x03, 0x07};\r
 172     byte left = lclip[x&0x03];\r
 173     byte right = rclip[(x+w)&0x03];\r
 174 \r
 175     /* handle the case which requires an extra group */\r
 176     if((x & 0x03) && !((x+w) & 0x03)) {\r
 177       right=0x0f;\r
 178     }\r
 179 \r
 180     __asm {\r
 181                 MOV AX, SCREEN_SEG      ; go to the VGA memory\r
 182                 MOV ES, AX\r
 183                 MOV DI, poffset         ; go to the first pixel\r
 184                 MOV DX, SC_INDEX        ; point to the map mask\r
 185                 MOV AL, MAP_MASK\r
 186                 OUT DX, AL\r
 187                 INC DX\r
 188                 MOV AL, color           ; get ready to write colors\r
 189         SCAN_START:\r
 190                 MOV CX, scanCount       ; count the line\r
 191                 MOV BL, AL              ; remember color\r
 192                 MOV AL, left            ; do the left clip\r
 193                 OUT DX, AL              ; set the left clip\r
 194                 MOV AL, BL              ; restore color\r
 195                 STOSB                   ; write the color\r
 196                 DEC CX\r
 197                 JZ SCAN_DONE            ; handle 1 group stuff\r
 198 \r
 199                 ;-- write the main body of the scanline\r
 200                 MOV BL, AL              ; remember color\r
 201                 MOV AL, 0x0f            ; write to all pixels\r
 202                 OUT DX, AL\r
 203                 MOV AL, BL              ; restore color\r
 204                 REP STOSB               ; write the color\r
 205         SCAN_DONE:\r
 206                 MOV BL, AL              ; remeber color\r
 207                 MOV AL, right\r
 208                 OUT DX, AL              ; do the right clip\r
 209                 MOV AL, BL              ; restore color\r
 210                 STOSB                   ; write pixel\r
 211                 ADD DI, nextRow         ; go to the next row\r
 212                 DEC h\r
 213                 JNZ SCAN_START\r
 214     }\r
 215 }\r
 216 \r
 217 \r
 218 void\r
 219 modexDrawBmp(page_t *page, int x, int y, bitmap_t *bmp) {\r
 220     /* draw the region (the entire freakin bitmap) */\r
 221     modexDrawBmpRegion(page, x, y, 0, 0, bmp->width, bmp->height, bmp);\r
 222 }\r
 223 \r
 224 \r
 225 void\r
 226 modexDrawBmpRegion(page_t *page, int x, int y,\r
 227                    int rx, int ry, int rw, int rh, bitmap_t *bmp) {\r
 228     word poffset = (word) page->data  + y*(page->width/4) + x/4;\r
 229     byte *data = bmp->data;\r
 230     word bmpOffset = (word) data + ry * bmp->width + rx;\r
 231     word width = rw;\r
 232     word height = rh;\r
 233     byte plane = 1 << ((byte) x & 0x03);\r
 234     word scanCount = width/4 + (width%4 ? 1 :0);\r
 235     word nextPageRow = page->width/4 - scanCount;\r
 236     word nextBmpRow = (word) bmp->width - width;\r
 237     word rowCounter;\r
 238     byte planeCounter = 4;\r
 239 \r
 240         //code is a bit slow here\r
 241     __asm {\r
 242                 MOV AX, SCREEN_SEG      ; go to the VGA memory\r
 243                 MOV ES, AX\r
 244 \r
 245                 MOV DX, SC_INDEX        ; point at the map mask register\r
 246                 MOV AL, MAP_MASK        ;\r
 247                 OUT DX, AL              ;\r
 248 \r
 249         PLANE_LOOP:\r
 250                 MOV DX, SC_DATA         ; select the current plane\r
 251                 MOV AL, plane           ;\r
 252                 OUT DX, AL              ;\r
 253 \r
 254                 ;-- begin plane painting\r
 255                 MOV AX, height          ; start the row counter\r
 256                 MOV rowCounter, AX      ; \r
 257                 MOV DI, poffset         ; go to the first pixel\r
 258                 MOV SI, bmpOffset       ; go to the bmp pixel\r
 259         ROW_LOOP:\r
 260                 MOV CX, width           ; count the columns\r
 261         SCAN_LOOP:\r
 262                 MOVSB                   ; copy the pixel\r
 263                 SUB CX, 3               ; we skip the next 3\r
 264                 ADD SI, 3               ; skip the bmp pixels\r
 265                 LOOP SCAN_LOOP          ; finish the scan\r
 266 \r
 267                 MOV AX, nextPageRow\r
 268                 ADD DI, AX              ; go to the next row on screen\r
 269                 MOV AX, nextBmpRow\r
 270                 ADD SI, AX              ; go to the next row on bmp\r
 271 \r
 272                 DEC rowCounter\r
 273                 JNZ ROW_LOOP            ; do all the rows\r
 274                 ;-- end plane painting\r
 275 \r
 276                 MOV AL, plane           ; advance to the next plane\r
 277                 SHL AL, 1               ;\r
 278                 AND AL, 0x0f            ; mask the plane properly\r
 279                 MOV plane, AL           ; store the plane\r
 280 \r
 281                 INC bmpOffset           ; start bmp at the right spot\r
 282 \r
 283                 DEC planeCounter\r
 284                 JNZ PLANE_LOOP          ; do all 4 planes\r
 285     }\r
 286 }\r
 287 \r
 288 \r
 289 void\r
 290 modexDrawSprite(page_t *page, int x, int y, bitmap_t *bmp) {\r
 291     /* draw the whole sprite */\r
 292     modexDrawSpriteRegion(page, x, y, 0, 0, bmp->width, bmp->height, bmp);\r
 293 }\r
 294 \r
 295 void\r
 296 modexDrawSpriteRegion(page_t *page, int x, int y,\r
 297                       int rx, int ry, int rw, int rh, bitmap_t *bmp) {\r
 298     word poffset = (word)page->data + y*(page->width/4) + x/4;\r
 299     byte *data = bmp->data;\r
 300     word bmpOffset = (word) data + ry * bmp->width + rx;\r
 301     word width = rw;\r
 302     word height = rh;\r
 303     byte plane = 1 << ((byte) x & 0x03);\r
 304     word scanCount = width/4 + (width%4 ? 1 :0);\r
 305     word nextPageRow = page->width/4 - scanCount;\r
 306     word nextBmpRow = (word) bmp->width - width;\r
 307     word rowCounter;\r
 308     byte planeCounter = 4;\r
 309 \r
 310     __asm {\r
 311                 MOV AX, SCREEN_SEG      ; go to the VGA memory\r
 312                 MOV ES, AX\r
 313 \r
 314                 MOV DX, SC_INDEX        ; point at the map mask register\r
 315                 MOV AL, MAP_MASK        ;\r
 316                 OUT DX, AL              ;\r
 317 \r
 318         PLANE_LOOP:\r
 319                 MOV DX, SC_DATA         ; select the current plane\r
 320                 MOV AL, plane           ;\r
 321                 OUT DX, AL              ;\r
 322 \r
 323                 ;-- begin plane painting\r
 324                 MOV AX, height          ; start the row counter\r
 325                 MOV rowCounter, AX      ; \r
 326                 MOV DI, poffset         ; go to the first pixel\r
 327                 MOV SI, bmpOffset       ; go to the bmp pixel\r
 328         ROW_LOOP:\r
 329                 MOV CX, width           ; count the columns\r
 330         SCAN_LOOP:\r
 331                 LODSB\r
 332                 DEC SI\r
 333                 CMP AL, 0\r
 334                 JNE DRAW_PIXEL          ; draw non-zero pixels\r
 335 \r
 336                 INC DI                  ; skip the transparent pixel\r
 337                 ADD SI, 1\r
 338                 JMP NEXT_PIXEL\r
 339         DRAW_PIXEL:\r
 340                 MOVSB                   ; copy the pixel\r
 341         NEXT_PIXEL:\r
 342                 SUB CX, 3               ; we skip the next 3\r
 343                 ADD SI, 3               ; skip the bmp pixels\r
 344                 LOOP SCAN_LOOP          ; finish the scan\r
 345 \r
 346                 MOV AX, nextPageRow\r
 347                 ADD DI, AX              ; go to the next row on screen\r
 348                 MOV AX, nextBmpRow\r
 349                 ADD SI, AX              ; go to the next row on bmp\r
 350 \r
 351                 DEC rowCounter\r
 352                 JNZ ROW_LOOP            ; do all the rows\r
 353                 ;-- end plane painting\r
 354 \r
 355                 MOV AL, plane           ; advance to the next plane\r
 356                 SHL AL, 1               ;\r
 357                 AND AL, 0x0f            ; mask the plane properly\r
 358                 MOV plane, AL           ; store the plane\r
 359 \r
 360                 INC bmpOffset           ; start bmp at the right spot\r
 361 \r
 362                 DEC planeCounter\r
 363                 JNZ PLANE_LOOP          ; do all 4 planes\r
 364     }\r
 365 }\r
 366 \r
 367 \r
 368 /* copy a region of video memory from one page to another.\r
 369  * It assumes that the left edge of the tile is the same on both\r
 370  * regions and the memory areas do not overlap.\r
 371  */\r
 372 void\r
 373 modexCopyPageRegion(page_t *dest, page_t *src,\r
 374                     word sx, word sy,\r
 375                     word dx, word dy,\r
 376                     word width, word height)\r
 377 {\r
 378     word doffset = (word)dest->data + dy*(dest->width/4) + dx/4;\r
 379     word soffset = (word)src->data + sy*(src->width/4) + sx/4;\r
 380     word scans   = width/4;\r
 381     word nextSrcRow = src->width/4 - scans - 1;\r
 382     word nextDestRow = dest->width/4 - scans - 1;\r
 383     byte lclip[] = {0x0f, 0x0e, 0x0c, 0x08};  /* clips for rectangles not on 4s */\r
 384     byte rclip[] = {0x0f, 0x01, 0x03, 0x07};\r
 385     byte left = lclip[sx&0x03];\r
 386     byte right = rclip[(sx+width)&0x03];\r
 387 \r
 388     __asm {\r
 389                 MOV AX, SCREEN_SEG      ; work in the vga space\r
 390                 MOV ES, AX              ;\r
 391                 MOV DI, doffset         ;\r
 392                 MOV SI, soffset         ;\r
 393 \r
 394                 MOV DX, GC_INDEX        ; turn off cpu bits\r
 395                 MOV AX, 0008h           ;\r
 396                 OUT DX, AX\r
 397 \r
 398                 MOV AX, SC_INDEX        ; point to the mask register\r
 399                 MOV DX, AX              ;\r
 400                 MOV AL, MAP_MASK        ;\r
 401                 OUT DX, AL              ;\r
 402                 INC DX                  ;\r
 403 \r
 404         ROW_START:\r
 405                 PUSH DS\r
 406                 MOV AX, ES\r
 407                 MOV DS, AX\r
 408                 MOV CX, scans           ; the number of latches\r
 409 \r
 410                 MOV AL, left            ; do the left column\r
 411                 OUT DX, AL              ;\r
 412                 MOVSB                   ;\r
 413                 DEC CX                  ;\r
 414 \r
 415                 MOV AL, 0fh             ; do the inner columns\r
 416                 OUT DX, AL\r
 417                 REP MOVSB               ; copy the pixels\r
 418 \r
 419                 MOV AL, right           ; do the right column\r
 420                 OUT DX, AL\r
 421                 MOVSB\r
 422                 POP DS\r
 423 \r
 424                 MOV AX, SI              ; go the start of the next row\r
 425                 ADD AX, nextSrcRow      ;\r
 426                 MOV SI, AX              ;\r
 427                 MOV AX, DI              ;\r
 428                 ADD AX, nextDestRow     ;\r
 429                 MOV DI, AX              ;\r
 430 \r
 431                 DEC height              ; do the rest of the actions\r
 432                 JNZ ROW_START           ;\r
 433 \r
 434                 MOV DX, GC_INDEX+1      ; go back to CPU data\r
 435                 MOV AL, 0ffh            ; none from latches\r
 436                 OUT DX, AL              ;\r
 437     }\r
 438 }\r
 439 \r
 440 \r
 441 /* fade and flash */\r
 442 void\r
 443 modexFadeOn(word fade, byte *palette) {\r
 444     fadePalette(-fade, 64, 64/fade+1, palette);\r
 445 }\r
 446 \r
 447 \r
 448 void\r
 449 modexFadeOff(word fade, byte *palette) {\r
 450     fadePalette(fade, 0, 64/fade+1, palette);\r
 451 }\r
 452 \r
 453 \r
 454 void\r
 455 modexFlashOn(word fade, byte *palette) {\r
 456     fadePalette(fade, -64, 64/fade+1, palette);\r
 457 }\r
 458 \r
 459 \r
 460 void\r
 461 modexFlashOff(word fade, byte *palette) {\r
 462     fadePalette(-fade, 0, 64/fade+1, palette);\r
 463 }\r
 464 \r
 465 \r
 466 static void\r
 467 fadePalette(sbyte fade, sbyte start, word iter, byte *palette) {\r
 468     word i;\r
 469     byte dim = start;\r
 470 \r
 471     /* handle the case where we just update */\r
 472     if(iter == 0) {\r
 473         modexPalUpdate(palette);\r
 474         return;\r
 475     }\r
 476 \r
 477     while(iter > 0) {  /* FadeLoop */\r
 478         for(i=0; i<PAL_SIZE; i++) { /* loadpal_loop */\r
 479             tmppal[i] = palette[i] - dim;\r
 480             if(tmppal[i] > 127) {\r
 481                 tmppal[i] = 0;\r
 482             } else if(tmppal[i] > 63) {\r
 483                 tmppal[i] = 63;\r
 484             }\r
 485         }\r
 486         modexPalUpdate(tmppal);\r
 487         iter--;\r
 488         dim += fade;\r
 489     }\r
 490 }\r
 491 \r
 492 \r
 493 /* save and load */\r
 494 void\r
 495 modexPalSave(byte *palette) {\r
 496     int  i;\r
 497 \r
 498     outp(PAL_READ_REG, 0);      /* start at palette entry 0 */\r
 499     for(i=0; i<PAL_SIZE; i++) {\r
 500         palette[i] = inp(PAL_DATA_REG); /* read the palette data */\r
 501     }\r
 502 }\r
 503 \r
 504 \r
 505 byte *\r
 506 modexNewPal() {\r
 507     byte *ptr;\r
 508     ptr = malloc(PAL_SIZE);\r
 509 \r
 510     /* handle errors */\r
 511     if(!ptr) {\r
 512         printf("Could not allocate palette.\n");\r
 513         exit(-1);\r
 514     }\r
 515 \r
 516     return ptr;\r
 517 }\r
 518 \r
 519 \r
 520 void\r
 521 modexLoadPalFile(byte *filename, byte **palette) {\r
 522     FILE *file;\r
 523     byte *ptr;\r
 524 \r
 525     /* free the palette if it exists */\r
 526     if(*palette) {\r
 527         free(*palette);\r
 528     }\r
 529 \r
 530     /* allocate the new palette */\r
 531     *palette = modexNewPal();\r
 532 \r
 533     /* open the file */\r
 534     file = fopen(filename, "rb");\r
 535     if(!file) {\r
 536         printf("Could not open palette file: %s\n", filename);\r
 537         exit(-2);\r
 538     }\r
 539 \r
 540     /* read the file */\r
 541     ptr = *palette;\r
 542     while(!feof(file)) {\r
 543         *ptr++ = fgetc(file);\r
 544     }\r
 545 \r
 546     fclose(file);\r
 547 }\r
 548 \r
 549 \r
 550 void\r
 551 modexSavePalFile(char *filename, byte *pal) {\r
 552     unsigned int i;\r
 553     FILE *file;\r
 554 \r
 555     /* open the file for writing */\r
 556     file = fopen(filename, "wb");\r
 557     if(!file) {\r
 558         printf("Could not open %s for writing\n", filename);\r
 559         exit(-2);\r
 560     }\r
 561 \r
 562     /* write the data to the file */\r
 563     fwrite(pal, 1, PAL_SIZE, file);\r
 564     fclose(file);\r
 565 }\r
 566 \r
 567 \r
 568 /* blanking */\r
 569 void\r
 570 modexPalBlack() {\r
 571     fadePalette(-1, 64, 1, tmppal);\r
 572 }\r
 573 \r
 574 \r
 575 void\r
 576 modexPalWhite() {\r
 577     fadePalette(-1, -64, 1, tmppal);\r
 578 }\r
 579 \r
 580 \r
 581 /* utility */\r
 582 void\r
 583 modexPalUpdate(byte *p) {\r
 584     int i;\r
 585     modexWaitBorder();\r
 586     outp(PAL_WRITE_REG, 0);  /* start at the beginning of palette */\r
 587     for(i=0; i<PAL_SIZE/2; i++) {\r
 588         outp(PAL_DATA_REG, p[i]);\r
 589     }\r
 590     modexWaitBorder();      /* waits one retrace -- less flicker */\r
 591     for(i=PAL_SIZE/2; i<PAL_SIZE; i++) {\r
 592         outp(PAL_DATA_REG, p[i]);\r
 593     }\r
 594 }\r
 595 \r
 596 \r
 597 void\r
 598 modexWaitBorder() {\r
 599     while(inp(INPUT_STATUS_1)  & 8)  {\r
 600         /* spin */\r
 601     }\r
 602 \r
 603     while(!(inp(INPUT_STATUS_1)  & 8))  {\r
 604         /* spin */\r
 605     }\r
 606 }\r