![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to d_draw16.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake] / quakeworld / client|
Return to d_draw16.s CVS log | Up to [Quake] / quakeworld / client |
1.1 ! root 1: /* ! 2: Copyright (C) 1996-1997 Id Software, Inc. ! 3: ! 4: This program is free software; you can redistribute it and/or ! 5: modify it under the terms of the GNU General Public License ! 6: as published by the Free Software Foundation; either version 2 ! 7: of the License, or (at your option) any later version. ! 8: ! 9: This program is distributed in the hope that it will be useful, ! 10: but WITHOUT ANY WARRANTY; without even the implied warranty of ! 11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ! 12: ! 13: See the GNU General Public License for more details. ! 14: ! 15: You should have received a copy of the GNU General Public License ! 16: along with this program; if not, write to the Free Software ! 17: Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ! 18: ! 19: */ ! 20: // ! 21: // d_draw16.s ! 22: // x86 assembly-language horizontal 8-bpp span-drawing code, with 16-pixel ! 23: // subdivision. ! 24: // ! 25: ! 26: #include "asm_i386.h" ! 27: #include "quakeasm.h" ! 28: #include "asm_draw.h" ! 29: #include "d_ifacea.h" ! 30: ! 31: #if id386 ! 32: ! 33: //---------------------------------------------------------------------- ! 34: // 8-bpp horizontal span drawing code for polygons, with no transparency and ! 35: // 16-pixel subdivision. ! 36: // ! 37: // Assumes there is at least one span in pspans, and that every span ! 38: // contains at least one pixel ! 39: //---------------------------------------------------------------------- ! 40: ! 41: .data ! 42: ! 43: .text ! 44: ! 45: // out-of-line, rarely-needed clamping code ! 46: ! 47: LClampHigh0: ! 48: movl C(bbextents),%esi ! 49: jmp LClampReentry0 ! 50: LClampHighOrLow0: ! 51: jg LClampHigh0 ! 52: xorl %esi,%esi ! 53: jmp LClampReentry0 ! 54: ! 55: LClampHigh1: ! 56: movl C(bbextentt),%edx ! 57: jmp LClampReentry1 ! 58: LClampHighOrLow1: ! 59: jg LClampHigh1 ! 60: xorl %edx,%edx ! 61: jmp LClampReentry1 ! 62: ! 63: LClampLow2: ! 64: movl $4096,%ebp ! 65: jmp LClampReentry2 ! 66: LClampHigh2: ! 67: movl C(bbextents),%ebp ! 68: jmp LClampReentry2 ! 69: ! 70: LClampLow3: ! 71: movl $4096,%ecx ! 72: jmp LClampReentry3 ! 73: LClampHigh3: ! 74: movl C(bbextentt),%ecx ! 75: jmp LClampReentry3 ! 76: ! 77: LClampLow4: ! 78: movl $4096,%eax ! 79: jmp LClampReentry4 ! 80: LClampHigh4: ! 81: movl C(bbextents),%eax ! 82: jmp LClampReentry4 ! 83: ! 84: LClampLow5: ! 85: movl $4096,%ebx ! 86: jmp LClampReentry5 ! 87: LClampHigh5: ! 88: movl C(bbextentt),%ebx ! 89: jmp LClampReentry5 ! 90: ! 91: ! 92: #define pspans 4+16 ! 93: ! 94: .align 4 ! 95: .globl C(D_DrawSpans16) ! 96: C(D_DrawSpans16): ! 97: pushl %ebp // preserve caller's stack frame ! 98: pushl %edi ! 99: pushl %esi // preserve register variables ! 100: pushl %ebx ! 101: ! 102: // ! 103: // set up scaled-by-16 steps, for 16-long segments; also set up cacheblock ! 104: // and span list pointers ! 105: // ! 106: // TODO: any overlap from rearranging? ! 107: flds C(d_sdivzstepu) ! 108: fmuls fp_16 ! 109: movl C(cacheblock),%edx ! 110: flds C(d_tdivzstepu) ! 111: fmuls fp_16 ! 112: movl pspans(%esp),%ebx // point to the first span descriptor ! 113: flds C(d_zistepu) ! 114: fmuls fp_16 ! 115: movl %edx,pbase // pbase = cacheblock ! 116: fstps zi16stepu ! 117: fstps tdivz16stepu ! 118: fstps sdivz16stepu ! 119: ! 120: LSpanLoop: ! 121: // ! 122: // set up the initial s/z, t/z, and 1/z on the FP stack, and generate the ! 123: // initial s and t values ! 124: // ! 125: // FIXME: pipeline FILD? ! 126: fildl espan_t_v(%ebx) ! 127: fildl espan_t_u(%ebx) ! 128: ! 129: fld %st(1) // dv | du | dv ! 130: fmuls C(d_sdivzstepv) // dv*d_sdivzstepv | du | dv ! 131: fld %st(1) // du | dv*d_sdivzstepv | du | dv ! 132: fmuls C(d_sdivzstepu) // du*d_sdivzstepu | dv*d_sdivzstepv | du | dv ! 133: fld %st(2) // du | du*d_sdivzstepu | dv*d_sdivzstepv | du | dv ! 134: fmuls C(d_tdivzstepu) // du*d_tdivzstepu | du*d_sdivzstepu | ! 135: // dv*d_sdivzstepv | du | dv ! 136: fxch %st(1) // du*d_sdivzstepu | du*d_tdivzstepu | ! 137: // dv*d_sdivzstepv | du | dv ! 138: faddp %st(0),%st(2) // du*d_tdivzstepu | ! 139: // du*d_sdivzstepu + dv*d_sdivzstepv | du | dv ! 140: fxch %st(1) // du*d_sdivzstepu + dv*d_sdivzstepv | ! 141: // du*d_tdivzstepu | du | dv ! 142: fld %st(3) // dv | du*d_sdivzstepu + dv*d_sdivzstepv | ! 143: // du*d_tdivzstepu | du | dv ! 144: fmuls C(d_tdivzstepv) // dv*d_tdivzstepv | ! 145: // du*d_sdivzstepu + dv*d_sdivzstepv | ! 146: // du*d_tdivzstepu | du | dv ! 147: fxch %st(1) // du*d_sdivzstepu + dv*d_sdivzstepv | ! 148: // dv*d_tdivzstepv | du*d_tdivzstepu | du | dv ! 149: fadds C(d_sdivzorigin) // sdivz = d_sdivzorigin + dv*d_sdivzstepv + ! 150: // du*d_sdivzstepu; stays in %st(2) at end ! 151: fxch %st(4) // dv | dv*d_tdivzstepv | du*d_tdivzstepu | du | ! 152: // s/z ! 153: fmuls C(d_zistepv) // dv*d_zistepv | dv*d_tdivzstepv | ! 154: // du*d_tdivzstepu | du | s/z ! 155: fxch %st(1) // dv*d_tdivzstepv | dv*d_zistepv | ! 156: // du*d_tdivzstepu | du | s/z ! 157: faddp %st(0),%st(2) // dv*d_zistepv | ! 158: // dv*d_tdivzstepv + du*d_tdivzstepu | du | s/z ! 159: fxch %st(2) // du | dv*d_tdivzstepv + du*d_tdivzstepu | ! 160: // dv*d_zistepv | s/z ! 161: fmuls C(d_zistepu) // du*d_zistepu | ! 162: // dv*d_tdivzstepv + du*d_tdivzstepu | ! 163: // dv*d_zistepv | s/z ! 164: fxch %st(1) // dv*d_tdivzstepv + du*d_tdivzstepu | ! 165: // du*d_zistepu | dv*d_zistepv | s/z ! 166: fadds C(d_tdivzorigin) // tdivz = d_tdivzorigin + dv*d_tdivzstepv + ! 167: // du*d_tdivzstepu; stays in %st(1) at end ! 168: fxch %st(2) // dv*d_zistepv | du*d_zistepu | t/z | s/z ! 169: faddp %st(0),%st(1) // dv*d_zistepv + du*d_zistepu | t/z | s/z ! 170: ! 171: flds fp_64k // fp_64k | dv*d_zistepv + du*d_zistepu | t/z | s/z ! 172: fxch %st(1) // dv*d_zistepv + du*d_zistepu | fp_64k | t/z | s/z ! 173: fadds C(d_ziorigin) // zi = d_ziorigin + dv*d_zistepv + ! 174: // du*d_zistepu; stays in %st(0) at end ! 175: // 1/z | fp_64k | t/z | s/z ! 176: // ! 177: // calculate and clamp s & t ! 178: // ! 179: fdivr %st(0),%st(1) // 1/z | z*64k | t/z | s/z ! 180: ! 181: // ! 182: // point %edi to the first pixel in the span ! 183: // ! 184: movl C(d_viewbuffer),%ecx ! 185: movl espan_t_v(%ebx),%eax ! 186: movl %ebx,pspantemp // preserve spans pointer ! 187: ! 188: movl C(tadjust),%edx ! 189: movl C(sadjust),%esi ! 190: movl C(d_scantable)(,%eax,4),%edi // v * screenwidth ! 191: addl %ecx,%edi ! 192: movl espan_t_u(%ebx),%ecx ! 193: addl %ecx,%edi // pdest = &pdestspan[scans->u]; ! 194: movl espan_t_count(%ebx),%ecx ! 195: ! 196: // ! 197: // now start the FDIV for the end of the span ! 198: // ! 199: cmpl $16,%ecx ! 200: ja LSetupNotLast1 ! 201: ! 202: decl %ecx ! 203: jz LCleanup1 // if only one pixel, no need to start an FDIV ! 204: movl %ecx,spancountminus1 ! 205: ! 206: // finish up the s and t calcs ! 207: fxch %st(1) // z*64k | 1/z | t/z | s/z ! 208: ! 209: fld %st(0) // z*64k | z*64k | 1/z | t/z | s/z ! 210: fmul %st(4),%st(0) // s | z*64k | 1/z | t/z | s/z ! 211: fxch %st(1) // z*64k | s | 1/z | t/z | s/z ! 212: fmul %st(3),%st(0) // t | s | 1/z | t/z | s/z ! 213: fxch %st(1) // s | t | 1/z | t/z | s/z ! 214: fistpl s // 1/z | t | t/z | s/z ! 215: fistpl t // 1/z | t/z | s/z ! 216: ! 217: fildl spancountminus1 ! 218: ! 219: flds C(d_tdivzstepu) // C(d_tdivzstepu) | spancountminus1 ! 220: flds C(d_zistepu) // C(d_zistepu) | C(d_tdivzstepu) | spancountminus1 ! 221: fmul %st(2),%st(0) // C(d_zistepu)*scm1 | C(d_tdivzstepu) | scm1 ! 222: fxch %st(1) // C(d_tdivzstepu) | C(d_zistepu)*scm1 | scm1 ! 223: fmul %st(2),%st(0) // C(d_tdivzstepu)*scm1 | C(d_zistepu)*scm1 | scm1 ! 224: fxch %st(2) // scm1 | C(d_zistepu)*scm1 | C(d_tdivzstepu)*scm1 ! 225: fmuls C(d_sdivzstepu) // C(d_sdivzstepu)*scm1 | C(d_zistepu)*scm1 | ! 226: // C(d_tdivzstepu)*scm1 ! 227: fxch %st(1) // C(d_zistepu)*scm1 | C(d_sdivzstepu)*scm1 | ! 228: // C(d_tdivzstepu)*scm1 ! 229: faddp %st(0),%st(3) // C(d_sdivzstepu)*scm1 | C(d_tdivzstepu)*scm1 ! 230: fxch %st(1) // C(d_tdivzstepu)*scm1 | C(d_sdivzstepu)*scm1 ! 231: faddp %st(0),%st(3) // C(d_sdivzstepu)*scm1 ! 232: faddp %st(0),%st(3) ! 233: ! 234: flds fp_64k ! 235: fdiv %st(1),%st(0) // this is what we've gone to all this trouble to ! 236: // overlap ! 237: jmp LFDIVInFlight1 ! 238: ! 239: LCleanup1: ! 240: // finish up the s and t calcs ! 241: fxch %st(1) // z*64k | 1/z | t/z | s/z ! 242: ! 243: fld %st(0) // z*64k | z*64k | 1/z | t/z | s/z ! 244: fmul %st(4),%st(0) // s | z*64k | 1/z | t/z | s/z ! 245: fxch %st(1) // z*64k | s | 1/z | t/z | s/z ! 246: fmul %st(3),%st(0) // t | s | 1/z | t/z | s/z ! 247: fxch %st(1) // s | t | 1/z | t/z | s/z ! 248: fistpl s // 1/z | t | t/z | s/z ! 249: fistpl t // 1/z | t/z | s/z ! 250: jmp LFDIVInFlight1 ! 251: ! 252: .align 4 ! 253: LSetupNotLast1: ! 254: // finish up the s and t calcs ! 255: fxch %st(1) // z*64k | 1/z | t/z | s/z ! 256: ! 257: fld %st(0) // z*64k | z*64k | 1/z | t/z | s/z ! 258: fmul %st(4),%st(0) // s | z*64k | 1/z | t/z | s/z ! 259: fxch %st(1) // z*64k | s | 1/z | t/z | s/z ! 260: fmul %st(3),%st(0) // t | s | 1/z | t/z | s/z ! 261: fxch %st(1) // s | t | 1/z | t/z | s/z ! 262: fistpl s // 1/z | t | t/z | s/z ! 263: fistpl t // 1/z | t/z | s/z ! 264: ! 265: fadds zi16stepu ! 266: fxch %st(2) ! 267: fadds sdivz16stepu ! 268: fxch %st(2) ! 269: flds tdivz16stepu ! 270: faddp %st(0),%st(2) ! 271: flds fp_64k ! 272: fdiv %st(1),%st(0) // z = 1/1/z ! 273: // this is what we've gone to all this trouble to ! 274: // overlap ! 275: LFDIVInFlight1: ! 276: ! 277: addl s,%esi ! 278: addl t,%edx ! 279: movl C(bbextents),%ebx ! 280: movl C(bbextentt),%ebp ! 281: cmpl %ebx,%esi ! 282: ja LClampHighOrLow0 ! 283: LClampReentry0: ! 284: movl %esi,s ! 285: movl pbase,%ebx ! 286: shll $16,%esi ! 287: cmpl %ebp,%edx ! 288: movl %esi,sfracf ! 289: ja LClampHighOrLow1 ! 290: LClampReentry1: ! 291: movl %edx,t ! 292: movl s,%esi // sfrac = scans->sfrac; ! 293: shll $16,%edx ! 294: movl t,%eax // tfrac = scans->tfrac; ! 295: sarl $16,%esi ! 296: movl %edx,tfracf ! 297: ! 298: // ! 299: // calculate the texture starting address ! 300: // ! 301: sarl $16,%eax ! 302: movl C(cachewidth),%edx ! 303: imull %edx,%eax // (tfrac >> 16) * cachewidth ! 304: addl %ebx,%esi ! 305: addl %eax,%esi // psource = pbase + (sfrac >> 16) + ! 306: // ((tfrac >> 16) * cachewidth); ! 307: // ! 308: // determine whether last span or not ! 309: // ! 310: cmpl $16,%ecx ! 311: jna LLastSegment ! 312: ! 313: // ! 314: // not the last segment; do full 16-wide segment ! 315: // ! 316: LNotLastSegment: ! 317: ! 318: // ! 319: // advance s/z, t/z, and 1/z, and calculate s & t at end of span and steps to ! 320: // get there ! 321: // ! 322: ! 323: // pick up after the FDIV that was left in flight previously ! 324: ! 325: fld %st(0) // duplicate it ! 326: fmul %st(4),%st(0) // s = s/z * z ! 327: fxch %st(1) ! 328: fmul %st(3),%st(0) // t = t/z * z ! 329: fxch %st(1) ! 330: fistpl snext ! 331: fistpl tnext ! 332: movl snext,%eax ! 333: movl tnext,%edx ! 334: ! 335: movb (%esi),%bl // get first source texel ! 336: subl $16,%ecx // count off this segments' pixels ! 337: movl C(sadjust),%ebp ! 338: movl %ecx,counttemp // remember count of remaining pixels ! 339: ! 340: movl C(tadjust),%ecx ! 341: movb %bl,(%edi) // store first dest pixel ! 342: ! 343: addl %eax,%ebp ! 344: addl %edx,%ecx ! 345: ! 346: movl C(bbextents),%eax ! 347: movl C(bbextentt),%edx ! 348: ! 349: cmpl $4096,%ebp ! 350: jl LClampLow2 ! 351: cmpl %eax,%ebp ! 352: ja LClampHigh2 ! 353: LClampReentry2: ! 354: ! 355: cmpl $4096,%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 $20,%eax // tstep >>= 16; ! 373: jz LZero ! 374: sarl $20,%edx // sstep >>= 16; ! 375: movl C(cachewidth),%ebx ! 376: imull %ebx,%eax ! 377: jmp LSetUp1 ! 378: ! 379: LZero: ! 380: sarl $20,%edx // sstep >>= 16; ! 381: movl C(cachewidth),%ebx ! 382: ! 383: LSetUp1: ! 384: ! 385: addl %edx,%eax // add in sstep ! 386: // (tstep >> 16) * cachewidth + (sstep >> 16); ! 387: movl tfracf,%edx ! 388: movl %eax,advancetable+4 // advance base in t ! 389: addl %ebx,%eax // ((tstep >> 16) + 1) * cachewidth + ! 390: // (sstep >> 16); ! 391: shll $12,%ebp // left-justify sstep fractional part ! 392: movl sfracf,%ebx ! 393: shll $12,%ecx // left-justify tstep fractional part ! 394: movl %eax,advancetable // advance extra in t ! 395: ! 396: movl %ecx,tstep ! 397: addl %ecx,%edx // advance tfrac fractional part by tstep frac ! 398: ! 399: sbbl %ecx,%ecx // turn tstep carry into -1 (0 if none) ! 400: addl %ebp,%ebx // advance sfrac fractional part by sstep frac ! 401: adcl advancetable+4(,%ecx,4),%esi // point to next source texel ! 402: ! 403: addl tstep,%edx ! 404: sbbl %ecx,%ecx ! 405: movb (%esi),%al ! 406: addl %ebp,%ebx ! 407: movb %al,1(%edi) ! 408: adcl advancetable+4(,%ecx,4),%esi ! 409: ! 410: addl tstep,%edx ! 411: sbbl %ecx,%ecx ! 412: addl %ebp,%ebx ! 413: movb (%esi),%al ! 414: adcl advancetable+4(,%ecx,4),%esi ! 415: ! 416: addl tstep,%edx ! 417: sbbl %ecx,%ecx ! 418: movb %al,2(%edi) ! 419: addl %ebp,%ebx ! 420: movb (%esi),%al ! 421: adcl advancetable+4(,%ecx,4),%esi ! 422: ! 423: addl tstep,%edx ! 424: sbbl %ecx,%ecx ! 425: movb %al,3(%edi) ! 426: addl %ebp,%ebx ! 427: movb (%esi),%al ! 428: adcl advancetable+4(,%ecx,4),%esi ! 429: ! 430: addl tstep,%edx ! 431: sbbl %ecx,%ecx ! 432: movb %al,4(%edi) ! 433: addl %ebp,%ebx ! 434: movb (%esi),%al ! 435: adcl advancetable+4(,%ecx,4),%esi ! 436: ! 437: addl tstep,%edx ! 438: sbbl %ecx,%ecx ! 439: movb %al,5(%edi) ! 440: addl %ebp,%ebx ! 441: movb (%esi),%al ! 442: adcl advancetable+4(,%ecx,4),%esi ! 443: ! 444: addl tstep,%edx ! 445: sbbl %ecx,%ecx ! 446: movb %al,6(%edi) ! 447: addl %ebp,%ebx ! 448: movb (%esi),%al ! 449: adcl advancetable+4(,%ecx,4),%esi ! 450: ! 451: addl tstep,%edx ! 452: sbbl %ecx,%ecx ! 453: movb %al,7(%edi) ! 454: addl %ebp,%ebx ! 455: movb (%esi),%al ! 456: adcl advancetable+4(,%ecx,4),%esi ! 457: ! 458: ! 459: // ! 460: // start FDIV for end of next segment in flight, so it can overlap ! 461: // ! 462: movl counttemp,%ecx ! 463: cmpl $16,%ecx // more than one segment after this? ! 464: ja LSetupNotLast2 // yes ! 465: ! 466: decl %ecx ! 467: jz LFDIVInFlight2 // if only one pixel, no need to start an FDIV ! 468: movl %ecx,spancountminus1 ! 469: fildl spancountminus1 ! 470: ! 471: flds C(d_zistepu) // C(d_zistepu) | spancountminus1 ! 472: fmul %st(1),%st(0) // C(d_zistepu)*scm1 | scm1 ! 473: flds C(d_tdivzstepu) // C(d_tdivzstepu) | C(d_zistepu)*scm1 | scm1 ! 474: fmul %st(2),%st(0) // C(d_tdivzstepu)*scm1 | C(d_zistepu)*scm1 | scm1 ! 475: fxch %st(1) // C(d_zistepu)*scm1 | C(d_tdivzstepu)*scm1 | scm1 ! 476: faddp %st(0),%st(3) // C(d_tdivzstepu)*scm1 | scm1 ! 477: fxch %st(1) // scm1 | C(d_tdivzstepu)*scm1 ! 478: fmuls C(d_sdivzstepu) // C(d_sdivzstepu)*scm1 | C(d_tdivzstepu)*scm1 ! 479: fxch %st(1) // C(d_tdivzstepu)*scm1 | C(d_sdivzstepu)*scm1 ! 480: faddp %st(0),%st(3) // C(d_sdivzstepu)*scm1 ! 481: flds fp_64k // 64k | C(d_sdivzstepu)*scm1 ! 482: fxch %st(1) // C(d_sdivzstepu)*scm1 | 64k ! 483: faddp %st(0),%st(4) // 64k ! 484: ! 485: fdiv %st(1),%st(0) // this is what we've gone to all this trouble to ! 486: // overlap ! 487: jmp LFDIVInFlight2 ! 488: ! 489: .align 4 ! 490: LSetupNotLast2: ! 491: fadds zi16stepu ! 492: fxch %st(2) ! 493: fadds sdivz16stepu ! 494: fxch %st(2) ! 495: flds tdivz16stepu ! 496: faddp %st(0),%st(2) ! 497: flds fp_64k ! 498: fdiv %st(1),%st(0) // z = 1/1/z ! 499: // this is what we've gone to all this trouble to ! 500: // overlap ! 501: LFDIVInFlight2: ! 502: movl %ecx,counttemp ! 503: ! 504: addl tstep,%edx ! 505: sbbl %ecx,%ecx ! 506: movb %al,8(%edi) ! 507: addl %ebp,%ebx ! 508: movb (%esi),%al ! 509: adcl advancetable+4(,%ecx,4),%esi ! 510: ! 511: addl tstep,%edx ! 512: sbbl %ecx,%ecx ! 513: movb %al,9(%edi) ! 514: addl %ebp,%ebx ! 515: movb (%esi),%al ! 516: adcl advancetable+4(,%ecx,4),%esi ! 517: ! 518: addl tstep,%edx ! 519: sbbl %ecx,%ecx ! 520: movb %al,10(%edi) ! 521: addl %ebp,%ebx ! 522: movb (%esi),%al ! 523: adcl advancetable+4(,%ecx,4),%esi ! 524: ! 525: addl tstep,%edx ! 526: sbbl %ecx,%ecx ! 527: movb %al,11(%edi) ! 528: addl %ebp,%ebx ! 529: movb (%esi),%al ! 530: adcl advancetable+4(,%ecx,4),%esi ! 531: ! 532: addl tstep,%edx ! 533: sbbl %ecx,%ecx ! 534: movb %al,12(%edi) ! 535: addl %ebp,%ebx ! 536: movb (%esi),%al ! 537: adcl advancetable+4(,%ecx,4),%esi ! 538: ! 539: addl tstep,%edx ! 540: sbbl %ecx,%ecx ! 541: movb %al,13(%edi) ! 542: addl %ebp,%ebx ! 543: movb (%esi),%al ! 544: adcl advancetable+4(,%ecx,4),%esi ! 545: ! 546: addl tstep,%edx ! 547: sbbl %ecx,%ecx ! 548: movb %al,14(%edi) ! 549: addl %ebp,%ebx ! 550: movb (%esi),%al ! 551: adcl advancetable+4(,%ecx,4),%esi ! 552: ! 553: addl $16,%edi ! 554: movl %edx,tfracf ! 555: movl snext,%edx ! 556: movl %ebx,sfracf ! 557: movl tnext,%ebx ! 558: movl %edx,s ! 559: movl %ebx,t ! 560: ! 561: movl counttemp,%ecx // retrieve count ! 562: ! 563: // ! 564: // determine whether last span or not ! 565: // ! 566: cmpl $16,%ecx // are there multiple segments remaining? ! 567: movb %al,-1(%edi) ! 568: ja LNotLastSegment // yes ! 569: ! 570: // ! 571: // last segment of scan ! 572: // ! 573: LLastSegment: ! 574: ! 575: // ! 576: // advance s/z, t/z, and 1/z, and calculate s & t at end of span and steps to ! 577: // get there. The number of pixels left is variable, and we want to land on the ! 578: // last pixel, not step one past it, so we can't run into arithmetic problems ! 579: // ! 580: testl %ecx,%ecx ! 581: jz LNoSteps // just draw the last pixel and we're done ! 582: ! 583: // pick up after the FDIV that was left in flight previously ! 584: ! 585: ! 586: fld %st(0) // duplicate it ! 587: fmul %st(4),%st(0) // s = s/z * z ! 588: fxch %st(1) ! 589: fmul %st(3),%st(0) // t = t/z * z ! 590: fxch %st(1) ! 591: fistpl snext ! 592: fistpl tnext ! 593: ! 594: movb (%esi),%al // load first texel in segment ! 595: movl C(tadjust),%ebx ! 596: movb %al,(%edi) // store first pixel in segment ! 597: movl C(sadjust),%eax ! 598: ! 599: addl snext,%eax ! 600: addl tnext,%ebx ! 601: ! 602: movl C(bbextents),%ebp ! 603: movl C(bbextentt),%edx ! 604: ! 605: cmpl $4096,%eax ! 606: jl LClampLow4 ! 607: cmpl %ebp,%eax ! 608: ja LClampHigh4 ! 609: LClampReentry4: ! 610: movl %eax,snext ! 611: ! 612: cmpl $4096,%ebx ! 613: jl LClampLow5 ! 614: cmpl %edx,%ebx ! 615: ja LClampHigh5 ! 616: LClampReentry5: ! 617: ! 618: cmpl $1,%ecx // don't bother ! 619: je LOnlyOneStep // if two pixels in segment, there's only one step, ! 620: // of the segment length ! 621: subl s,%eax ! 622: subl t,%ebx ! 623: ! 624: addl %eax,%eax // convert to 15.17 format so multiply by 1.31 ! 625: addl %ebx,%ebx // reciprocal yields 16.48 ! 626: ! 627: imull reciprocal_table_16-8(,%ecx,4) // sstep = (snext - s) / ! 628: // (spancount-1) ! 629: movl %edx,%ebp ! 630: ! 631: movl %ebx,%eax ! 632: imull reciprocal_table_16-8(,%ecx,4) // tstep = (tnext - t) / ! 633: // (spancount-1) ! 634: LSetEntryvec: ! 635: // ! 636: // set up advancetable ! 637: // ! 638: movl entryvec_table_16(,%ecx,4),%ebx ! 639: movl %edx,%eax ! 640: movl %ebx,jumptemp // entry point into code for RET later ! 641: movl %ebp,%ecx ! 642: sarl $16,%edx // tstep >>= 16; ! 643: movl C(cachewidth),%ebx ! 644: sarl $16,%ecx // sstep >>= 16; ! 645: imull %ebx,%edx ! 646: ! 647: addl %ecx,%edx // add in sstep ! 648: // (tstep >> 16) * cachewidth + (sstep >> 16); ! 649: movl tfracf,%ecx ! 650: movl %edx,advancetable+4 // advance base in t ! 651: addl %ebx,%edx // ((tstep >> 16) + 1) * cachewidth + ! 652: // (sstep >> 16); ! 653: shll $16,%ebp // left-justify sstep fractional part ! 654: movl sfracf,%ebx ! 655: shll $16,%eax // left-justify tstep fractional part ! 656: movl %edx,advancetable // advance extra in t ! 657: ! 658: movl %eax,tstep ! 659: movl %ecx,%edx ! 660: addl %eax,%edx ! 661: sbbl %ecx,%ecx ! 662: addl %ebp,%ebx ! 663: adcl advancetable+4(,%ecx,4),%esi ! 664: ! 665: jmp *jumptemp // jump to the number-of-pixels handler ! 666: ! 667: //---------------------------------------- ! 668: ! 669: LNoSteps: ! 670: movb (%esi),%al // load first texel in segment ! 671: subl $15,%edi // adjust for hardwired offset ! 672: jmp LEndSpan ! 673: ! 674: ! 675: LOnlyOneStep: ! 676: subl s,%eax ! 677: subl t,%ebx ! 678: movl %eax,%ebp ! 679: movl %ebx,%edx ! 680: jmp LSetEntryvec ! 681: ! 682: //---------------------------------------- ! 683: ! 684: .globl Entry2_16, Entry3_16, Entry4_16, Entry5_16 ! 685: .globl Entry6_16, Entry7_16, Entry8_16, Entry9_16 ! 686: .globl Entry10_16, Entry11_16, Entry12_16, Entry13_16 ! 687: .globl Entry14_16, Entry15_16, Entry16_16 ! 688: ! 689: Entry2_16: ! 690: subl $14,%edi // adjust for hardwired offsets ! 691: movb (%esi),%al ! 692: jmp LEntry2_16 ! 693: ! 694: //---------------------------------------- ! 695: ! 696: Entry3_16: ! 697: subl $13,%edi // adjust for hardwired offsets ! 698: addl %eax,%edx ! 699: movb (%esi),%al ! 700: sbbl %ecx,%ecx ! 701: addl %ebp,%ebx ! 702: adcl advancetable+4(,%ecx,4),%esi ! 703: jmp LEntry3_16 ! 704: ! 705: //---------------------------------------- ! 706: ! 707: Entry4_16: ! 708: subl $12,%edi // adjust for hardwired offsets ! 709: addl %eax,%edx ! 710: movb (%esi),%al ! 711: sbbl %ecx,%ecx ! 712: addl %ebp,%ebx ! 713: adcl advancetable+4(,%ecx,4),%esi ! 714: addl tstep,%edx ! 715: jmp LEntry4_16 ! 716: ! 717: //---------------------------------------- ! 718: ! 719: Entry5_16: ! 720: subl $11,%edi // adjust for hardwired offsets ! 721: addl %eax,%edx ! 722: movb (%esi),%al ! 723: sbbl %ecx,%ecx ! 724: addl %ebp,%ebx ! 725: adcl advancetable+4(,%ecx,4),%esi ! 726: addl tstep,%edx ! 727: jmp LEntry5_16 ! 728: ! 729: //---------------------------------------- ! 730: ! 731: Entry6_16: ! 732: subl $10,%edi // adjust for hardwired offsets ! 733: addl %eax,%edx ! 734: movb (%esi),%al ! 735: sbbl %ecx,%ecx ! 736: addl %ebp,%ebx ! 737: adcl advancetable+4(,%ecx,4),%esi ! 738: addl tstep,%edx ! 739: jmp LEntry6_16 ! 740: ! 741: //---------------------------------------- ! 742: ! 743: Entry7_16: ! 744: subl $9,%edi // adjust for hardwired offsets ! 745: addl %eax,%edx ! 746: movb (%esi),%al ! 747: sbbl %ecx,%ecx ! 748: addl %ebp,%ebx ! 749: adcl advancetable+4(,%ecx,4),%esi ! 750: addl tstep,%edx ! 751: jmp LEntry7_16 ! 752: ! 753: //---------------------------------------- ! 754: ! 755: Entry8_16: ! 756: subl $8,%edi // adjust for hardwired offsets ! 757: addl %eax,%edx ! 758: movb (%esi),%al ! 759: sbbl %ecx,%ecx ! 760: addl %ebp,%ebx ! 761: adcl advancetable+4(,%ecx,4),%esi ! 762: addl tstep,%edx ! 763: jmp LEntry8_16 ! 764: ! 765: //---------------------------------------- ! 766: ! 767: Entry9_16: ! 768: subl $7,%edi // adjust for hardwired offsets ! 769: addl %eax,%edx ! 770: movb (%esi),%al ! 771: sbbl %ecx,%ecx ! 772: addl %ebp,%ebx ! 773: adcl advancetable+4(,%ecx,4),%esi ! 774: addl tstep,%edx ! 775: jmp LEntry9_16 ! 776: ! 777: //---------------------------------------- ! 778: ! 779: Entry10_16: ! 780: subl $6,%edi // adjust for hardwired offsets ! 781: addl %eax,%edx ! 782: movb (%esi),%al ! 783: sbbl %ecx,%ecx ! 784: addl %ebp,%ebx ! 785: adcl advancetable+4(,%ecx,4),%esi ! 786: addl tstep,%edx ! 787: jmp LEntry10_16 ! 788: ! 789: //---------------------------------------- ! 790: ! 791: Entry11_16: ! 792: subl $5,%edi // adjust for hardwired offsets ! 793: addl %eax,%edx ! 794: movb (%esi),%al ! 795: sbbl %ecx,%ecx ! 796: addl %ebp,%ebx ! 797: adcl advancetable+4(,%ecx,4),%esi ! 798: addl tstep,%edx ! 799: jmp LEntry11_16 ! 800: ! 801: //---------------------------------------- ! 802: ! 803: Entry12_16: ! 804: subl $4,%edi // adjust for hardwired offsets ! 805: addl %eax,%edx ! 806: movb (%esi),%al ! 807: sbbl %ecx,%ecx ! 808: addl %ebp,%ebx ! 809: adcl advancetable+4(,%ecx,4),%esi ! 810: addl tstep,%edx ! 811: jmp LEntry12_16 ! 812: ! 813: //---------------------------------------- ! 814: ! 815: Entry13_16: ! 816: subl $3,%edi // adjust for hardwired offsets ! 817: addl %eax,%edx ! 818: movb (%esi),%al ! 819: sbbl %ecx,%ecx ! 820: addl %ebp,%ebx ! 821: adcl advancetable+4(,%ecx,4),%esi ! 822: addl tstep,%edx ! 823: jmp LEntry13_16 ! 824: ! 825: //---------------------------------------- ! 826: ! 827: Entry14_16: ! 828: subl $2,%edi // adjust for hardwired offsets ! 829: addl %eax,%edx ! 830: movb (%esi),%al ! 831: sbbl %ecx,%ecx ! 832: addl %ebp,%ebx ! 833: adcl advancetable+4(,%ecx,4),%esi ! 834: addl tstep,%edx ! 835: jmp LEntry14_16 ! 836: ! 837: //---------------------------------------- ! 838: ! 839: Entry15_16: ! 840: decl %edi // adjust for hardwired offsets ! 841: addl %eax,%edx ! 842: movb (%esi),%al ! 843: sbbl %ecx,%ecx ! 844: addl %ebp,%ebx ! 845: adcl advancetable+4(,%ecx,4),%esi ! 846: addl tstep,%edx ! 847: jmp LEntry15_16 ! 848: ! 849: //---------------------------------------- ! 850: ! 851: Entry16_16: ! 852: addl %eax,%edx ! 853: movb (%esi),%al ! 854: sbbl %ecx,%ecx ! 855: addl %ebp,%ebx ! 856: adcl advancetable+4(,%ecx,4),%esi ! 857: ! 858: addl tstep,%edx ! 859: sbbl %ecx,%ecx ! 860: movb %al,1(%edi) ! 861: addl %ebp,%ebx ! 862: movb (%esi),%al ! 863: adcl advancetable+4(,%ecx,4),%esi ! 864: addl tstep,%edx ! 865: LEntry15_16: ! 866: sbbl %ecx,%ecx ! 867: movb %al,2(%edi) ! 868: addl %ebp,%ebx ! 869: movb (%esi),%al ! 870: adcl advancetable+4(,%ecx,4),%esi ! 871: addl tstep,%edx ! 872: LEntry14_16: ! 873: sbbl %ecx,%ecx ! 874: movb %al,3(%edi) ! 875: addl %ebp,%ebx ! 876: movb (%esi),%al ! 877: adcl advancetable+4(,%ecx,4),%esi ! 878: addl tstep,%edx ! 879: LEntry13_16: ! 880: sbbl %ecx,%ecx ! 881: movb %al,4(%edi) ! 882: addl %ebp,%ebx ! 883: movb (%esi),%al ! 884: adcl advancetable+4(,%ecx,4),%esi ! 885: addl tstep,%edx ! 886: LEntry12_16: ! 887: sbbl %ecx,%ecx ! 888: movb %al,5(%edi) ! 889: addl %ebp,%ebx ! 890: movb (%esi),%al ! 891: adcl advancetable+4(,%ecx,4),%esi ! 892: addl tstep,%edx ! 893: LEntry11_16: ! 894: sbbl %ecx,%ecx ! 895: movb %al,6(%edi) ! 896: addl %ebp,%ebx ! 897: movb (%esi),%al ! 898: adcl advancetable+4(,%ecx,4),%esi ! 899: addl tstep,%edx ! 900: LEntry10_16: ! 901: sbbl %ecx,%ecx ! 902: movb %al,7(%edi) ! 903: addl %ebp,%ebx ! 904: movb (%esi),%al ! 905: adcl advancetable+4(,%ecx,4),%esi ! 906: addl tstep,%edx ! 907: LEntry9_16: ! 908: sbbl %ecx,%ecx ! 909: movb %al,8(%edi) ! 910: addl %ebp,%ebx ! 911: movb (%esi),%al ! 912: adcl advancetable+4(,%ecx,4),%esi ! 913: addl tstep,%edx ! 914: LEntry8_16: ! 915: sbbl %ecx,%ecx ! 916: movb %al,9(%edi) ! 917: addl %ebp,%ebx ! 918: movb (%esi),%al ! 919: adcl advancetable+4(,%ecx,4),%esi ! 920: addl tstep,%edx ! 921: LEntry7_16: ! 922: sbbl %ecx,%ecx ! 923: movb %al,10(%edi) ! 924: addl %ebp,%ebx ! 925: movb (%esi),%al ! 926: adcl advancetable+4(,%ecx,4),%esi ! 927: addl tstep,%edx ! 928: LEntry6_16: ! 929: sbbl %ecx,%ecx ! 930: movb %al,11(%edi) ! 931: addl %ebp,%ebx ! 932: movb (%esi),%al ! 933: adcl advancetable+4(,%ecx,4),%esi ! 934: addl tstep,%edx ! 935: LEntry5_16: ! 936: sbbl %ecx,%ecx ! 937: movb %al,12(%edi) ! 938: addl %ebp,%ebx ! 939: movb (%esi),%al ! 940: adcl advancetable+4(,%ecx,4),%esi ! 941: addl tstep,%edx ! 942: LEntry4_16: ! 943: sbbl %ecx,%ecx ! 944: movb %al,13(%edi) ! 945: addl %ebp,%ebx ! 946: movb (%esi),%al ! 947: adcl advancetable+4(,%ecx,4),%esi ! 948: LEntry3_16: ! 949: movb %al,14(%edi) ! 950: movb (%esi),%al ! 951: LEntry2_16: ! 952: ! 953: LEndSpan: ! 954: ! 955: // ! 956: // clear s/z, t/z, 1/z from FP stack ! 957: // ! 958: fstp %st(0) ! 959: fstp %st(0) ! 960: fstp %st(0) ! 961: ! 962: movl pspantemp,%ebx // restore spans pointer ! 963: movl espan_t_pnext(%ebx),%ebx // point to next span ! 964: testl %ebx,%ebx // any more spans? ! 965: movb %al,15(%edi) ! 966: jnz LSpanLoop // more spans ! 967: ! 968: popl %ebx // restore register variables ! 969: popl %esi ! 970: popl %edi ! 971: popl %ebp // restore the caller's stack frame ! 972: ret ! 973: ! 974: #endif // id386
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.