![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to r_drawa.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_drawa.s CVS log | Up to [Quake II] / quake2 / linux |
1.1 ! root 1: // ! 2: // r_drawa.s ! 3: // x86 assembly-language edge clipping and emission code ! 4: // ! 5: ! 6: #include "qasm.h" ! 7: #include "d_ifacea.h" ! 8: ! 9: #if id386 ! 10: ! 11: // !!! if these are changed, they must be changed in r_draw.c too !!! ! 12: #define FULLY_CLIPPED_CACHED 0x80000000 ! 13: #define FRAMECOUNT_MASK 0x7FFFFFFF ! 14: ! 15: .data ! 16: ! 17: Ld0: .single 0.0 ! 18: Ld1: .single 0.0 ! 19: Lstack: .long 0 ! 20: Lfp_near_clip: .single NEAR_CLIP ! 21: Lceilv0: .long 0 ! 22: Lv: .long 0 ! 23: Lu0: .long 0 ! 24: Lv0: .long 0 ! 25: Lzi0: .long 0 ! 26: ! 27: .text ! 28: ! 29: //---------------------------------------------------------------------- ! 30: // edge clipping code ! 31: //---------------------------------------------------------------------- ! 32: ! 33: #define pv0 4+12 ! 34: #define pv1 8+12 ! 35: #define clip 12+12 ! 36: ! 37: .align 4 ! 38: .globl C(R_ClipEdge) ! 39: C(R_ClipEdge): ! 40: pushl %esi // preserve register variables ! 41: pushl %edi ! 42: pushl %ebx ! 43: movl %esp,Lstack // for clearing the stack later ! 44: ! 45: // float d0, d1, f; ! 46: // mvertex_t clipvert; ! 47: ! 48: movl clip(%esp),%ebx ! 49: movl pv0(%esp),%esi ! 50: movl pv1(%esp),%edx ! 51: ! 52: // if (clip) ! 53: // { ! 54: testl %ebx,%ebx ! 55: jz Lemit ! 56: ! 57: // do ! 58: // { ! 59: ! 60: Lcliploop: ! 61: ! 62: // d0 = DotProduct (pv0->position, clip->normal) - clip->dist; ! 63: // d1 = DotProduct (pv1->position, clip->normal) - clip->dist; ! 64: flds mv_position+0(%esi) ! 65: fmuls cp_normal+0(%ebx) ! 66: flds mv_position+4(%esi) ! 67: fmuls cp_normal+4(%ebx) ! 68: flds mv_position+8(%esi) ! 69: fmuls cp_normal+8(%ebx) ! 70: fxch %st(1) ! 71: faddp %st(0),%st(2) // d0mul2 | d0add0 ! 72: ! 73: flds mv_position+0(%edx) ! 74: fmuls cp_normal+0(%ebx) ! 75: flds mv_position+4(%edx) ! 76: fmuls cp_normal+4(%ebx) ! 77: flds mv_position+8(%edx) ! 78: fmuls cp_normal+8(%ebx) ! 79: fxch %st(1) ! 80: faddp %st(0),%st(2) // d1mul2 | d1add0 | d0mul2 | d0add0 ! 81: fxch %st(3) // d0add0 | d1add0 | d0mul2 | d1mul2 ! 82: ! 83: faddp %st(0),%st(2) // d1add0 | dot0 | d1mul2 ! 84: faddp %st(0),%st(2) // dot0 | dot1 ! 85: ! 86: fsubs cp_dist(%ebx) // d0 | dot1 ! 87: fxch %st(1) // dot1 | d0 ! 88: fsubs cp_dist(%ebx) // d1 | d0 ! 89: fxch %st(1) ! 90: fstps Ld0 ! 91: fstps Ld1 ! 92: ! 93: // if (d0 >= 0) ! 94: // { ! 95: movl Ld0,%eax ! 96: movl Ld1,%ecx ! 97: orl %eax,%ecx ! 98: js Lp2 ! 99: ! 100: // both points are unclipped ! 101: ! 102: Lcontinue: ! 103: ! 104: // ! 105: // R_ClipEdge (&clipvert, pv1, clip->next); ! 106: // return; ! 107: // } ! 108: // } while ((clip = clip->next) != NULL); ! 109: movl cp_next(%ebx),%ebx ! 110: testl %ebx,%ebx ! 111: jnz Lcliploop ! 112: ! 113: // } ! 114: ! 115: //// add the edge ! 116: // R_EmitEdge (pv0, pv1); ! 117: Lemit: ! 118: ! 119: // ! 120: // set integer rounding to ceil mode, set to single precision ! 121: // ! 122: // FIXME: do away with by manually extracting integers from floats? ! 123: // FIXME: set less often ! 124: fldcw ceil_cw ! 125: ! 126: // edge_t *edge, *pcheck; ! 127: // int u_check; ! 128: // float u, u_step; ! 129: // vec3_t local, transformed; ! 130: // float *world; ! 131: // int v, v2, ceilv0; ! 132: // float scale, lzi0, u0, v0; ! 133: // int side; ! 134: ! 135: // if (r_lastvertvalid) ! 136: // { ! 137: cmpl $0,C(r_lastvertvalid) ! 138: jz LCalcFirst ! 139: ! 140: // u0 = r_u1; ! 141: // v0 = r_v1; ! 142: // lzi0 = r_lzi1; ! 143: // ceilv0 = r_ceilv1; ! 144: movl C(r_lzi1),%eax ! 145: movl C(r_u1),%ecx ! 146: movl %eax,Lzi0 ! 147: movl %ecx,Lu0 ! 148: movl C(r_v1),%ecx ! 149: movl C(r_ceilv1),%eax ! 150: movl %ecx,Lv0 ! 151: movl %eax,Lceilv0 ! 152: jmp LCalcSecond ! 153: ! 154: // } ! 155: ! 156: LCalcFirst: ! 157: ! 158: // else ! 159: // { ! 160: // world = &pv0->position[0]; ! 161: ! 162: call LTransformAndProject // v0 | lzi0 | u0 ! 163: ! 164: fsts Lv0 ! 165: fxch %st(2) // u0 | lzi0 | v0 ! 166: fstps Lu0 // lzi0 | v0 ! 167: fstps Lzi0 // v0 ! 168: ! 169: // ceilv0 = (int)(v0 - 2000) + 2000; // ceil(v0); ! 170: fistpl Lceilv0 ! 171: ! 172: // } ! 173: ! 174: LCalcSecond: ! 175: ! 176: // world = &pv1->position[0]; ! 177: movl %edx,%esi ! 178: ! 179: call LTransformAndProject // v1 | lzi1 | u1 ! 180: ! 181: flds Lu0 // u0 | v1 | lzi1 | u1 ! 182: fxch %st(3) // u1 | v1 | lzi1 | u0 ! 183: flds Lzi0 // lzi0 | u1 | v1 | lzi1 | u0 ! 184: fxch %st(3) // lzi1 | u1 | v1 | lzi0 | u0 ! 185: flds Lv0 // v0 | lzi1 | u1 | v1 | lzi0 | u0 ! 186: fxch %st(3) // v1 | lzi1 | u1 | v0 | lzi0 | u0 ! 187: ! 188: // r_ceilv1 = (int)(r_v1 - 2000) + 2000; // ceil(r_v1); ! 189: fistl C(r_ceilv1) ! 190: ! 191: fldcw single_cw // put back normal floating-point state ! 192: ! 193: fsts C(r_v1) ! 194: fxch %st(4) // lzi0 | lzi1 | u1 | v0 | v1 | u0 ! 195: ! 196: // if (r_lzi1 > lzi0) ! 197: // lzi0 = r_lzi1; ! 198: fcom %st(1) ! 199: fnstsw %ax ! 200: testb $1,%ah ! 201: jz LP0 ! 202: fstp %st(0) ! 203: fld %st(0) ! 204: LP0: ! 205: ! 206: fxch %st(1) // lzi1 | lzi0 | u1 | v0 | v1 | u0 ! 207: fstps C(r_lzi1) // lzi0 | u1 | v0 | v1 | u0 ! 208: fxch %st(1) ! 209: fsts C(r_u1) ! 210: fxch %st(1) ! 211: ! 212: // if (lzi0 > r_nearzi) // for mipmap finding ! 213: // r_nearzi = lzi0; ! 214: fcoms C(r_nearzi) ! 215: fnstsw %ax ! 216: testb $0x45,%ah ! 217: jnz LP1 ! 218: fsts C(r_nearzi) ! 219: LP1: ! 220: ! 221: // // for right edges, all we want is the effect on 1/z ! 222: // if (r_nearzionly) ! 223: // return; ! 224: movl C(r_nearzionly),%eax ! 225: testl %eax,%eax ! 226: jz LP2 ! 227: LPop5AndDone: ! 228: movl C(cacheoffset),%eax ! 229: movl C(r_framecount),%edx ! 230: cmpl $0x7FFFFFFF,%eax ! 231: jz LDoPop ! 232: andl $(FRAMECOUNT_MASK),%edx ! 233: orl $(FULLY_CLIPPED_CACHED),%edx ! 234: movl %edx,C(cacheoffset) ! 235: ! 236: LDoPop: ! 237: fstp %st(0) // u1 | v0 | v1 | u0 ! 238: fstp %st(0) // v0 | v1 | u0 ! 239: fstp %st(0) // v1 | u0 ! 240: fstp %st(0) // u0 ! 241: fstp %st(0) ! 242: jmp Ldone ! 243: ! 244: LP2: ! 245: ! 246: // // create the edge ! 247: // if (ceilv0 == r_ceilv1) ! 248: // return; // horizontal edge ! 249: movl Lceilv0,%ebx ! 250: movl C(edge_p),%edi ! 251: movl C(r_ceilv1),%ecx ! 252: movl %edi,%edx ! 253: movl C(r_pedge),%esi ! 254: addl $(et_size),%edx ! 255: cmpl %ecx,%ebx ! 256: jz LPop5AndDone ! 257: ! 258: movl C(r_pedge),%eax ! 259: movl %eax,et_owner(%edi) ! 260: ! 261: // side = ceilv0 > r_ceilv1; ! 262: // ! 263: // edge->nearzi = lzi0; ! 264: fstps et_nearzi(%edi) // u1 | v0 | v1 | u0 ! 265: ! 266: // if (side == 1) ! 267: // { ! 268: jc LSide0 ! 269: ! 270: LSide1: ! 271: ! 272: // // leading edge (go from p2 to p1) ! 273: ! 274: // u_step = ((u0 - r_u1) / (v0 - r_v1)); ! 275: fsubrp %st(0),%st(3) // v0 | v1 | u0-u1 ! 276: fsub %st(1),%st(0) // v0-v1 | v1 | u0-u1 ! 277: fdivrp %st(0),%st(2) // v1 | ustep ! 278: ! 279: // r_emitted = 1; ! 280: movl $1,C(r_emitted) ! 281: ! 282: // edge = edge_p++; ! 283: movl %edx,C(edge_p) ! 284: ! 285: // pretouch next edge ! 286: movl (%edx),%eax ! 287: ! 288: // v2 = ceilv0 - 1; ! 289: // v = r_ceilv1; ! 290: movl %ecx,%eax ! 291: leal -1(%ebx),%ecx ! 292: movl %eax,%ebx ! 293: ! 294: // edge->surfs[0] = 0; ! 295: // edge->surfs[1] = surface_p - surfaces; ! 296: movl C(surface_p),%eax ! 297: movl C(surfaces),%esi ! 298: subl %edx,%edx ! 299: subl %esi,%eax ! 300: shrl $(SURF_T_SHIFT),%eax ! 301: movl %edx,et_surfs(%edi) ! 302: movl %eax,et_surfs+2(%edi) ! 303: ! 304: subl %esi,%esi ! 305: ! 306: // u = r_u1 + ((float)v - r_v1) * u_step; ! 307: movl %ebx,Lv ! 308: fildl Lv // v | v1 | ustep ! 309: fsubp %st(0),%st(1) // v-v1 | ustep ! 310: fmul %st(1),%st(0) // (v-v1)*ustep | ustep ! 311: fadds C(r_u1) // u | ustep ! 312: ! 313: jmp LSideDone ! 314: ! 315: // } ! 316: ! 317: LSide0: ! 318: ! 319: // else ! 320: // { ! 321: // // trailing edge (go from p1 to p2) ! 322: ! 323: // u_step = ((r_u1 - u0) / (r_v1 - v0)); ! 324: fsub %st(3),%st(0) // u1-u0 | v0 | v1 | u0 ! 325: fxch %st(2) // v1 | v0 | u1-u0 | u0 ! 326: fsub %st(1),%st(0) // v1-v0 | v0 | u1-u0 | u0 ! 327: fdivrp %st(0),%st(2) // v0 | ustep | u0 ! 328: ! 329: // r_emitted = 1; ! 330: movl $1,C(r_emitted) ! 331: ! 332: // edge = edge_p++; ! 333: movl %edx,C(edge_p) ! 334: ! 335: // pretouch next edge ! 336: movl (%edx),%eax ! 337: ! 338: // v = ceilv0; ! 339: // v2 = r_ceilv1 - 1; ! 340: decl %ecx ! 341: ! 342: // edge->surfs[0] = surface_p - surfaces; ! 343: // edge->surfs[1] = 0; ! 344: movl C(surface_p),%eax ! 345: movl C(surfaces),%esi ! 346: subl %edx,%edx ! 347: subl %esi,%eax ! 348: shrl $(SURF_T_SHIFT),%eax ! 349: movl %edx,et_surfs+2(%edi) ! 350: movl %eax,et_surfs(%edi) ! 351: ! 352: movl $1,%esi ! 353: ! 354: // u = u0 + ((float)v - v0) * u_step; ! 355: movl %ebx,Lv ! 356: fildl Lv // v | v0 | ustep | u0 ! 357: fsubp %st(0),%st(1) // v-v0 | ustep | u0 ! 358: fmul %st(1),%st(0) // (v-v0)*ustep | ustep | u0 ! 359: faddp %st(0),%st(2) // ustep | u ! 360: fxch %st(1) // u | ustep ! 361: ! 362: // } ! 363: ! 364: LSideDone: ! 365: ! 366: // edge->u_step = u_step*0x100000; ! 367: // edge->u = u*0x100000 + 0xFFFFF; ! 368: ! 369: fmuls fp_1m // u*0x100000 | ustep ! 370: fxch %st(1) // ustep | u*0x100000 ! 371: fmuls fp_1m // ustep*0x100000 | u*0x100000 ! 372: fxch %st(1) // u*0x100000 | ustep*0x100000 ! 373: fadds fp_1m_minus_1 // u*0x100000 + 0xFFFFF | ustep*0x100000 ! 374: fxch %st(1) // ustep*0x100000 | u*0x100000 + 0xFFFFF ! 375: fistpl et_u_step(%edi) // u*0x100000 + 0xFFFFF ! 376: fistpl et_u(%edi) ! 377: ! 378: // // we need to do this to avoid stepping off the edges if a very nearly ! 379: // // horizontal edge is less than epsilon above a scan, and numeric error ! 380: // // causes it to incorrectly extend to the scan, and the extension of the ! 381: // // line goes off the edge of the screen ! 382: // // FIXME: is this actually needed? ! 383: // if (edge->u < r_refdef.vrect_x_adj_shift20) ! 384: // edge->u = r_refdef.vrect_x_adj_shift20; ! 385: // if (edge->u > r_refdef.vrectright_adj_shift20) ! 386: // edge->u = r_refdef.vrectright_adj_shift20; ! 387: movl et_u(%edi),%eax ! 388: movl C(r_refdef)+rd_vrect_x_adj_shift20,%edx ! 389: cmpl %edx,%eax ! 390: jl LP4 ! 391: movl C(r_refdef)+rd_vrectright_adj_shift20,%edx ! 392: cmpl %edx,%eax ! 393: jng LP5 ! 394: LP4: ! 395: movl %edx,et_u(%edi) ! 396: movl %edx,%eax ! 397: LP5: ! 398: ! 399: // // sort the edge in normally ! 400: // u_check = edge->u; ! 401: // ! 402: // if (edge->surfs[0]) ! 403: // u_check++; // sort trailers after leaders ! 404: addl %esi,%eax ! 405: ! 406: // if (!newedges[v] || newedges[v]->u >= u_check) ! 407: // { ! 408: movl C(newedges)(,%ebx,4),%esi ! 409: testl %esi,%esi ! 410: jz LDoFirst ! 411: cmpl %eax,et_u(%esi) ! 412: jl LNotFirst ! 413: LDoFirst: ! 414: ! 415: // edge->next = newedges[v]; ! 416: // newedges[v] = edge; ! 417: movl %esi,et_next(%edi) ! 418: movl %edi,C(newedges)(,%ebx,4) ! 419: ! 420: jmp LSetRemove ! 421: ! 422: // } ! 423: ! 424: LNotFirst: ! 425: ! 426: // else ! 427: // { ! 428: // pcheck = newedges[v]; ! 429: // ! 430: // while (pcheck->next && pcheck->next->u < u_check) ! 431: // pcheck = pcheck->next; ! 432: LFindInsertLoop: ! 433: movl %esi,%edx ! 434: movl et_next(%esi),%esi ! 435: testl %esi,%esi ! 436: jz LInsertFound ! 437: cmpl %eax,et_u(%esi) ! 438: jl LFindInsertLoop ! 439: ! 440: LInsertFound: ! 441: ! 442: // edge->next = pcheck->next; ! 443: // pcheck->next = edge; ! 444: movl %esi,et_next(%edi) ! 445: movl %edi,et_next(%edx) ! 446: ! 447: // } ! 448: ! 449: LSetRemove: ! 450: ! 451: // edge->nextremove = removeedges[v2]; ! 452: // removeedges[v2] = edge; ! 453: movl C(removeedges)(,%ecx,4),%eax ! 454: movl %edi,C(removeedges)(,%ecx,4) ! 455: movl %eax,et_nextremove(%edi) ! 456: ! 457: Ldone: ! 458: movl Lstack,%esp // clear temporary variables from stack ! 459: ! 460: popl %ebx // restore register variables ! 461: popl %edi ! 462: popl %esi ! 463: ret ! 464: ! 465: // at least one point is clipped ! 466: ! 467: Lp2: ! 468: testl %eax,%eax ! 469: jns Lp1 ! 470: ! 471: // else ! 472: // { ! 473: // // point 0 is clipped ! 474: ! 475: // if (d1 < 0) ! 476: // { ! 477: movl Ld1,%eax ! 478: testl %eax,%eax ! 479: jns Lp3 ! 480: ! 481: // // both points are clipped ! 482: // // we do cache fully clipped edges ! 483: // if (!leftclipped) ! 484: movl C(r_leftclipped),%eax ! 485: movl C(r_pedge),%ecx ! 486: testl %eax,%eax ! 487: jnz Ldone ! 488: ! 489: // r_pedge->framecount = r_framecount; ! 490: movl C(r_framecount),%eax ! 491: andl $(FRAMECOUNT_MASK),%eax ! 492: orl $(FULLY_CLIPPED_CACHED),%eax ! 493: movl %eax,C(cacheoffset) ! 494: ! 495: // return; ! 496: jmp Ldone ! 497: ! 498: // } ! 499: ! 500: Lp1: ! 501: ! 502: // // point 0 is unclipped ! 503: // if (d1 >= 0) ! 504: // { ! 505: // // both points are unclipped ! 506: // continue; ! 507: ! 508: // // only point 1 is clipped ! 509: ! 510: // f = d0 / (d0 - d1); ! 511: flds Ld0 ! 512: flds Ld1 ! 513: fsubr %st(1),%st(0) ! 514: ! 515: // // we don't cache partially clipped edges ! 516: movl $0x7FFFFFFF,C(cacheoffset) ! 517: ! 518: fdivrp %st(0),%st(1) ! 519: ! 520: subl $(mv_size),%esp // allocate space for clipvert ! 521: ! 522: // clipvert.position[0] = pv0->position[0] + ! 523: // f * (pv1->position[0] - pv0->position[0]); ! 524: // clipvert.position[1] = pv0->position[1] + ! 525: // f * (pv1->position[1] - pv0->position[1]); ! 526: // clipvert.position[2] = pv0->position[2] + ! 527: // f * (pv1->position[2] - pv0->position[2]); ! 528: flds mv_position+8(%edx) ! 529: fsubs mv_position+8(%esi) ! 530: flds mv_position+4(%edx) ! 531: fsubs mv_position+4(%esi) ! 532: flds mv_position+0(%edx) ! 533: fsubs mv_position+0(%esi) // 0 | 1 | 2 ! 534: ! 535: // replace pv1 with the clip point ! 536: movl %esp,%edx ! 537: movl cp_leftedge(%ebx),%eax ! 538: testb %al,%al ! 539: ! 540: fmul %st(3),%st(0) ! 541: fxch %st(1) // 1 | 0 | 2 ! 542: fmul %st(3),%st(0) ! 543: fxch %st(2) // 2 | 0 | 1 ! 544: fmulp %st(0),%st(3) // 0 | 1 | 2 ! 545: fadds mv_position+0(%esi) ! 546: fxch %st(1) // 1 | 0 | 2 ! 547: fadds mv_position+4(%esi) ! 548: fxch %st(2) // 2 | 0 | 1 ! 549: fadds mv_position+8(%esi) ! 550: fxch %st(1) // 0 | 2 | 1 ! 551: fstps mv_position+0(%esp) // 2 | 1 ! 552: fstps mv_position+8(%esp) // 1 ! 553: fstps mv_position+4(%esp) ! 554: ! 555: // if (clip->leftedge) ! 556: // { ! 557: jz Ltestright ! 558: ! 559: // r_leftclipped = true; ! 560: // r_leftexit = clipvert; ! 561: movl $1,C(r_leftclipped) ! 562: movl mv_position+0(%esp),%eax ! 563: movl %eax,C(r_leftexit)+mv_position+0 ! 564: movl mv_position+4(%esp),%eax ! 565: movl %eax,C(r_leftexit)+mv_position+4 ! 566: movl mv_position+8(%esp),%eax ! 567: movl %eax,C(r_leftexit)+mv_position+8 ! 568: ! 569: jmp Lcontinue ! 570: ! 571: // } ! 572: ! 573: Ltestright: ! 574: // else if (clip->rightedge) ! 575: // { ! 576: testb %ah,%ah ! 577: jz Lcontinue ! 578: ! 579: // r_rightclipped = true; ! 580: // r_rightexit = clipvert; ! 581: movl $1,C(r_rightclipped) ! 582: movl mv_position+0(%esp),%eax ! 583: movl %eax,C(r_rightexit)+mv_position+0 ! 584: movl mv_position+4(%esp),%eax ! 585: movl %eax,C(r_rightexit)+mv_position+4 ! 586: movl mv_position+8(%esp),%eax ! 587: movl %eax,C(r_rightexit)+mv_position+8 ! 588: ! 589: // } ! 590: // ! 591: // R_ClipEdge (pv0, &clipvert, clip->next); ! 592: // return; ! 593: // } ! 594: jmp Lcontinue ! 595: ! 596: // } ! 597: ! 598: Lp3: ! 599: ! 600: // // only point 0 is clipped ! 601: // r_lastvertvalid = false; ! 602: ! 603: movl $0,C(r_lastvertvalid) ! 604: ! 605: // f = d0 / (d0 - d1); ! 606: flds Ld0 ! 607: flds Ld1 ! 608: fsubr %st(1),%st(0) ! 609: ! 610: // // we don't cache partially clipped edges ! 611: movl $0x7FFFFFFF,C(cacheoffset) ! 612: ! 613: fdivrp %st(0),%st(1) ! 614: ! 615: subl $(mv_size),%esp // allocate space for clipvert ! 616: ! 617: // clipvert.position[0] = pv0->position[0] + ! 618: // f * (pv1->position[0] - pv0->position[0]); ! 619: // clipvert.position[1] = pv0->position[1] + ! 620: // f * (pv1->position[1] - pv0->position[1]); ! 621: // clipvert.position[2] = pv0->position[2] + ! 622: // f * (pv1->position[2] - pv0->position[2]); ! 623: flds mv_position+8(%edx) ! 624: fsubs mv_position+8(%esi) ! 625: flds mv_position+4(%edx) ! 626: fsubs mv_position+4(%esi) ! 627: flds mv_position+0(%edx) ! 628: fsubs mv_position+0(%esi) // 0 | 1 | 2 ! 629: ! 630: movl cp_leftedge(%ebx),%eax ! 631: testb %al,%al ! 632: ! 633: fmul %st(3),%st(0) ! 634: fxch %st(1) // 1 | 0 | 2 ! 635: fmul %st(3),%st(0) ! 636: fxch %st(2) // 2 | 0 | 1 ! 637: fmulp %st(0),%st(3) // 0 | 1 | 2 ! 638: fadds mv_position+0(%esi) ! 639: fxch %st(1) // 1 | 0 | 2 ! 640: fadds mv_position+4(%esi) ! 641: fxch %st(2) // 2 | 0 | 1 ! 642: fadds mv_position+8(%esi) ! 643: fxch %st(1) // 0 | 2 | 1 ! 644: fstps mv_position+0(%esp) // 2 | 1 ! 645: fstps mv_position+8(%esp) // 1 ! 646: fstps mv_position+4(%esp) ! 647: ! 648: // replace pv0 with the clip point ! 649: movl %esp,%esi ! 650: ! 651: // if (clip->leftedge) ! 652: // { ! 653: jz Ltestright2 ! 654: ! 655: // r_leftclipped = true; ! 656: // r_leftenter = clipvert; ! 657: movl $1,C(r_leftclipped) ! 658: movl mv_position+0(%esp),%eax ! 659: movl %eax,C(r_leftenter)+mv_position+0 ! 660: movl mv_position+4(%esp),%eax ! 661: movl %eax,C(r_leftenter)+mv_position+4 ! 662: movl mv_position+8(%esp),%eax ! 663: movl %eax,C(r_leftenter)+mv_position+8 ! 664: ! 665: jmp Lcontinue ! 666: ! 667: // } ! 668: ! 669: Ltestright2: ! 670: // else if (clip->rightedge) ! 671: // { ! 672: testb %ah,%ah ! 673: jz Lcontinue ! 674: ! 675: // r_rightclipped = true; ! 676: // r_rightenter = clipvert; ! 677: movl $1,C(r_rightclipped) ! 678: movl mv_position+0(%esp),%eax ! 679: movl %eax,C(r_rightenter)+mv_position+0 ! 680: movl mv_position+4(%esp),%eax ! 681: movl %eax,C(r_rightenter)+mv_position+4 ! 682: movl mv_position+8(%esp),%eax ! 683: movl %eax,C(r_rightenter)+mv_position+8 ! 684: ! 685: // } ! 686: jmp Lcontinue ! 687: ! 688: // %esi = vec3_t point to transform and project ! 689: // %edx preserved ! 690: LTransformAndProject: ! 691: ! 692: // // transform and project ! 693: // VectorSubtract (world, modelorg, local); ! 694: flds mv_position+0(%esi) ! 695: fsubs C(modelorg)+0 ! 696: flds mv_position+4(%esi) ! 697: fsubs C(modelorg)+4 ! 698: flds mv_position+8(%esi) ! 699: fsubs C(modelorg)+8 ! 700: fxch %st(2) // local[0] | local[1] | local[2] ! 701: ! 702: // TransformVector (local, transformed); ! 703: // ! 704: // if (transformed[2] < NEAR_CLIP) ! 705: // transformed[2] = NEAR_CLIP; ! 706: // ! 707: // lzi0 = 1.0 / transformed[2]; ! 708: fld %st(0) // local[0] | local[0] | local[1] | local[2] ! 709: fmuls C(vpn)+0 // zm0 | local[0] | local[1] | local[2] ! 710: fld %st(1) // local[0] | zm0 | local[0] | local[1] | ! 711: // local[2] ! 712: fmuls C(vright)+0 // xm0 | zm0 | local[0] | local[1] | local[2] ! 713: fxch %st(2) // local[0] | zm0 | xm0 | local[1] | local[2] ! 714: fmuls C(vup)+0 // ym0 | zm0 | xm0 | local[1] | local[2] ! 715: fld %st(3) // local[1] | ym0 | zm0 | xm0 | local[1] | ! 716: // local[2] ! 717: fmuls C(vpn)+4 // zm1 | ym0 | zm0 | xm0 | local[1] | ! 718: // local[2] ! 719: fld %st(4) // local[1] | zm1 | ym0 | zm0 | xm0 | ! 720: // local[1] | local[2] ! 721: fmuls C(vright)+4 // xm1 | zm1 | ym0 | zm0 | xm0 | ! 722: // local[1] | local[2] ! 723: fxch %st(5) // local[1] | zm1 | ym0 | zm0 | xm0 | ! 724: // xm1 | local[2] ! 725: fmuls C(vup)+4 // ym1 | zm1 | ym0 | zm0 | xm0 | ! 726: // xm1 | local[2] ! 727: fxch %st(1) // zm1 | ym1 | ym0 | zm0 | xm0 | ! 728: // xm1 | local[2] ! 729: faddp %st(0),%st(3) // ym1 | ym0 | zm2 | xm0 | xm1 | local[2] ! 730: fxch %st(3) // xm0 | ym0 | zm2 | ym1 | xm1 | local[2] ! 731: faddp %st(0),%st(4) // ym0 | zm2 | ym1 | xm2 | local[2] ! 732: faddp %st(0),%st(2) // zm2 | ym2 | xm2 | local[2] ! 733: fld %st(3) // local[2] | zm2 | ym2 | xm2 | local[2] ! 734: fmuls C(vpn)+8 // zm3 | zm2 | ym2 | xm2 | local[2] ! 735: fld %st(4) // local[2] | zm3 | zm2 | ym2 | xm2 | local[2] ! 736: fmuls C(vright)+8 // xm3 | zm3 | zm2 | ym2 | xm2 | local[2] ! 737: fxch %st(5) // local[2] | zm3 | zm2 | ym2 | xm2 | xm3 ! 738: fmuls C(vup)+8 // ym3 | zm3 | zm2 | ym2 | xm2 | xm3 ! 739: fxch %st(1) // zm3 | ym3 | zm2 | ym2 | xm2 | xm3 ! 740: faddp %st(0),%st(2) // ym3 | zm4 | ym2 | xm2 | xm3 ! 741: fxch %st(4) // xm3 | zm4 | ym2 | xm2 | ym3 ! 742: faddp %st(0),%st(3) // zm4 | ym2 | xm4 | ym3 ! 743: fxch %st(1) // ym2 | zm4 | xm4 | ym3 ! 744: faddp %st(0),%st(3) // zm4 | xm4 | ym4 ! 745: ! 746: fcoms Lfp_near_clip ! 747: fnstsw %ax ! 748: testb $1,%ah ! 749: jz LNoClip ! 750: fstp %st(0) ! 751: flds Lfp_near_clip ! 752: ! 753: LNoClip: ! 754: ! 755: fdivrs float_1 // lzi0 | x | y ! 756: fxch %st(1) // x | lzi0 | y ! 757: ! 758: // // FIXME: build x/yscale into transform? ! 759: // scale = xscale * lzi0; ! 760: // u0 = (xcenter + scale*transformed[0]); ! 761: flds C(xscale) // xscale | x | lzi0 | y ! 762: fmul %st(2),%st(0) // scale | x | lzi0 | y ! 763: fmulp %st(0),%st(1) // scale*x | lzi0 | y ! 764: fadds C(xcenter) // u0 | lzi0 | y ! 765: ! 766: // if (u0 < r_refdef.fvrectx_adj) ! 767: // u0 = r_refdef.fvrectx_adj; ! 768: // if (u0 > r_refdef.fvrectright_adj) ! 769: // u0 = r_refdef.fvrectright_adj; ! 770: // FIXME: use integer compares of floats? ! 771: fcoms C(r_refdef)+rd_fvrectx_adj ! 772: fnstsw %ax ! 773: testb $1,%ah ! 774: jz LClampP0 ! 775: fstp %st(0) ! 776: flds C(r_refdef)+rd_fvrectx_adj ! 777: LClampP0: ! 778: fcoms C(r_refdef)+rd_fvrectright_adj ! 779: fnstsw %ax ! 780: testb $0x45,%ah ! 781: jnz LClampP1 ! 782: fstp %st(0) ! 783: flds C(r_refdef)+rd_fvrectright_adj ! 784: LClampP1: ! 785: ! 786: fld %st(1) // lzi0 | u0 | lzi0 | y ! 787: ! 788: // scale = yscale * lzi0; ! 789: // v0 = (ycenter - scale*transformed[1]); ! 790: fmuls C(yscale) // scale | u0 | lzi0 | y ! 791: fmulp %st(0),%st(3) // u0 | lzi0 | scale*y ! 792: fxch %st(2) // scale*y | lzi0 | u0 ! 793: fsubrs C(ycenter) // v0 | lzi0 | u0 ! 794: ! 795: // if (v0 < r_refdef.fvrecty_adj) ! 796: // v0 = r_refdef.fvrecty_adj; ! 797: // if (v0 > r_refdef.fvrectbottom_adj) ! 798: // v0 = r_refdef.fvrectbottom_adj; ! 799: // FIXME: use integer compares of floats? ! 800: fcoms C(r_refdef)+rd_fvrecty_adj ! 801: fnstsw %ax ! 802: testb $1,%ah ! 803: jz LClampP2 ! 804: fstp %st(0) ! 805: flds C(r_refdef)+rd_fvrecty_adj ! 806: LClampP2: ! 807: fcoms C(r_refdef)+rd_fvrectbottom_adj ! 808: fnstsw %ax ! 809: testb $0x45,%ah ! 810: jnz LClampP3 ! 811: fstp %st(0) ! 812: flds C(r_refdef)+rd_fvrectbottom_adj ! 813: LClampP3: ! 814: ret ! 815: ! 816: #endif // id386 ! 817:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.