r_polysa.asm

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

 add ebx,ds:dword ptr[_a_sstepxfrac]	
 adc esi,ds:dword ptr[advancetable+4+eax*4]	

LDraw6IR:	
 cmp bp,ds:word ptr[4+ecx]	
 jl Lp3IR	
 xor eax,eax	
 mov al,ds:byte ptr[esi]	
 mov al,ds:byte ptr[_irtable+eax]
 mov ds:word ptr[4+ecx],bp	
 mov al,ds:byte ptr[12345678h+eax]	
LPatch6IR:	
 mov ds:byte ptr[2+edi],al	
Lp3IR:	
 add edx,ds:dword ptr[tstep]	
 sbb eax,eax	
 add ebp,ds:dword ptr[lzistepx]	
 adc ebp,0	
 add ebx,ds:dword ptr[_a_sstepxfrac]	
 adc esi,ds:dword ptr[advancetable+4+eax*4]	

LDraw5IR:	
 cmp bp,ds:word ptr[6+ecx]	
 jl Lp4IR
 xor eax,eax	
 mov al,ds:byte ptr[esi]	
 mov al,ds:byte ptr[_irtable+eax]
 mov ds:word ptr[6+ecx],bp	
 mov al,ds:byte ptr[12345678h+eax]	
LPatch5IR:	
 mov ds:byte ptr[3+edi],al	
Lp4IR:	
 add edx,ds:dword ptr[tstep]	
 sbb eax,eax	
 add ebp,ds:dword ptr[lzistepx]	
 adc ebp,0	
 add ebx,ds:dword ptr[_a_sstepxfrac]	
 adc esi,ds:dword ptr[advancetable+4+eax*4]	

LDraw4IR:	
 cmp bp,ds:word ptr[8+ecx]	
 jl Lp5IR
 xor eax,eax	
 mov al,ds:byte ptr[esi]	
 mov al,ds:byte ptr[_irtable+eax]
 mov ds:word ptr[8+ecx],bp	
 mov al,ds:byte ptr[12345678h+eax]	
LPatch4IR:	
 mov ds:byte ptr[4+edi],al	
Lp5IR:	
 add edx,ds:dword ptr[tstep]	
 sbb eax,eax	
 add ebp,ds:dword ptr[lzistepx]	
 adc ebp,0	
 add ebx,ds:dword ptr[_a_sstepxfrac]	
 adc esi,ds:dword ptr[advancetable+4+eax*4]	

LDraw3IR:	
 cmp bp,ds:word ptr[10+ecx]	
 jl Lp6IR	
 xor eax,eax	
 mov al,ds:byte ptr[esi]	
 mov al,ds:byte ptr[_irtable+eax]
 mov ds:word ptr[10+ecx],bp	
 mov al,ds:byte ptr[12345678h+eax]	
LPatch3IR:	
 mov ds:byte ptr[5+edi],al	
Lp6IR:	
 add edx,ds:dword ptr[tstep]	
 sbb eax,eax	
 add ebp,ds:dword ptr[lzistepx]	
 adc ebp,0	
 add ebx,ds:dword ptr[_a_sstepxfrac]	
 adc esi,ds:dword ptr[advancetable+4+eax*4]	

LDraw2IR:	
 cmp bp,ds:word ptr[12+ecx]	
 jl Lp7IR
 xor eax,eax	
 mov al,ds:byte ptr[esi]	
 mov al,ds:byte ptr[_irtable+eax]
 mov ds:word ptr[12+ecx],bp	
 mov al,ds:byte ptr[12345678h+eax]	
LPatch2IR:	
 mov ds:byte ptr[6+edi],al	
Lp7IR:	
 add edx,ds:dword ptr[tstep]	
 sbb eax,eax	
 add ebp,ds:dword ptr[lzistepx]	
 adc ebp,0	
 add ebx,ds:dword ptr[_a_sstepxfrac]	
 adc esi,ds:dword ptr[advancetable+4+eax*4]	

LDraw1IR:	
 cmp bp,ds:word ptr[14+ecx]	
 jl Lp8IR
 xor eax,eax
 mov al,ds:byte ptr[esi]	
 mov al,ds:byte ptr[_irtable+eax]
 mov ds:word ptr[14+ecx],bp	
 mov al,ds:byte ptr[12345678h+eax]	
LPatch1IR:	
 mov ds:byte ptr[7+edi],al	
Lp8IR:	
 add edx,ds:dword ptr[tstep]	
 sbb eax,eax	
 add ebp,ds:dword ptr[lzistepx]	
 adc ebp,0	
 add ebx,ds:dword ptr[_a_sstepxfrac]	
 adc esi,ds:dword ptr[advancetable+4+eax*4]	

 add edi,8	
 add ecx,16	

 dec bx	
 jnz LDrawLoopIR	

 pop esi	; restore spans pointer
LNextSpanIR:	
 add esi,offset spanpackage_t_size	; point to next span
LNextSpanESISetIR:	
 mov edx,ds:dword ptr[spanpackage_t_count+esi]	
 cmp edx,offset -999999	; any more spans?
 jnz LSpanLoop	; yes

 pop edi	
 pop ebp	; restore the caller's stack frame
 pop ebx	; restore register variables
 pop esi	
 ret	

;=======
; Standard One-Long Draw
;=======
; draw a one-long span

LExactlyOneLong:	
 mov al,[_iractive]
 cmp al,0
 jne LExactlyOneLongIR

 mov ecx,ds:dword ptr[spanpackage_t_pz+esi]	
 mov ebp,ds:dword ptr[spanpackage_t_zi+esi]	

 ror ebp,16	; put high 16 bits of 1/z in low word
 mov ebx,ds:dword ptr[spanpackage_t_ptex+esi]	

 cmp bp,ds:word ptr[ecx]	
 jl LNextSpan	
 xor eax,eax	
 mov edi,ds:dword ptr[spanpackage_t_pdest+esi]	
 mov ah,ds:byte ptr[spanpackage_t_light+1+esi]	
 add esi,offset spanpackage_t_size	; point to next span
 mov al,ds:byte ptr[ebx]	
 mov ds:word ptr[ecx],bp	
 mov al,ds:byte ptr[12345678h+eax]	
LPatch9:	
 mov ds:byte ptr[edi],al	

 jmp LNextSpanESISet	


;========
;========
; draw a one-long span

LExactlyOneLongIR:	

 mov ecx,ds:dword ptr[spanpackage_t_pz+esi]	
 mov ebp,ds:dword ptr[spanpackage_t_zi+esi]	

 ror ebp,16	; put high 16 bits of 1/z in low word
 mov ebx,ds:dword ptr[spanpackage_t_ptex+esi]	

 cmp bp,ds:word ptr[ecx]	
 jl LNextSpanIR
 xor eax,eax	
 mov edi,ds:dword ptr[spanpackage_t_pdest+esi]	
 add esi,offset spanpackage_t_size	; point to next span
 mov al,ds:byte ptr[ebx]	
 mov al,ds:byte ptr[_irtable+eax]
 mov ds:word ptr[ecx],bp	
 mov al,ds:byte ptr[12345678h+eax]	
LPatch9IR:	
 mov ds:byte ptr[edi],al	

 jmp LNextSpanESISetIR

;===================================
;===================================
 public _D_Aff8Patch	
_D_Aff8Patch:	
 mov eax,[_alias_colormap]
 mov ds:dword ptr[LPatch1-4],eax	
 mov ds:dword ptr[LPatch2-4],eax	
 mov ds:dword ptr[LPatch3-4],eax	
 mov ds:dword ptr[LPatch4-4],eax	
 mov ds:dword ptr[LPatch5-4],eax	
 mov ds:dword ptr[LPatch6-4],eax	
 mov ds:dword ptr[LPatch7-4],eax	
 mov ds:dword ptr[LPatch8-4],eax	
 mov ds:dword ptr[LPatch9-4],eax	
 mov ds:dword ptr[LPatch1IR-4],eax	
 mov ds:dword ptr[LPatch2IR-4],eax	
 mov ds:dword ptr[LPatch3IR-4],eax	
 mov ds:dword ptr[LPatch4IR-4],eax	
 mov ds:dword ptr[LPatch5IR-4],eax	
 mov ds:dword ptr[LPatch6IR-4],eax	
 mov ds:dword ptr[LPatch7IR-4],eax	
 mov ds:dword ptr[LPatch8IR-4],eax	
 mov ds:dword ptr[LPatch9IR-4],eax	

 ret	



;===================================
;===================================

height	equ		4+16

 public _R_PolysetScanLeftEdge	
_R_PolysetScanLeftEdge:	
 push ebp	; preserve caller stack frame pointer
 push esi	; preserve register variables
 push edi	
 push ebx	

 mov eax,ds:dword ptr[height+esp]	
 mov ecx,ds:dword ptr[_d_sfrac]

 and eax,0FFFFh	
 mov ebx,ds:dword ptr[_d_ptex]	
 or ecx,eax	
 mov esi,ds:dword ptr[_d_pedgespanpackage]	
 mov edx,ds:dword ptr[_d_tfrac]	
 mov edi,ds:dword ptr[_d_light]	
 mov ebp,ds:dword ptr[_d_zi]	

; %eax: scratch
; %ebx: d_ptex
; %ecx: d_sfrac in high word, count in low word
; %edx: d_tfrac
; %esi: d_pedgespanpackage, errorterm, scratch alternately
; %edi: d_light
; %ebp: d_zi

;	do
;	{

LScanLoop:	

;		d_pedgespanpackage->ptex = ptex;
;		d_pedgespanpackage->pdest = d_pdest;
;		d_pedgespanpackage->pz = d_pz;
;		d_pedgespanpackage->count = d_aspancount;
;		d_pedgespanpackage->light = d_light;
;		d_pedgespanpackage->zi = d_zi;
;		d_pedgespanpackage->sfrac = d_sfrac << 16;
;		d_pedgespanpackage->tfrac = d_tfrac << 16;
 mov ds:dword ptr[spanpackage_t_ptex+esi],ebx	
 mov eax,ds:dword ptr[_d_pdest]	
 mov ds:dword ptr[spanpackage_t_pdest+esi],eax	
 mov eax,ds:dword ptr[_d_pz]	
 mov ds:dword ptr[spanpackage_t_pz+esi],eax	
 mov eax,ds:dword ptr[_d_aspancount]	
 mov ds:dword ptr[spanpackage_t_count+esi],eax	
 mov ds:dword ptr[spanpackage_t_light+esi],edi	
 mov ds:dword ptr[spanpackage_t_zi+esi],ebp	
 mov ds:dword ptr[spanpackage_t_sfrac+esi],ecx	
 mov ds:dword ptr[spanpackage_t_tfrac+esi],edx	

; pretouch the next cache line
 mov al,ds:byte ptr[spanpackage_t_size+esi]	

;		d_pedgespanpackage++;
 add esi,offset spanpackage_t_size	
 mov eax,ds:dword ptr[_erroradjustup]	
 mov ds:dword ptr[_d_pedgespanpackage],esi	

;		errorterm += erroradjustup;
 mov esi,ds:dword ptr[_errorterm]	
 add esi,eax	
 mov eax,ds:dword ptr[_d_pdest]	

;		if (errorterm >= 0)
;		{
 js LNoLeftEdgeTurnover	

;			errorterm -= erroradjustdown;
;			d_pdest += d_pdestextrastep;
 sub esi,ds:dword ptr[_erroradjustdown]	
 add eax,ds:dword ptr[_d_pdestextrastep]	
 mov ds:dword ptr[_errorterm],esi	
 mov ds:dword ptr[_d_pdest],eax	

;			d_pz += d_pzextrastep;
;			d_aspancount += d_countextrastep;
;			d_ptex += d_ptexextrastep;
;			d_sfrac += d_sfracextrastep;
;			d_ptex += d_sfrac >> 16;
;			d_sfrac &= 0xFFFF;
;			d_tfrac += d_tfracextrastep;
 mov eax,ds:dword ptr[_d_pz]	
 mov esi,ds:dword ptr[_d_aspancount]	
 add eax,ds:dword ptr[_d_pzextrastep]	
 add ecx,ds:dword ptr[_d_sfracextrastep]	
 adc ebx,ds:dword ptr[_d_ptexextrastep]	
 add esi,ds:dword ptr[_d_countextrastep]	
 mov ds:dword ptr[_d_pz],eax	
 mov eax,ds:dword ptr[_d_tfracextrastep]	
 mov ds:dword ptr[_d_aspancount],esi	
 add edx,eax	

;			if (d_tfrac & 0x10000)
;			{
 jnc LSkip1	

;				d_ptex += r_affinetridesc.skinwidth;
;				d_tfrac &= 0xFFFF;
 add ebx,ds:dword ptr[_r_affinetridesc+atd_skinwidth]	

;			}

LSkip1:	

;			d_light += d_lightextrastep;
;			d_zi += d_ziextrastep;
 add edi,ds:dword ptr[_d_lightextrastep]	
 add ebp,ds:dword ptr[_d_ziextrastep]	

;		}
 mov esi,ds:dword ptr[_d_pedgespanpackage]	
 dec ecx	
 test ecx,0FFFFh	
 jnz LScanLoop	

 pop ebx	
 pop edi	
 pop esi	
 pop ebp	
 ret	

;		else
;		{

LNoLeftEdgeTurnover:	
 mov ds:dword ptr[_errorterm],esi	

;			d_pdest += d_pdestbasestep;
 add eax,ds:dword ptr[_d_pdestbasestep]	
 mov ds:dword ptr[_d_pdest],eax	

;			d_pz += d_pzbasestep;
;			d_aspancount += ubasestep;
;			d_ptex += d_ptexbasestep;
;			d_sfrac += d_sfracbasestep;
;			d_ptex += d_sfrac >> 16;
;			d_sfrac &= 0xFFFF;
 mov eax,ds:dword ptr[_d_pz]	
 mov esi,ds:dword ptr[_d_aspancount]	
 add eax,ds:dword ptr[_d_pzbasestep]	
 add ecx,ds:dword ptr[_d_sfracbasestep]	
 adc ebx,ds:dword ptr[_d_ptexbasestep]	
 add esi,ds:dword ptr[_ubasestep]	
 mov ds:dword ptr[_d_pz],eax	
 mov ds:dword ptr[_d_aspancount],esi	

;			d_tfrac += d_tfracbasestep;
 mov esi,ds:dword ptr[_d_tfracbasestep]	
 add edx,esi	

;			if (d_tfrac & 0x10000)
;			{
 jnc LSkip2	

;				d_ptex += r_affinetridesc.skinwidth;
;				d_tfrac &= 0xFFFF;
 add ebx,ds:dword ptr[_r_affinetridesc+atd_skinwidth]	

;			}

LSkip2:	

;			d_light += d_lightbasestep;
;			d_zi += d_zibasestep;
 add edi,ds:dword ptr[_d_lightbasestep]	
 add ebp,ds:dword ptr[_d_zibasestep]	

;		}
;	} while (--height);
 mov esi,ds:dword ptr[_d_pedgespanpackage]	
 dec ecx	
 test ecx,0FFFFh	
 jnz LScanLoop	

 pop ebx	
 pop edi	
 pop esi	
 pop ebp	
 ret	

_TEXT ENDS
endif	;id386
 END