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