| 0,0 → 1,838 |
|---|
| /* |
| Copyright (C) 1996-1997 Id Software, Inc. |
| |
| This program is free software; you can redistribute it and/or |
| modify it under the terms of the GNU General Public License |
| as published by the Free Software Foundation; either version 2 |
| of the License, or (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| |
| See the GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| |
| */ |
| // |
| // r_drawa.s |
| // x86 assembly-language edge clipping and emission code |
| // |
| |
| #include "asm_i386.h" |
| #include "quakeasm.h" |
| #include "asm_draw.h" |
| #include "d_ifacea.h" |
| |
| #if id386 |
| |
| // !!! if these are changed, they must be changed in r_draw.c too !!! |
| #define FULLY_CLIPPED_CACHED 0x80000000 |
| #define FRAMECOUNT_MASK 0x7FFFFFFF |
| |
| .data |
| |
| Ld0: .single 0.0 |
| Ld1: .single 0.0 |
| Lstack: .long 0 |
| Lfp_near_clip: .single NEAR_CLIP |
| Lceilv0: .long 0 |
| Lv: .long 0 |
| Lu0: .long 0 |
| Lv0: .long 0 |
| Lzi0: .long 0 |
| |
| .text |
| |
| //---------------------------------------------------------------------- |
| // edge clipping code |
| //---------------------------------------------------------------------- |
| |
| #define pv0 4+12 |
| #define pv1 8+12 |
| #define clip 12+12 |
| |
| .align 4 |
| .globl C(R_ClipEdge) |
| C(R_ClipEdge): |
| pushl %esi // preserve register variables |
| pushl %edi |
| pushl %ebx |
| movl %esp,Lstack // for clearing the stack later |
| |
| // float d0, d1, f; |
| // mvertex_t clipvert; |
| |
| movl clip(%esp),%ebx |
| movl pv0(%esp),%esi |
| movl pv1(%esp),%edx |
| |
| // if (clip) |
| // { |
| testl %ebx,%ebx |
| jz Lemit |
| |
| // do |
| // { |
| |
| Lcliploop: |
| |
| // d0 = DotProduct (pv0->position, clip->normal) - clip->dist; |
| // d1 = DotProduct (pv1->position, clip->normal) - clip->dist; |
| flds mv_position+0(%esi) |
| fmuls cp_normal+0(%ebx) |
| flds mv_position+4(%esi) |
| fmuls cp_normal+4(%ebx) |
| flds mv_position+8(%esi) |
| fmuls cp_normal+8(%ebx) |
| fxch %st(1) |
| faddp %st(0),%st(2) // d0mul2 | d0add0 |
| |
| flds mv_position+0(%edx) |
| fmuls cp_normal+0(%ebx) |
| flds mv_position+4(%edx) |
| fmuls cp_normal+4(%ebx) |
| flds mv_position+8(%edx) |
| fmuls cp_normal+8(%ebx) |
| fxch %st(1) |
| faddp %st(0),%st(2) // d1mul2 | d1add0 | d0mul2 | d0add0 |
| fxch %st(3) // d0add0 | d1add0 | d0mul2 | d1mul2 |
| |
| faddp %st(0),%st(2) // d1add0 | dot0 | d1mul2 |
| faddp %st(0),%st(2) // dot0 | dot1 |
| |
| fsubs cp_dist(%ebx) // d0 | dot1 |
| fxch %st(1) // dot1 | d0 |
| fsubs cp_dist(%ebx) // d1 | d0 |
| fxch %st(1) |
| fstps Ld0 |
| fstps Ld1 |
| |
| // if (d0 >= 0) |
| // { |
| movl Ld0,%eax |
| movl Ld1,%ecx |
| orl %eax,%ecx |
| js Lp2 |
| |
| // both points are unclipped |
| |
| Lcontinue: |
| |
| // |
| // R_ClipEdge (&clipvert, pv1, clip->next); |
| // return; |
| // } |
| // } while ((clip = clip->next) != NULL); |
| movl cp_next(%ebx),%ebx |
| testl %ebx,%ebx |
| jnz Lcliploop |
| |
| // } |
| |
| //// add the edge |
| // R_EmitEdge (pv0, pv1); |
| Lemit: |
| |
| // |
| // set integer rounding to ceil mode, set to single precision |
| // |
| // FIXME: do away with by manually extracting integers from floats? |
| // FIXME: set less often |
| fldcw ceil_cw |
| |
| // edge_t *edge, *pcheck; |
| // int u_check; |
| // float u, u_step; |
| // vec3_t local, transformed; |
| // float *world; |
| // int v, v2, ceilv0; |
| // float scale, lzi0, u0, v0; |
| // int side; |
| |
| // if (r_lastvertvalid) |
| // { |
| cmpl $0,C(r_lastvertvalid) |
| jz LCalcFirst |
| |
| // u0 = r_u1; |
| // v0 = r_v1; |
| // lzi0 = r_lzi1; |
| // ceilv0 = r_ceilv1; |
| movl C(r_lzi1),%eax |
| movl C(r_u1),%ecx |
| movl %eax,Lzi0 |
| movl %ecx,Lu0 |
| movl C(r_v1),%ecx |
| movl C(r_ceilv1),%eax |
| movl %ecx,Lv0 |
| movl %eax,Lceilv0 |
| jmp LCalcSecond |
| |
| // } |
| |
| LCalcFirst: |
| |
| // else |
| // { |
| // world = &pv0->position[0]; |
| |
| call LTransformAndProject // v0 | lzi0 | u0 |
| |
| fsts Lv0 |
| fxch %st(2) // u0 | lzi0 | v0 |
| fstps Lu0 // lzi0 | v0 |
| fstps Lzi0 // v0 |
| |
| // ceilv0 = (int)(v0 - 2000) + 2000; // ceil(v0); |
| fistpl Lceilv0 |
| |
| // } |
| |
| LCalcSecond: |
| |
| // world = &pv1->position[0]; |
| movl %edx,%esi |
| |
| call LTransformAndProject // v1 | lzi1 | u1 |
| |
| flds Lu0 // u0 | v1 | lzi1 | u1 |
| fxch %st(3) // u1 | v1 | lzi1 | u0 |
| flds Lzi0 // lzi0 | u1 | v1 | lzi1 | u0 |
| fxch %st(3) // lzi1 | u1 | v1 | lzi0 | u0 |
| flds Lv0 // v0 | lzi1 | u1 | v1 | lzi0 | u0 |
| fxch %st(3) // v1 | lzi1 | u1 | v0 | lzi0 | u0 |
| |
| // r_ceilv1 = (int)(r_v1 - 2000) + 2000; // ceil(r_v1); |
| fistl C(r_ceilv1) |
| |
| fldcw single_cw // put back normal floating-point state |
| |
| fsts C(r_v1) |
| fxch %st(4) // lzi0 | lzi1 | u1 | v0 | v1 | u0 |
| |
| // if (r_lzi1 > lzi0) |
| // lzi0 = r_lzi1; |
| fcom %st(1) |
| fnstsw %ax |
| testb $1,%ah |
| jz LP0 |
| fstp %st(0) |
| fld %st(0) |
| LP0: |
| |
| fxch %st(1) // lzi1 | lzi0 | u1 | v0 | v1 | u0 |
| fstps C(r_lzi1) // lzi0 | u1 | v0 | v1 | u0 |
| fxch %st(1) |
| fsts C(r_u1) |
| fxch %st(1) |
| |
| // if (lzi0 > r_nearzi) // for mipmap finding |
| // r_nearzi = lzi0; |
| fcoms C(r_nearzi) |
| fnstsw %ax |
| testb $0x45,%ah |
| jnz LP1 |
| fsts C(r_nearzi) |
| LP1: |
| |
| // // for right edges, all we want is the effect on 1/z |
| // if (r_nearzionly) |
| // return; |
| movl C(r_nearzionly),%eax |
| testl %eax,%eax |
| jz LP2 |
| LPop5AndDone: |
| movl C(cacheoffset),%eax |
| movl C(r_framecount),%edx |
| cmpl $0x7FFFFFFF,%eax |
| jz LDoPop |
| andl $(FRAMECOUNT_MASK),%edx |
| orl $(FULLY_CLIPPED_CACHED),%edx |
| movl %edx,C(cacheoffset) |
| |
| LDoPop: |
| fstp %st(0) // u1 | v0 | v1 | u0 |
| fstp %st(0) // v0 | v1 | u0 |
| fstp %st(0) // v1 | u0 |
| fstp %st(0) // u0 |
| fstp %st(0) |
| jmp Ldone |
| |
| LP2: |
| |
| // // create the edge |
| // if (ceilv0 == r_ceilv1) |
| // return; // horizontal edge |
| movl Lceilv0,%ebx |
| movl C(edge_p),%edi |
| movl C(r_ceilv1),%ecx |
| movl %edi,%edx |
| movl C(r_pedge),%esi |
| addl $(et_size),%edx |
| cmpl %ecx,%ebx |
| jz LPop5AndDone |
| |
| movl C(r_pedge),%eax |
| movl %eax,et_owner(%edi) |
| |
| // side = ceilv0 > r_ceilv1; |
| // |
| // edge->nearzi = lzi0; |
| fstps et_nearzi(%edi) // u1 | v0 | v1 | u0 |
| |
| // if (side == 1) |
| // { |
| jc LSide0 |
| |
| LSide1: |
| |
| // // leading edge (go from p2 to p1) |
| |
| // u_step = ((u0 - r_u1) / (v0 - r_v1)); |
| fsubrp %st(0),%st(3) // v0 | v1 | u0-u1 |
| fsub %st(1),%st(0) // v0-v1 | v1 | u0-u1 |
| fdivrp %st(0),%st(2) // v1 | ustep |
| |
| // r_emitted = 1; |
| movl $1,C(r_emitted) |
| |
| // edge = edge_p++; |
| movl %edx,C(edge_p) |
| |
| // pretouch next edge |
| movl (%edx),%eax |
| |
| // v2 = ceilv0 - 1; |
| // v = r_ceilv1; |
| movl %ecx,%eax |
| leal -1(%ebx),%ecx |
| movl %eax,%ebx |
| |
| // edge->surfs[0] = 0; |
| // edge->surfs[1] = surface_p - surfaces; |
| movl C(surface_p),%eax |
| movl C(surfaces),%esi |
| subl %edx,%edx |
| subl %esi,%eax |
| shrl $(SURF_T_SHIFT),%eax |
| movl %edx,et_surfs(%edi) |
| movl %eax,et_surfs+2(%edi) |
| |
| subl %esi,%esi |
| |
| // u = r_u1 + ((float)v - r_v1) * u_step; |
| movl %ebx,Lv |
| fildl Lv // v | v1 | ustep |
| fsubp %st(0),%st(1) // v-v1 | ustep |
| fmul %st(1),%st(0) // (v-v1)*ustep | ustep |
| fadds C(r_u1) // u | ustep |
| |
| jmp LSideDone |
| |
| // } |
| |
| LSide0: |
| |
| // else |
| // { |
| // // trailing edge (go from p1 to p2) |
| |
| // u_step = ((r_u1 - u0) / (r_v1 - v0)); |
| fsub %st(3),%st(0) // u1-u0 | v0 | v1 | u0 |
| fxch %st(2) // v1 | v0 | u1-u0 | u0 |
| fsub %st(1),%st(0) // v1-v0 | v0 | u1-u0 | u0 |
| fdivrp %st(0),%st(2) // v0 | ustep | u0 |
| |
| // r_emitted = 1; |
| movl $1,C(r_emitted) |
| |
| // edge = edge_p++; |
| movl %edx,C(edge_p) |
| |
| // pretouch next edge |
| movl (%edx),%eax |
| |
| // v = ceilv0; |
| // v2 = r_ceilv1 - 1; |
| decl %ecx |
| |
| // edge->surfs[0] = surface_p - surfaces; |
| // edge->surfs[1] = 0; |
| movl C(surface_p),%eax |
| movl C(surfaces),%esi |
| subl %edx,%edx |
| subl %esi,%eax |
| shrl $(SURF_T_SHIFT),%eax |
| movl %edx,et_surfs+2(%edi) |
| movl %eax,et_surfs(%edi) |
| |
| movl $1,%esi |
| |
| // u = u0 + ((float)v - v0) * u_step; |
| movl %ebx,Lv |
| fildl Lv // v | v0 | ustep | u0 |
| fsubp %st(0),%st(1) // v-v0 | ustep | u0 |
| fmul %st(1),%st(0) // (v-v0)*ustep | ustep | u0 |
| faddp %st(0),%st(2) // ustep | u |
| fxch %st(1) // u | ustep |
| |
| // } |
| |
| LSideDone: |
| |
| // edge->u_step = u_step*0x100000; |
| // edge->u = u*0x100000 + 0xFFFFF; |
| |
| fmuls fp_1m // u*0x100000 | ustep |
| fxch %st(1) // ustep | u*0x100000 |
| fmuls fp_1m // ustep*0x100000 | u*0x100000 |
| fxch %st(1) // u*0x100000 | ustep*0x100000 |
| fadds fp_1m_minus_1 // u*0x100000 + 0xFFFFF | ustep*0x100000 |
| fxch %st(1) // ustep*0x100000 | u*0x100000 + 0xFFFFF |
| fistpl et_u_step(%edi) // u*0x100000 + 0xFFFFF |
| fistpl et_u(%edi) |
| |
| // // we need to do this to avoid stepping off the edges if a very nearly |
| // // horizontal edge is less than epsilon above a scan, and numeric error |
| // // causes it to incorrectly extend to the scan, and the extension of the |
| // // line goes off the edge of the screen |
| // // FIXME: is this actually needed? |
| // if (edge->u < r_refdef.vrect_x_adj_shift20) |
| // edge->u = r_refdef.vrect_x_adj_shift20; |
| // if (edge->u > r_refdef.vrectright_adj_shift20) |
| // edge->u = r_refdef.vrectright_adj_shift20; |
| movl et_u(%edi),%eax |
| movl C(r_refdef)+rd_vrect_x_adj_shift20,%edx |
| cmpl %edx,%eax |
| jl LP4 |
| movl C(r_refdef)+rd_vrectright_adj_shift20,%edx |
| cmpl %edx,%eax |
| jng LP5 |
| LP4: |
| movl %edx,et_u(%edi) |
| movl %edx,%eax |
| LP5: |
| |
| // // sort the edge in normally |
| // u_check = edge->u; |
| // |
| // if (edge->surfs[0]) |
| // u_check++; // sort trailers after leaders |
| addl %esi,%eax |
| |
| // if (!newedges[v] || newedges[v]->u >= u_check) |
| // { |
| movl C(newedges)(,%ebx,4),%esi |
| testl %esi,%esi |
| jz LDoFirst |
| cmpl %eax,et_u(%esi) |
| jl LNotFirst |
| LDoFirst: |
| |
| // edge->next = newedges[v]; |
| // newedges[v] = edge; |
| movl %esi,et_next(%edi) |
| movl %edi,C(newedges)(,%ebx,4) |
| |
| jmp LSetRemove |
| |
| // } |
| |
| LNotFirst: |
| |
| // else |
| // { |
| // pcheck = newedges[v]; |
| // |
| // while (pcheck->next && pcheck->next->u < u_check) |
| // pcheck = pcheck->next; |
| LFindInsertLoop: |
| movl %esi,%edx |
| movl et_next(%esi),%esi |
| testl %esi,%esi |
| jz LInsertFound |
| cmpl %eax,et_u(%esi) |
| jl LFindInsertLoop |
| |
| LInsertFound: |
| |
| // edge->next = pcheck->next; |
| // pcheck->next = edge; |
| movl %esi,et_next(%edi) |
| movl %edi,et_next(%edx) |
| |
| // } |
| |
| LSetRemove: |
| |
| // edge->nextremove = removeedges[v2]; |
| // removeedges[v2] = edge; |
| movl C(removeedges)(,%ecx,4),%eax |
| movl %edi,C(removeedges)(,%ecx,4) |
| movl %eax,et_nextremove(%edi) |
| |
| Ldone: |
| movl Lstack,%esp // clear temporary variables from stack |
| |
| popl %ebx // restore register variables |
| popl %edi |
| popl %esi |
| ret |
| |
| // at least one point is clipped |
| |
| Lp2: |
| testl %eax,%eax |
| jns Lp1 |
| |
| // else |
| // { |
| // // point 0 is clipped |
| |
| // if (d1 < 0) |
| // { |
| movl Ld1,%eax |
| testl %eax,%eax |
| jns Lp3 |
| |
| // // both points are clipped |
| // // we do cache fully clipped edges |
| // if (!leftclipped) |
| movl C(r_leftclipped),%eax |
| movl C(r_pedge),%ecx |
| testl %eax,%eax |
| jnz Ldone |
| |
| // r_pedge->framecount = r_framecount; |
| movl C(r_framecount),%eax |
| andl $(FRAMECOUNT_MASK),%eax |
| orl $(FULLY_CLIPPED_CACHED),%eax |
| movl %eax,C(cacheoffset) |
| |
| // return; |
| jmp Ldone |
| |
| // } |
| |
| Lp1: |
| |
| // // point 0 is unclipped |
| // if (d1 >= 0) |
| // { |
| // // both points are unclipped |
| // continue; |
| |
| // // only point 1 is clipped |
| |
| // f = d0 / (d0 - d1); |
| flds Ld0 |
| flds Ld1 |
| fsubr %st(1),%st(0) |
| |
| // // we don't cache partially clipped edges |
| movl $0x7FFFFFFF,C(cacheoffset) |
| |
| fdivrp %st(0),%st(1) |
| |
| subl $(mv_size),%esp // allocate space for clipvert |
| |
| // clipvert.position[0] = pv0->position[0] + |
| // f * (pv1->position[0] - pv0->position[0]); |
| // clipvert.position[1] = pv0->position[1] + |
| // f * (pv1->position[1] - pv0->position[1]); |
| // clipvert.position[2] = pv0->position[2] + |
| // f * (pv1->position[2] - pv0->position[2]); |
| flds mv_position+8(%edx) |
| fsubs mv_position+8(%esi) |
| flds mv_position+4(%edx) |
| fsubs mv_position+4(%esi) |
| flds mv_position+0(%edx) |
| fsubs mv_position+0(%esi) // 0 | 1 | 2 |
| |
| // replace pv1 with the clip point |
| movl %esp,%edx |
| movl cp_leftedge(%ebx),%eax |
| testb %al,%al |
| |
| fmul %st(3),%st(0) |
| fxch %st(1) // 1 | 0 | 2 |
| fmul %st(3),%st(0) |
| fxch %st(2) // 2 | 0 | 1 |
| fmulp %st(0),%st(3) // 0 | 1 | 2 |
| fadds mv_position+0(%esi) |
| fxch %st(1) // 1 | 0 | 2 |
| fadds mv_position+4(%esi) |
| fxch %st(2) // 2 | 0 | 1 |
| fadds mv_position+8(%esi) |
| fxch %st(1) // 0 | 2 | 1 |
| fstps mv_position+0(%esp) // 2 | 1 |
| fstps mv_position+8(%esp) // 1 |
| fstps mv_position+4(%esp) |
| |
| // if (clip->leftedge) |
| // { |
| jz Ltestright |
| |
| // r_leftclipped = true; |
| // r_leftexit = clipvert; |
| movl $1,C(r_leftclipped) |
| movl mv_position+0(%esp),%eax |
| movl %eax,C(r_leftexit)+mv_position+0 |
| movl mv_position+4(%esp),%eax |
| movl %eax,C(r_leftexit)+mv_position+4 |
| movl mv_position+8(%esp),%eax |
| movl %eax,C(r_leftexit)+mv_position+8 |
| |
| jmp Lcontinue |
| |
| // } |
| |
| Ltestright: |
| // else if (clip->rightedge) |
| // { |
| testb %ah,%ah |
| jz Lcontinue |
| |
| // r_rightclipped = true; |
| // r_rightexit = clipvert; |
| movl $1,C(r_rightclipped) |
| movl mv_position+0(%esp),%eax |
| movl %eax,C(r_rightexit)+mv_position+0 |
| movl mv_position+4(%esp),%eax |
| movl %eax,C(r_rightexit)+mv_position+4 |
| movl mv_position+8(%esp),%eax |
| movl %eax,C(r_rightexit)+mv_position+8 |
| |
| // } |
| // |
| // R_ClipEdge (pv0, &clipvert, clip->next); |
| // return; |
| // } |
| jmp Lcontinue |
| |
| // } |
| |
| Lp3: |
| |
| // // only point 0 is clipped |
| // r_lastvertvalid = false; |
| |
| movl $0,C(r_lastvertvalid) |
| |
| // f = d0 / (d0 - d1); |
| flds Ld0 |
| flds Ld1 |
| fsubr %st(1),%st(0) |
| |
| // // we don't cache partially clipped edges |
| movl $0x7FFFFFFF,C(cacheoffset) |
| |
| fdivrp %st(0),%st(1) |
| |
| subl $(mv_size),%esp // allocate space for clipvert |
| |
| // clipvert.position[0] = pv0->position[0] + |
| // f * (pv1->position[0] - pv0->position[0]); |
| // clipvert.position[1] = pv0->position[1] + |
| // f * (pv1->position[1] - pv0->position[1]); |
| // clipvert.position[2] = pv0->position[2] + |
| // f * (pv1->position[2] - pv0->position[2]); |
| flds mv_position+8(%edx) |
| fsubs mv_position+8(%esi) |
| flds mv_position+4(%edx) |
| fsubs mv_position+4(%esi) |
| flds mv_position+0(%edx) |
| fsubs mv_position+0(%esi) // 0 | 1 | 2 |
| |
| movl cp_leftedge(%ebx),%eax |
| testb %al,%al |
| |
| fmul %st(3),%st(0) |
| fxch %st(1) // 1 | 0 | 2 |
| fmul %st(3),%st(0) |
| fxch %st(2) // 2 | 0 | 1 |
| fmulp %st(0),%st(3) // 0 | 1 | 2 |
| fadds mv_position+0(%esi) |
| fxch %st(1) // 1 | 0 | 2 |
| fadds mv_position+4(%esi) |
| fxch %st(2) // 2 | 0 | 1 |
| fadds mv_position+8(%esi) |
| fxch %st(1) // 0 | 2 | 1 |
| fstps mv_position+0(%esp) // 2 | 1 |
| fstps mv_position+8(%esp) // 1 |
| fstps mv_position+4(%esp) |
| |
| // replace pv0 with the clip point |
| movl %esp,%esi |
| |
| // if (clip->leftedge) |
| // { |
| jz Ltestright2 |
| |
| // r_leftclipped = true; |
| // r_leftenter = clipvert; |
| movl $1,C(r_leftclipped) |
| movl mv_position+0(%esp),%eax |
| movl %eax,C(r_leftenter)+mv_position+0 |
| movl mv_position+4(%esp),%eax |
| movl %eax,C(r_leftenter)+mv_position+4 |
| movl mv_position+8(%esp),%eax |
| movl %eax,C(r_leftenter)+mv_position+8 |
| |
| jmp Lcontinue |
| |
| // } |
| |
| Ltestright2: |
| // else if (clip->rightedge) |
| // { |
| testb %ah,%ah |
| jz Lcontinue |
| |
| // r_rightclipped = true; |
| // r_rightenter = clipvert; |
| movl $1,C(r_rightclipped) |
| movl mv_position+0(%esp),%eax |
| movl %eax,C(r_rightenter)+mv_position+0 |
| movl mv_position+4(%esp),%eax |
| movl %eax,C(r_rightenter)+mv_position+4 |
| movl mv_position+8(%esp),%eax |
| movl %eax,C(r_rightenter)+mv_position+8 |
| |
| // } |
| jmp Lcontinue |
| |
| // %esi = vec3_t point to transform and project |
| // %edx preserved |
| LTransformAndProject: |
| |
| // // transform and project |
| // VectorSubtract (world, modelorg, local); |
| flds mv_position+0(%esi) |
| fsubs C(modelorg)+0 |
| flds mv_position+4(%esi) |
| fsubs C(modelorg)+4 |
| flds mv_position+8(%esi) |
| fsubs C(modelorg)+8 |
| fxch %st(2) // local[0] | local[1] | local[2] |
| |
| // TransformVector (local, transformed); |
| // |
| // if (transformed[2] < NEAR_CLIP) |
| // transformed[2] = NEAR_CLIP; |
| // |
| // lzi0 = 1.0 / transformed[2]; |
| fld %st(0) // local[0] | local[0] | local[1] | local[2] |
| fmuls C(vpn)+0 // zm0 | local[0] | local[1] | local[2] |
| fld %st(1) // local[0] | zm0 | local[0] | local[1] | |
| // local[2] |
| fmuls C(vright)+0 // xm0 | zm0 | local[0] | local[1] | local[2] |
| fxch %st(2) // local[0] | zm0 | xm0 | local[1] | local[2] |
| fmuls C(vup)+0 // ym0 | zm0 | xm0 | local[1] | local[2] |
| fld %st(3) // local[1] | ym0 | zm0 | xm0 | local[1] | |
| // local[2] |
| fmuls C(vpn)+4 // zm1 | ym0 | zm0 | xm0 | local[1] | |
| // local[2] |
| fld %st(4) // local[1] | zm1 | ym0 | zm0 | xm0 | |
| // local[1] | local[2] |
| fmuls C(vright)+4 // xm1 | zm1 | ym0 | zm0 | xm0 | |
| // local[1] | local[2] |
| fxch %st(5) // local[1] | zm1 | ym0 | zm0 | xm0 | |
| // xm1 | local[2] |
| fmuls C(vup)+4 // ym1 | zm1 | ym0 | zm0 | xm0 | |
| // xm1 | local[2] |
| fxch %st(1) // zm1 | ym1 | ym0 | zm0 | xm0 | |
| // xm1 | local[2] |
| faddp %st(0),%st(3) // ym1 | ym0 | zm2 | xm0 | xm1 | local[2] |
| fxch %st(3) // xm0 | ym0 | zm2 | ym1 | xm1 | local[2] |
| faddp %st(0),%st(4) // ym0 | zm2 | ym1 | xm2 | local[2] |
| faddp %st(0),%st(2) // zm2 | ym2 | xm2 | local[2] |
| fld %st(3) // local[2] | zm2 | ym2 | xm2 | local[2] |
| fmuls C(vpn)+8 // zm3 | zm2 | ym2 | xm2 | local[2] |
| fld %st(4) // local[2] | zm3 | zm2 | ym2 | xm2 | local[2] |
| fmuls C(vright)+8 // xm3 | zm3 | zm2 | ym2 | xm2 | local[2] |
| fxch %st(5) // local[2] | zm3 | zm2 | ym2 | xm2 | xm3 |
| fmuls C(vup)+8 // ym3 | zm3 | zm2 | ym2 | xm2 | xm3 |
| fxch %st(1) // zm3 | ym3 | zm2 | ym2 | xm2 | xm3 |
| faddp %st(0),%st(2) // ym3 | zm4 | ym2 | xm2 | xm3 |
| fxch %st(4) // xm3 | zm4 | ym2 | xm2 | ym3 |
| faddp %st(0),%st(3) // zm4 | ym2 | xm4 | ym3 |
| fxch %st(1) // ym2 | zm4 | xm4 | ym3 |
| faddp %st(0),%st(3) // zm4 | xm4 | ym4 |
| |
| fcoms Lfp_near_clip |
| fnstsw %ax |
| testb $1,%ah |
| jz LNoClip |
| fstp %st(0) |
| flds Lfp_near_clip |
| |
| LNoClip: |
| |
| fdivrs float_1 // lzi0 | x | y |
| fxch %st(1) // x | lzi0 | y |
| |
| // // FIXME: build x/yscale into transform? |
| // scale = xscale * lzi0; |
| // u0 = (xcenter + scale*transformed[0]); |
| flds C(xscale) // xscale | x | lzi0 | y |
| fmul %st(2),%st(0) // scale | x | lzi0 | y |
| fmulp %st(0),%st(1) // scale*x | lzi0 | y |
| fadds C(xcenter) // u0 | lzi0 | y |
| |
| // if (u0 < r_refdef.fvrectx_adj) |
| // u0 = r_refdef.fvrectx_adj; |
| // if (u0 > r_refdef.fvrectright_adj) |
| // u0 = r_refdef.fvrectright_adj; |
| // FIXME: use integer compares of floats? |
| fcoms C(r_refdef)+rd_fvrectx_adj |
| fnstsw %ax |
| testb $1,%ah |
| jz LClampP0 |
| fstp %st(0) |
| flds C(r_refdef)+rd_fvrectx_adj |
| LClampP0: |
| fcoms C(r_refdef)+rd_fvrectright_adj |
| fnstsw %ax |
| testb $0x45,%ah |
| jnz LClampP1 |
| fstp %st(0) |
| flds C(r_refdef)+rd_fvrectright_adj |
| LClampP1: |
| |
| fld %st(1) // lzi0 | u0 | lzi0 | y |
| |
| // scale = yscale * lzi0; |
| // v0 = (ycenter - scale*transformed[1]); |
| fmuls C(yscale) // scale | u0 | lzi0 | y |
| fmulp %st(0),%st(3) // u0 | lzi0 | scale*y |
| fxch %st(2) // scale*y | lzi0 | u0 |
| fsubrs C(ycenter) // v0 | lzi0 | u0 |
| |
| // if (v0 < r_refdef.fvrecty_adj) |
| // v0 = r_refdef.fvrecty_adj; |
| // if (v0 > r_refdef.fvrectbottom_adj) |
| // v0 = r_refdef.fvrectbottom_adj; |
| // FIXME: use integer compares of floats? |
| fcoms C(r_refdef)+rd_fvrecty_adj |
| fnstsw %ax |
| testb $1,%ah |
| jz LClampP2 |
| fstp %st(0) |
| flds C(r_refdef)+rd_fvrecty_adj |
| LClampP2: |
| fcoms C(r_refdef)+rd_fvrectbottom_adj |
| fnstsw %ax |
| testb $0x45,%ah |
| jnz LClampP3 |
| fstp %st(0) |
| flds C(r_refdef)+rd_fvrectbottom_adj |
| LClampP3: |
| ret |
| |
| #endif // id386 |
| |