16/modex16/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 "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     __asm {\r
 241                 MOV AX, SCREEN_SEG      ; go to the VGA memory\r
 242                 MOV ES, AX\r
 243 \r
 244                 MOV DX, SC_INDEX        ; point at the map mask register\r
 245                 MOV AL, MAP_MASK        ;\r
 246                 OUT DX, AL              ;\r
 247 \r
 248         PLANE_LOOP:\r
 249                 MOV DX, SC_DATA         ; select the current plane\r
 250                 MOV AL, plane           ;\r
 251                 OUT DX, AL              ;\r
 252 \r
 253                 ;-- begin plane painting\r
 254                 MOV AX, height          ; start the row counter\r
 255                 MOV rowCounter, AX      ; \r
 256                 MOV DI, poffset         ; go to the first pixel\r
 257                 MOV SI, bmpOffset       ; go to the bmp pixel\r
 258         ROW_LOOP:\r
 259                 MOV CX, width           ; count the columns\r
 260         SCAN_LOOP:\r
 261                 MOVSB                   ; copy the pixel\r
 262                 SUB CX, 3               ; we skip the next 3\r
 263                 ADD SI, 3               ; skip the bmp pixels\r
 264                 LOOP SCAN_LOOP          ; finish the scan\r
 265 \r
 266                 MOV AX, nextPageRow\r
 267                 ADD DI, AX              ; go to the next row on screen\r
 268                 MOV AX, nextBmpRow\r
 269                 ADD SI, AX              ; go to the next row on bmp\r
 270 \r
 271                 DEC rowCounter\r
 272                 JNZ ROW_LOOP            ; do all the rows\r
 273                 ;-- end plane painting\r
 274 \r
 275                 MOV AL, plane           ; advance to the next plane\r
 276                 SHL AL, 1               ;\r
 277                 AND AL, 0x0f            ; mask the plane properly\r
 278                 MOV plane, AL           ; store the plane\r
 279 \r
 280                 INC bmpOffset           ; start bmp at the right spot\r
 281 \r
 282                 DEC planeCounter\r
 283                 JNZ PLANE_LOOP          ; do all 4 planes\r
 284     }\r
 285 }\r
 286 \r
 287 \r
 288 void\r
 289 modexDrawSprite(page_t *page, int x, int y, bitmap_t *bmp) {\r
 290     /* draw the whole sprite */\r
 291     modexDrawSpriteRegion(page, x, y, 0, 0, bmp->width, bmp->height, bmp);\r
 292 }\r
 293 \r
 294 void\r
 295 modexDrawSpriteRegion(page_t *page, int x, int y,\r
 296                       int rx, int ry, int rw, int rh, bitmap_t *bmp) {\r
 297     word poffset = (word)page->data + y*(page->width/4) + x/4;\r
 298     byte *data = bmp->data;\r
 299     word bmpOffset = (word) data + ry * bmp->width + rx;\r
 300     word width = rw;\r
 301     word height = rh;\r
 302     byte plane = 1 << ((byte) x & 0x03);\r
 303     word scanCount = width/4 + (width%4 ? 1 :0);\r
 304     word nextPageRow = page->width/4 - scanCount;\r
 305     word nextBmpRow = (word) bmp->width - width;\r
 306     word rowCounter;\r
 307     byte planeCounter = 4;\r
 308 \r
 309     __asm {\r
 310                 MOV AX, SCREEN_SEG      ; go to the VGA memory\r
 311                 MOV ES, AX\r
 312 \r
 313                 MOV DX, SC_INDEX        ; point at the map mask register\r
 314                 MOV AL, MAP_MASK        ;\r
 315                 OUT DX, AL              ;\r
 316 \r
 317         PLANE_LOOP:\r
 318                 MOV DX, SC_DATA         ; select the current plane\r
 319                 MOV AL, plane           ;\r
 320                 OUT DX, AL              ;\r
 321 \r
 322                 ;-- begin plane painting\r
 323                 MOV AX, height          ; start the row counter\r
 324                 MOV rowCounter, AX      ; \r
 325                 MOV DI, poffset         ; go to the first pixel\r
 326                 MOV SI, bmpOffset       ; go to the bmp pixel\r
 327         ROW_LOOP:\r
 328                 MOV CX, width           ; count the columns\r
 329         SCAN_LOOP:\r
 330                 LODSB\r
 331                 DEC SI\r
 332                 CMP AL, 0\r
 333                 JNE DRAW_PIXEL          ; draw non-zero pixels\r
 334 \r
 335                 INC DI                  ; skip the transparent pixel\r
 336                 ADD SI, 1\r
 337                 JMP NEXT_PIXEL\r
 338         DRAW_PIXEL:\r
 339                 MOVSB                   ; copy the pixel\r
 340         NEXT_PIXEL:\r
 341                 SUB CX, 3               ; we skip the next 3\r
 342                 ADD SI, 3               ; skip the bmp pixels\r
 343                 LOOP SCAN_LOOP          ; finish the scan\r
 344 \r
 345                 MOV AX, nextPageRow\r
 346                 ADD DI, AX              ; go to the next row on screen\r
 347                 MOV AX, nextBmpRow\r
 348                 ADD SI, AX              ; go to the next row on bmp\r
 349 \r
 350                 DEC rowCounter\r
 351                 JNZ ROW_LOOP            ; do all the rows\r
 352                 ;-- end plane painting\r
 353 \r
 354                 MOV AL, plane           ; advance to the next plane\r
 355                 SHL AL, 1               ;\r
 356                 AND AL, 0x0f            ; mask the plane properly\r
 357                 MOV plane, AL           ; store the plane\r
 358 \r
 359                 INC bmpOffset           ; start bmp at the right spot\r
 360 \r
 361                 DEC planeCounter\r
 362                 JNZ PLANE_LOOP          ; do all 4 planes\r
 363     }\r
 364 }\r
 365 \r
 366 \r
 367 /* copy a region of video memory from one page to another.\r
 368  * It assumes that the left edge of the tile is the same on both\r
 369  * regions and the memory areas do not overlap.\r
 370  */\r
 371 void\r
 372 modexCopyPageRegion(page_t *dest, page_t *src,\r
 373                     word sx, word sy,\r
 374                     word dx, word dy,\r
 375                     word width, word height)\r
 376 {\r
 377     word doffset = (word)dest->data + dy*(dest->width/4) + dx/4;\r
 378     word soffset = (word)src->data + sy*(src->width/4) + sx/4;\r
 379     word scans   = width/4;\r
 380     word nextSrcRow = src->width/4 - scans - 1;\r
 381     word nextDestRow = dest->width/4 - scans - 1;\r
 382     byte lclip[] = {0x0f, 0x0e, 0x0c, 0x08};  /* clips for rectangles not on 4s */\r
 383     byte rclip[] = {0x0f, 0x01, 0x03, 0x07};\r
 384     byte left = lclip[sx&0x03];\r
 385     byte right = rclip[(sx+width)&0x03];\r
 386 \r
 387     __asm {\r
 388                 MOV AX, SCREEN_SEG      ; work in the vga space\r
 389                 MOV ES, AX              ;\r
 390                 MOV DI, doffset         ;\r
 391                 MOV SI, soffset         ;\r
 392 \r
 393                 MOV DX, GC_INDEX        ; turn off cpu bits\r
 394                 MOV AX, 0008h           ;\r
 395                 OUT DX, AX\r
 396 \r
 397                 MOV AX, SC_INDEX        ; point to the mask register\r
 398                 MOV DX, AX              ;\r
 399                 MOV AL, MAP_MASK        ;\r
 400                 OUT DX, AL              ;\r
 401                 INC DX                  ;\r
 402 \r
 403         ROW_START:\r
 404                 PUSH DS\r
 405                 MOV AX, ES\r
 406                 MOV DS, AX\r
 407                 MOV CX, scans           ; the number of latches\r
 408 \r
 409                 MOV AL, left            ; do the left column\r
 410                 OUT DX, AL              ;\r
 411                 MOVSB                   ;\r
 412                 DEC CX                  ;\r
 413 \r
 414                 MOV AL, 0fh             ; do the inner columns\r
 415                 OUT DX, AL\r
 416                 REP MOVSB               ; copy the pixels\r
 417 \r
 418                 MOV AL, right           ; do the right column\r
 419                 OUT DX, AL\r
 420                 MOVSB\r
 421                 POP DS\r
 422 \r
 423                 MOV AX, SI              ; go the start of the next row\r
 424                 ADD AX, nextSrcRow      ;\r
 425                 MOV SI, AX              ;\r
 426                 MOV AX, DI              ;\r
 427                 ADD AX, nextDestRow     ;\r
 428                 MOV DI, AX              ;\r
 429 \r
 430                 DEC height              ; do the rest of the actions\r
 431                 JNZ ROW_START           ;\r
 432 \r
 433                 MOV DX, GC_INDEX+1      ; go back to CPU data\r
 434                 MOV AL, 0ffh            ; none from latches\r
 435                 OUT DX, AL              ;\r
 436     }\r
 437 }\r
 438 \r
 439 \r
 440 /* fade and flash */\r
 441 void\r
 442 modexFadeOn(word fade, byte *palette) {\r
 443     fadePalette(-fade, 64, 64/fade+1, palette);\r
 444 }\r
 445 \r
 446 \r
 447 void\r
 448 modexFadeOff(word fade, byte *palette) {\r
 449     fadePalette(fade, 0, 64/fade+1, palette);\r
 450 }\r
 451 \r
 452 \r
 453 void\r
 454 modexFlashOn(word fade, byte *palette) {\r
 455     fadePalette(fade, -64, 64/fade+1, palette);\r
 456 }\r
 457 \r
 458 \r
 459 void\r
 460 modexFlashOff(word fade, byte *palette) {\r
 461     fadePalette(-fade, 0, 64/fade+1, palette);\r
 462 }\r
 463 \r
 464 \r
 465 static void\r
 466 fadePalette(sbyte fade, sbyte start, word iter, byte *palette) {\r
 467     word i;\r
 468     byte dim = start;\r
 469 \r
 470     /* handle the case where we just update */\r
 471     if(iter == 0) {\r
 472         modexPalUpdate(palette);\r
 473         return;\r
 474     }\r
 475 \r
 476     while(iter > 0) {  /* FadeLoop */\r
 477         for(i=0; i<PAL_SIZE; i++) { /* loadpal_loop */\r
 478             tmppal[i] = palette[i] - dim;\r
 479             if(tmppal[i] > 127) {\r
 480                 tmppal[i] = 0;\r
 481             } else if(tmppal[i] > 63) {\r
 482                 tmppal[i] = 63;\r
 483             }\r
 484         }\r
 485         modexPalUpdate(tmppal);\r
 486         iter--;\r
 487         dim += fade;\r
 488     }\r
 489 }\r
 490 \r
 491 \r
 492 /* save and load */\r
 493 void\r
 494 modexPalSave(byte *palette) {\r
 495     int  i;\r
 496 \r
 497     outp(PAL_READ_REG, 0);      /* start at palette entry 0 */\r
 498     for(i=0; i<PAL_SIZE; i++) {\r
 499         palette[i] = inp(PAL_DATA_REG); /* read the palette data */\r
 500     }\r
 501 }\r
 502 \r
 503 \r
 504 byte *\r
 505 modexNewPal() {\r
 506     byte *ptr;\r
 507     ptr = malloc(PAL_SIZE);\r
 508 \r
 509     /* handle errors */\r
 510     if(!ptr) {\r
 511         printf("Could not allocate palette.\n");\r
 512         exit(-1);\r
 513     }\r
 514 \r
 515     return ptr;\r
 516 }\r
 517 \r
 518 \r
 519 void\r
 520 modexLoadPalFile(byte *filename, byte **palette) {\r
 521     FILE *file;\r
 522     byte *ptr;\r
 523 \r
 524     /* free the palette if it exists */\r
 525     if(*palette) {\r
 526         free(*palette);\r
 527     }\r
 528 \r
 529     /* allocate the new palette */\r
 530     *palette = modexNewPal();\r
 531 \r
 532     /* open the file */\r
 533     file = fopen(filename, "rb");\r
 534     if(!file) {\r
 535         printf("Could not open palette file: %s\n", filename);\r
 536         exit(-2);\r
 537     }\r
 538 \r
 539     /* read the file */\r
 540     ptr = *palette;\r
 541     while(!feof(file)) {\r
 542         *ptr++ = fgetc(file);\r
 543     }\r
 544 \r
 545     fclose(file);\r
 546 }\r
 547 \r
 548 \r
 549 void\r
 550 modexSavePalFile(char *filename, byte *pal) {\r
 551     unsigned int i;\r
 552     FILE *file;\r
 553 \r
 554     /* open the file for writing */\r
 555     file = fopen(filename, "wb");\r
 556     if(!file) {\r
 557         printf("Could not open %s for writing\n", filename);\r
 558         exit(-2);\r
 559     }\r
 560 \r
 561     /* write the data to the file */\r
 562     fwrite(pal, 1, PAL_SIZE, file);\r
 563     fclose(file);\r
 564 }\r
 565 \r
 566 \r
 567 /* blanking */\r
 568 void\r
 569 modexPalBlack() {\r
 570     fadePalette(-1, 64, 1, tmppal);\r
 571 }\r
 572 \r
 573 \r
 574 void\r
 575 modexPalWhite() {\r
 576     fadePalette(-1, -64, 1, tmppal);\r
 577 }\r
 578 \r
 579 \r
 580 /* utility */\r
 581 void\r
 582 modexPalUpdate(byte *p) {\r
 583     int i;\r
 584     modexWaitBorder();\r
 585     outp(PAL_WRITE_REG, 0);  /* start at the beginning of palette */\r
 586     for(i=0; i<PAL_SIZE/2; i++) {\r
 587         outp(PAL_DATA_REG, p[i]);\r
 588     }\r
 589     modexWaitBorder();      /* waits one retrace -- less flicker */\r
 590     for(i=PAL_SIZE/2; i<PAL_SIZE; i++) {\r
 591         outp(PAL_DATA_REG, p[i]);\r
 592     }\r
 593 }\r
 594 \r
 595 \r
 596 void\r
 597 modexWaitBorder() {\r
 598     while(inp(INPUT_STATUS_1)  & 8)  {\r
 599         /* spin */\r
 600     }\r
 601 \r
 602     while(!(inp(INPUT_STATUS_1)  & 8))  {\r
 603         /* spin */\r
 604     }\r
 605 }\r