![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vgastrps.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 vgastrps.asm CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga / i386 |
1.1 ! root 1: ;---------------------------Module-Header------------------------------; ! 2: ; Module Name: vgastrps.asm ! 3: ; ! 4: ; Routines used by line code to draw strips of pixels. ! 5: ; ! 6: ; Copyright (c) 1992 Microsoft Corporation ! 7: ;-----------------------------------------------------------------------; ! 8: ! 9: .386 ! 10: ! 11: .model small,c ! 12: ! 13: assume cs:FLAT,ds:FLAT,es:FLAT,ss:FLAT ! 14: assume fs:nothing,gs:nothing ! 15: ! 16: ; Set LOOP_UNROLL_SHIFT to the log2 of the number of times you want loops in ! 17: ; this module unrolled. For example, LOOP_UNROLL_SHIFT of 3 yields 2**3 = 8 ! 18: ; times unrolling. This is the only thing you need to change to control ! 19: ; unrolling. ! 20: ! 21: LOOP_UNROLL_SHIFT equ 2 ! 22: ! 23: .xlist ! 24: include stdcall.inc ;calling convention cmacros ! 25: include i386\egavga.inc ! 26: include i386\strucs.inc ! 27: include i386\lines.inc ! 28: include i386\unroll.inc ! 29: .list ! 30: ! 31: .code ! 32: ! 33: _TEXT$04 SEGMENT DWORD USE32 PUBLIC 'CODE' ! 34: ASSUME CS:FLAT, DS:FLAT, ES:FLAT, SS:NOTHING, FS:NOTHING, GS:NOTHING ! 35: ! 36: ;---------------------------Public-Routine------------------------------; ! 37: ; vSetStrips ! 38: ; ! 39: ; Set the VGA into the appropriate mode for line drawing. ! 40: ; ! 41: ;-----------------------------------------------------------------------; ! 42: ! 43: cProc vSetStrips,8,< \ ! 44: clr: dword, \ ! 45: mode: dword > ! 46: ! 47: mov edx, VGA_BASE + GRAF_ADDR ! 48: ! 49: mov al, GRAF_SET_RESET ! 50: mov ah, byte ptr clr ! 51: out dx, ax ! 52: ! 53: cmp mode, DR_SET ! 54: je @F ! 55: ! 56: mov al, GRAF_DATA_ROT ! 57: mov ah, byte ptr mode ! 58: out dx, ax ! 59: ! 60: @@: ! 61: mov eax, GRAF_MODE + ((M_AND_WRITE + M_COLOR_READ) SHL 8) ! 62: out dx, ax ;write mode 3 so we can do the masking ! 63: ; without OUTs, read mode 1 so we can ! 64: ; read 0xFF from memory always, for ! 65: ; ANDing (because Color Don't Care is ! 66: ; all zeros) ! 67: cRet vSetStrips ! 68: ! 69: endProc vSetStrips ! 70: ! 71: ;---------------------------Public-Routine------------------------------; ! 72: ; vClearStrips ! 73: ; ! 74: ; Restore the VGA to its default state. ! 75: ; ! 76: ;-----------------------------------------------------------------------; ! 77: ! 78: cProc vClearStrips,4,< \ ! 79: oldmode: dword > ! 80: ! 81: ; Restore the EGA/VGA to its default state: ! 82: ! 83: mov edx, VGA_BASE + GRAF_ADDR ! 84: ! 85: cmp oldmode, DR_SET ! 86: je @F ! 87: mov eax, (DR_SET shl 8) + GRAF_DATA_ROT ! 88: out dx, ax ! 89: ! 90: @@: ! 91: mov eax, GRAF_MODE + ((M_PROC_WRITE + M_DATA_READ) SHL 8) ! 92: out dx, ax ;restore read mode 0 and write mode 0 ! 93: ! 94: cRet vClearStrips ! 95: ! 96: endProc vClearStrips ! 97: ! 98: ;--------------------------Private-Routine------------------------------; ! 99: ; vStripSolidDiagonalHorizontal ! 100: ; ! 101: ; Draw an x-major near-diagonal strip left-to-right ! 102: ; ! 103: ;-----------------------------------------------------------------------; ! 104: ! 105: cProc vStripSolidDiagonalHorizontal,12,< \ ! 106: uses esi edi ebx, \ ! 107: pStrips: ptr STRIPS, \ ! 108: pls: ptr LINESTATE, \ ! 109: plStripEnd: ptr > ! 110: ! 111: mov esi, pStrips ! 112: push ebp ! 113: mov ebp, plStripEnd ! 114: mov ecx, [esi].ST_lNextScan ! 115: mov al, [esi].ST_jBitMask ! 116: mov edi, [esi].ST_pjScreen ! 117: add esi, offset ST_alStrips ! 118: ! 119: ; al = bit mask ! 120: ; ebx = pixel count ! 121: ; ecx = delta ! 122: ; edx = port # ! 123: ; esi = strip pointer ! 124: ; edi = memory pointer ! 125: ; ebp = end of strips pointer ! 126: ! 127: next_diagonal: ! 128: mov ebx, [esi] ! 129: add esi, 4 ! 130: ! 131: align 4 ! 132: diagonal_loop: ! 133: and [edi], al ! 134: ror al, 1 ! 135: adc edi, ecx ! 136: dec ebx ! 137: jnz short diagonal_loop ! 138: ! 139: sub edi, ecx ; side step ! 140: cmp esi, ebp ! 141: jl short next_diagonal ! 142: ! 143: pop ebp ! 144: mov esi, pStrips ! 145: mov [esi].ST_pjScreen, edi ! 146: mov [esi].ST_jBitmask, al ! 147: cRet vStripSolidDiagonalHorizontal ! 148: ! 149: endProc vStripSolidDiagonalHorizontal ! 150: ! 151: ;--------------------------Private-Routine------------------------------; ! 152: ; vStripSolidDiagonalVertical ! 153: ; ! 154: ; Draw a y-major near-diagonal strip left-to-right ! 155: ; ! 156: ;-----------------------------------------------------------------------; ! 157: ! 158: cProc vStripSolidDiagonalVertical,12,< \ ! 159: uses esi edi ebx, \ ! 160: pStrips: ptr STRIPS, \ ! 161: pls: ptr LINESTATE, \ ! 162: plStripEnd: ptr > ! 163: ! 164: mov esi, pStrips ! 165: push ebp ! 166: mov ebp, plStripEnd ! 167: mov ecx, [esi].ST_lNextScan ! 168: mov al, [esi].ST_jBitMask ! 169: mov edi, [esi].ST_pjScreen ! 170: add esi, offset ST_alStrips ! 171: ! 172: ; al = bit mask ! 173: ; ebx = pixel count ! 174: ; ecx = delta ! 175: ; edx = port # ! 176: ; esi = strip pointer ! 177: ; edi = memory pointer ! 178: ; ebp = end of strips pointer ! 179: ! 180: next_diagonal: ! 181: mov ebx, [esi] ! 182: add esi, 4 ! 183: ! 184: align 4 ! 185: diagonal_loop: ! 186: and [edi], al ! 187: ror al, 1 ! 188: adc edi, ecx ! 189: dec ebx ! 190: jnz short diagonal_loop ! 191: ! 192: rol al, 1 ; side step ! 193: sbb edi, 0 ! 194: cmp esi, ebp ! 195: jl short next_diagonal ! 196: ! 197: pop ebp ! 198: mov esi, pStrips ! 199: mov [esi].ST_pjScreen, edi ! 200: mov [esi].ST_jBitmask, al ! 201: cRet vStripSolidDiagonalVertical ! 202: ! 203: endProc vStripSolidDiagonalVertical ! 204: ! 205: ;--------------------------Private-Routine------------------------------; ! 206: ; vStripSolidHorizontal ! 207: ; ! 208: ; Draw a horizontal strip left to right ! 209: ; ! 210: ;-----------------------------------------------------------------------; ! 211: ! 212: cProc vStripSolidHorizontal,12,< \ ! 213: uses esi edi ebx, \ ! 214: pStrips: ptr STRIPS, \ ! 215: pls: ptr LINESTATE, \ ! 216: plStripEnd: ptr > ! 217: ! 218: ; Do some initializing: ! 219: ! 220: mov esi, pStrips ! 221: push ebp ! 222: mov ebp, plStripEnd ! 223: mov edx, [esi].ST_lNextScan ! 224: mov al, [esi].ST_jBitMask ! 225: mov edi, [esi].ST_pjScreen ! 226: add esi, offset ST_alStrips ! 227: ! 228: ; (al) = rotating bit ! 229: ; (bl) = current mask ! 230: ; (ecx) = pixel count ! 231: ; (edx) = delta ! 232: ; (esi) = strip pointer ! 233: ; (edi) = display pointer ! 234: ; (ebp) = end of strips pointer ! 235: ! 236: next_horizontal: ! 237: mov ecx, [esi] ! 238: add esi, 4 ! 239: ! 240: lea ebx, [2 * eax - 1] ; bl = start mask ! 241: ror al, cl ; rotate bit ! 242: shr ecx, 3 ; compute # bytes to lay down ! 243: cmp bl, al ; we have to adjust for wrap ! 244: adc ecx, 0 ! 245: jnz short extends_out_of_first_byte ! 246: ! 247: sub bl, al ; zero out end bits ! 248: sub bl, al ! 249: inc bl ! 250: and [edi], bl ; write result ! 251: add edi, edx ; increment to next scan ! 252: cmp esi, ebp ; see if done strips ! 253: jb short next_horizontal ! 254: ! 255: pop ebp ; we're done ! 256: mov esi, pStrips ! 257: mov [esi].ST_pjScreen, edi ! 258: mov [esi].ST_jBitmask, al ! 259: cRet vStripSolidHorizontal ! 260: ! 261: extends_out_of_first_byte: ! 262: ! 263: ; This part gets called when the current strip doesn't fit entirely ! 264: ; into one byte: ! 265: ! 266: and [edi], bl ; output with start mask ! 267: inc edi ; go on to next byte ! 268: ! 269: dec ecx ; see if there's any bytes in ! 270: jnz short output_bunch ; between start and end byte ! 271: ! 272: last_byte: ! 273: lea ebx, [2 * eax - 1] ; compute end mask ! 274: not bl ! 275: and [edi], bl ; write result ! 276: add edi, edx ; increment to next scan ! 277: cmp esi, ebp ; see if done strips ! 278: jb short next_horizontal ! 279: ! 280: pop ebp ; we're done ! 281: mov esi, pStrips ! 282: mov [esi].ST_pjScreen, edi ! 283: mov [esi].ST_jBitmask, al ! 284: cRet vStripSolidHorizontal ! 285: ! 286: output_bunch: ! 287: ! 288: ; We have a bunch of complete bytes to lay down. ! 289: ! 290: mov ebx, esi ; we're gonna overwrite esi ! 291: mov esi, edi ! 292: rep movsb ; Write the bytes. Mask is 0ffh because ! 293: ; we're in read mode 1, reading 0ffh, ! 294: ; which becomes the write mode 3 mask. ! 295: ! 296: mov esi, ebx ; restore esi ! 297: ! 298: jmp short last_byte ; do last byte in scan ! 299: ! 300: endProc vStripSolidHorizontal ! 301: ! 302: ;--------------------------Private-Routine------------------------------; ! 303: ; vStripSolidHorizontalSet ! 304: ; ! 305: ; Draw horizontal strips left to right for SRCCOPY lines. ! 306: ; ! 307: ;-----------------------------------------------------------------------; ! 308: ! 309: cProc vStripSolidHorizontalSet,12,< \ ! 310: uses esi edi ebx, \ ! 311: pStrips: ptr STRIPS, \ ! 312: pls: ptr LINESTATE, \ ! 313: plStripEnd: ptr > ! 314: ! 315: ; Do some initializing: ! 316: ! 317: mov esi, pStrips ! 318: push ebp ! 319: mov ebp, plStripEnd ! 320: mov edx, [esi].ST_lNextScan ! 321: mov al, [esi].ST_jBitMask ! 322: mov edi, [esi].ST_pjScreen ! 323: add esi, offset ST_alStrips ! 324: ! 325: ; (al) = rotating bit ! 326: ; (bl) = current mask ! 327: ; (ecx) = pixel count ! 328: ; (edx) = delta ! 329: ; (esi) = strip pointer ! 330: ; (edi) = display pointer ! 331: ; (ebp) = end of strips pointer ! 332: ! 333: next_horizontal: ! 334: mov ecx, [esi] ! 335: add esi, 4 ! 336: ! 337: lea ebx, [2 * eax - 1] ; bl = start mask ! 338: ror al, cl ; rotate bit ! 339: shr ecx, 3 ; compute # bytes to lay down ! 340: cmp bl, al ; we have to adjust for wrap ! 341: adc ecx, 0 ! 342: jnz short extends_out_of_first_byte ! 343: ! 344: sub bl, al ; zero out end bits ! 345: sub bl, al ! 346: inc bl ! 347: and [edi], bl ; write result ! 348: add edi, edx ; increment to next scan ! 349: cmp esi, ebp ; see if done strips ! 350: jb short next_horizontal ! 351: ! 352: pop ebp ; we're done ! 353: mov esi, pStrips ! 354: mov [esi].ST_pjScreen, edi ! 355: mov [esi].ST_jBitmask, al ! 356: cRet vStripSolidHorizontalSet ! 357: ! 358: extends_out_of_first_byte: ! 359: ! 360: ; This part gets called when the current strip doesn't fit entirely ! 361: ; into one byte: ! 362: ! 363: and [edi], bl ; output with start mask ! 364: inc edi ; go on to next byte ! 365: ! 366: dec ecx ; see if there's any bytes in ! 367: jnz short output_bunch ; between start and end byte ! 368: ! 369: last_byte: ! 370: lea ebx, [2 * eax - 1] ; compute end mask ! 371: not bl ! 372: and [edi], bl ; write result ! 373: add edi, edx ; increment to next scan ! 374: cmp esi, ebp ; see if done strips ! 375: jb short next_horizontal ! 376: ! 377: pop ebp ; we're done ! 378: mov esi, pStrips ! 379: mov [esi].ST_pjScreen, edi ! 380: mov [esi].ST_jBitmask, al ! 381: cRet vStripSolidHorizontalSet ! 382: ! 383: output_bunch: ! 384: ! 385: ; We have a bunch of complete bytes to lay down. Since we're doing ! 386: ; the interior of the line and we have a SRCCOPY ROP, we don't have ! 387: ; to worry about loading the latches properly, so we can do this ! 388: ; without reading the VGA memory. We also use 16 bit writes since ! 389: ; on some devices it's faster to write a single word than to write ! 390: ; two bytes -- doing so means we must be word-aligned. ! 391: ! 392: test edi, 1 ! 393: jz now_aligned ! 394: mov byte ptr [edi], 0ffh ; write a byte to get alignment right ! 395: inc edi ! 396: dec ecx ! 397: jz short last_byte ; maybe that was only byte we had to do ! 398: ! 399: now_aligned: ! 400: shr ecx, 1 ; divide by 2 to determine the number ! 401: ; of words to write ! 402: ; NOTE: We check the carry later on! ! 403: ! 404: jz short last_byte_in_bunch ; small optimization: skip word stuff ! 405: ; if we've only got a single byte ! 406: ! 407: mov ebx, eax ; save eax ! 408: mov eax, 0ffffh ; prepare ax ! 409: rep stosw ; lay those words down ! 410: mov eax, ebx ; restore eax ! 411: jnc short last_byte ; NOTE: NOW we're checking the carry! ! 412: ! 413: last_byte_in_bunch: ! 414: mov byte ptr [edi], 0ffh ; write that last byte ! 415: inc edi ! 416: jmp short last_byte ! 417: ! 418: endProc vStripSolidHorizontalSet ! 419: ! 420: ! 421: ;--------------------------Private-Routine------------------------------; ! 422: ; vStripSolidVertical ! 423: ; ! 424: ; Draw a vertical strip left to right ! 425: ; ! 426: ;-----------------------------------------------------------------------; ! 427: ! 428: cProc vStripSolidVertical,12,< \ ! 429: uses esi edi ebx, \ ! 430: pStrips: ptr STRIPS, \ ! 431: pls: ptr LINESTATE, \ ! 432: plStripEnd: ptr > ! 433: ! 434: ; So some initialization: ! 435: ! 436: mov esi, pStrips ! 437: mov edx, plStripEnd ! 438: mov ecx, [esi].ST_lNextScan ! 439: mov al, [esi].ST_jBitmask ! 440: mov edi, [esi].ST_pjScreen ! 441: add esi, offset ST_alStrips ! 442: mov [edx], ebp ; save ebp ! 443: ! 444: align 4 ! 445: next_vertical: ! 446: mov ebx, [esi] ; ebx = # bits to set ! 447: add esi, 4 ! 448: ! 449: SET_UP_UNROLL_VARS ebx,ebp,ebx,pfnWriteVerticalStripEntry, \ ! 450: LOOP_UNROLL_SHIFT ! 451: jmp ebp ! 452: ! 453: ; Table of entry points for writing a vertical strip scan: ! 454: ! 455: UNROLL_LOOP_ENTRY_TABLE pfnWriteVerticalStripEntry,VERTICAL_STRIP, \ ! 456: LOOP_UNROLL_COUNT ! 457: ! 458: ; Unrolled loop for writing a single vertical strip scan: ! 459: ! 460: WRITE_VERTICAL_STRIP macro ENTRY_LABEL,ENTRY_INDEX ! 461: &ENTRY_LABEL&ENTRY_INDEX&: ! 462: and [edi], al ; write the byte ! 463: add edi, ecx ; go to next scan ! 464: endm ;-----------------------------; ! 465: ! 466: align 4 ! 467: vertical_strip_loop: ! 468: ! 469: ; Now we're going to paste the bytes to the screen. ! 470: ; ! 471: ; (al) = rotating bit ! 472: ; (ebx) = # of complete unrolled loops to do ! 473: ; (ecx) = minor add ! 474: ; (edx) = end of strips pointer ! 475: ; (esi) = strip pointer ! 476: ; (edi) = address of byte to write ! 477: ; (ebp) = garbage ! 478: ! 479: UNROLL_LOOP WRITE_VERTICAL_STRIP,VERTICAL_STRIP,LOOP_UNROLL_COUNT ! 480: dec ebx ! 481: jnz vertical_strip_loop ! 482: ! 483: ; Adjust address and rotating bit for sidestep: ! 484: ! 485: ror al, 1 ; one to the right ! 486: adc edi, 0 ! 487: ! 488: cmp esi, edx ! 489: jl short next_vertical ; hit end of array? ! 490: ! 491: ; Remember where we left off, for next time: ! 492: ! 493: mov ebp, [edx] ; restore ebp ! 494: mov esi, pStrips ! 495: mov [esi].ST_pjScreen, edi ! 496: mov [esi].ST_jBitmask, al ! 497: cRet vStripSolidVertical ! 498: ! 499: endProc vStripSolidVertical ! 500: ! 501: ;--------------------------Private-Routine------------------------------; ! 502: ; vStripStyledHorizontal ! 503: ; ! 504: ; Draws an arbitrarily styled horizontal strip left-to-right. ! 505: ; ! 506: ;-----------------------------------------------------------------------; ! 507: ! 508: cProc vStripStyledHorizontal,12,< \ ! 509: uses esi edi ebx, \ ! 510: pStrips: ptr STRIPS, \ ! 511: pls: ptr LINESTATE, \ ! 512: plStripEnd: ptr > ! 513: ! 514: local aEnd:dword ; end of length array ! 515: local minoradd:dword ! 516: local spToGo:dword ! 517: ! 518: ; So some initialization: ! 519: ! 520: mov esi, pStrips ! 521: mov eax, plStripEnd ! 522: mov aEnd, eax ! 523: ! 524: mov eax, [esi].ST_lNextScan ! 525: mov bl, [esi].ST_jBitmask ! 526: mov edi, [esi].ST_pjScreen ! 527: mov minoradd, eax ! 528: ! 529: ; Initialize styling: ! 530: ! 531: mov eax, [esi].ST_spRemaining ! 532: mov bh, [esi].ST_jStyleMask ! 533: mov spToGo, eax ! 534: add esi, offset ST_alStrips ! 535: ! 536: Strip_loop: ! 537: mov ecx, [esi] ; ecx = # bits to write ! 538: add esi, 4 ! 539: ! 540: ; Now we're going to paste the bytes to the screen ! 541: ; ! 542: ; (al) = used to accumulate the mask ! 543: ; (bl) = rotating bit ! 544: ; (bh) = jStyleMask ! 545: ; (ecx) = # of bits to write ! 546: ; (edx) = ! 547: ; (esi) = ptr to spot in ST_alStrips ! 548: ; (edi) = address of byte to write ! 549: ! 550: xor al, al ; clear style mask ! 551: ! 552: Strip_count: ! 553: xor al, bh ; set bit in output mask if style bit 0 ! 554: or al, bl ! 555: xor al, bh ! 556: ! 557: dec spToGo ! 558: jz short Next_style_entry ! 559: ! 560: Next_bit: ! 561: ror bl, 1 ! 562: jc short Output_byte ! 563: dec ecx ! 564: jnz short Strip_count ! 565: ! 566: ; Do sidestep ! 567: ! 568: Side_step: ! 569: and byte ptr [edi], al ! 570: add edi, minoradd ! 571: ! 572: cmp esi, aEnd ! 573: jl short Strip_loop ! 574: ! 575: mov esi, pStrips ! 576: mov [esi].ST_pjScreen, edi ! 577: mov [esi].ST_jBitmask, bl ! 578: mov [esi].ST_jStyleMask, bh ! 579: mov eax, spToGo ! 580: mov [esi].ST_spRemaining, eax ! 581: ! 582: cRet vStripStyledHorizontal ! 583: ! 584: Output_byte: ! 585: and byte ptr [edi], al ! 586: xor al, al ! 587: inc edi ; Moved one byte to right on screen ! 588: dec ecx ! 589: jnz short Strip_count ! 590: jz short Side_step ! 591: ! 592: ; We're on to a new entry in the style array: ! 593: ! 594: Next_style_entry: ! 595: push eax ! 596: mov edx, pStrips ! 597: mov eax, [edx].ST_psp ! 598: add eax, 4 ! 599: cmp [edx].ST_pspEnd, eax ! 600: jae short @F ! 601: mov eax, [edx].ST_pspStart ; Go back to start of array ! 602: @@: ! 603: mov [edx].ST_psp, eax ! 604: mov edx, [eax] ; Load up new style entry ! 605: ! 606: add spToGo, edx ! 607: not bh ; jStyleMask = !jStyleMask ! 608: ! 609: pop eax ! 610: jmp short Next_bit ! 611: ! 612: endProc vStripStyledHorizontal ! 613: ! 614: ! 615: ;--------------------------Private-Routine------------------------------; ! 616: ; vStripStyledVertical ! 617: ; ! 618: ; Draw an arbitrarily styled vertical strip left-to-right. ! 619: ; ! 620: ;-----------------------------------------------------------------------; ! 621: ! 622: cProc vStripStyledVertical,12,< \ ! 623: uses esi edi ebx, \ ! 624: pStrips: ptr STRIPS, \ ! 625: pls: ptr LINESTATE, \ ! 626: plStripEnd: ptr > ! 627: ! 628: local aEnd:dword ; end of length array ! 629: local minoradd:dword ! 630: local spToGo:dword ! 631: ! 632: ; So some initialization: ! 633: ! 634: mov esi, pStrips ! 635: mov eax, plStripEnd ! 636: mov aEnd, eax ! 637: ! 638: mov ecx, [esi].ST_lNextScan ! 639: mov al, [esi].ST_jBitmask ! 640: mov edi, [esi].ST_pjScreen ! 641: mov minoradd, ecx ! 642: ! 643: ; Initialize styling: ! 644: ! 645: mov ebx, [esi].ST_spRemaining ! 646: mov ah, [esi].ST_jStyleMask ! 647: mov spToGo, ebx ! 648: add esi, offset ST_alStrips ! 649: ! 650: Strip_loop: ! 651: mov ebx, [esi] ; ebx = # bits to set ! 652: add esi, 4 ! 653: ! 654: ; Now we're going to paste the bytes to the screen ! 655: ; ! 656: ; (al) = rotating bit ! 657: ; (ah) = jStyleMask ! 658: ; (ebx) = # of bits to write ! 659: ; (ecx) = minor add ! 660: ; (edx) = ! 661: ; (esi) = ptr to spot in ST_alStrips ! 662: ; (edi) = address of byte to write ! 663: ! 664: Strip_count: ! 665: or ah, ah ! 666: jnz short @F ; Don't output pixel if in a gap ! 667: and [edi], al ! 668: @@: ! 669: dec spToGo ! 670: jz short Next_style_entry ! 671: ! 672: Minor_add: ! 673: add edi, ecx ! 674: dec ebx ! 675: jnz short Strip_count ! 676: ! 677: ; Adjust address and rotating bit for sidestep ! 678: ! 679: ror al, 1 ; one to the right ! 680: adc edi, 0 ! 681: ! 682: cmp esi, aEnd ! 683: jl short Strip_loop ; hit end of array? ! 684: ! 685: mov esi, pStrips ! 686: mov [esi].ST_pjScreen, edi ! 687: mov [esi].ST_jBitmask, al ! 688: mov [esi].ST_jStyleMask, ah ! 689: mov eax, spToGo ! 690: mov [esi].ST_spRemaining, eax ! 691: ! 692: cRet vStripStyledVertical ! 693: ! 694: Next_style_entry: ! 695: mov edx, pStrips ! 696: mov ecx, [edx].ST_psp ! 697: add ecx, 4 ! 698: cmp [edx].ST_pspEnd, ecx ! 699: jae short @F ! 700: mov ecx, [edx].ST_pspStart ; Go back to start of array ! 701: @@: ! 702: mov [edx].ST_psp, ecx ; Save our pointer ! 703: mov edx, [ecx] ; Load up new style entry ! 704: add spToGo, edx ! 705: not ah ; jStyleMask = !jStyleMask ! 706: ! 707: ; Restore the registers we used: ! 708: ! 709: mov ecx, minoradd ! 710: jmp short Minor_add ! 711: ! 712: endProc vStripStyledVertical ! 713: ! 714: ! 715: ;--------------------------Private-Routine------------------------------; ! 716: ; vStripMaskedHorizontal ! 717: ; ! 718: ; Draws a mask-styled horizontal strip left to right. ! 719: ; ! 720: ;-----------------------------------------------------------------------; ! 721: ! 722: cProc vStripMaskedHorizontal,12,< \ ! 723: uses esi edi ebx, \ ! 724: pStrips: ptr STRIPS, \ ! 725: pls: ptr LINESTATE, \ ! 726: plStripEnd: ptr > ! 727: ! 728: local aEnd:dword ; end of length array ! 729: local minoradd:dword ! 730: local density:dword ! 731: ! 732: ; So some initialization: ! 733: ! 734: mov esi, pStrips ! 735: mov eax, plStripEnd ! 736: mov aEnd, eax ! 737: mov eax, [esi].ST_lNextScan ! 738: mov bl, [esi].ST_jBitmask ! 739: mov edi, [esi].ST_pjScreen ! 740: mov minoradd, eax ! 741: ! 742: ; Initialize styling: ! 743: ! 744: mov ecx, [esi].ST_xyDensity ! 745: mov ah, byte ptr [esi].ST_spRemaining ! 746: mov bh, [esi].ST_jStyleMask ! 747: mov density, ecx ! 748: add esi, offset ST_alStrips ! 749: ! 750: Strip_loop: ! 751: mov ecx, [esi] ; ecx = # bits to write ! 752: add esi, 4 ! 753: ! 754: ; Now we're going to paste the bytes to the screen ! 755: ; ! 756: ; (al) = used to accumulate style mask ! 757: ; (ah) = # pixels left in style ! 758: ; (bl) = rotating bit ! 759: ; (bh) = style mask ! 760: ; (ecx) = # of bits to write ! 761: ; (esi) = ptr to spot in ST_alStrips ! 762: ; (edi) = address of byte to write ! 763: ! 764: xor al, al ; clear output mask ! 765: ! 766: Strip_count: ! 767: xor al, bh ; set bit in output mask if style bit 0 ! 768: or al, bl ! 769: xor al, bh ! 770: ! 771: dec ah ! 772: jnz short @F ! 773: rol bh, 1 ! 774: mov ah, byte ptr density ! 775: @@: ror bh, 1 ! 776: ror bl, 1 ! 777: jc short Output_byte ! 778: dec ecx ! 779: jnz short Strip_count ! 780: ! 781: ; Do sidestep ! 782: ! 783: Side_step: ! 784: and byte ptr [edi], al ! 785: add edi, minoradd ! 786: ! 787: cmp esi, aEnd ! 788: jl short Strip_loop ! 789: ! 790: mov esi, pStrips ! 791: ! 792: mov [esi].ST_pjScreen, edi ! 793: mov [esi].ST_jBitmask, bl ! 794: mov [esi].ST_jStyleMask, bh ! 795: mov byte ptr [esi].ST_spRemaining, ah ! 796: ! 797: cRet vStripMaskedHorizontal ! 798: ! 799: Output_byte: ! 800: and byte ptr [edi], al ! 801: xor al, al ! 802: inc edi ! 803: dec ecx ! 804: jnz short Strip_count ! 805: jz short Side_step ! 806: ! 807: endProc vStripMaskedHorizontal ! 808: ! 809: ;--------------------------Private-Routine------------------------------; ! 810: ; vStripMaskedVertical ! 811: ; ! 812: ; Draw a mask-styled vertical strip left to right. ! 813: ; ! 814: ;-----------------------------------------------------------------------; ! 815: ! 816: cProc vStripMaskedVertical,12,< \ ! 817: uses esi edi ebx, \ ! 818: pStrips: ptr STRIPS, \ ! 819: pls: ptr LINESTATE, \ ! 820: plStripEnd: ptr > ! 821: ! 822: local aEnd:dword ; end of length array ! 823: local minoradd:dword ! 824: local density:dword ! 825: ! 826: ; So some initialization: ! 827: ! 828: mov esi, pStrips ! 829: mov al, [esi].ST_jBitmask ! 830: mov edi, [esi].ST_pjScreen ! 831: mov ebx, [esi].ST_lNextScan ! 832: mov ecx, plStripEnd ! 833: mov minoradd, ebx ! 834: mov aEnd, ecx ! 835: ! 836: ; Initialize styling: ! 837: ! 838: mov ecx, [esi].ST_xyDensity ! 839: mov ah, byte ptr [esi].ST_spRemaining ! 840: mov bh, [esi].ST_jStyleMask ! 841: mov density, ecx ! 842: add esi, offset ST_alStrips ! 843: ! 844: Strip_loop: ! 845: mov ecx, [esi] ; ecx = # bits to set ! 846: add esi, 4 ! 847: ! 848: ; Now we're going to paste the bytes to the screen ! 849: ; (al) = rotating bit ! 850: ; (ah) = # pixels left in style ! 851: ; (bh) = style mask ! 852: ; (ecx) = # bits to write ! 853: ; (dx) = io address of mask register ! 854: ; (esi) = ptr to spot in ST_alStrips ! 855: ; (edi) = address of byte to write ! 856: ! 857: Strip_count: ! 858: test bh, al ! 859: jnz short @F ; don't output pixel if style bit is 1 ! 860: and [edi], al ! 861: @@: ! 862: dec ah ; we've advanced 1 pel in the style ! 863: jnz short @F ! 864: mov ah, byte ptr density ! 865: rol bh, 1 ! 866: @@: ! 867: add edi, minoradd ! 868: ! 869: dec ecx ! 870: jnz short Strip_count ! 871: ! 872: ; Adjust address, style mask and rotating bit for sidestep: ! 873: ! 874: ror bh, 1 ; rotate style mask to stay in sync ! 875: ror al, 1 ; move rotating bit one to the right ! 876: adc edi, 0 ! 877: ! 878: cmp esi, aEnd ! 879: jl short Strip_loop ; hit end of array? ! 880: ! 881: mov esi, pStrips ! 882: ! 883: mov [esi].ST_pjScreen, edi ! 884: mov [esi].ST_jBitmask, al ! 885: mov [esi].ST_jStyleMask, bh ! 886: mov byte ptr [esi].ST_spRemaining, ah ! 887: ! 888: cRet vStripMaskedVertical ! 889: ! 890: endProc vStripMaskedVertical ! 891: ! 892: _TEXT$04 ends ! 893: ! 894: end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.