Spectere
/
quake2-cmake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
A version of the Quake 2 source tree that should be easier to compile and run on modern *nixes.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
0 Tags
1.1 MiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
quake2-cmake/src/ref_soft/r_polysa.asm

812 lines
18 KiB
Raw Permalink Blame History

.386P
.model FLAT
;
; d_polysa.s
; x86 assembly-language polygon model drawing code
;
include qasm.inc
include d_if.inc
if id386
; !!! if this is changed, it must be changed in d_polyse.c too !!!
;DPS_MAXSPANS equ (MAXHEIGHT+1)
; 1 extra for spanpackage that marks end
;SPAN_SIZE equ (((DPS_MAXSPANS + 1 + ((CACHE_SIZE - 1) / spanpackage_t_size)) + 1) * spanpackage_t_size)
MASK_1K equ 03FFh
_DATA SEGMENT
align 4
;p10_minus_p20 dd 0
;p01_minus_p21 dd 0
;temp0 dd 0
;temp1 dd 0
;Ltemp dd 0
aff8entryvec_table dd LDraw8, LDraw7, LDraw6, LDraw5
dd LDraw4, LDraw3, LDraw2, LDraw1, LDraw8IR, LDraw7IR, LDraw6IR, LDraw5IR, LDraw4IR, LDraw3IR, LDraw2IR, LDraw1IR
lzistepx dd 0
externdef _rand1k:dword
externdef _rand1k_index:dword
externdef _alias_colormap:dword
;PGM
externdef _irtable:dword
externdef _iractive:byte
;PGM
_DATA ENDS
_TEXT SEGMENT
;----------------------------------------------------------------------
; 8-bpp horizontal span drawing code for affine polygons, with smooth
; shading and no transparency
;----------------------------------------------------------------------
;===================================
;===================================
pspans equ 4+8
public _D_PolysetAff8Start
_D_PolysetAff8Start:
public _R_PolysetDrawSpans8_Opaque
_R_PolysetDrawSpans8_Opaque:
push esi ; preserve register variables
push ebx
mov esi,ds:dword ptr[pspans+esp] ; point to the first span descriptor
mov ecx,ds:dword ptr[_r_zistepx]
push ebp ; preserve caller's stack frame
push edi
ror ecx,16 ; put high 16 bits of 1/z step in low word
mov edx,ds:dword ptr[spanpackage_t_count+esi]
mov ds:dword ptr[lzistepx],ecx
LSpanLoop:
; lcount = d_aspancount - pspanpackage->count;
;
; errorterm += erroradjustup;
; if (errorterm >= 0)
; {
; d_aspancount += d_countextrastep;
; errorterm -= erroradjustdown;
; }
; else
; {
; d_aspancount += ubasestep;
; }
mov eax,ds:dword ptr[_d_aspancount]
sub eax,edx
mov edx,ds:dword ptr[_erroradjustup]
mov ebx,ds:dword ptr[_errorterm]
add ebx,edx
js LNoTurnover
mov edx,ds:dword ptr[_erroradjustdown]
mov edi,ds:dword ptr[_d_countextrastep]
sub ebx,edx
mov ebp,ds:dword ptr[_d_aspancount]
mov ds:dword ptr[_errorterm],ebx
add ebp,edi
mov ds:dword ptr[_d_aspancount],ebp
jmp LRightEdgeStepped
LNoTurnover:
mov edi,ds:dword ptr[_d_aspancount]
mov edx,ds:dword ptr[_ubasestep]
mov ds:dword ptr[_errorterm],ebx
add edi,edx
mov ds:dword ptr[_d_aspancount],edi
LRightEdgeStepped:
cmp eax,1
jl LNextSpan
jz LExactlyOneLong
;
; set up advancetable
;
mov ecx,ds:dword ptr[_a_ststepxwhole]
mov edx,ds:dword ptr[_r_affinetridesc+atd_skinwidth]
mov ds:dword ptr[advancetable+4],ecx ; advance base in t
add ecx,edx
mov ds:dword ptr[advancetable],ecx ; advance extra in t
mov ecx,ds:dword ptr[_a_tstepxfrac]
mov cx,ds:word ptr[_r_lstepx]
mov edx,eax ; count
mov ds:dword ptr[tstep],ecx
add edx,7
shr edx,3 ; count of full and partial loops
mov ebx,ds:dword ptr[spanpackage_t_sfrac+esi]
mov bx,dx
mov ecx,ds:dword ptr[spanpackage_t_pz+esi]
neg eax
mov edi,ds:dword ptr[spanpackage_t_pdest+esi]
and eax,7 ; 0->0, 1->7, 2->6, ... , 7->1
sub edi,eax ; compensate for hardwired offsets
sub ecx,eax
sub ecx,eax
mov edx,ds:dword ptr[spanpackage_t_tfrac+esi]
mov dx,ds:word ptr[spanpackage_t_light+esi]
mov ebp,ds:dword ptr[spanpackage_t_zi+esi]
ror ebp,16 ; put high 16 bits of 1/z in low word
push esi
push eax
mov al, [_iractive]
cmp al, 0
pop eax
jne IRInsert
mov esi,ds:dword ptr[spanpackage_t_ptex+esi]
jmp dword ptr[aff8entryvec_table+eax*4]
IRInsert:
mov esi,ds:dword ptr[spanpackage_t_ptex+esi]
add eax, 8
jmp dword ptr[aff8entryvec_table+eax*4]
; %bx = count of full and partial loops
; %ebx high word = sfrac
; %ecx = pz
; %dx = light
; %edx high word = tfrac
; %esi = ptex
; %edi = pdest
; %ebp = 1/z
; tstep low word = C(r_lstepx)
; tstep high word = C(a_tstepxfrac)
; C(a_sstepxfrac) low word = 0
; C(a_sstepxfrac) high word = C(a_sstepxfrac)
;===
;Standard Draw Loop
;===
LDrawLoop:
mov al,[_iractive]
cmp al,0
jne LDrawLoopIR
; FIXME: do we need to clamp light? We may need at least a buffer bit to
; keep it from poking into tfrac and causing problems
LDraw8:
cmp bp,ds:word ptr[ecx]
jl Lp1
xor eax,eax
mov ah,dh
mov al,ds:byte ptr[esi]
mov ds:word ptr[ecx],bp
mov al,ds:byte ptr[12345678h+eax]
LPatch8:
mov ds:byte ptr[edi],al
Lp1:
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]
LDraw7:
cmp bp,ds:word ptr[2+ecx]
jl Lp2
xor eax,eax
mov ah,dh
mov al,ds:byte ptr[esi]
mov ds:word ptr[2+ecx],bp
mov al,ds:byte ptr[12345678h+eax]
LPatch7:
mov ds:byte ptr[1+edi],al
Lp2:
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]
LDraw6:
cmp bp,ds:word ptr[4+ecx]
jl Lp3
xor eax,eax
mov ah,dh
mov al,ds:byte ptr[esi]
mov ds:word ptr[4+ecx],bp
mov al,ds:byte ptr[12345678h+eax]
LPatch6:
mov ds:byte ptr[2+edi],al
Lp3:
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]
LDraw5:
cmp bp,ds:word ptr[6+ecx]
jl Lp4
xor eax,eax
mov ah,dh
mov al,ds:byte ptr[esi]
mov ds:word ptr[6+ecx],bp
mov al,ds:byte ptr[12345678h+eax]
LPatch5:
mov ds:byte ptr[3+edi],al
Lp4:
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]
LDraw4:
cmp bp,ds:word ptr[8+ecx]
jl Lp5
xor eax,eax
mov ah,dh
mov al,ds:byte ptr[esi]
mov ds:word ptr[8+ecx],bp
mov al,ds:byte ptr[12345678h+eax]
LPatch4:
mov ds:byte ptr[4+edi],al
Lp5:
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]
LDraw3:
cmp bp,ds:word ptr[10+ecx]
jl Lp6
xor eax,eax
mov ah,dh
mov al,ds:byte ptr[esi]
mov ds:word ptr[10+ecx],bp
mov al,ds:byte ptr[12345678h+eax]
LPatch3:
mov ds:byte ptr[5+edi],al
Lp6:
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]
LDraw2:
cmp bp,ds:word ptr[12+ecx]
jl Lp7
xor eax,eax
mov ah,dh
mov al,ds:byte ptr[esi]
mov ds:word ptr[12+ecx],bp
mov al,ds:byte ptr[12345678h+eax]
LPatch2:
mov ds:byte ptr[6+edi],al
Lp7:
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]
LDraw1:
cmp bp,ds:word ptr[14+ecx]
jl Lp8
xor eax,eax
mov ah,dh
mov al,ds:byte ptr[esi]
mov ds:word ptr[14+ecx],bp
mov al,ds:byte ptr[12345678h+eax]
LPatch1:
mov ds:byte ptr[7+edi],al
Lp8:
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 LDrawLoop
pop esi ; restore spans pointer
LNextSpan:
add esi,offset spanpackage_t_size ; point to next span
LNextSpanESISet:
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
;=======
; IR active draw loop
;=======
LDrawLoopIR:
; FIXME: do we need to clamp light? We may need at least a buffer bit to
; keep it from poking into tfrac and causing problems
LDraw8IR:
cmp bp,ds:word ptr[ecx]
jl Lp1IR
xor eax,eax
mov al,ds:byte ptr[esi]
mov al,ds:byte ptr[_irtable+eax]
mov ds:word ptr[ecx],bp
mov al,ds:byte ptr[12345678h+eax]
LPatch8IR:
mov ds:byte ptr[edi],al
Lp1IR:
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]
LDraw7IR:
cmp bp,ds:word ptr[2+ecx]
jl Lp2IR
xor eax,eax
mov al,ds:byte ptr[esi]
mov al,ds:byte ptr[_irtable+eax]
mov ds:word ptr[2+ecx],bp
mov al,ds:byte ptr[12345678h+eax]
LPatch7IR:
mov ds:byte ptr[1+edi],al
Lp2IR:
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]
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