![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to r_spr8.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake II] / quake2 / linux|
Return to r_spr8.s CVS log | Up to [Quake II] / quake2 / linux |
1.1 ! root 1: // ! 2: // d_spr8.s ! 3: // x86 assembly-language horizontal 8-bpp transparent span-drawing code. ! 4: // ! 5: ! 6: #include "qasm.h" ! 7: ! 8: #if id386 ! 9: ! 10: //---------------------------------------------------------------------- ! 11: // 8-bpp horizontal span drawing code for polygons, with transparency. ! 12: //---------------------------------------------------------------------- ! 13: ! 14: .text ! 15: ! 16: // out-of-line, rarely-needed clamping code ! 17: ! 18: LClampHigh0: ! 19: movl C(bbextents),%esi ! 20: jmp LClampReentry0 ! 21: LClampHighOrLow0: ! 22: jg LClampHigh0 ! 23: xorl %esi,%esi ! 24: jmp LClampReentry0 ! 25: ! 26: LClampHigh1: ! 27: movl C(bbextentt),%edx ! 28: jmp LClampReentry1 ! 29: LClampHighOrLow1: ! 30: jg LClampHigh1 ! 31: xorl %edx,%edx ! 32: jmp LClampReentry1 ! 33: ! 34: LClampLow2: ! 35: movl $2048,%ebp ! 36: jmp LClampReentry2 ! 37: LClampHigh2: ! 38: movl C(bbextents),%ebp ! 39: jmp LClampReentry2 ! 40: ! 41: LClampLow3: ! 42: movl $2048,%ecx ! 43: jmp LClampReentry3 ! 44: LClampHigh3: ! 45: movl C(bbextentt),%ecx ! 46: jmp LClampReentry3 ! 47: ! 48: LClampLow4: ! 49: movl $2048,%eax ! 50: jmp LClampReentry4 ! 51: LClampHigh4: ! 52: movl C(bbextents),%eax ! 53: jmp LClampReentry4 ! 54: ! 55: LClampLow5: ! 56: movl $2048,%ebx ! 57: jmp LClampReentry5 ! 58: LClampHigh5: ! 59: movl C(bbextentt),%ebx ! 60: jmp LClampReentry5 ! 61: ! 62: ! 63: #define pspans 4+16 ! 64: ! 65: .align 4 ! 66: .globl C(D_SpriteDrawSpans) ! 67: C(D_SpriteDrawSpans): ! 68: pushl %ebp // preserve caller's stack frame ! 69: pushl %edi ! 70: pushl %esi // preserve register variables ! 71: pushl %ebx ! 72: ! 73: // ! 74: // set up scaled-by-8 steps, for 8-long segments; also set up cacheblock ! 75: // and span list pointers, and 1/z step in 0.32 fixed-point ! 76: // ! 77: // FIXME: any overlap from rearranging? ! 78: flds C(d_sdivzstepu) ! 79: fmuls fp_8 ! 80: movl C(cacheblock),%edx ! 81: flds C(d_tdivzstepu) ! 82: fmuls fp_8 ! 83: movl pspans(%esp),%ebx // point to the first span descriptor ! 84: flds C(d_zistepu) ! 85: fmuls fp_8 ! 86: movl %edx,pbase // pbase = cacheblock ! 87: flds C(d_zistepu) ! 88: fmuls fp_64kx64k ! 89: fxch %st(3) ! 90: fstps sdivz8stepu ! 91: fstps zi8stepu ! 92: fstps tdivz8stepu ! 93: fistpl izistep ! 94: movl izistep,%eax ! 95: rorl $16,%eax // put upper 16 bits in low word ! 96: movl sspan_t_count(%ebx),%ecx ! 97: movl %eax,izistep ! 98: ! 99: cmpl $0,%ecx ! 100: jle LNextSpan ! 101: ! 102: LSpanLoop: ! 103: ! 104: // ! 105: // set up the initial s/z, t/z, and 1/z on the FP stack, and generate the ! 106: // initial s and t values ! 107: // ! 108: // FIXME: pipeline FILD? ! 109: fildl sspan_t_v(%ebx) ! 110: fildl sspan_t_u(%ebx) ! 111: ! 112: fld %st(1) // dv | du | dv ! 113: fmuls C(d_sdivzstepv) // dv*d_sdivzstepv | du | dv ! 114: fld %st(1) // du | dv*d_sdivzstepv | du | dv ! 115: fmuls C(d_sdivzstepu) // du*d_sdivzstepu | dv*d_sdivzstepv | du | dv ! 116: fld %st(2) // du | du*d_sdivzstepu | dv*d_sdivzstepv | du | dv ! 117: fmuls C(d_tdivzstepu) // du*d_tdivzstepu | du*d_sdivzstepu | ! 118: // dv*d_sdivzstepv | du | dv ! 119: fxch %st(1) // du*d_sdivzstepu | du*d_tdivzstepu | ! 120: // dv*d_sdivzstepv | du | dv ! 121: faddp %st(0),%st(2) // du*d_tdivzstepu | ! 122: // du*d_sdivzstepu + dv*d_sdivzstepv | du | dv ! 123: fxch %st(1) // du*d_sdivzstepu + dv*d_sdivzstepv | ! 124: // du*d_tdivzstepu | du | dv ! 125: fld %st(3) // dv | du*d_sdivzstepu + dv*d_sdivzstepv | ! 126: // du*d_tdivzstepu | du | dv ! 127: fmuls C(d_tdivzstepv) // dv*d_tdivzstepv | ! 128: // du*d_sdivzstepu + dv*d_sdivzstepv | ! 129: // du*d_tdivzstepu | du | dv ! 130: fxch %st(1) // du*d_sdivzstepu + dv*d_sdivzstepv | ! 131: // dv*d_tdivzstepv | du*d_tdivzstepu | du | dv ! 132: fadds C(d_sdivzorigin) // sdivz = d_sdivzorigin + dv*d_sdivzstepv + ! 133: // du*d_sdivzstepu; stays in %st(2) at end ! 134: fxch %st(4) // dv | dv*d_tdivzstepv | du*d_tdivzstepu | du | ! 135: // s/z ! 136: fmuls C(d_zistepv) // dv*d_zistepv | dv*d_tdivzstepv | ! 137: // du*d_tdivzstepu | du | s/z ! 138: fxch %st(1) // dv*d_tdivzstepv | dv*d_zistepv | ! 139: // du*d_tdivzstepu | du | s/z ! 140: faddp %st(0),%st(2) // dv*d_zistepv | ! 141: // dv*d_tdivzstepv + du*d_tdivzstepu | du | s/z ! 142: fxch %st(2) // du | dv*d_tdivzstepv + du*d_tdivzstepu | ! 143: // dv*d_zistepv | s/z ! 144: fmuls C(d_zistepu) // du*d_zistepu | ! 145: // dv*d_tdivzstepv + du*d_tdivzstepu | ! 146: // dv*d_zistepv | s/z ! 147: fxch %st(1) // dv*d_tdivzstepv + du*d_tdivzstepu | ! 148: // du*d_zistepu | dv*d_zistepv | s/z ! 149: fadds C(d_tdivzorigin) // tdivz = d_tdivzorigin + dv*d_tdivzstepv + ! 150: // du*d_tdivzstepu; stays in %st(1) at end ! 151: fxch %st(2) // dv*d_zistepv | du*d_zistepu | t/z | s/z ! 152: faddp %st(0),%st(1) // dv*d_zistepv + du*d_zistepu | t/z | s/z ! 153: ! 154: flds fp_64k // fp_64k | dv*d_zistepv + du*d_zistepu | t/z | s/z ! 155: fxch %st(1) // dv*d_zistepv + du*d_zistepu | fp_64k | t/z | s/z ! 156: fadds C(d_ziorigin) // zi = d_ziorigin + dv*d_zistepv + ! 157: // du*d_zistepu; stays in %st(0) at end ! 158: // 1/z | fp_64k | t/z | s/z ! 159: ! 160: fld %st(0) // FIXME: get rid of stall on FMUL? ! 161: fmuls fp_64kx64k ! 162: fxch %st(1) ! 163: ! 164: // ! 165: // calculate and clamp s & t ! 166: // ! 167: fdivr %st(0),%st(2) // 1/z | z*64k | t/z | s/z ! 168: fxch %st(1) ! 169: ! 170: fistpl izi // 0.32 fixed-point 1/z ! 171: movl izi,%ebp ! 172: ! 173: // ! 174: // set pz to point to the first z-buffer pixel in the span ! 175: // ! 176: rorl $16,%ebp // put upper 16 bits in low word ! 177: movl sspan_t_v(%ebx),%eax ! 178: movl %ebp,izi ! 179: movl sspan_t_u(%ebx),%ebp ! 180: imull C(d_zrowbytes) ! 181: shll $1,%ebp // a word per pixel ! 182: addl C(d_pzbuffer),%eax ! 183: addl %ebp,%eax ! 184: movl %eax,pz ! 185: ! 186: // ! 187: // point %edi to the first pixel in the span ! 188: // ! 189: movl C(d_viewbuffer),%ebp ! 190: movl sspan_t_v(%ebx),%eax ! 191: pushl %ebx // preserve spans pointer ! 192: movl C(tadjust),%edx ! 193: movl C(sadjust),%esi ! 194: movl C(d_scantable)(,%eax,4),%edi // v * screenwidth ! 195: addl %ebp,%edi ! 196: movl sspan_t_u(%ebx),%ebp ! 197: addl %ebp,%edi // pdest = &pdestspan[scans->u]; ! 198: ! 199: // ! 200: // now start the FDIV for the end of the span ! 201: // ! 202: cmpl $8,%ecx ! 203: ja LSetupNotLast1 ! 204: ! 205: decl %ecx ! 206: jz LCleanup1 // if only one pixel, no need to start an FDIV ! 207: movl %ecx,spancountminus1 ! 208: ! 209: // finish up the s and t calcs ! 210: fxch %st(1) // z*64k | 1/z | t/z | s/z ! 211: ! 212: fld %st(0) // z*64k | z*64k | 1/z | t/z | s/z ! 213: fmul %st(4),%st(0) // s | z*64k | 1/z | t/z | s/z ! 214: fxch %st(1) // z*64k | s | 1/z | t/z | s/z ! 215: fmul %st(3),%st(0) // t | s | 1/z | t/z | s/z ! 216: fxch %st(1) // s | t | 1/z | t/z | s/z ! 217: fistpl s // 1/z | t | t/z | s/z ! 218: fistpl t // 1/z | t/z | s/z ! 219: ! 220: fildl spancountminus1 ! 221: ! 222: flds C(d_tdivzstepu) // _d_tdivzstepu | spancountminus1 ! 223: flds C(d_zistepu) // _d_zistepu | _d_tdivzstepu | spancountminus1 ! 224: fmul %st(2),%st(0) // _d_zistepu*scm1 | _d_tdivzstepu | scm1 ! 225: fxch %st(1) // _d_tdivzstepu | _d_zistepu*scm1 | scm1 ! 226: fmul %st(2),%st(0) // _d_tdivzstepu*scm1 | _d_zistepu*scm1 | scm1 ! 227: fxch %st(2) // scm1 | _d_zistepu*scm1 | _d_tdivzstepu*scm1 ! 228: fmuls C(d_sdivzstepu) // _d_sdivzstepu*scm1 | _d_zistepu*scm1 | ! 229: // _d_tdivzstepu*scm1 ! 230: fxch %st(1) // _d_zistepu*scm1 | _d_sdivzstepu*scm1 | ! 231: // _d_tdivzstepu*scm1 ! 232: faddp %st(0),%st(3) // _d_sdivzstepu*scm1 | _d_tdivzstepu*scm1 ! 233: fxch %st(1) // _d_tdivzstepu*scm1 | _d_sdivzstepu*scm1 ! 234: faddp %st(0),%st(3) // _d_sdivzstepu*scm1 ! 235: faddp %st(0),%st(3) ! 236: ! 237: flds fp_64k ! 238: fdiv %st(1),%st(0) // this is what we've gone to all this trouble to ! 239: // overlap ! 240: jmp LFDIVInFlight1 ! 241: ! 242: LCleanup1: ! 243: // finish up the s and t calcs ! 244: fxch %st(1) // z*64k | 1/z | t/z | s/z ! 245: ! 246: fld %st(0) // z*64k | z*64k | 1/z | t/z | s/z ! 247: fmul %st(4),%st(0) // s | z*64k | 1/z | t/z | s/z ! 248: fxch %st(1) // z*64k | s | 1/z | t/z | s/z ! 249: fmul %st(3),%st(0) // t | s | 1/z | t/z | s/z ! 250: fxch %st(1) // s | t | 1/z | t/z | s/z ! 251: fistpl s // 1/z | t | t/z | s/z ! 252: fistpl t // 1/z | t/z | s/z ! 253: jmp LFDIVInFlight1 ! 254: ! 255: .align 4 ! 256: LSetupNotLast1: ! 257: // finish up the s and t calcs ! 258: fxch %st(1) // z*64k | 1/z | t/z | s/z ! 259: ! 260: fld %st(0) // z*64k | z*64k | 1/z | t/z | s/z ! 261: fmul %st(4),%st(0) // s | z*64k | 1/z | t/z | s/z ! 262: fxch %st(1) // z*64k | s | 1/z | t/z | s/z ! 263: fmul %st(3),%st(0) // t | s | 1/z | t/z | s/z ! 264: fxch %st(1) // s | t | 1/z | t/z | s/z ! 265: fistpl s // 1/z | t | t/z | s/z ! 266: fistpl t // 1/z | t/z | s/z ! 267: ! 268: fadds zi8stepu ! 269: fxch %st(2) ! 270: fadds sdivz8stepu ! 271: fxch %st(2) ! 272: flds tdivz8stepu ! 273: faddp %st(0),%st(2) ! 274: flds fp_64k ! 275: fdiv %st(1),%st(0) // z = 1/1/z ! 276: // this is what we've gone to all this trouble to ! 277: // overlap ! 278: LFDIVInFlight1: ! 279: ! 280: addl s,%esi ! 281: addl t,%edx ! 282: movl C(bbextents),%ebx ! 283: movl C(bbextentt),%ebp ! 284: cmpl %ebx,%esi ! 285: ja LClampHighOrLow0 ! 286: LClampReentry0: ! 287: movl %esi,s ! 288: movl pbase,%ebx ! 289: shll $16,%esi ! 290: cmpl %ebp,%edx ! 291: movl %esi,sfracf ! 292: ja LClampHighOrLow1 ! 293: LClampReentry1: ! 294: movl %edx,t ! 295: movl s,%esi // sfrac = scans->sfrac; ! 296: shll $16,%edx ! 297: movl t,%eax // tfrac = scans->tfrac; ! 298: sarl $16,%esi ! 299: movl %edx,tfracf ! 300: ! 301: // ! 302: // calculate the texture starting address ! 303: // ! 304: sarl $16,%eax ! 305: addl %ebx,%esi ! 306: imull C(cachewidth),%eax // (tfrac >> 16) * cachewidth ! 307: addl %eax,%esi // psource = pbase + (sfrac >> 16) + ! 308: // ((tfrac >> 16) * cachewidth); ! 309: ! 310: // ! 311: // determine whether last span or not ! 312: // ! 313: cmpl $8,%ecx ! 314: jna LLastSegment ! 315: ! 316: // ! 317: // not the last segment; do full 8-wide segment ! 318: // ! 319: LNotLastSegment: ! 320: ! 321: // ! 322: // advance s/z, t/z, and 1/z, and calculate s & t at end of span and steps to ! 323: // get there ! 324: // ! 325: ! 326: // pick up after the FDIV that was left in flight previously ! 327: ! 328: fld %st(0) // duplicate it ! 329: fmul %st(4),%st(0) // s = s/z * z ! 330: fxch %st(1) ! 331: fmul %st(3),%st(0) // t = t/z * z ! 332: fxch %st(1) ! 333: fistpl snext ! 334: fistpl tnext ! 335: movl snext,%eax ! 336: movl tnext,%edx ! 337: ! 338: subl $8,%ecx // count off this segments' pixels ! 339: movl C(sadjust),%ebp ! 340: pushl %ecx // remember count of remaining pixels ! 341: movl C(tadjust),%ecx ! 342: ! 343: addl %eax,%ebp ! 344: addl %edx,%ecx ! 345: ! 346: movl C(bbextents),%eax ! 347: movl C(bbextentt),%edx ! 348: ! 349: cmpl $2048,%ebp ! 350: jl LClampLow2 ! 351: cmpl %eax,%ebp ! 352: ja LClampHigh2 ! 353: LClampReentry2: ! 354: ! 355: cmpl $2048,%ecx ! 356: jl LClampLow3 ! 357: cmpl %edx,%ecx ! 358: ja LClampHigh3 ! 359: LClampReentry3: ! 360: ! 361: movl %ebp,snext ! 362: movl %ecx,tnext ! 363: ! 364: subl s,%ebp ! 365: subl t,%ecx ! 366: ! 367: // ! 368: // set up advancetable ! 369: // ! 370: movl %ecx,%eax ! 371: movl %ebp,%edx ! 372: sarl $19,%edx // sstep >>= 16; ! 373: movl C(cachewidth),%ebx ! 374: sarl $19,%eax // tstep >>= 16; ! 375: jz LIsZero ! 376: imull %ebx,%eax // (tstep >> 16) * cachewidth; ! 377: LIsZero: ! 378: addl %edx,%eax // add in sstep ! 379: // (tstep >> 16) * cachewidth + (sstep >> 16); ! 380: movl tfracf,%edx ! 381: movl %eax,advancetable+4 // advance base in t ! 382: addl %ebx,%eax // ((tstep >> 16) + 1) * cachewidth + ! 383: // (sstep >> 16); ! 384: shll $13,%ebp // left-justify sstep fractional part ! 385: movl %ebp,sstep ! 386: movl sfracf,%ebx ! 387: shll $13,%ecx // left-justify tstep fractional part ! 388: movl %eax,advancetable // advance extra in t ! 389: movl %ecx,tstep ! 390: ! 391: movl pz,%ecx ! 392: movl izi,%ebp ! 393: ! 394: cmpw (%ecx),%bp ! 395: jl Lp1 ! 396: movb (%esi),%al // get first source texel ! 397: cmpb $(TRANSPARENT_COLOR),%al ! 398: jz Lp1 ! 399: movw %bp,(%ecx) ! 400: movb %al,(%edi) // store first dest pixel ! 401: Lp1: ! 402: addl izistep,%ebp ! 403: adcl $0,%ebp ! 404: addl tstep,%edx // advance tfrac fractional part by tstep frac ! 405: ! 406: sbbl %eax,%eax // turn tstep carry into -1 (0 if none) ! 407: addl sstep,%ebx // advance sfrac fractional part by sstep frac ! 408: adcl advancetable+4(,%eax,4),%esi // point to next source texel ! 409: ! 410: cmpw 2(%ecx),%bp ! 411: jl Lp2 ! 412: movb (%esi),%al ! 413: cmpb $(TRANSPARENT_COLOR),%al ! 414: jz Lp2 ! 415: movw %bp,2(%ecx) ! 416: movb %al,1(%edi) ! 417: Lp2: ! 418: addl izistep,%ebp ! 419: adcl $0,%ebp ! 420: addl tstep,%edx ! 421: sbbl %eax,%eax ! 422: addl sstep,%ebx ! 423: adcl advancetable+4(,%eax,4),%esi ! 424: ! 425: cmpw 4(%ecx),%bp ! 426: jl Lp3 ! 427: movb (%esi),%al ! 428: cmpb $(TRANSPARENT_COLOR),%al ! 429: jz Lp3 ! 430: movw %bp,4(%ecx) ! 431: movb %al,2(%edi) ! 432: Lp3: ! 433: addl izistep,%ebp ! 434: adcl $0,%ebp ! 435: addl tstep,%edx ! 436: sbbl %eax,%eax ! 437: addl sstep,%ebx ! 438: adcl advancetable+4(,%eax,4),%esi ! 439: ! 440: cmpw 6(%ecx),%bp ! 441: jl Lp4 ! 442: movb (%esi),%al ! 443: cmpb $(TRANSPARENT_COLOR),%al ! 444: jz Lp4 ! 445: movw %bp,6(%ecx) ! 446: movb %al,3(%edi) ! 447: Lp4: ! 448: addl izistep,%ebp ! 449: adcl $0,%ebp ! 450: addl tstep,%edx ! 451: sbbl %eax,%eax ! 452: addl sstep,%ebx ! 453: adcl advancetable+4(,%eax,4),%esi ! 454: ! 455: cmpw 8(%ecx),%bp ! 456: jl Lp5 ! 457: movb (%esi),%al ! 458: cmpb $(TRANSPARENT_COLOR),%al ! 459: jz Lp5 ! 460: movw %bp,8(%ecx) ! 461: movb %al,4(%edi) ! 462: Lp5: ! 463: addl izistep,%ebp ! 464: adcl $0,%ebp ! 465: addl tstep,%edx ! 466: sbbl %eax,%eax ! 467: addl sstep,%ebx ! 468: adcl advancetable+4(,%eax,4),%esi ! 469: ! 470: // ! 471: // start FDIV for end of next segment in flight, so it can overlap ! 472: // ! 473: popl %eax ! 474: cmpl $8,%eax // more than one segment after this? ! 475: ja LSetupNotLast2 // yes ! 476: ! 477: decl %eax ! 478: jz LFDIVInFlight2 // if only one pixel, no need to start an FDIV ! 479: movl %eax,spancountminus1 ! 480: fildl spancountminus1 ! 481: ! 482: flds C(d_zistepu) // _d_zistepu | spancountminus1 ! 483: fmul %st(1),%st(0) // _d_zistepu*scm1 | scm1 ! 484: flds C(d_tdivzstepu) // _d_tdivzstepu | _d_zistepu*scm1 | scm1 ! 485: fmul %st(2),%st(0) // _d_tdivzstepu*scm1 | _d_zistepu*scm1 | scm1 ! 486: fxch %st(1) // _d_zistepu*scm1 | _d_tdivzstepu*scm1 | scm1 ! 487: faddp %st(0),%st(3) // _d_tdivzstepu*scm1 | scm1 ! 488: fxch %st(1) // scm1 | _d_tdivzstepu*scm1 ! 489: fmuls C(d_sdivzstepu) // _d_sdivzstepu*scm1 | _d_tdivzstepu*scm1 ! 490: fxch %st(1) // _d_tdivzstepu*scm1 | _d_sdivzstepu*scm1 ! 491: faddp %st(0),%st(3) // _d_sdivzstepu*scm1 ! 492: flds fp_64k // 64k | _d_sdivzstepu*scm1 ! 493: fxch %st(1) // _d_sdivzstepu*scm1 | 64k ! 494: faddp %st(0),%st(4) // 64k ! 495: ! 496: fdiv %st(1),%st(0) // this is what we've gone to all this trouble to ! 497: // overlap ! 498: jmp LFDIVInFlight2 ! 499: ! 500: .align 4 ! 501: LSetupNotLast2: ! 502: fadds zi8stepu ! 503: fxch %st(2) ! 504: fadds sdivz8stepu ! 505: fxch %st(2) ! 506: flds tdivz8stepu ! 507: faddp %st(0),%st(2) ! 508: flds fp_64k ! 509: fdiv %st(1),%st(0) // z = 1/1/z ! 510: // this is what we've gone to all this trouble to ! 511: // overlap ! 512: LFDIVInFlight2: ! 513: pushl %eax ! 514: ! 515: cmpw 10(%ecx),%bp ! 516: jl Lp6 ! 517: movb (%esi),%al ! 518: cmpb $(TRANSPARENT_COLOR),%al ! 519: jz Lp6 ! 520: movw %bp,10(%ecx) ! 521: movb %al,5(%edi) ! 522: Lp6: ! 523: addl izistep,%ebp ! 524: adcl $0,%ebp ! 525: addl tstep,%edx ! 526: sbbl %eax,%eax ! 527: addl sstep,%ebx ! 528: adcl advancetable+4(,%eax,4),%esi ! 529: ! 530: cmpw 12(%ecx),%bp ! 531: jl Lp7 ! 532: movb (%esi),%al ! 533: cmpb $(TRANSPARENT_COLOR),%al ! 534: jz Lp7 ! 535: movw %bp,12(%ecx) ! 536: movb %al,6(%edi) ! 537: Lp7: ! 538: addl izistep,%ebp ! 539: adcl $0,%ebp ! 540: addl tstep,%edx ! 541: sbbl %eax,%eax ! 542: addl sstep,%ebx ! 543: adcl advancetable+4(,%eax,4),%esi ! 544: ! 545: cmpw 14(%ecx),%bp ! 546: jl Lp8 ! 547: movb (%esi),%al ! 548: cmpb $(TRANSPARENT_COLOR),%al ! 549: jz Lp8 ! 550: movw %bp,14(%ecx) ! 551: movb %al,7(%edi) ! 552: Lp8: ! 553: addl izistep,%ebp ! 554: adcl $0,%ebp ! 555: addl tstep,%edx ! 556: sbbl %eax,%eax ! 557: addl sstep,%ebx ! 558: adcl advancetable+4(,%eax,4),%esi ! 559: ! 560: addl $8,%edi ! 561: addl $16,%ecx ! 562: movl %edx,tfracf ! 563: movl snext,%edx ! 564: movl %ebx,sfracf ! 565: movl tnext,%ebx ! 566: movl %edx,s ! 567: movl %ebx,t ! 568: ! 569: movl %ecx,pz ! 570: movl %ebp,izi ! 571: ! 572: popl %ecx // retrieve count ! 573: ! 574: // ! 575: // determine whether last span or not ! 576: // ! 577: cmpl $8,%ecx // are there multiple segments remaining? ! 578: ja LNotLastSegment // yes ! 579: ! 580: // ! 581: // last segment of scan ! 582: // ! 583: LLastSegment: ! 584: ! 585: // ! 586: // advance s/z, t/z, and 1/z, and calculate s & t at end of span and steps to ! 587: // get there. The number of pixels left is variable, and we want to land on the ! 588: // last pixel, not step one past it, so we can't run into arithmetic problems ! 589: // ! 590: testl %ecx,%ecx ! 591: jz LNoSteps // just draw the last pixel and we're done ! 592: ! 593: // pick up after the FDIV that was left in flight previously ! 594: ! 595: ! 596: fld %st(0) // duplicate it ! 597: fmul %st(4),%st(0) // s = s/z * z ! 598: fxch %st(1) ! 599: fmul %st(3),%st(0) // t = t/z * z ! 600: fxch %st(1) ! 601: fistpl snext ! 602: fistpl tnext ! 603: ! 604: movl C(tadjust),%ebx ! 605: movl C(sadjust),%eax ! 606: ! 607: addl snext,%eax ! 608: addl tnext,%ebx ! 609: ! 610: movl C(bbextents),%ebp ! 611: movl C(bbextentt),%edx ! 612: ! 613: cmpl $2048,%eax ! 614: jl LClampLow4 ! 615: cmpl %ebp,%eax ! 616: ja LClampHigh4 ! 617: LClampReentry4: ! 618: movl %eax,snext ! 619: ! 620: cmpl $2048,%ebx ! 621: jl LClampLow5 ! 622: cmpl %edx,%ebx ! 623: ja LClampHigh5 ! 624: LClampReentry5: ! 625: ! 626: cmpl $1,%ecx // don't bother ! 627: je LOnlyOneStep // if two pixels in segment, there's only one step, ! 628: // of the segment length ! 629: subl s,%eax ! 630: subl t,%ebx ! 631: ! 632: addl %eax,%eax // convert to 15.17 format so multiply by 1.31 ! 633: addl %ebx,%ebx // reciprocal yields 16.48 ! 634: imull reciprocal_table-8(,%ecx,4) // sstep = (snext - s) / (spancount-1) ! 635: movl %edx,%ebp ! 636: ! 637: movl %ebx,%eax ! 638: imull reciprocal_table-8(,%ecx,4) // tstep = (tnext - t) / (spancount-1) ! 639: ! 640: LSetEntryvec: ! 641: // ! 642: // set up advancetable ! 643: // ! 644: movl spr8entryvec_table(,%ecx,4),%ebx ! 645: movl %edx,%eax ! 646: pushl %ebx // entry point into code for RET later ! 647: movl %ebp,%ecx ! 648: sarl $16,%ecx // sstep >>= 16; ! 649: movl C(cachewidth),%ebx ! 650: sarl $16,%edx // tstep >>= 16; ! 651: jz LIsZeroLast ! 652: imull %ebx,%edx // (tstep >> 16) * cachewidth; ! 653: LIsZeroLast: ! 654: addl %ecx,%edx // add in sstep ! 655: // (tstep >> 16) * cachewidth + (sstep >> 16); ! 656: movl tfracf,%ecx ! 657: movl %edx,advancetable+4 // advance base in t ! 658: addl %ebx,%edx // ((tstep >> 16) + 1) * cachewidth + ! 659: // (sstep >> 16); ! 660: shll $16,%ebp // left-justify sstep fractional part ! 661: movl sfracf,%ebx ! 662: shll $16,%eax // left-justify tstep fractional part ! 663: movl %edx,advancetable // advance extra in t ! 664: ! 665: movl %eax,tstep ! 666: movl %ebp,sstep ! 667: movl %ecx,%edx ! 668: ! 669: movl pz,%ecx ! 670: movl izi,%ebp ! 671: ! 672: ret // jump to the number-of-pixels handler ! 673: ! 674: //---------------------------------------- ! 675: ! 676: LNoSteps: ! 677: movl pz,%ecx ! 678: subl $7,%edi // adjust for hardwired offset ! 679: subl $14,%ecx ! 680: jmp LEndSpan ! 681: ! 682: ! 683: LOnlyOneStep: ! 684: subl s,%eax ! 685: subl t,%ebx ! 686: movl %eax,%ebp ! 687: movl %ebx,%edx ! 688: jmp LSetEntryvec ! 689: ! 690: //---------------------------------------- ! 691: ! 692: .globl Spr8Entry2_8 ! 693: Spr8Entry2_8: ! 694: subl $6,%edi // adjust for hardwired offsets ! 695: subl $12,%ecx ! 696: movb (%esi),%al ! 697: jmp LLEntry2_8 ! 698: ! 699: //---------------------------------------- ! 700: ! 701: .globl Spr8Entry3_8 ! 702: Spr8Entry3_8: ! 703: subl $5,%edi // adjust for hardwired offsets ! 704: subl $10,%ecx ! 705: jmp LLEntry3_8 ! 706: ! 707: //---------------------------------------- ! 708: ! 709: .globl Spr8Entry4_8 ! 710: Spr8Entry4_8: ! 711: subl $4,%edi // adjust for hardwired offsets ! 712: subl $8,%ecx ! 713: jmp LLEntry4_8 ! 714: ! 715: //---------------------------------------- ! 716: ! 717: .globl Spr8Entry5_8 ! 718: Spr8Entry5_8: ! 719: subl $3,%edi // adjust for hardwired offsets ! 720: subl $6,%ecx ! 721: jmp LLEntry5_8 ! 722: ! 723: //---------------------------------------- ! 724: ! 725: .globl Spr8Entry6_8 ! 726: Spr8Entry6_8: ! 727: subl $2,%edi // adjust for hardwired offsets ! 728: subl $4,%ecx ! 729: jmp LLEntry6_8 ! 730: ! 731: //---------------------------------------- ! 732: ! 733: .globl Spr8Entry7_8 ! 734: Spr8Entry7_8: ! 735: decl %edi // adjust for hardwired offsets ! 736: subl $2,%ecx ! 737: jmp LLEntry7_8 ! 738: ! 739: //---------------------------------------- ! 740: ! 741: .globl Spr8Entry8_8 ! 742: Spr8Entry8_8: ! 743: cmpw (%ecx),%bp ! 744: jl Lp9 ! 745: movb (%esi),%al ! 746: cmpb $(TRANSPARENT_COLOR),%al ! 747: jz Lp9 ! 748: movw %bp,(%ecx) ! 749: movb %al,(%edi) ! 750: Lp9: ! 751: addl izistep,%ebp ! 752: adcl $0,%ebp ! 753: addl tstep,%edx ! 754: sbbl %eax,%eax ! 755: addl sstep,%ebx ! 756: adcl advancetable+4(,%eax,4),%esi ! 757: LLEntry7_8: ! 758: cmpw 2(%ecx),%bp ! 759: jl Lp10 ! 760: movb (%esi),%al ! 761: cmpb $(TRANSPARENT_COLOR),%al ! 762: jz Lp10 ! 763: movw %bp,2(%ecx) ! 764: movb %al,1(%edi) ! 765: Lp10: ! 766: addl izistep,%ebp ! 767: adcl $0,%ebp ! 768: addl tstep,%edx ! 769: sbbl %eax,%eax ! 770: addl sstep,%ebx ! 771: adcl advancetable+4(,%eax,4),%esi ! 772: LLEntry6_8: ! 773: cmpw 4(%ecx),%bp ! 774: jl Lp11 ! 775: movb (%esi),%al ! 776: cmpb $(TRANSPARENT_COLOR),%al ! 777: jz Lp11 ! 778: movw %bp,4(%ecx) ! 779: movb %al,2(%edi) ! 780: Lp11: ! 781: addl izistep,%ebp ! 782: adcl $0,%ebp ! 783: addl tstep,%edx ! 784: sbbl %eax,%eax ! 785: addl sstep,%ebx ! 786: adcl advancetable+4(,%eax,4),%esi ! 787: LLEntry5_8: ! 788: cmpw 6(%ecx),%bp ! 789: jl Lp12 ! 790: movb (%esi),%al ! 791: cmpb $(TRANSPARENT_COLOR),%al ! 792: jz Lp12 ! 793: movw %bp,6(%ecx) ! 794: movb %al,3(%edi) ! 795: Lp12: ! 796: addl izistep,%ebp ! 797: adcl $0,%ebp ! 798: addl tstep,%edx ! 799: sbbl %eax,%eax ! 800: addl sstep,%ebx ! 801: adcl advancetable+4(,%eax,4),%esi ! 802: LLEntry4_8: ! 803: cmpw 8(%ecx),%bp ! 804: jl Lp13 ! 805: movb (%esi),%al ! 806: cmpb $(TRANSPARENT_COLOR),%al ! 807: jz Lp13 ! 808: movw %bp,8(%ecx) ! 809: movb %al,4(%edi) ! 810: Lp13: ! 811: addl izistep,%ebp ! 812: adcl $0,%ebp ! 813: addl tstep,%edx ! 814: sbbl %eax,%eax ! 815: addl sstep,%ebx ! 816: adcl advancetable+4(,%eax,4),%esi ! 817: LLEntry3_8: ! 818: cmpw 10(%ecx),%bp ! 819: jl Lp14 ! 820: movb (%esi),%al ! 821: cmpb $(TRANSPARENT_COLOR),%al ! 822: jz Lp14 ! 823: movw %bp,10(%ecx) ! 824: movb %al,5(%edi) ! 825: Lp14: ! 826: addl izistep,%ebp ! 827: adcl $0,%ebp ! 828: addl tstep,%edx ! 829: sbbl %eax,%eax ! 830: addl sstep,%ebx ! 831: adcl advancetable+4(,%eax,4),%esi ! 832: LLEntry2_8: ! 833: cmpw 12(%ecx),%bp ! 834: jl Lp15 ! 835: movb (%esi),%al ! 836: cmpb $(TRANSPARENT_COLOR),%al ! 837: jz Lp15 ! 838: movw %bp,12(%ecx) ! 839: movb %al,6(%edi) ! 840: Lp15: ! 841: addl izistep,%ebp ! 842: adcl $0,%ebp ! 843: addl tstep,%edx ! 844: sbbl %eax,%eax ! 845: addl sstep,%ebx ! 846: adcl advancetable+4(,%eax,4),%esi ! 847: ! 848: LEndSpan: ! 849: cmpw 14(%ecx),%bp ! 850: jl Lp16 ! 851: movb (%esi),%al // load first texel in segment ! 852: cmpb $(TRANSPARENT_COLOR),%al ! 853: jz Lp16 ! 854: movw %bp,14(%ecx) ! 855: movb %al,7(%edi) ! 856: Lp16: ! 857: ! 858: // ! 859: // clear s/z, t/z, 1/z from FP stack ! 860: // ! 861: fstp %st(0) ! 862: fstp %st(0) ! 863: fstp %st(0) ! 864: ! 865: popl %ebx // restore spans pointer ! 866: LNextSpan: ! 867: addl $(sspan_t_size),%ebx // point to next span ! 868: movl sspan_t_count(%ebx),%ecx ! 869: cmpl $0,%ecx // any more spans? ! 870: jg LSpanLoop // yes ! 871: jz LNextSpan // yes, but this one's empty ! 872: ! 873: popl %ebx // restore register variables ! 874: popl %esi ! 875: popl %edi ! 876: popl %ebp // restore the caller's stack frame ! 877: ret ! 878: ! 879: #endif // id386
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.