mirror of
https://git.code.sf.net/p/quake/quake2forge
synced 2024-12-12 21:51:58 +00:00
812 lines
18 KiB
NASM
812 lines
18 KiB
NASM
.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
|