![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to glyphblt.asm CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga / i386|
Return to glyphblt.asm CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga / i386 |
1.1 ! root 1: ;---------------------------Module-Header------------------------------; ! 2: ; Module Name: glyphblt.asm ! 3: ; ! 4: ; Output a glyph onto VGA screen ! 5: ; ! 6: ; Copyright (c) 1992 Microsoft Corporation ! 7: ;-----------------------------------------------------------------------; ! 8: ! 9: .386 ! 10: ! 11: ifndef DOS_PLATFORM ! 12: .model small,c ! 13: else ! 14: ifdef STD_CALL ! 15: .model small,c ! 16: else ! 17: .model small,pascal ! 18: endif; STD_CALL ! 19: endif; DOS_PLATFORM ! 20: ! 21: assume cs:FLAT,ds:FLAT,es:FLAT,ss:FLAT ! 22: assume fs:nothing,gs:nothing ! 23: ! 24: .xlist ! 25: include stdcall.inc ;calling convention cmacros ! 26: include i386\egavga.inc ! 27: include i386\strucs.inc ! 28: .list ! 29: ! 30: include i386\strblt.inc ! 31: ! 32: .code ! 33: ! 34: ;---------------------------Public-Routine------------------------------; ! 35: ; vGlyphBlt ! 36: ; ! 37: ; Draw a glyph to the VGA screen ! 38: ; ! 39: ;-----------------------------------------------------------------------; ! 40: ! 41: _TEXT$01 SEGMENT DWORD USE32 PUBLIC 'CODE' ! 42: ASSUME CS:FLAT, DS:FLAT, ES:FLAT, SS:NOTHING, FS:NOTHING, GS:NOTHING ! 43: ! 44: ProcName xxxvGlyphBlt,vGlyphBlt,32 ! 45: ! 46: xxxvGlyphBlt proc uses esi edi ebx, \ ! 47: pdsurf: ptr DEVSURF, \ ! 48: prcl: ptr RECTL, \ ! 49: cStr: DWORD, \ ! 50: pgp: ptr GLYPHPOS, \ ! 51: iForeClr: dword, \ ! 52: iBackClr: dword, \ ! 53: ulMode: dword, \ ! 54: flOption: dword ! 55: ! 56: local pjScreen :ptr ; screen pointer ! 57: local pjGlyph :ptr ; pointer to glyph bits ! 58: local cScan :dword ; visible glyph height ! 59: local cPels :dword ; visible glyph width ! 60: local cjBytes :dword ; glyph scan size ! 61: local cTmp :dword ; temporary scan count ! 62: local cInnerBytes :dword ! 63: local ulNextScan :dword ;offset from one screen scan to next ! 64: local cfBits :byte ! 65: local cfLeft :byte ! 66: local fjMask :byte ! 67: local fjLastMask :byte ! 68: local cfLastBits :byte ! 69: ! 70: ; Initialize stuff ! 71: ! 72: cld ! 73: mov edi,pdsurf ! 74: mov esi,prcl ! 75: ! 76: ; Set the offset from one scan to the next ! 77: ! 78: mov eax,[edi].dsurf_lNextScan ! 79: mov ulNextScan,eax ! 80: ! 81: ; Calculate number of scans for bltting cell ! 82: ! 83: gblt_calc_dest_addr: ! 84: mov eax,[esi].yTop ! 85: mov edx,[esi].yBottom ! 86: sub edx,eax ! 87: mov cScan,edx ; Number of scans ! 88: ! 89: ; Can we assume positive value? ! 90: ! 91: mov edx,ulNextScan ! 92: mul edx ; EAX = byte offset to scan ! 93: ! 94: ; Calculate cell width in pels ! 95: ! 96: mov ebx,[esi].xRight ! 97: mov ecx,[esi].xLeft ! 98: sub ebx,ecx ! 99: mov cPels,ebx ; Width in pels ! 100: ! 101: ; Calculate pointer to the 1st screen byte to blt ! 102: ! 103: mov edx,ecx ! 104: shr edx,3 ! 105: add eax,edx ! 106: add eax,[edi].dsurf_pvBitmapStart ! 107: mov pjScreen,eax ; Base address of blit ! 108: ! 109: ; Calculate the destination left edge mask ! 110: ! 111: gblt_left_mask: ! 112: xor eax,eax ! 113: cdq ! 114: mov cInnerBytes,eax ; Assume glyph fits one byte ! 115: mov fjLastMask,al ! 116: and cl,7 ! 117: mov dl,8 ! 118: sub dl,cl ; DL = bits in mask ! 119: ! 120: dec al ! 121: shr al,cl ; AL = left mask ! 122: ! 123: ; Assume cell is at least one byte wide ! 124: ! 125: mov fjMask,al ; then we have this left mask ! 126: mov cfBits,dl ; along with 1 bits count ! 127: sub ebx,edx ; EBX = cPels, EDX = bits in left mask ! 128: jg short gblt_inner_count ; but if the assume is true? ! 129: je short gblt_glyph_info ! 130: ! 131: ; It is less than one byte wide, calculate the right edge mask ! 132: ! 133: mov cl,bl ! 134: neg cl ! 135: inc ah ; AH = 1 ! 136: shl ah,cl ! 137: neg ah ; AH = right mask ! 138: and al,ah ; AL = composite mask ! 139: mov fjMask,al ! 140: jmp short gblt_glyph_info ; no middle or last bytes ! 141: ! 142: ; Calculate the inner count ! 143: ! 144: gblt_inner_count: ! 145: mov ecx,ebx ; EBX = # bits left in cell ! 146: shr ebx,3 ! 147: mov cInnerBytes,ebx ; inner byte count ! 148: ! 149: ; Calculate the last byte mask ! 150: ! 151: gblt_last_mask: ! 152: and cl,7 ; CL = # of trailing bits ! 153: mov cfLastBits,cl ! 154: dec ah ; AH = 0FFh ! 155: shr ah,cl ! 156: not ah ! 157: mov fjLastMask,ah ! 158: ! 159: ; Now get the glyph information ! 160: ! 161: gblt_glyph_info: ! 162: mov edi,pgp ! 163: mov ebx,[edi].gp_pgdf ! 164: mov ebx,[ebx].gdf_pgb ; ptr to glyph bits ! 165: ! 166: ; Calculate the glyph scan size ! 167: ! 168: gblt_glyph_scan: ! 169: mov eax,[ebx].gb_cx ; Glyph width in pels ! 170: add eax,7 ! 171: ; and al,0e0h ; DWORD aligned ! 172: shr eax,3 ! 173: mov cjBytes,eax ; Count to move to next line of glyph ! 174: ! 175: ; Assume the glyph is not clipped ! 176: ! 177: lea edx,[ebx].gb_aj ! 178: mov pjGlyph,edx ; Start of glyph ! 179: mov dl,8 ! 180: mov cfLeft,dl ; Bits left in glyph byte ! 181: test flOption,VGB_VERT_CLIPPED_GLYPH or VGB_HORIZ_CLIPPED_GLYPH ! 182: jz short gblt_draw_glyph ! 183: ! 184: ; Calculate byte offset of the 1st scan in glyph ! 185: ! 186: gblt_glyph_offset: ! 187: mov edx,[esi].yTop ! 188: sub edx,[edi].gp_y ; Vertical offset into glyph ! 189: mul edx ; Can we assume positive value? ! 190: ! 191: ; Calculate offset to the 1st byte in Glyph ! 192: ! 193: mov edx,[esi].xLeft ! 194: sub edx,[edi].gp_x ; Horizontal offset into glyph ! 195: mov ecx,edx ! 196: shr edx,3 ! 197: add eax,edx ; Offset into glyph ! 198: add pjGlyph,eax ; Start of glyph ! 199: ! 200: ; Calculate glyph's left mask ! 201: ! 202: gblt_glyph_left_mask: ! 203: and cl,7 ! 204: sub cfLeft,cl ; Bits left in glyph byte ! 205: ! 206: ; Setup the drawing parameters ! 207: ! 208: gblt_draw_glyph: ! 209: mov eax,ulMode ; determine the write mode ! 210: call offset FLAT:vgblt_table.[eax*4] ! 211: ! 212: ; Everything is done, go home ! 213: ! 214: glyph_blt_exit: ! 215: ! 216: cRet vGlyphBlt ! 217: ! 218: vgblt_table equ this dword ! 219: dd offset FLAT:vgblt_mix_glyph ! 220: dd offset FLAT:vgblt_opaque_glyph ! 221: ! 222: .errnz VGB_MIX_STRING ! 223: .errnz VGB_OPAQUE_STRING-1 ! 224: ! 225: ;---------------------------Public-Routine------------------------------; ! 226: ; vgblt_mix_glyph ! 227: ; ! 228: ; Draw a glyph to the VGA screen using the write mode 0 ! 229: ; ! 230: ;-----------------------------------------------------------------------; ! 231: ! 232: vgblt_mix_glyph:: ! 233: ! 234: mov dx,VGA_BASE + GRAF_ADDR ; Leave this in a register ! 235: mov eax,cScan ! 236: mov cTmp,eax ; Scans to draw ! 237: mov esi,pjGlyph ; Read glyph from here ! 238: mov edi,pjScreen ; Write glyph to there ! 239: mov bh,fjMask ; Current mask ! 240: mov cl,cfLeft ; Bits available in current byte ! 241: ! 242: sub cl,cfBits ! 243: jl short vmg_fetch_two_bytes ! 244: ! 245: ; ! 246: ; Fetching one byte means we are at the left edge of the glyph, or ! 247: ; by some miracle we are aligned with the VGA memory. Either way ! 248: ; we will still mask the data with fjMask. ! 249: ; ! 250: ! 251: vmg_fetch_one_byte: ! 252: mov al,GRAF_BIT_MASK ; leave it in AL ! 253: ! 254: vmg_fetch_one_byte_next: ! 255: mov ah,[esi] ; AH = glyph data ! 256: ! 257: shr ah,cl ; Put usable glyph data in place ! 258: ! 259: and ah,bh ; AH = masked glyph data ! 260: jz short @F ; Don't waste time ! 261: ! 262: out dx,ax ! 263: xchg ah,[edi] ; Set the bits ! 264: ! 265: @@: ! 266: add edi,ulNextScan ; Next scan on VGA ! 267: add esi,cjBytes ; Next line of glyph ! 268: dec cTmp ! 269: jnz short vmg_fetch_one_byte_next ; finish column ! 270: ! 271: neg cl ! 272: and cl,7 ; CL = # usable bits in next byte ! 273: jnz short vmg_advance_screen_ptr ! 274: jmp short vmg_advance_glyph_ptr ! 275: ! 276: ; The current screen byte covers two glyph bytes ! 277: ! 278: vmg_fetch_two_bytes: ! 279: mov bl,GRAF_BIT_MASK ; Set bitmask for altered bits ! 280: neg cl ; CL = # bits required from next byte ! 281: add cl,8 ; we will have to swap AH and AL ! 282: ! 283: vmg_fetch_two_bytes_next: ! 284: mov ax,[esi] ; AL = current byte, AH = next byte ! 285: rol ax,cl ; AH = glyph data ! 286: ! 287: and ah,bh ; AH = masked glyph data ! 288: jz short @F ; Don't waste time ! 289: ! 290: mov al,bl ! 291: out dx,ax ! 292: xchg al,[edi] ; Set the bits ! 293: ! 294: @@: ! 295: add edi,ulNextScan ; Next scan on VGA ! 296: add esi,cjBytes ; Next line of glyph ! 297: dec cTmp ! 298: jnz short vmg_fetch_two_bytes_next ; finish column ! 299: sub cl,8 ; CL = # bits required from next byte ! 300: ! 301: ; We will start the next screen column byte. Recalculate parameters. ! 302: ! 303: vmg_advance_glyph_ptr: ! 304: inc pjGlyph ; increment glyph pointer ! 305: ! 306: vmg_advance_screen_ptr: ! 307: inc pjScreen ; Increment screen pointer ! 308: ! 309: vmg_inner_bytes: ! 310: mov ebx,cInnerBytes ; do we have inner bytes? ! 311: or ebx,ebx ! 312: jz short vmg_last_byte ! 313: ! 314: mov eax,cScan ! 315: mov cTmp,eax ; Scans to draw ! 316: mov esi,pjGlyph ; Read glyph from here ! 317: mov edi,pjScreen ; Write glyph to there ! 318: add pjGlyph,ebx ; advance pointer ! 319: add pjScreen,ebx ! 320: sub cjBytes,ebx ; glyph scan incremental ! 321: or cl,cl ! 322: jnz short vmg_inner_fetch_two_bytes ! 323: ! 324: mov al,GRAF_BIT_MASK ; leave it in AL ! 325: ! 326: vmg_inner_fetch_one_byte: ! 327: mov ah,[esi] ; AH = glyph data ! 328: or ah,ah ! 329: jz short @F ; Don't waste time ! 330: ! 331: out dx,ax ! 332: xchg ah,[edi] ; Set the bits ! 333: ! 334: @@: ! 335: inc esi ! 336: inc edi ! 337: dec ebx ! 338: jnz short vmg_inner_fetch_one_byte ! 339: ! 340: mov ebx,cInnerBytes ! 341: add edi,ulNextScan ; Next scan on VGA ! 342: add esi,cjBytes ; Next line of glyph ! 343: sub edi,ebx ; adjust for previous increment ! 344: dec cTmp ! 345: jnz short vmg_inner_fetch_one_byte ; finish column ! 346: ! 347: jmp short vmg_inner_byte_end ! 348: ! 349: ; The current screen byte covers two glyph bytes ! 350: ! 351: vmg_inner_fetch_two_bytes: ! 352: add cl,8 ; we will have to swap AH and AL ! 353: ! 354: vmg_inner_fetch_two_bytes_next: ! 355: mov ax,[esi] ; AL = curr byte, AH = next byte ! 356: rol ax,cl ; AH = glyph data ! 357: jz short @F ; Don't waste time ! 358: ! 359: mov al,GRAF_BIT_MASK ! 360: out dx,ax ! 361: xchg al,[edi] ; Set the bits ! 362: @@: ! 363: inc esi ! 364: inc edi ! 365: dec ebx ! 366: jnz short vmg_inner_fetch_two_bytes_next ! 367: ! 368: mov ebx,cInnerBytes ! 369: add edi,ulNextScan ; Next scan on VGA ! 370: add esi,cjBytes ; Next line of glyph ! 371: sub edi,ebx ; adjust for previous increment ! 372: dec cTmp ! 373: jnz short vmg_inner_fetch_two_bytes_next ; finish column ! 374: sub cl,8 ! 375: ! 376: vmg_inner_byte_end: ! 377: add cjBytes,ebx ; restore its actual value ! 378: ! 379: vmg_last_byte: ! 380: mov bl,fjLastMask ; BL = last byte mask ! 381: or bl,bl ! 382: jz short vmg_exit ! 383: ! 384: mov esi,pjGlyph ; Read glyph from here ! 385: mov edi,pjScreen ; Write glyph to there ! 386: mov ch,8 ! 387: sub ch,cl ; CH = # usable bits in current byte ! 388: cmp ch,cfLastBits ; do we need the next byte? ! 389: jl short vmg_last_fetch_two_bytes ! 390: ! 391: mov al,GRAF_BIT_MASK ! 392: ! 393: vmg_last_fetch_one_byte: ! 394: mov ah,[esi] ; AH = glyph data ! 395: shl ah,cl ! 396: and ah,bl ! 397: jz short @F ; Don't waste time ! 398: ! 399: out dx,ax ! 400: xchg ah,[edi] ; Set the bits ! 401: ! 402: @@: ! 403: add edi,ulNextScan ; Next scan on VGA ! 404: add esi,cjBytes ; Next line of glyph ! 405: dec cScan ! 406: jnz short vmg_last_fetch_one_byte ; finish column ! 407: ! 408: jmp short vmg_exit ! 409: ! 410: ; The current screen byte covers two glyph bytes ! 411: ! 412: vmg_last_fetch_two_bytes: ! 413: add cl,8 ; we will swap AH and AL ! 414: mov bh,GRAF_BIT_MASK ! 415: ! 416: vmg_last_fetch_two_bytes_next: ! 417: mov ax,[esi] ! 418: rol ax,cl ; AH = glyph data ! 419: and ah,bl ! 420: jz short @F ; Don't waste time ! 421: ! 422: mov al,bh ! 423: out dx,ax ! 424: xchg al,[edi] ; Set the bits ! 425: ! 426: @@: ! 427: add edi,ulNextScan ; Next scan on VGA ! 428: add esi,cjBytes ; Next line of glyph ! 429: dec cScan ! 430: jnz short vmg_last_fetch_two_bytes_next ; finish column ! 431: ! 432: vmg_exit: ! 433: retn ! 434: ! 435: ;---------------------------Public-Routine------------------------------; ! 436: ; vgblt_opaque_glyph ! 437: ; ! 438: ; Draw a glyph to the VGA screen using the write mode 3 ! 439: ; ! 440: ;-----------------------------------------------------------------------; ! 441: ! 442: vgblt_opaque_glyph: ! 443: ! 444: mov eax,cScan ! 445: mov cTmp,eax ; Scans to draw ! 446: mov esi,pjGlyph ; Read glyph from here ! 447: mov edi,pjScreen ; Write glyph to there ! 448: mov bh,fjMask ; Current mask ! 449: mov edx,ulNextScan ! 450: ! 451: mov cl,cfLeft ; Bits available in current byte ! 452: sub cl,cfBits ! 453: jl short vog_fetch_two_bytes ! 454: ! 455: ; ! 456: ; Fetching one byte means we are at the left edge of the glyph, or ! 457: ; by some miracle we are aligned with the VGA memory. Either way ! 458: ; we will still mask the data with fjMask. ! 459: ; ! 460: ! 461: vog_fetch_one_byte: ! 462: mov ah,[esi] ; AH = glyph data ! 463: shr ah,cl ; Put usable glyph data in place ! 464: and ah,bh ! 465: jz short @F ; don't waste time ! 466: xchg ah,[edi] ; Set the bits ! 467: @@: ! 468: add edi,edx ; Next scan on VGA ! 469: add esi,cjBytes ; Next line of glyph ! 470: dec cTmp ! 471: jnz short vog_fetch_one_byte ; finish column ! 472: ! 473: neg cl ! 474: and cl,7 ; CL = # usable bits in next byte ! 475: jnz short vog_advance_screen_ptr ! 476: jmp short vog_advance_glyph_ptr ! 477: ! 478: ; The current screen byte covers two glyph bytes ! 479: ! 480: vog_fetch_two_bytes: ! 481: neg cl ; CL = cfBits - cfLeft ! 482: add cl,8 ; we will swap AH and AL ! 483: ! 484: vog_fetch_two_bytes_next: ! 485: mov ax,[esi] ; AL = curr byte, AH = next byte ! 486: rol ax,cl ; AH = glyph data ! 487: and ah,bh ! 488: jz short @F ; don't waste time ! 489: xchg ah,[edi] ; Set the bits ! 490: @@: ! 491: add edi,edx ; Next scan on VGA ! 492: add esi,cjBytes ; Next line of glyph ! 493: dec cTmp ! 494: jnz short vog_fetch_two_bytes_next ; finish column ! 495: sub cl,8 ! 496: ! 497: ; We will start the next screen column byte. Recalculate parameters. ! 498: ! 499: vog_advance_glyph_ptr: ! 500: inc pjGlyph ! 501: ! 502: vog_advance_screen_ptr: ! 503: inc pjScreen ; Increment screen pointer ! 504: ! 505: vog_inner_bytes: ! 506: mov ebx,cInnerBytes ; do we have inner bytes? ! 507: or ebx,ebx ! 508: jz short vog_last_byte ! 509: ! 510: mov eax,cScan ! 511: mov cTmp,eax ; Scans to draw ! 512: mov esi,pjGlyph ; Read glyph from here ! 513: mov edi,pjScreen ; Write glyph to there ! 514: add pjGlyph,ebx ; advance pointer ! 515: add pjScreen,ebx ! 516: sub cjBytes,ebx ; glyph scan size ! 517: sub edx,ebx ; screen scan size ! 518: or cl,cl ! 519: jnz short vog_inner_fetch_two_bytes ! 520: ! 521: vog_inner_fetch_one_byte: ! 522: mov ecx,ebx ! 523: ! 524: vog_inner_loop: ! 525: lodsb ! 526: or al,al ! 527: jz short @F ! 528: xchg al,[edi] ! 529: @@: ! 530: inc edi ! 531: loop short vog_inner_loop ! 532: ! 533: add edi,edx ; Next scan on VGA ! 534: add esi,cjBytes ; Next line of glyph ! 535: dec cTmp ! 536: jnz short vog_inner_fetch_one_byte ; finish column ! 537: ! 538: jmp short vog_inner_byte_end ! 539: ! 540: ; The current screen byte covers two glyph bytes ! 541: ! 542: vog_inner_fetch_two_bytes: ! 543: add cl,8 ! 544: ! 545: vog_inner_fetch_two_bytes_next: ! 546: mov ax,[esi] ; AL = curr byte, AH = next byte ! 547: rol ax,cl ; AH = glyph data ! 548: or ah,ah ! 549: jz short @F ! 550: xchg ah,[edi] ; Set the bits ! 551: @@: ! 552: inc esi ! 553: inc edi ! 554: dec ebx ! 555: jnz short vog_inner_fetch_two_bytes_next ! 556: ! 557: mov ebx,cInnerBytes ! 558: add edi,edx ; Next scan on VGA ! 559: add esi,cjBytes ; Next line of glyph ! 560: dec cTmp ! 561: jnz short vog_inner_fetch_two_bytes_next ; finish column ! 562: sub cl,8 ! 563: ! 564: vog_inner_byte_end: ! 565: add edx,ebx ; restore its original value ! 566: add cjBytes,ebx ; restore its original value ! 567: ! 568: vog_last_byte: ! 569: mov bl,fjLastMask ; BL = last byte mask ! 570: or bl,bl ! 571: jz short vog_exit ! 572: ! 573: mov esi,pjGlyph ; Read glyph from here ! 574: mov edi,pjScreen ; Write glyph to there ! 575: mov ch,8 ! 576: sub ch,cl ; CH = # usable bits in current byte ! 577: cmp ch,cfLastBits ; do we need the next byte? ! 578: jl short vog_last_fetch_two_bytes ! 579: ! 580: ! 581: vog_last_fetch_one_byte: ! 582: mov ah,[esi] ; AH = glyph data ! 583: shl ah,cl ! 584: and ah,bl ! 585: jz short @F ! 586: xchg ah,[edi] ; Set the bits ! 587: @@: ! 588: add edi,edx ; Next scan on VGA ! 589: add esi,cjBytes ; Next line of glyph ! 590: dec cScan ! 591: jnz short vog_last_fetch_one_byte ; finish column ! 592: ! 593: jmp short vog_exit ! 594: ! 595: ; The current screen byte covers two glyph bytes ! 596: ! 597: vog_last_fetch_two_bytes: ! 598: add cl,8 ; we will swap AH and AL ! 599: ! 600: vog_last_fetch_two_bytes_next: ! 601: mov ax,[esi] ! 602: rol ax,cl ; AH = glyph data ! 603: and ah,bl ! 604: jz short @F ! 605: xchg ah,[edi] ; Set the bits ! 606: @@: ! 607: add edi,edx ; Next scan on VGA ! 608: add esi,cjBytes ; Next line of glyph ! 609: dec cScan ! 610: jnz short vog_last_fetch_two_bytes_next ; finish column ! 611: ! 612: vog_exit: ! 613: retn ! 614: ! 615: xxxvGlyphBlt endp ! 616: ! 617: ! 618: ;---------------------------Public-Routine------------------------------; ! 619: ; ulSetXParentRegs ! 620: ; ! 621: ; Set the VGA control registers for the specified Rop4 and foreground ! 622: ; color when background is transparent. ! 623: ; ! 624: ;-----------------------------------------------------------------------; ! 625: ! 626: cProc ulSetXParentRegs,12,< \ ! 627: uses ebx edi, \ ! 628: rop4: dword, \ ! 629: pclr: ptr, \ ! 630: bSet: dword > ! 631: ! 632: mov edi,VGB_OPAQUE_STRING ! 633: mov ebx,rop4 ! 634: xor ecx,ecx ; Color = 00, mode = set ! 635: or ebx,ebx ! 636: jz short vsv_set_vga_mode ! 637: ! 638: dec ch ; Color = FF, mode = set ! 639: inc bx ! 640: jz short vsv_set_vga_mode ! 641: ! 642: mov eax,pclr ! 643: mov ch,byte ptr [eax] ; Color = passed color, mode = set ! 644: cmp bx,0f0f0h + 1 ! 645: je short vsv_set_vga_mode ! 646: ! 647: not ch ; ~passed color ! 648: cmp bx,00f0fh + 1 ! 649: je short vsv_set_vga_mode ! 650: ! 651: mov cx,0FF00h + DR_XOR ; Color = FF, mode = xor ! 652: mov edi,VGB_MIX_STRING ; We will actually do mode 0 ! 653: ! 654: vsv_set_vga_mode: ! 655: mov eax,bSet ; set flag ! 656: or eax,eax ! 657: jz short vsv_exit ! 658: ! 659: mov dx,VGA_BASE + GRAF_ADDR ! 660: mov al,GRAF_SET_RESET ! 661: mov ah,ch ! 662: out dx,ax ! 663: mov ax,0f00h + GRAF_ENAB_SR ! 664: out dx,ax ! 665: mov ah,cl ! 666: mov al,GRAF_DATA_ROT ! 667: out dx,ax ! 668: ! 669: or edi,edi ! 670: .errnz VGB_MIX_STRING ! 671: jz short vsv_exit ! 672: mov ax,(M_AND_WRITE shl 8)+GRAF_MODE ! 673: out dx,ax ! 674: ! 675: vsv_exit: ! 676: mov eax,edi ; return VGA mode ! 677: mov edi,pclr ! 678: mov byte ptr [edi],ch ; CH = actual foreground color ! 679: cRet ulSetXParentRegs ! 680: ! 681: endProc ulSetXParentRegs ! 682: ! 683: ;---------------------------Public-Routine------------------------------; ! 684: ; vResetVGARegs ! 685: ; ! 686: ; Reset the VGA control registers to a default state. ! 687: ; ! 688: ;-----------------------------------------------------------------------; ! 689: ! 690: cProc vResetVGARegs ! 691: ! 692: mov dx,VGA_BASE + GRAF_ADDR ! 693: mov ax,0ff00h + GRAF_BIT_MASK ! 694: out dx,ax ! 695: mov ax,0000h + GRAF_SET_RESET ! 696: out dx,ax ! 697: mov ax,0000h + GRAF_ENAB_SR ! 698: out dx,ax ! 699: mov ax,(DR_SET shl 8) + GRAF_DATA_ROT ! 700: out dx,ax ! 701: mov ax,((M_PROC_WRITE or M_DATA_READ) shl 8) + GRAF_MODE ! 702: out dx,ax ! 703: ! 704: cRet vResetVGARegs ! 705: ! 706: endProc vResetVGARegs ! 707: ! 708: public gblt_calc_dest_addr ! 709: public gblt_left_mask ! 710: public gblt_inner_count ! 711: public gblt_last_mask ! 712: public gblt_glyph_info ! 713: public gblt_glyph_offset ! 714: public gblt_draw_glyph ! 715: public glyph_blt_exit ! 716: public vgblt_mix_glyph ! 717: public vmg_fetch_one_byte ! 718: public vmg_fetch_two_bytes ! 719: public vmg_advance_glyph_ptr ! 720: public vmg_advance_screen_ptr ! 721: public vmg_inner_bytes ! 722: public vmg_inner_fetch_one_byte ! 723: public vmg_inner_fetch_two_bytes ! 724: public vmg_last_byte ! 725: public vmg_last_fetch_one_byte ! 726: public vmg_last_fetch_two_bytes ! 727: public vmg_exit ! 728: public vgblt_opaque_glyph ! 729: public vog_fetch_one_byte ! 730: public vog_fetch_two_bytes ! 731: public vog_advance_glyph_ptr ! 732: public vog_advance_screen_ptr ! 733: public vog_inner_bytes ! 734: public vog_inner_fetch_one_byte ! 735: public vog_inner_fetch_two_bytes ! 736: public vog_last_byte ! 737: public vog_last_fetch_one_byte ! 738: public vog_last_fetch_two_bytes ! 739: public vog_exit ! 740: ! 741: _TEXT$01 ends ! 742: ! 743: end ! 744:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.