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