![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lines.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 / s3 / i386|
Return to lines.asm CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / s3 / i386 |
1.1 ! root 1: ;---------------------------Module-Header------------------------------; ! 2: ; Module Name: lines.asm ! 3: ; ! 4: ; ASM version of the line DDA calculator. ! 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: .xlist ! 17: include stdcall.inc ;calling convention cmacros ! 18: include i386\strucs.inc ! 19: include i386\lines.inc ! 20: .list ! 21: ! 22: .data ! 23: ! 24: public gaflRoundTable ! 25: gaflRoundTable label dword ! 26: dd FL_H_ROUND_DOWN + FL_V_ROUND_DOWN ; no flips ! 27: dd FL_H_ROUND_DOWN + FL_V_ROUND_DOWN ; D flip ! 28: dd FL_H_ROUND_DOWN ; V flip ! 29: dd FL_V_ROUND_DOWN ; D & V flip ! 30: dd FL_V_ROUND_DOWN ; slope one ! 31: dd 0baadf00dh ! 32: dd FL_H_ROUND_DOWN ; slope one & V flip ! 33: dd 0baadf00dh ! 34: ! 35: .code ! 36: ! 37: ;--------------------------------Macro----------------------------------; ! 38: ; testb ebx, <mask> ! 39: ; ! 40: ; Substitutes a byte compare if the mask is entirely in the lo-byte or ! 41: ; hi-byte (thus saving 3 bytes of code space). ! 42: ; ! 43: ;-----------------------------------------------------------------------; ! 44: ! 45: TESTB macro targ,mask,thirdarg ! 46: local mask2,delta ! 47: ! 48: ifnb <thirdarg> ! 49: .err TESTB mask must be enclosed in brackets! ! 50: endif ! 51: ! 52: delta = 0 ! 53: mask2 = mask ! 54: ! 55: if mask2 AND 0ffff0000h ! 56: test targ,mask ; If bit set in hi-word, ! 57: exitm ; test entire dword ! 58: endif ! 59: ! 60: if mask2 AND 0ff00h ! 61: if mask2 AND 0ffh ; If bit set in lo-byte and ! 62: test targ,mask ; hi-byte, test entire dword ! 63: exitm ! 64: endif ! 65: ! 66: mask2 = mask2 SHR 8 ! 67: delta = 1 ! 68: endif ! 69: ! 70: ifidni <targ>,<EBX> ! 71: if delta ! 72: test bh,mask2 ! 73: else ! 74: test bl,mask2 ! 75: endif ! 76: exitm ! 77: endif ! 78: ! 79: .err Too bad TESTB doesn't support targets other than ebx! ! 80: endm ! 81: ! 82: ;---------------------------Public-Routine------------------------------; ! 83: ; bLines(ppdev, pptfxFirst, pptfxBuf, prun, cptfx, pls, ! 84: ; prclClip, apfn[], flStart) ! 85: ; ! 86: ; Handles lines with trivial or simple clipping. ! 87: ; ! 88: ;-----------------------------------------------------------------------; ! 89: ! 90: cProc bLines,36,< \ ! 91: uses esi edi ebx, \ ! 92: ppdev: ptr, \ ! 93: pptfxFirst: ptr, \ ! 94: pptfxBuf: ptr, \ ! 95: prun: ptr, \ ! 96: cptfx: dword, \ ! 97: pls: ptr, \ ! 98: prclClip: ptr, \ ! 99: apfn: ptr, \ ! 100: flStart: dword > ! 101: ! 102: local pptfxBufEnd: ptr ; Last point in pptfxBuf ! 103: local M0: dword ; Normalized x0 in device coords ! 104: local dM: dword ; Delta-x in device coords ! 105: local N0: dword ; Normalized y0 in device coords ! 106: local dN: dword ; Delta-y in device coords ! 107: local fl: dword ; Flags for current line ! 108: local x: dword ; Normalized start pixel x-coord ! 109: local y: dword ; Normalized start pixel y-coord ! 110: local eqGamma_lo: dword ; Upper 32 bits of Gamma ! 111: local eqGamma_hi: dword ; Lower 32 bits of Gamma ! 112: local x0: dword ; Start pixel x-offset ! 113: local y0: dword ; Start pixel y-offset ! 114: local ulSlopeOneAdjustment: dword ; Special offset if line of slope 1 ! 115: local cStylePels: dword ; # of pixels in line (before clip) ! 116: local xStart: dword ; Start pixel x-offset before clip ! 117: local pfn: ptr ; Pointer to strip drawing function ! 118: local cPels: dword ; # pixels to be drawn (after clip) ! 119: local i: dword ; # pixels in strip ! 120: local r: dword ; Remainder (or "error") term ! 121: local d_I: dword ; Delta-I ! 122: local d_R: dword ; Delta-R ! 123: local plStripEnd: ptr ; Last strip in buffer ! 124: local ptlStart[size POINTL]: byte ; Unnormalized start coord ! 125: local dN_Original: dword ; dN before half-flip ! 126: local xClipLeft: dword ; Left side of clip rectangle ! 127: local xClipRight: dword ; Right side of clip rectangle ! 128: local strip[size STRIPS]: byte ; Our strip buffer ! 129: ! 130: mov ecx, cptfx ! 131: mov edx, pptfxBuf ! 132: lea eax, [edx + ecx * (size POINTL) - (size POINTL)] ! 133: mov pptfxBufEnd, eax ; pptfxBufEnd is inclusive of end point ! 134: ! 135: mov eax, [edx].ptl_x ; Load up end point (M1, N1) ! 136: mov edi, [edx].ptl_y ! 137: ! 138: mov edx, pptfxFirst ; Load up start point (M0, N0) ! 139: mov esi, [edx].ptl_x ! 140: mov ecx, [edx].ptl_y ! 141: ! 142: mov ebx, flStart ! 143: ! 144: ;-----------------------------------------------------------------------; ! 145: ; Flip to the first octant. ; ! 146: ;-----------------------------------------------------------------------; ! 147: ! 148: ; Register state: esi = M0 ! 149: ; ecx = N0 ! 150: ; eax = dM (M1) ! 151: ; edi = dN (N1) ! 152: ; ebx = fl ! 153: ! 154: ; Make sure we go left to right: ! 155: ! 156: the_main_loop: ! 157: cmp esi, eax ! 158: jle short is_left_to_right ; skip if M0 <= M1 ! 159: xchg esi, eax ; swap M0, M1 ! 160: xchg ecx, edi ; swap N0, N1 ! 161: or ebx, FL_FLIP_H ! 162: ! 163: is_left_to_right: ! 164: ! 165: ; Compute the deltas, remembering that the DDI says we should get ! 166: ; deltas less than 2^31. If we get more, we ensure we don't crash ! 167: ; later on by simply skipping the line: ! 168: ! 169: sub eax, esi ; eax = dM ! 170: jo next_line ; dM must be less than 2^31 ! 171: sub edi, ecx ; edi = dN ! 172: jo next_line ; dN must be less than 2^31 ! 173: ! 174: jge short is_top_to_bottom ; skip if dN >= 0 ! 175: neg ecx ; N0 = -N0 ! 176: neg edi ; N1 = -N1 ! 177: or ebx, FL_FLIP_V ! 178: ! 179: is_top_to_bottom: ! 180: cmp edi, eax ! 181: jb short done_flips ; skip if dN < dM ! 182: jne short slope_more_than_one ! 183: ! 184: ; We must special case slopes of one: ! 185: ! 186: or ebx, FL_FLIP_SLOPE_ONE ! 187: jmp short done_flips ! 188: ! 189: slope_more_than_one: ! 190: xchg eax, edi ; swap dM, dN ! 191: xchg esi, ecx ; swap M0, N0 ! 192: or ebx, FL_FLIP_D ! 193: ! 194: done_flips: ! 195: ! 196: mov edx, ebx ! 197: and edx, FL_ROUND_MASK ! 198: .errnz FL_ROUND_SHIFT - 2 ! 199: or ebx, [gaflRoundTable + edx] ; get our rounding flags ! 200: ! 201: mov dM, eax ; save some info ! 202: mov dN, edi ! 203: mov fl, ebx ! 204: ! 205: mov edx, esi ; x = LFLOOR(M0) ! 206: sar edx, FLOG2 ! 207: mov x, edx ! 208: ! 209: mov edx, ecx ; y = LFLOOR(N0) ! 210: sar edx, FLOG2 ! 211: mov y, edx ! 212: ! 213: ;-----------------------------------------------------------------------; ! 214: ; Compute the fractional remainder term ; ! 215: ;-----------------------------------------------------------------------; ! 216: ! 217: public compute_fractional ! 218: compute_fractional: ! 219: and esi, F - 1 ; M0 = FXFRAC(M0) ! 220: and ecx, F - 1 ; N0 = FXFRAC(N0) ! 221: ! 222: mov M0, esi ; save M0, N0 for later ! 223: mov N0, ecx ! 224: ! 225: lea edx, [ecx + F/2] ! 226: mul edx ; [edx:eax] = dM * (N0 + F/2) ! 227: xchg eax, edi ! 228: mov ecx, edx ; [ecx:edi] = dM * (N0 + F/2) ! 229: ; (we just nuked N0) ! 230: ! 231: mul esi ; [edx:eax] = dN * M0 ! 232: ! 233: ; Now gamma = dM * (N0 + F/2) - dN * M0 - bRoundDown ! 234: ! 235: .errnz FL_V_ROUND_DOWN - 8000h ! 236: ror bh, 8 ! 237: sbb edi, eax ! 238: sbb ecx, edx ! 239: ! 240: shrd edi, ecx, FLOG2 ! 241: sar ecx, FLOG2 ; gamma = [ecx:edi] >>= 4 ! 242: ! 243: mov eqGamma_hi, ecx ! 244: mov eqGamma_lo, edi ! 245: ! 246: mov eax, N0 ! 247: ! 248: ; Register state: ! 249: ; eax = N0 ! 250: ; ebx = fl ! 251: ; ecx = eqGamma_hi ! 252: ; edx = garbage ! 253: ; esi = M0 ! 254: ; edi = eqGamma_lo ! 255: ! 256: testb ebx, FL_FLIP_H ! 257: jnz line_runs_right_to_left ! 258: ! 259: ;-----------------------------------------------------------------------; ! 260: ; Figure out which pixels are at the ends of a left-to-right line. ; ! 261: ; --------> ; ! 262: ;-----------------------------------------------------------------------; ! 263: ! 264: public line_runs_left_to_right ! 265: line_runs_left_to_right: ! 266: or esi, esi ! 267: jz short LtoR_check_slope_one ! 268: ; skip ahead if M0 == 0 ! 269: ; (in that case, x0 = 0 which is to be ! 270: ; kept in esi, and is already ! 271: ; conventiently zero) ! 272: ! 273: or eax, eax ! 274: jnz short LtoR_N0_not_zero ! 275: ! 276: .errnz FL_H_ROUND_DOWN - 80h ! 277: ror bl, 8 ! 278: sbb esi, -F/2 ! 279: shr esi, FLOG2 ! 280: jmp short LtoR_check_slope_one ! 281: ; esi = x0 = rounded M0 ! 282: ! 283: LtoR_N0_not_zero: ! 284: sub eax, F/2 ! 285: sbb edx, edx ! 286: xor eax, edx ! 287: sub eax, edx ! 288: cmp esi, eax ! 289: sbb esi, esi ! 290: inc esi ; esi = x0 = (abs(N0 - F/2) <= M0) ! 291: ! 292: public LtoR_check_slope_one ! 293: LtoR_check_slope_one: ! 294: mov ulSlopeOneAdjustment, 0 ! 295: mov eax, ebx ! 296: and eax, FL_FLIP_SLOPE_ONE + FL_H_ROUND_DOWN ! 297: cmp eax, FL_FLIP_SLOPE_ONE + FL_H_ROUND_DOWN ! 298: jne short LtoR_compute_y0_from_x0 ! 299: ! 300: ; We have to special case lines that are exactly of slope 1 or -1: ! 301: ! 302: mov eax, N0 ! 303: add eax, dN ! 304: and eax, F - 1 ; eax = N1 ! 305: jz short LtoR_slope_one_check_start_point ! 306: ! 307: mov edx, M0 ! 308: add edx, dM ! 309: and edx, F - 1 ; edx = M1 ! 310: ! 311: add eax, F/2 ! 312: cmp edx, eax ; cmp M1, N1 + F/2 ! 313: jne short LtoR_slope_one_check_start_point ! 314: mov ulSlopeOneAdjustment, -1 ! 315: ! 316: LtoR_slope_one_check_start_point: ! 317: mov eax, M0 ! 318: or eax, eax ! 319: jz short LtoR_compute_y0_from_x0 ! 320: ! 321: add eax, F/2 ! 322: cmp eax, N0 ; cmp M0 + 8, N0 ! 323: jne short LtoR_compute_y0_from_x0 ! 324: ! 325: xor esi, esi ; x0 = 0 ! 326: ! 327: LtoR_compute_y0_from_x0: ! 328: ! 329: ; ecx = eqGamma_hi ! 330: ; esi = x0 ! 331: ; edi = eqGamma_lo ! 332: ! 333: mov eax, dN ! 334: mov edx, dM ! 335: ! 336: mov x0, esi ! 337: mov y0, 0 ! 338: cmp ecx, 0 ! 339: jl short LtoR_compute_x1 ! 340: ! 341: neg esi ! 342: and esi, eax ! 343: sub edx, esi ! 344: cmp edi, edx ! 345: mov edx, dM ! 346: jl short LtoR_compute_x1 ! 347: mov y0, 1 ; y0 = floor((dN * x0 + eqGamma) / dM) ! 348: ! 349: LtoR_compute_x1: ! 350: ! 351: ; Register state: ! 352: ; eax = dN ! 353: ; ebx = fl ! 354: ; ecx = garbage ! 355: ; edx = dM ! 356: ; esi = garbage ! 357: ; edi = garbage ! 358: ! 359: mov esi, M0 ! 360: add esi, edx ! 361: mov ecx, esi ! 362: shr esi, FLOG2 ! 363: dec esi ; x1 = ((M0 + dM) >> 4) - 1 ! 364: add esi, ulSlopeOneAdjustment ! 365: and ecx, F-1 ; M1 = (M0 + dM) & 15 ! 366: jz done_first_pel_last_pel ! 367: ! 368: add eax, N0 ! 369: and eax, F-1 ; N1 = (N0 + dN) & 15 ! 370: jnz short LtoR_N1_not_zero ! 371: ! 372: .errnz FL_H_ROUND_DOWN - 80h ! 373: ror bl, 8 ! 374: sbb ecx, -F/2 ! 375: shr ecx, FLOG2 ; ecx = LROUND(M1, fl & FL_ROUND_DOWN) ! 376: add esi, ecx ! 377: jmp done_first_pel_last_pel ! 378: ! 379: LtoR_N1_not_zero: ! 380: sub eax, F/2 ! 381: sbb edx, edx ! 382: xor eax, edx ! 383: sub eax, edx ! 384: cmp eax, ecx ! 385: jg done_first_pel_last_pel ! 386: inc esi ! 387: jmp done_first_pel_last_pel ! 388: ! 389: ;-----------------------------------------------------------------------; ! 390: ; Figure out which pixels are at the ends of a right-to-left line. ; ! 391: ; <-------- ; ! 392: ;-----------------------------------------------------------------------; ! 393: ! 394: ; Compute x0: ! 395: ! 396: public line_runs_right_to_left ! 397: line_runs_right_to_left: ! 398: mov x0, 1 ; x0 = 1 ! 399: or eax, eax ! 400: jnz short RtoL_N0_not_zero ! 401: ! 402: xor edx, edx ; ulDelta = 0 ! 403: .errnz FL_H_ROUND_DOWN - 80h ! 404: ror bl, 8 ! 405: sbb esi, -F/2 ! 406: shr esi, FLOG2 ; esi = LROUND(M0, fl & FL_H_ROUND_DOWN) ! 407: jz short RtoL_check_slope_one ! 408: ! 409: mov x0, 2 ! 410: mov edx, dN ! 411: jmp short RtoL_check_slope_one ! 412: ! 413: RtoL_N0_not_zero: ! 414: sub eax, F/2 ! 415: sbb edx, edx ! 416: xor eax, edx ! 417: sub eax, edx ! 418: add eax, esi ; eax = ABS(N0 - F/2) + M0 ! 419: xor edx, edx ; ulDelta = 0 ! 420: cmp eax, F ! 421: jle short RtoL_check_slope_one ! 422: ! 423: mov x0, 2 ; x0 = 2 ! 424: mov edx, dN ; ulDelta = dN ! 425: ! 426: public RtoL_check_slope_one ! 427: RtoL_check_slope_one: ! 428: mov ulSlopeOneAdjustment, 0 ! 429: mov eax, ebx ! 430: and eax, FL_FLIP_SLOPE_ONE + FL_H_ROUND_DOWN ! 431: cmp eax, FL_FLIP_SLOPE_ONE ! 432: jne short RtoL_compute_y0_from_x0 ! 433: ! 434: ; We have to special case lines that are exactly of slope 1 or -1: ! 435: ! 436: mov eax, N0 ! 437: add eax, dN ! 438: and eax, F - 1 ; eax = N1 ! 439: jz short RtoL_slope_one_check_start_point ! 440: ! 441: mov esi, M0 ! 442: add esi, dM ! 443: and esi, F - 1 ; esi = M1 ! 444: ! 445: add eax, F/2 ! 446: cmp esi, eax ; cmp M1, N1 + F/2 ! 447: jne short RtoL_slope_one_check_start_point ! 448: mov ulSlopeOneAdjustment, 1 ! 449: ! 450: RtoL_slope_one_check_start_point: ! 451: mov eax, M0 ! 452: or eax, eax ! 453: jz short RtoL_compute_y0_from_x0 ! 454: ! 455: add eax, F/2 ! 456: cmp eax, N0 ; cmp M0 + 8, N0 ! 457: jne short RtoL_compute_y0_from_x0 ! 458: ! 459: mov x0, 2 ; x0 = 2 ! 460: mov edx, dN ; ulDelta = dN ! 461: ! 462: RtoL_compute_y0_from_x0: ! 463: ! 464: ; eax = garbage ! 465: ; ebx = fl ! 466: ; ecx = eqGamma_hi ! 467: ; edx = ulDelta ! 468: ; esi = garbage ! 469: ; edi = eqGamma_lo ! 470: ! 471: mov eax, dN ; eax = dN ! 472: mov y0, 0 ; y0 = 0 ! 473: ! 474: add edi, edx ! 475: adc ecx, 0 ; eqGamma += ulDelta ! 476: ; NOTE: Setting flags here! ! 477: mov edx, dM ; edx = dM ! 478: jl short RtoL_compute_x1 ; NOTE: Looking at the flags here! ! 479: jg short RtoL_y0_is_2 ! 480: ! 481: lea ecx, [edx + edx] ! 482: sub ecx, eax ; ecx = 2 * dM - dN ! 483: cmp edi, ecx ! 484: jge short RtoL_y0_is_2 ! 485: ! 486: sub ecx, edx ; ecx = dM - dN ! 487: cmp edi, ecx ! 488: jl short RtoL_compute_x1 ! 489: ! 490: mov y0, 1 ! 491: jmp short RtoL_compute_x1 ! 492: ! 493: RtoL_y0_is_2: ! 494: mov y0, 2 ! 495: ! 496: RtoL_compute_x1: ! 497: ! 498: ; Register state: ! 499: ; eax = dN ! 500: ; ebx = fl ! 501: ; ecx = garbage ! 502: ; edx = dM ! 503: ; esi = garbage ! 504: ; edi = garbage ! 505: ! 506: mov esi, M0 ! 507: add esi, edx ! 508: mov ecx, esi ! 509: shr esi, FLOG2 ; x1 = (M0 + dM) >> 4 ! 510: add esi, ulSlopeOneAdjustment ! 511: and ecx, F-1 ; M1 = (M0 + dM) & 15 ! 512: ! 513: add eax, N0 ! 514: and eax, F-1 ; N1 = (N0 + dN) & 15 ! 515: jnz short RtoL_N1_not_zero ! 516: ! 517: .errnz FL_H_ROUND_DOWN - 80h ! 518: ror bl, 8 ! 519: sbb ecx, -F/2 ! 520: shr ecx, FLOG2 ; ecx = LROUND(M1, fl & FL_ROUND_DOWN) ! 521: add esi, ecx ! 522: jmp done_first_pel_last_pel ! 523: ! 524: RtoL_N1_not_zero: ! 525: sub eax, F/2 ! 526: sbb edx, edx ! 527: xor eax, edx ! 528: sub eax, edx ! 529: add eax, ecx ; eax = ABS(N1 - F/2) + M1 ! 530: cmp eax, F+1 ! 531: sbb esi, -1 ! 532: ! 533: done_first_pel_last_pel: ! 534: ! 535: ; Register state: ! 536: ; eax = garbage ! 537: ; ebx = fl ! 538: ; ecx = garbage ! 539: ; edx = garbage ! 540: ; esi = x1 ! 541: ; edi = garbage ! 542: ! 543: mov ecx, x0 ! 544: lea edx, [esi + 1] ! 545: sub edx, ecx ; edx = x1 - x0 + 1 ! 546: ! 547: jle next_line ! 548: mov cStylePels, edx ! 549: mov xStart, ecx ! 550: ! 551: ;-----------------------------------------------------------------------; ! 552: ; See if clipping or styling needs to be done. ; ! 553: ;-----------------------------------------------------------------------; ! 554: ! 555: testb ebx, FL_CLIP ! 556: jnz do_some_clipping ! 557: ! 558: ; Register state: ! 559: ; eax = garbage ! 560: ; ebx = fl ! 561: ; ecx = x0 ! 562: ; edx = garbage ! 563: ; esi = x1 ! 564: ; edi = garbage ! 565: ! 566: done_clipping: ! 567: mov eax, y0 ! 568: ! 569: sub esi, ecx ! 570: inc esi ; esi = cPels = x1 - x0 + 1 ! 571: mov cPels, esi ! 572: ! 573: add ecx, x ; ecx = ptlStart.ptl_x ! 574: add eax, y ; eax = ptlStart.ptl_y ! 575: ! 576: testb ebx, FL_FLIP_D ! 577: jz short do_v_unflip ! 578: xchg ecx, eax ! 579: ! 580: do_v_unflip: ! 581: testb ebx, FL_FLIP_V ! 582: jz short done_unflips ! 583: neg eax ! 584: ! 585: done_unflips: ! 586: testb ebx, FL_STYLED ! 587: jnz do_some_styling ! 588: ! 589: done_styling: ! 590: lea edx, [strip.ST_alStrips + (STRIP_MAX * 4)] ! 591: mov plStripEnd, edx ! 592: ! 593: ;-----------------------------------------------------------------------; ! 594: ; Setup to do DDA. ; ! 595: ;-----------------------------------------------------------------------; ! 596: ! 597: ; Register state: ! 598: ; eax = ptlStart.ptl_y ! 599: ; ebx = fl ! 600: ; ecx = ptlStart.ptl_x ! 601: ; edx = garbage ! 602: ; esi = garbage ! 603: ; edi = garbage ! 604: ! 605: mov strip.ST_ptlStart.ptl_x, ecx ! 606: mov strip.ST_ptlStart.ptl_y, eax ! 607: ! 608: mov eax, dM ! 609: mov ecx, dN ! 610: mov esi, eqGamma_lo ! 611: mov edi, eqGamma_hi ! 612: ! 613: ! 614: ; Register state: ! 615: ; eax = dM ! 616: ; ebx = fl ! 617: ; ecx = dN ! 618: ; edx = garbage ! 619: ; esi = eqGamma_lo ! 620: ; edi = eqGamma_hi ! 621: ! 622: lea edx, [ecx + ecx] ; if (2 * dN > dM) ! 623: cmp edx, eax ! 624: mov edx, y0 ; Load y0 again ! 625: jbe short after_half_flip ! 626: ! 627: test ebx, (FL_STYLED + FL_DONT_DO_HALF_FLIP) ! 628: jnz short after_half_flip ! 629: ! 630: or ebx, FL_FLIP_HALF ! 631: mov fl, ebx ! 632: ! 633: ; Do a half flip! ! 634: ! 635: not esi ! 636: not edi ! 637: add esi, eax ! 638: adc edi, 0 ; eqGamma = -eqGamma - 1 + dM ! 639: ! 640: neg ecx ! 641: add ecx, eax ; dN = dM - dN ! 642: ! 643: neg edx ! 644: add edx, x0 ; y0 = x0 - y0 ! 645: ! 646: after_half_flip: ! 647: mov strip.ST_flFlips, ebx ! 648: mov eax, dM ! 649: ! 650: ; Register state: ! 651: ; eax = dM ! 652: ; ebx = fl ! 653: ; ecx = dN ! 654: ; edx = y0 ! 655: ; esi = eqGamma_lo ! 656: ; edi = eqGamma_hi ! 657: ! 658: or ecx, ecx ! 659: jz short zero_slope ! 660: ! 661: compute_dda_stuff: ! 662: inc edx ! 663: mul edx ! 664: stc ; set the carry to accomplish -1 ! 665: sbb eax, esi ! 666: sbb edx, edi ; (y0 + 1) * dM - eqGamma - 1 ! 667: div ecx ! 668: ! 669: mov esi, eax ; esi = i ! 670: mov edi, edx ; edi = r ! 671: ! 672: xor edx, edx ! 673: mov eax, dM ! 674: div ecx ; edx = d_R, eax = d_I ! 675: mov d_I, eax ! 676: ! 677: sub esi, x0 ! 678: inc esi ! 679: ! 680: done_dda_stuff: ! 681: ! 682: ; Register state: ! 683: ; eax = d_I ! 684: ; ebx = fl ! 685: ; ecx = dN ! 686: ; edx = d_R ! 687: ; esi = i ! 688: ; edi = r ! 689: ! 690: ; We're going to decide if we can call the short-vector routines. They ! 691: ; can only take strips that have a maximum length of 15 pixels each. ! 692: ; We happen to know that the longest strip in our line could be is d_I + 1. ! 693: ! 694: and ebx, FL_STRIP_MASK ! 695: mov eax, apfn ! 696: ! 697: .errnz FL_STRIP_SHIFT ! 698: lea eax, [eax + ebx * 4] ! 699: ! 700: cmp d_I, MAX_SHORT_STROKE_LENGTH ! 701: sbb ebx, ebx ; ffffffffh when < 15, 0 when >= 15 ! 702: and ebx, NUM_STRIP_DRAW_DIRECTIONS * 4 ! 703: ; Look four entries further into table ! 704: ! 705: mov eax, [eax + ebx] ! 706: mov pfn, eax ! 707: ! 708: lea eax, [strip.ST_alStrips] ! 709: mov ebx, cPels ! 710: ! 711: ;-----------------------------------------------------------------------; ! 712: ; Do our main DDA loop. ; ! 713: ;-----------------------------------------------------------------------; ! 714: ! 715: ; Register state: ! 716: ; eax = plStrip ! 717: ; ebx = cPels ! 718: ; ecx = dN ! 719: ; edx = d_R ! 720: ; esi = i ! 721: ; edi = r ! 722: ! 723: dda_loop: ! 724: sub ebx, esi ! 725: jle final_strip ! 726: ! 727: mov [eax], esi ! 728: add eax, 4 ! 729: cmp plStripEnd, eax ! 730: jbe short output_strips ! 731: ! 732: done_output_strips: ! 733: mov esi, d_I ! 734: add edi, edx ! 735: cmp edi, ecx ! 736: jb short dda_loop ! 737: ! 738: sub edi, ecx ! 739: inc esi ! 740: jmp short dda_loop ! 741: ! 742: zero_slope: ! 743: mov esi, 7fffffffh ; Make run maximum length (cPels ! 744: ; actually decideds how long the line ! 745: ; is) ! 746: mov d_I, 7fffffffh ; Make delta maximum length so that ! 747: ; we don't try to do short vectors ! 748: mov eax, cPels ; We need this when we decide if to do ! 749: dec eax ; short strip routines. ! 750: jmp short done_dda_stuff ! 751: ! 752: ;-----------------------------------------------------------------------; ! 753: ; Empty strips buffer. ; ! 754: ;-----------------------------------------------------------------------; ! 755: ! 756: output_strips: ! 757: mov d_R, edx ! 758: mov cPels, ebx ! 759: mov i, esi ! 760: mov r, edi ! 761: mov dN, ecx ! 762: ! 763: lea edx, [strip.ST_alStrips] ! 764: sub eax, edx ! 765: shr eax, 2 ! 766: mov strip.ST_cStrips, eax ! 767: ! 768: mov eax, ppdev ! 769: lea edx, [strip] ! 770: mov ecx, pls ! 771: ! 772: ptrCall <dword ptr pfn>, \ ! 773: <eax, edx, ecx> ! 774: ! 775: mov esi, i ! 776: mov edi, r ! 777: mov ebx, cPels ! 778: mov edx, d_R ! 779: mov ecx, dN ! 780: lea eax, [strip.ST_alStrips] ! 781: jmp done_output_strips ! 782: ! 783: ;-----------------------------------------------------------------------; ! 784: ; Empty strips buffer and go on to next line. ; ! 785: ;-----------------------------------------------------------------------; ! 786: ! 787: final_strip: ! 788: add ebx, esi ! 789: mov [eax], ebx ! 790: add eax, 4 ! 791: ! 792: very_final_strip: ! 793: lea edx, [strip.ST_alStrips] ! 794: sub eax, edx ! 795: shr eax, 2 ! 796: mov strip.ST_cStrips, eax ! 797: ! 798: mov eax, ppdev ! 799: lea edx, [strip] ! 800: mov ecx, pls ! 801: ! 802: ptrCall <dword ptr pfn>, \ ! 803: <eax, edx, ecx> ! 804: ! 805: next_line: ! 806: mov ebx, flStart ! 807: testb ebx, FL_COMPLEX_CLIP ! 808: jnz short see_if_done_complex_clipping ! 809: ! 810: mov edx, pptfxBuf ! 811: cmp edx, pptfxBufEnd ! 812: je short all_done ! 813: ! 814: mov esi, [edx].ptl_x ! 815: mov ecx, [edx].ptl_y ! 816: add edx, size POINTL ! 817: mov pptfxBuf, edx ! 818: mov eax, [edx].ptl_x ! 819: mov edi, [edx].ptl_y ! 820: jmp the_main_loop ! 821: ! 822: all_done: ! 823: mov eax, 1 ! 824: ! 825: cRet bLines ! 826: ! 827: see_if_done_complex_clipping: ! 828: mov ebx, fl ! 829: dec cptfx ! 830: jz short all_done ! 831: jmp continue_complex_clipping ! 832: ! 833: ;---------------------------Private-Routine-----------------------------; ! 834: ; do_some_styling ! 835: ; ! 836: ; Inputs: ! 837: ; eax = ptlStart.ptl_y ! 838: ; ebx = fl ! 839: ; ecx = ptlStart.ptl_x ! 840: ; Preserves: ! 841: ; eax, ebx, ecx ! 842: ; Output: ! 843: ; Exits to done_styling. ! 844: ; ! 845: ;-----------------------------------------------------------------------; ! 846: ! 847: do_some_styling: ! 848: mov ptlStart.ptl_x, ecx ! 849: ! 850: mov esi, pls ! 851: mov edi, [esi].LS_spNext ; spThis ! 852: mov edx, edi ! 853: add edx, cStylePels ; spNext ! 854: ! 855: ; For styles, we don't bother to keep the style position normalized. ! 856: ; (we do ensure that it's positive, though). If a figure is over 2 ! 857: ; billion pels long, we'll be a pel off in our style state (oops!). ! 858: ! 859: and edx, 7fffffffh ! 860: mov [esi].LS_spNext, edx ! 861: mov ptlStart.ptl_y, eax ! 862: ! 863: ; Do arbitrary styles: ! 864: ! 865: do_arbitrary_style: ! 866: testb ebx, FL_FLIP_H ! 867: jz short arbitrary_left_to_right ! 868: ! 869: sub edx, x0 ! 870: add edx, xStart ! 871: mov eax, edx ! 872: xor edx, edx ! 873: div [esi].LS_spTotal ! 874: ! 875: neg edx ! 876: jge short continue_right_to_left ! 877: add edx, [esi].LS_spTotal ! 878: not eax ! 879: ! 880: continue_right_to_left: ! 881: mov edi, dword ptr [esi].LS_jStartMask ! 882: not edi ! 883: mov ecx, [esi].LS_aspRtoL ! 884: jmp short compute_arbitrary_stuff ! 885: ! 886: arbitrary_left_to_right: ! 887: add edi, x0 ! 888: sub edi, xStart ! 889: mov eax, edi ! 890: xor edx, edx ! 891: div [esi].LS_spTotal ! 892: mov edi, dword ptr [esi].LS_jStartMask ! 893: mov ecx, [esi].LS_aspLtoR ! 894: ! 895: compute_arbitrary_stuff: ! 896: ; eax = sp / spTotal ! 897: ; ebx = fl ! 898: ; ecx = pspStart ! 899: ; edx = sp % spTotal ! 900: ; esi = pla ! 901: ; edi = jStyleMask ! 902: ! 903: and eax, [esi].LS_cStyle ; if odd length style and second run ! 904: and al, 1 ; through style array, flip the ! 905: jz short odd_style_array_done ; meaning of the elements ! 906: not edi ! 907: ! 908: odd_style_array_done: ! 909: mov [esi].LS_pspStart, ecx ! 910: mov eax, [esi].LS_cStyle ! 911: lea eax, [ecx + eax * 4 - 4] ! 912: mov [esi].LS_pspEnd, eax ! 913: ! 914: find_psp: ! 915: sub edx, [ecx] ! 916: jl short found_psp ! 917: add ecx, 4 ! 918: jmp short find_psp ! 919: ! 920: found_psp: ! 921: mov [esi].LS_psp, ecx ! 922: neg edx ! 923: mov [esi].LS_spRemaining, edx ! 924: ! 925: sub ecx, [esi].LS_pspStart ! 926: test ecx, 4 ; size STYLEPOS ! 927: jz short done_arbitrary ! 928: not edi ! 929: ! 930: done_arbitrary: ! 931: mov dword ptr [esi].LS_jStyleMask, edi ! 932: mov eax, ptlStart.ptl_y ! 933: mov ecx, ptlStart.ptl_x ! 934: jmp done_styling ! 935: ! 936: ! 937: ;---------------------------Private-Routine-----------------------------; ! 938: ; do_some_clipping ! 939: ; ! 940: ; Inputs: ! 941: ; eax = garbage ! 942: ; ebx = fl ! 943: ; ecx = x0 ! 944: ; edx = garbage ! 945: ; esi = x1 ! 946: ; edi = garbage ! 947: ; ! 948: ; Decides whether to do simple or complex clipping. ! 949: ; ! 950: ;-----------------------------------------------------------------------; ! 951: ! 952: align 4 ! 953: ! 954: public do_some_clipping ! 955: do_some_clipping: ! 956: testb ebx, FL_COMPLEX_CLIP ! 957: jnz initialize_complex_clipping ! 958: ! 959: ;-----------------------------------------------------------------------; ! 960: ; simple_clipping ! 961: ; ! 962: ; Inputs: ! 963: ; ebx = fl ! 964: ; ecx = x0 ! 965: ; esi = x1 ! 966: ; Output: ! 967: ; ebx = fl ! 968: ; ecx = new x0 (stack variable updated too) ! 969: ; esi = new x1 ! 970: ; y0 stack variable updated ! 971: ; Uses: ! 972: ; All registers ! 973: ; Exits: ! 974: ; to done_clipping ! 975: ; ! 976: ; This routine handles clipping the line to the clip rectangle (it's ! 977: ; faster to handle this case in the driver than to call the engine to ! 978: ; clip for us). ! 979: ; ! 980: ; Fractional end-point lines complicate our lives a bit when doing ! 981: ; clipping: ! 982: ; ! 983: ; 1) For styling, we must know the unclipped line's length in pels, so ! 984: ; that we can correctly update the styling state when the line is ! 985: ; clipped. For this reason, I do clipping after doing the hard work ! 986: ; of figuring out which pixels are at the ends of the line (this is ! 987: ; wasted work if the line is not styled and is completely clipped, ! 988: ; but I think it's simpler this way). Another reason is that we'll ! 989: ; have calculated eqGamma already, which we use for the intercept ! 990: ; calculations. ! 991: ; ! 992: ; With the assumption that most lines will not be completely clipped ! 993: ; away, this strategy isn't too painful. ! 994: ; ! 995: ; 2) x0, y0 are not necessarily zero, where (x0, y0) is the start pel of ! 996: ; the line. ! 997: ; ! 998: ; 3) We know x0, y0 and x1, but not y1. We haven't needed to calculate ! 999: ; y1 until now. We'll need the actual value, and not an upper bound ! 1000: ; like y1 = LFLOOR(dM) + 2 because we have to be careful when ! 1001: ; calculating x(y) that y0 <= y <= y1, otherwise we can cause an ! 1002: ; overflow on the divide (which, needless to say, is bad). ! 1003: ; ! 1004: ;-----------------------------------------------------------------------; ! 1005: ! 1006: public simple_clipping ! 1007: simple_clipping: ! 1008: mov edi, prclClip ; get pointer to normalized clip rect ! 1009: and ebx, FL_RECTLCLIP_MASK ; (it's lower-right exclusive) ! 1010: ! 1011: .errnz (FL_RECTLCLIP_SHIFT - 2); ((ebx AND FL_RECTLCLIP_MASK) shr ! 1012: .errnz (size RECTL) - 16 ; FL_RECTLCLIP_SHIFT) is our index ! 1013: lea edi, [edi + ebx*4] ; into the array of rectangles ! 1014: ! 1015: mov edx, [edi].xRight ; load the rect coordinates ! 1016: mov eax, [edi].xLeft ! 1017: mov ebx, [edi].yBottom ! 1018: mov edi, [edi].yTop ! 1019: ! 1020: ; Translate to our origin and so some quick completely clipped tests: ! 1021: ! 1022: sub edx, x ! 1023: cmp ecx, edx ! 1024: jge totally_clipped ; totally clipped if x0 >= xRight ! 1025: ! 1026: sub eax, x ! 1027: cmp esi, eax ! 1028: jl totally_clipped ; totally clipped if x1 < xLeft ! 1029: ! 1030: sub ebx, y ! 1031: cmp y0, ebx ! 1032: jge totally_clipped ; totally clipped if y0 >= yBottom ! 1033: ! 1034: sub edi, y ! 1035: ! 1036: ; Save some state: ! 1037: ! 1038: mov xClipRight, edx ! 1039: mov xClipLeft, eax ! 1040: ! 1041: cmp esi, edx ; if (x1 >= xRight) x1 = xRight - 1 ! 1042: jl short calculate_y1 ! 1043: lea esi, [edx - 1] ! 1044: ! 1045: calculate_y1: ! 1046: mov eax, esi ; y1 = (x1 * dN + eqGamma) / dM ! 1047: mul dN ! 1048: add eax, eqGamma_lo ! 1049: adc edx, eqGamma_hi ! 1050: div dM ! 1051: ! 1052: cmp edi, eax ; if (yTop > y1) clipped ! 1053: jg short totally_clipped ! 1054: ! 1055: cmp ebx, eax ; if (yBottom > y1) know x1 ! 1056: jg short x1_computed ! 1057: ! 1058: mov eax, ebx ; x1 = (yBottom * dM + eqBeta) / dN ! 1059: mul dM ! 1060: stc ! 1061: sbb eax, eqGamma_lo ! 1062: sbb edx, eqGamma_hi ! 1063: div dN ! 1064: mov esi, eax ! 1065: ! 1066: ; At this point, we've taken care of calculating the intercepts with the ! 1067: ; right and bottom edges. Now we work on the left and top edges: ! 1068: ! 1069: x1_computed: ! 1070: mov edx, y0 ! 1071: ! 1072: mov eax, xClipLeft ; don't have to compute y intercept ! 1073: cmp eax, ecx ; at left edge if line starts to ! 1074: jle short top_intercept ; right of left edge ! 1075: ! 1076: mov ecx, eax ; x0 = xLeft ! 1077: mul dN ; y0 = (xLeft * dN + eqGamma) / dM ! 1078: add eax, eqGamma_lo ! 1079: adc edx, eqGamma_hi ! 1080: div dM ! 1081: ! 1082: cmp ebx, eax ; if (yBottom <= y0) clipped ! 1083: jle short totally_clipped ! 1084: ! 1085: mov edx, eax ! 1086: mov y0, eax ! 1087: ! 1088: top_intercept: ! 1089: mov ebx, fl ; get ready to leave ! 1090: mov x0, ecx ! 1091: ! 1092: cmp edi, edx ; if (yTop <= y0) done clipping ! 1093: jle done_clipping ! 1094: ! 1095: mov eax, edi ; x0 = (yTop * dM + eqBeta) / dN + 1 ! 1096: mul dM ! 1097: stc ! 1098: sbb eax, eqGamma_lo ! 1099: sbb edx, eqGamma_hi ! 1100: div dN ! 1101: lea ecx, [eax + 1] ! 1102: ! 1103: cmp xClipRight, ecx ; if (xRight <= x0) clipped ! 1104: jle short totally_clipped ! 1105: ! 1106: mov y0, edi ; y0 = yTop ! 1107: mov x0, ecx ! 1108: jmp done_clipping ; all done! ! 1109: ! 1110: totally_clipped: ! 1111: ! 1112: ; The line is completely clipped. See if we have to update our style state: ! 1113: ! 1114: mov ebx, fl ! 1115: testb ebx, FL_STYLED ! 1116: jz next_line ! 1117: ! 1118: ; Adjust our style state: ! 1119: ! 1120: mov esi, pls ! 1121: mov eax, [esi].LS_spNext ! 1122: add eax, cStylePels ! 1123: mov [esi].LS_spNext, eax ! 1124: ! 1125: cmp eax, [esi].LS_spTotal2 ! 1126: jb next_line ! 1127: ! 1128: ; Have to normalize first: ! 1129: ! 1130: xor edx, edx ! 1131: div [esi].LS_spTotal2 ! 1132: mov [esi].LS_spNext, edx ! 1133: ! 1134: jmp next_line ! 1135: ! 1136: ;-----------------------------------------------------------------------; ! 1137: ! 1138: initialize_complex_clipping: ! 1139: mov eax, dN ; save a copy of original dN ! 1140: mov dN_Original, eax ! 1141: ! 1142: ;---------------------------Private-Routine-----------------------------; ! 1143: ; continue_complex_clipping ! 1144: ; ! 1145: ; Inputs: ! 1146: ; ebx = fl ! 1147: ; Output: ! 1148: ; ebx = fl ! 1149: ; ecx = x0 ! 1150: ; esi = x1 ! 1151: ; Uses: ! 1152: ; All registers. ! 1153: ; Exits: ! 1154: ; to done_clipping ! 1155: ; ! 1156: ; This routine handles the necessary initialization for the next ! 1157: ; run in the CLIPLINE structure. ! 1158: ; ! 1159: ; NOTE: This routine is jumped to from two places! ! 1160: ;-----------------------------------------------------------------------; ! 1161: ! 1162: public continue_complex_clipping ! 1163: continue_complex_clipping: ! 1164: mov edi, prun ! 1165: mov ecx, xStart ! 1166: testb ebx, FL_FLIP_H ! 1167: jz short complex_left_to_right ! 1168: ! 1169: complex_right_to_left: ! 1170: ! 1171: ; Figure out x0 and x1 for right-to-left lines: ! 1172: ! 1173: add ecx, cStylePels ! 1174: dec ecx ! 1175: mov esi, ecx ; esi = ecx = xStart + cStylePels - 1 ! 1176: sub ecx, [edi].RUN_iStop ; New x0 ! 1177: sub esi, [edi].RUN_iStart ; New x1 ! 1178: jmp short complex_reset_variables ! 1179: ! 1180: complex_left_to_right: ! 1181: ! 1182: ; Figure out x0 and x1 for left-to-right lines: ! 1183: ! 1184: mov esi, ecx ; esi = ecx = xStart ! 1185: add ecx, [edi].RUN_iStart ; New x0 ! 1186: add esi, [edi].RUN_iStop ; New x1 ! 1187: ! 1188: complex_reset_variables: ! 1189: mov x0, ecx ! 1190: ! 1191: ; The half flip mucks with some of our variables, and we have to reset ! 1192: ; them every pass. We would have to reset eqGamma too, but it never ! 1193: ; got saved to memory in its modified form. ! 1194: ! 1195: add edi, size RUN ! 1196: mov prun, edi ; Increment run pointer for next time ! 1197: ! 1198: mov edi, pls ! 1199: mov eax, [edi].LS_spComplex ! 1200: mov [edi].LS_spNext, eax ; pls->spNext = pls->spComplex ! 1201: ! 1202: mov eax, dN_Original ; dN = dN_Original ! 1203: mov dN, eax ! 1204: ! 1205: mul ecx ! 1206: add eax, eqGamma_lo ! 1207: adc edx, eqGamma_hi ; [edx:eax] = dN*x0 + eqGamma ! 1208: ! 1209: div dM ! 1210: mov y0, eax ! 1211: jmp done_clipping ! 1212: ! 1213: endProc bLines ! 1214: end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.