r_drawa.asm

Quake 2 Source code for students by Theerthan You can also download from idsoftwares.com

 jz LDoFirst	
 cmp ds:dword ptr[et_u+esi],eax	
 jl LNotFirst	
LDoFirst:	

;		edge->next = newedges[v];
;		newedges[v] = edge;
 mov ds:dword ptr[et_next+edi],esi	
 mov ds:dword ptr[_newedges+ebx*4],edi	

 jmp LSetRemove	

;	}

LNotFirst:	

;	else
;	{
;		pcheck = newedges[v];
;
;		while (pcheck->next && pcheck->next->u < u_check)
;			pcheck = pcheck->next;
LFindInsertLoop:	
 mov edx,esi	
 mov esi,ds:dword ptr[et_next+esi]	
 test esi,esi	
 jz LInsertFound	
 cmp ds:dword ptr[et_u+esi],eax	
 jl LFindInsertLoop	

LInsertFound:	

;		edge->next = pcheck->next;
;		pcheck->next = edge;
 mov ds:dword ptr[et_next+edi],esi	
 mov ds:dword ptr[et_next+edx],edi	

;	}

LSetRemove:	

;	edge->nextremove = removeedges[v2];
;	removeedges[v2] = edge;
 mov eax,ds:dword ptr[_removeedges+ecx*4]	
 mov ds:dword ptr[_removeedges+ecx*4],edi	
 mov ds:dword ptr[et_nextremove+edi],eax	

Ldone:	
 mov esp,ds:dword ptr[Lstack]	; clear temporary variables from stack

 pop ebx	; restore register variables
 pop edi	
 pop esi	
 ret	

; at least one point is clipped

Lp2:	
 test eax,eax	
 jns Lp1	

;			else
;			{
;			// point 0 is clipped

;				if (d1 < 0)
;				{
 mov eax,ds:dword ptr[Ld1]	
 test eax,eax	
 jns Lp3	

;				// both points are clipped
;				// we do cache fully clipped edges
;					if (!leftclipped)
 mov eax,ds:dword ptr[_r_leftclipped]	
 mov ecx,ds:dword ptr[_r_pedge]	
 test eax,eax	
 jnz Ldone	

;						r_pedge->framecount = r_framecount;
 mov eax,ds:dword ptr[_r_framecount]	
 and eax,offset FRAMECOUNT_MASK	
 or eax,offset FULLY_CLIPPED_CACHED	
 mov ds:dword ptr[_cacheoffset],eax	

;					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);
 fld ds:dword ptr[Ld0]	
 fld ds:dword ptr[Ld1]	
 fsubr st(0),st(1)	

;			// we don't cache partially clipped edges
 mov ds:dword ptr[_cacheoffset],07FFFFFFFh	

 fdivp st(1),st(0)	

 sub esp,offset mv_size	; 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]);
 fld ds:dword ptr[mv_position+8+edx]	
 fsub ds:dword ptr[mv_position+8+esi]	
 fld ds:dword ptr[mv_position+4+edx]	
 fsub ds:dword ptr[mv_position+4+esi]	
 fld ds:dword ptr[mv_position+0+edx]	
 fsub ds:dword ptr[mv_position+0+esi]	; 0 | 1 | 2

; replace pv1 with the clip point
 mov edx,esp	
 mov eax,ds:dword ptr[cp_leftedge+ebx]	
 test al,al	

 fmul st(0),st(3)	
 fxch st(1)	; 1 | 0 | 2
 fmul st(0),st(3)	
 fxch st(2)	; 2 | 0 | 1
 fmulp st(3),st(0)	; 0 | 1 | 2
 fadd ds:dword ptr[mv_position+0+esi]	
 fxch st(1)	; 1 | 0 | 2
 fadd ds:dword ptr[mv_position+4+esi]	
 fxch st(2)	; 2 | 0 | 1
 fadd ds:dword ptr[mv_position+8+esi]	
 fxch st(1)	; 0 | 2 | 1
 fstp ds:dword ptr[mv_position+0+esp]	; 2 | 1
 fstp ds:dword ptr[mv_position+8+esp]	; 1
 fstp ds:dword ptr[mv_position+4+esp]	

;				if (clip->leftedge)
;				{
 jz Ltestright	

;					r_leftclipped = true;
;					r_leftexit = clipvert;
 mov ds:dword ptr[_r_leftclipped],1	
 mov eax,ds:dword ptr[mv_position+0+esp]	
 mov ds:dword ptr[_r_leftexit+mv_position+0],eax	
 mov eax,ds:dword ptr[mv_position+4+esp]	
 mov ds:dword ptr[_r_leftexit+mv_position+4],eax	
 mov eax,ds:dword ptr[mv_position+8+esp]	
 mov ds:dword ptr[_r_leftexit+mv_position+8],eax	

 jmp Lcontinue	

;				}

Ltestright:	
;				else if (clip->rightedge)
;				{
 test ah,ah	
 jz Lcontinue	

;					r_rightclipped = true;
;					r_rightexit = clipvert;
 mov ds:dword ptr[_r_rightclipped],1	
 mov eax,ds:dword ptr[mv_position+0+esp]	
 mov ds:dword ptr[_r_rightexit+mv_position+0],eax	
 mov eax,ds:dword ptr[mv_position+4+esp]	
 mov ds:dword ptr[_r_rightexit+mv_position+4],eax	
 mov eax,ds:dword ptr[mv_position+8+esp]	
 mov ds:dword ptr[_r_rightexit+mv_position+8],eax	

;				}
;
;				R_ClipEdge (pv0, &clipvert, clip->next);
;				return;
;			}
 jmp Lcontinue	

;			}

Lp3:	

;			// only point 0 is clipped
;				r_lastvertvalid = false;

 mov ds:dword ptr[_r_lastvertvalid],0	

;				f = d0 / (d0 - d1);
 fld ds:dword ptr[Ld0]	
 fld ds:dword ptr[Ld1]	
 fsubr st(0),st(1)	

;			// we don't cache partially clipped edges
 mov ds:dword ptr[_cacheoffset],07FFFFFFFh	

 fdivp st(1),st(0)	

 sub esp,offset mv_size	; 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]);
 fld ds:dword ptr[mv_position+8+edx]	
 fsub ds:dword ptr[mv_position+8+esi]	
 fld ds:dword ptr[mv_position+4+edx]	
 fsub ds:dword ptr[mv_position+4+esi]	
 fld ds:dword ptr[mv_position+0+edx]	
 fsub ds:dword ptr[mv_position+0+esi]	; 0 | 1 | 2

 mov eax,ds:dword ptr[cp_leftedge+ebx]	
 test al,al	

 fmul st(0),st(3)	
 fxch st(1)	; 1 | 0 | 2
 fmul st(0),st(3)	
 fxch st(2)	; 2 | 0 | 1
 fmulp st(3),st(0)	; 0 | 1 | 2
 fadd ds:dword ptr[mv_position+0+esi]	
 fxch st(1)	; 1 | 0 | 2
 fadd ds:dword ptr[mv_position+4+esi]	
 fxch st(2)	; 2 | 0 | 1
 fadd ds:dword ptr[mv_position+8+esi]	
 fxch st(1)	; 0 | 2 | 1
 fstp ds:dword ptr[mv_position+0+esp]	; 2 | 1
 fstp ds:dword ptr[mv_position+8+esp]	; 1
 fstp ds:dword ptr[mv_position+4+esp]	

; replace pv0 with the clip point
 mov esi,esp	

;				if (clip->leftedge)
;				{
 jz Ltestright2	

;					r_leftclipped = true;
;					r_leftenter = clipvert;
 mov ds:dword ptr[_r_leftclipped],1	
 mov eax,ds:dword ptr[mv_position+0+esp]	
 mov ds:dword ptr[_r_leftenter+mv_position+0],eax	
 mov eax,ds:dword ptr[mv_position+4+esp]	
 mov ds:dword ptr[_r_leftenter+mv_position+4],eax	
 mov eax,ds:dword ptr[mv_position+8+esp]	
 mov ds:dword ptr[_r_leftenter+mv_position+8],eax	

 jmp Lcontinue	

;				}

Ltestright2:	
;				else if (clip->rightedge)
;				{
 test ah,ah	
 jz Lcontinue	

;					r_rightclipped = true;
;					r_rightenter = clipvert;
 mov ds:dword ptr[_r_rightclipped],1	
 mov eax,ds:dword ptr[mv_position+0+esp]	
 mov ds:dword ptr[_r_rightenter+mv_position+0],eax	
 mov eax,ds:dword ptr[mv_position+4+esp]	
 mov ds:dword ptr[_r_rightenter+mv_position+4],eax	
 mov eax,ds:dword ptr[mv_position+8+esp]	
 mov ds:dword ptr[_r_rightenter+mv_position+8],eax	

;				}
 jmp Lcontinue	

; %esi = vec3_t point to transform and project
; %edx preserved
LTransformAndProject:	

;	// transform and project
;		VectorSubtract (world, modelorg, local);
 fld ds:dword ptr[mv_position+0+esi]	
 fsub ds:dword ptr[_modelorg+0]	
 fld ds:dword ptr[mv_position+4+esi]	
 fsub ds:dword ptr[_modelorg+4]	
 fld ds:dword ptr[mv_position+8+esi]	
 fsub ds:dword ptr[_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]
 fmul ds:dword ptr[_vpn+0]	; zm0 | local[0] | local[1] | local[2]
 fld st(1)	; local[0] | zm0 | local[0] | local[1] |
;  local[2]
 fmul ds:dword ptr[_vright+0]	; xm0 | zm0 | local[0] | local[1] | local[2]
 fxch st(2)	; local[0] | zm0 | xm0 | local[1] | local[2]
 fmul ds:dword ptr[_vup+0]	; ym0 |  zm0 | xm0 | local[1] | local[2]
 fld st(3)	; local[1] | ym0 |  zm0 | xm0 | local[1] |
;  local[2]
 fmul ds:dword ptr[_vpn+4]	; zm1 | ym0 | zm0 | xm0 | local[1] |
;  local[2]
 fld st(4)	; local[1] | zm1 | ym0 | zm0 | xm0 |
;  local[1] | local[2]
 fmul ds:dword ptr[_vright+4]	; xm1 | zm1 | ym0 |  zm0 | xm0 |
;  local[1] | local[2]
 fxch st(5)	; local[1] | zm1 | ym0 | zm0 | xm0 |
;  xm1 | local[2]
 fmul ds:dword ptr[_vup+4]	; ym1 | zm1 | ym0 | zm0 | xm0 |
;  xm1 | local[2]
 fxch st(1)	; zm1 | ym1 | ym0 | zm0 | xm0 |
;  xm1 | local[2]
 faddp st(3),st(0)	; ym1 | ym0 | zm2 | xm0 | xm1 | local[2]
 fxch st(3)	; xm0 | ym0 | zm2 | ym1 | xm1 | local[2]
 faddp st(4),st(0)	; ym0 | zm2 | ym1 | xm2 | local[2]
 faddp st(2),st(0)	; zm2 | ym2 | xm2 | local[2]
 fld st(3)	; local[2] | zm2 | ym2 | xm2 | local[2]
 fmul ds:dword ptr[_vpn+8]	; zm3 | zm2 | ym2 | xm2 | local[2]
 fld st(4)	; local[2] | zm3 | zm2 | ym2 | xm2 | local[2]
 fmul ds:dword ptr[_vright+8]	; xm3 | zm3 | zm2 | ym2 | xm2 | local[2]
 fxch st(5)	; local[2] | zm3 | zm2 | ym2 | xm2 | xm3
 fmul ds:dword ptr[_vup+8]	; ym3 | zm3 | zm2 | ym2 | xm2 | xm3
 fxch st(1)	; zm3 | ym3 | zm2 | ym2 | xm2 | xm3
 faddp st(2),st(0)	; ym3 | zm4 | ym2 | xm2 | xm3
 fxch st(4)	; xm3 | zm4 | ym2 | xm2 | ym3
 faddp st(3),st(0)	; zm4 | ym2 | xm4 | ym3
 fxch st(1)	; ym2 | zm4 | xm4 | ym3
 faddp st(3),st(0)	; zm4 | xm4 | ym4

 fcom ds:dword ptr[Lfp_near_clip]	
 fnstsw ax	
 test ah,1	
 jz LNoClip	
 fstp st(0)	
 fld ds:dword ptr[Lfp_near_clip]	

LNoClip:	

 fdivr ds:dword ptr[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]);
 fld ds:dword ptr[_xscale]	; xscale | x | lzi0 | y
 fmul st(0),st(2)	; scale | x | lzi0 | y
 fmulp st(1),st(0)	; scale*x | lzi0 | y
 fadd ds:dword ptr[_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?
 fcom ds:dword ptr[_r_refdef+rd_fvrectx_adj]	
 fnstsw ax	
 test ah,1	
 jz LClampP0	
 fstp st(0)	
 fld ds:dword ptr[_r_refdef+rd_fvrectx_adj]	
LClampP0:	
 fcom ds:dword ptr[_r_refdef+rd_fvrectright_adj]	
 fnstsw ax	
 test ah,045h	
 jnz LClampP1	
 fstp st(0)	
 fld ds:dword ptr[_r_refdef+rd_fvrectright_adj]	
LClampP1:	

 fld st(1)	; lzi0 | u0 | lzi0 | y

;		scale = yscale * lzi0;
;		v0 = (ycenter - scale*transformed[1]);
 fmul ds:dword ptr[_yscale]	; scale | u0 | lzi0 | y
 fmulp st(3),st(0)	; u0 | lzi0 | scale*y
 fxch st(2)	; scale*y | lzi0 | u0
 fsubr ds:dword ptr[_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?
 fcom ds:dword ptr[_r_refdef+rd_fvrecty_adj]	
 fnstsw ax	
 test ah,1	
 jz LClampP2	
 fstp st(0)	
 fld ds:dword ptr[_r_refdef+rd_fvrecty_adj]	
LClampP2:	
 fcom ds:dword ptr[_r_refdef+rd_fvrectbottom_adj]	
 fnstsw ax	
 test ah,045h	
 jnz LClampP3	
 fstp st(0)	
 fld ds:dword ptr[_r_refdef+rd_fvrectbottom_adj]	
LClampP3:	
 ret	


_TEXT ENDS
endif	;id386
 END