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.
733 lines
18 KiB
733 lines
18 KiB
.386P |
|
.model FLAT |
|
; |
|
; r_edgea.s |
|
; x86 assembly-language edge-processing code. |
|
; |
|
|
|
include qasm.inc |
|
|
|
if id386 |
|
|
|
_DATA SEGMENT |
|
Ltemp dd 0 |
|
float_1_div_0100000h dd 035800000h ; 1.0/(float)0x100000 |
|
float_point_999 dd 0.999 |
|
float_1_point_001 dd 1.001 |
|
|
|
_DATA ENDS |
|
_TEXT SEGMENT |
|
|
|
;-------------------------------------------------------------------- |
|
|
|
edgestoadd equ 4+8 ; note odd stack offsets because of interleaving |
|
edgelist equ 8+12 ; with pushes |
|
|
|
public _R_EdgeCodeStart |
|
_R_EdgeCodeStart: |
|
|
|
public _R_InsertNewEdges |
|
_R_InsertNewEdges: |
|
push edi |
|
push esi ; preserve register variables |
|
mov edx,ds:dword ptr[edgestoadd+esp] |
|
push ebx |
|
mov ecx,ds:dword ptr[edgelist+esp] |
|
|
|
LDoNextEdge: |
|
mov eax,ds:dword ptr[et_u+edx] |
|
mov edi,edx |
|
|
|
LContinueSearch: |
|
mov ebx,ds:dword ptr[et_u+ecx] |
|
mov esi,ds:dword ptr[et_next+ecx] |
|
cmp eax,ebx |
|
jle LAddedge |
|
mov ebx,ds:dword ptr[et_u+esi] |
|
mov ecx,ds:dword ptr[et_next+esi] |
|
cmp eax,ebx |
|
jle LAddedge2 |
|
mov ebx,ds:dword ptr[et_u+ecx] |
|
mov esi,ds:dword ptr[et_next+ecx] |
|
cmp eax,ebx |
|
jle LAddedge |
|
mov ebx,ds:dword ptr[et_u+esi] |
|
mov ecx,ds:dword ptr[et_next+esi] |
|
cmp eax,ebx |
|
jg LContinueSearch |
|
|
|
LAddedge2: |
|
mov edx,ds:dword ptr[et_next+edx] |
|
mov ebx,ds:dword ptr[et_prev+esi] |
|
mov ds:dword ptr[et_next+edi],esi |
|
mov ds:dword ptr[et_prev+edi],ebx |
|
mov ds:dword ptr[et_next+ebx],edi |
|
mov ds:dword ptr[et_prev+esi],edi |
|
mov ecx,esi |
|
|
|
cmp edx,0 |
|
jnz LDoNextEdge |
|
jmp LDone |
|
|
|
align 4 |
|
LAddedge: |
|
mov edx,ds:dword ptr[et_next+edx] |
|
mov ebx,ds:dword ptr[et_prev+ecx] |
|
mov ds:dword ptr[et_next+edi],ecx |
|
mov ds:dword ptr[et_prev+edi],ebx |
|
mov ds:dword ptr[et_next+ebx],edi |
|
mov ds:dword ptr[et_prev+ecx],edi |
|
|
|
cmp edx,0 |
|
jnz LDoNextEdge |
|
|
|
LDone: |
|
pop ebx ; restore register variables |
|
pop esi |
|
pop edi |
|
|
|
ret |
|
|
|
;-------------------------------------------------------------------- |
|
|
|
predge equ 4+4 |
|
|
|
public _R_RemoveEdges |
|
_R_RemoveEdges: |
|
push ebx |
|
mov eax,ds:dword ptr[predge+esp] |
|
|
|
Lre_loop: |
|
mov ecx,ds:dword ptr[et_next+eax] |
|
mov ebx,ds:dword ptr[et_nextremove+eax] |
|
mov edx,ds:dword ptr[et_prev+eax] |
|
test ebx,ebx |
|
mov ds:dword ptr[et_prev+ecx],edx |
|
jz Lre_done |
|
mov ds:dword ptr[et_next+edx],ecx |
|
|
|
mov ecx,ds:dword ptr[et_next+ebx] |
|
mov edx,ds:dword ptr[et_prev+ebx] |
|
mov eax,ds:dword ptr[et_nextremove+ebx] |
|
mov ds:dword ptr[et_prev+ecx],edx |
|
test eax,eax |
|
mov ds:dword ptr[et_next+edx],ecx |
|
jnz Lre_loop |
|
|
|
pop ebx |
|
ret |
|
|
|
Lre_done: |
|
mov ds:dword ptr[et_next+edx],ecx |
|
pop ebx |
|
|
|
ret |
|
|
|
;-------------------------------------------------------------------- |
|
|
|
pedgelist equ 4+4 ; note odd stack offset because of interleaving |
|
; with pushes |
|
|
|
public _R_StepActiveU |
|
_R_StepActiveU: |
|
push edi |
|
mov edx,ds:dword ptr[pedgelist+esp] |
|
push esi ; preserve register variables |
|
push ebx |
|
|
|
mov esi,ds:dword ptr[et_prev+edx] |
|
|
|
LNewEdge: |
|
mov edi,ds:dword ptr[et_u+esi] |
|
|
|
LNextEdge: |
|
mov eax,ds:dword ptr[et_u+edx] |
|
mov ebx,ds:dword ptr[et_u_step+edx] |
|
add eax,ebx |
|
mov esi,ds:dword ptr[et_next+edx] |
|
mov ds:dword ptr[et_u+edx],eax |
|
cmp eax,edi |
|
jl LPushBack |
|
|
|
mov edi,ds:dword ptr[et_u+esi] |
|
mov ebx,ds:dword ptr[et_u_step+esi] |
|
add edi,ebx |
|
mov edx,ds:dword ptr[et_next+esi] |
|
mov ds:dword ptr[et_u+esi],edi |
|
cmp edi,eax |
|
jl LPushBack2 |
|
|
|
mov eax,ds:dword ptr[et_u+edx] |
|
mov ebx,ds:dword ptr[et_u_step+edx] |
|
add eax,ebx |
|
mov esi,ds:dword ptr[et_next+edx] |
|
mov ds:dword ptr[et_u+edx],eax |
|
cmp eax,edi |
|
jl LPushBack |
|
|
|
mov edi,ds:dword ptr[et_u+esi] |
|
mov ebx,ds:dword ptr[et_u_step+esi] |
|
add edi,ebx |
|
mov edx,ds:dword ptr[et_next+esi] |
|
mov ds:dword ptr[et_u+esi],edi |
|
cmp edi,eax |
|
jnl LNextEdge |
|
|
|
LPushBack2: |
|
mov ebx,edx |
|
mov eax,edi |
|
mov edx,esi |
|
mov esi,ebx |
|
|
|
LPushBack: |
|
; push it back to keep it sorted |
|
mov ecx,ds:dword ptr[et_prev+edx] |
|
mov ebx,ds:dword ptr[et_next+edx] |
|
|
|
; done if the -1 in edge_aftertail triggered this |
|
cmp edx,offset _edge_aftertail |
|
jz LUDone |
|
|
|
; pull the edge out of the edge list |
|
mov edi,ds:dword ptr[et_prev+ecx] |
|
mov ds:dword ptr[et_prev+esi],ecx |
|
mov ds:dword ptr[et_next+ecx],ebx |
|
|
|
; find out where the edge goes in the edge list |
|
LPushBackLoop: |
|
mov ecx,ds:dword ptr[et_prev+edi] |
|
mov ebx,ds:dword ptr[et_u+edi] |
|
cmp eax,ebx |
|
jnl LPushBackFound |
|
|
|
mov edi,ds:dword ptr[et_prev+ecx] |
|
mov ebx,ds:dword ptr[et_u+ecx] |
|
cmp eax,ebx |
|
jl LPushBackLoop |
|
|
|
mov edi,ecx |
|
|
|
; put the edge back into the edge list |
|
LPushBackFound: |
|
mov ebx,ds:dword ptr[et_next+edi] |
|
mov ds:dword ptr[et_prev+edx],edi |
|
mov ds:dword ptr[et_next+edx],ebx |
|
mov ds:dword ptr[et_next+edi],edx |
|
mov ds:dword ptr[et_prev+ebx],edx |
|
|
|
mov edx,esi |
|
mov esi,ds:dword ptr[et_prev+esi] |
|
|
|
cmp edx,offset _edge_tail |
|
jnz LNewEdge |
|
|
|
LUDone: |
|
pop ebx ; restore register variables |
|
pop esi |
|
pop edi |
|
|
|
ret |
|
|
|
;-------------------------------------------------------------------- |
|
|
|
surf equ 4 ; note this is loaded before any pushes |
|
|
|
align 4 |
|
TrailingEdge: |
|
mov eax,ds:dword ptr[st_spanstate+esi] ; check for edge inversion |
|
dec eax |
|
jnz LInverted |
|
|
|
mov ds:dword ptr[st_spanstate+esi],eax |
|
mov ecx,ds:dword ptr[st_insubmodel+esi] |
|
mov edx,ds:dword ptr[12345678h] ; surfaces[1].st_next |
|
LPatch0: |
|
mov eax,ds:dword ptr[_r_bmodelactive] |
|
sub eax,ecx |
|
cmp edx,esi |
|
mov ds:dword ptr[_r_bmodelactive],eax |
|
jnz LNoEmit ; surface isn't on top, just remove |
|
|
|
; emit a span (current top going away) |
|
mov eax,ds:dword ptr[et_u+ebx] |
|
shr eax,20 ; iu = integral pixel u |
|
mov edx,ds:dword ptr[st_last_u+esi] |
|
mov ecx,ds:dword ptr[st_next+esi] |
|
cmp eax,edx |
|
jle LNoEmit2 ; iu <= surf->last_u, so nothing to emit |
|
|
|
mov ds:dword ptr[st_last_u+ecx],eax ; surf->next->last_u = iu; |
|
sub eax,edx |
|
mov ds:dword ptr[espan_t_u+ebp],edx ; span->u = surf->last_u; |
|
|
|
mov ds:dword ptr[espan_t_count+ebp],eax ; span->count = iu - span->u; |
|
mov eax,ds:dword ptr[_current_iv] |
|
mov ds:dword ptr[espan_t_v+ebp],eax ; span->v = current_iv; |
|
mov eax,ds:dword ptr[st_spans+esi] |
|
mov ds:dword ptr[espan_t_pnext+ebp],eax ; span->pnext = surf->spans; |
|
mov ds:dword ptr[st_spans+esi],ebp ; surf->spans = span; |
|
add ebp,offset espan_t_size |
|
|
|
mov edx,ds:dword ptr[st_next+esi] ; remove the surface from the surface |
|
mov esi,ds:dword ptr[st_prev+esi] ; stack |
|
|
|
mov ds:dword ptr[st_next+esi],edx |
|
mov ds:dword ptr[st_prev+edx],esi |
|
ret |
|
|
|
LNoEmit2: |
|
mov ds:dword ptr[st_last_u+ecx],eax ; surf->next->last_u = iu; |
|
mov edx,ds:dword ptr[st_next+esi] ; remove the surface from the surface |
|
mov esi,ds:dword ptr[st_prev+esi] ; stack |
|
|
|
mov ds:dword ptr[st_next+esi],edx |
|
mov ds:dword ptr[st_prev+edx],esi |
|
ret |
|
|
|
LNoEmit: |
|
mov edx,ds:dword ptr[st_next+esi] ; remove the surface from the surface |
|
mov esi,ds:dword ptr[st_prev+esi] ; stack |
|
|
|
mov ds:dword ptr[st_next+esi],edx |
|
mov ds:dword ptr[st_prev+edx],esi |
|
ret |
|
|
|
LInverted: |
|
mov ds:dword ptr[st_spanstate+esi],eax |
|
ret |
|
|
|
;-------------------------------------------------------------------- |
|
|
|
; trailing edge only |
|
Lgs_trailing: |
|
push offset Lgs_nextedge |
|
jmp TrailingEdge |
|
|
|
|
|
public _R_GenerateSpans |
|
_R_GenerateSpans: |
|
push ebp ; preserve caller's stack frame |
|
push edi |
|
push esi ; preserve register variables |
|
push ebx |
|
|
|
; clear active surfaces to just the background surface |
|
mov eax,ds:dword ptr[_surfaces] |
|
mov edx,ds:dword ptr[_edge_head_u_shift20] |
|
add eax,offset st_size |
|
; %ebp = span_p throughout |
|
mov ebp,ds:dword ptr[_span_p] |
|
|
|
mov ds:dword ptr[_r_bmodelactive],0 |
|
|
|
mov ds:dword ptr[st_next+eax],eax |
|
mov ds:dword ptr[st_prev+eax],eax |
|
mov ds:dword ptr[st_last_u+eax],edx |
|
mov ebx,ds:dword ptr[_edge_head+et_next] ; edge=edge_head.next |
|
|
|
; generate spans |
|
cmp ebx,offset _edge_tail ; done if empty list |
|
jz Lgs_lastspan |
|
|
|
Lgs_edgeloop: |
|
|
|
mov edi,ds:dword ptr[et_surfs+ebx] |
|
mov eax,ds:dword ptr[_surfaces] |
|
mov esi,edi |
|
and edi,0FFFF0000h |
|
and esi,0FFFFh |
|
jz Lgs_leading ; not a trailing edge |
|
|
|
; it has a left surface, so a surface is going away for this span |
|
shl esi,offset SURF_T_SHIFT |
|
add esi,eax |
|
test edi,edi |
|
jz Lgs_trailing |
|
|
|
; both leading and trailing |
|
call near ptr TrailingEdge |
|
mov eax,ds:dword ptr[_surfaces] |
|
|
|
; --------------------------------------------------------------- |
|
; handle a leading edge |
|
; --------------------------------------------------------------- |
|
|
|
Lgs_leading: |
|
shr edi,16-SURF_T_SHIFT |
|
mov eax,ds:dword ptr[_surfaces] |
|
add edi,eax |
|
mov esi,ds:dword ptr[12345678h] ; surf2 = surfaces[1].next; |
|
LPatch2: |
|
mov edx,ds:dword ptr[st_spanstate+edi] |
|
mov eax,ds:dword ptr[st_insubmodel+edi] |
|
test eax,eax |
|
jnz Lbmodel_leading |
|
|
|
; handle a leading non-bmodel edge |
|
|
|
; don't start a span if this is an inverted span, with the end edge preceding |
|
; the start edge (that is, we've already seen the end edge) |
|
test edx,edx |
|
jnz Lxl_done |
|
|
|
|
|
; if (surf->key < surf2->key) |
|
; goto newtop; |
|
inc edx |
|
mov eax,ds:dword ptr[st_key+edi] |
|
mov ds:dword ptr[st_spanstate+edi],edx |
|
mov ecx,ds:dword ptr[st_key+esi] |
|
cmp eax,ecx |
|
jl Lnewtop |
|
|
|
; main sorting loop to search through surface stack until insertion point |
|
; found. Always terminates because background surface is sentinel |
|
; do |
|
; { |
|
; surf2 = surf2->next; |
|
; } while (surf->key >= surf2->key); |
|
Lsortloopnb: |
|
mov esi,ds:dword ptr[st_next+esi] |
|
mov ecx,ds:dword ptr[st_key+esi] |
|
cmp eax,ecx |
|
jge Lsortloopnb |
|
|
|
jmp LInsertAndExit |
|
|
|
|
|
; handle a leading bmodel edge |
|
align 4 |
|
Lbmodel_leading: |
|
|
|
; don't start a span if this is an inverted span, with the end edge preceding |
|
; the start edge (that is, we've already seen the end edge) |
|
test edx,edx |
|
jnz Lxl_done |
|
|
|
mov ecx,ds:dword ptr[_r_bmodelactive] |
|
inc edx |
|
inc ecx |
|
mov ds:dword ptr[st_spanstate+edi],edx |
|
mov ds:dword ptr[_r_bmodelactive],ecx |
|
|
|
; if (surf->key < surf2->key) |
|
; goto newtop; |
|
mov eax,ds:dword ptr[st_key+edi] |
|
mov ecx,ds:dword ptr[st_key+esi] |
|
cmp eax,ecx |
|
jl Lnewtop |
|
|
|
; if ((surf->key == surf2->key) && surf->insubmodel) |
|
; { |
|
jz Lzcheck_for_newtop |
|
|
|
; main sorting loop to search through surface stack until insertion point |
|
; found. Always terminates because background surface is sentinel |
|
; do |
|
; { |
|
; surf2 = surf2->next; |
|
; } while (surf->key > surf2->key); |
|
Lsortloop: |
|
mov esi,ds:dword ptr[st_next+esi] |
|
mov ecx,ds:dword ptr[st_key+esi] |
|
cmp eax,ecx |
|
jg Lsortloop |
|
|
|
jne LInsertAndExit |
|
|
|
; Do 1/z sorting to see if we've arrived in the right position |
|
mov eax,ds:dword ptr[et_u+ebx] |
|
sub eax,0FFFFFh |
|
mov ds:dword ptr[Ltemp],eax |
|
fild ds:dword ptr[Ltemp] |
|
|
|
fmul ds:dword ptr[float_1_div_0100000h] ; fu = (float)(edge->u - 0xFFFFF) * |
|
; (1.0 / 0x100000); |
|
|
|
fld st(0) ; fu | fu |
|
fmul ds:dword ptr[st_d_zistepu+edi] ; fu*surf->d_zistepu | fu |
|
fld ds:dword ptr[_fv] ; fv | fu*surf->d_zistepu | fu |
|
fmul ds:dword ptr[st_d_zistepv+edi] ; fv*surf->d_zistepv | fu*surf->d_zistepu | fu |
|
fxch st(1) ; fu*surf->d_zistepu | fv*surf->d_zistepv | fu |
|
fadd ds:dword ptr[st_d_ziorigin+edi] ; fu*surf->d_zistepu + surf->d_ziorigin | |
|
; fv*surf->d_zistepv | fu |
|
|
|
fld ds:dword ptr[st_d_zistepu+esi] ; surf2->d_zistepu | |
|
; fu*surf->d_zistepu + surf->d_ziorigin | |
|
; fv*surf->d_zistepv | fu |
|
fmul st(0),st(3) ; fu*surf2->d_zistepu | |
|
; fu*surf->d_zistepu + surf->d_ziorigin | |
|
; fv*surf->d_zistepv | fu |
|
fxch st(1) ; fu*surf->d_zistepu + surf->d_ziorigin | |
|
; fu*surf2->d_zistepu | |
|
; fv*surf->d_zistepv | fu |
|
faddp st(2),st(0) ; fu*surf2->d_zistepu | newzi | fu |
|
|
|
fld ds:dword ptr[_fv] ; fv | fu*surf2->d_zistepu | newzi | fu |
|
fmul ds:dword ptr[st_d_zistepv+esi] ; fv*surf2->d_zistepv | |
|
; fu*surf2->d_zistepu | newzi | fu |
|
fld st(2) ; newzi | fv*surf2->d_zistepv | |
|
; fu*surf2->d_zistepu | newzi | fu |
|
fmul ds:dword ptr[float_point_999] ; newzibottom | fv*surf2->d_zistepv | |
|
; fu*surf2->d_zistepu | newzi | fu |
|
|
|
fxch st(2) ; fu*surf2->d_zistepu | fv*surf2->d_zistepv | |
|
; newzibottom | newzi | fu |
|
fadd ds:dword ptr[st_d_ziorigin+esi] ; fu*surf2->d_zistepu + surf2->d_ziorigin | |
|
; fv*surf2->d_zistepv | newzibottom | newzi | |
|
; fu |
|
faddp st(1),st(0) ; testzi | newzibottom | newzi | fu |
|
fxch st(1) ; newzibottom | testzi | newzi | fu |
|
|
|
; if (newzibottom >= testzi) |
|
; goto Lgotposition; |
|
|
|
fcomp st(1) ; testzi | newzi | fu |
|
|
|
fxch st(1) ; newzi | testzi | fu |
|
fmul ds:dword ptr[float_1_point_001] ; newzitop | testzi | fu |
|
fxch st(1) ; testzi | newzitop | fu |
|
|
|
fnstsw ax |
|
test ah,001h |
|
jz Lgotposition_fpop3 |
|
|
|
; if (newzitop >= testzi) |
|
; { |
|
|
|
fcomp st(1) ; newzitop | fu |
|
fnstsw ax |
|
test ah,045h |
|
jz Lsortloop_fpop2 |
|
|
|
; if (surf->d_zistepu >= surf2->d_zistepu) |
|
; goto newtop; |
|
|
|
fld ds:dword ptr[st_d_zistepu+edi] ; surf->d_zistepu | newzitop| fu |
|
fcomp ds:dword ptr[st_d_zistepu+esi] ; newzitop | fu |
|
fnstsw ax |
|
test ah,001h |
|
jz Lgotposition_fpop2 |
|
|
|
fstp st(0) ; clear the FPstack |
|
fstp st(0) |
|
mov eax,ds:dword ptr[st_key+edi] |
|
jmp Lsortloop |
|
|
|
|
|
Lgotposition_fpop3: |
|
fstp st(0) |
|
Lgotposition_fpop2: |
|
fstp st(0) |
|
fstp st(0) |
|
jmp LInsertAndExit |
|
|
|
|
|
; emit a span (obscures current top) |
|
|
|
Lnewtop_fpop3: |
|
fstp st(0) |
|
Lnewtop_fpop2: |
|
fstp st(0) |
|
fstp st(0) |
|
mov eax,ds:dword ptr[st_key+edi] ; reload the sorting key |
|
|
|
Lnewtop: |
|
mov eax,ds:dword ptr[et_u+ebx] |
|
mov edx,ds:dword ptr[st_last_u+esi] |
|
shr eax,20 ; iu = integral pixel u |
|
mov ds:dword ptr[st_last_u+edi],eax ; surf->last_u = iu; |
|
cmp eax,edx |
|
jle LInsertAndExit ; iu <= surf->last_u, so nothing to emit |
|
|
|
sub eax,edx |
|
mov ds:dword ptr[espan_t_u+ebp],edx ; span->u = surf->last_u; |
|
|
|
mov ds:dword ptr[espan_t_count+ebp],eax ; span->count = iu - span->u; |
|
mov eax,ds:dword ptr[_current_iv] |
|
mov ds:dword ptr[espan_t_v+ebp],eax ; span->v = current_iv; |
|
mov eax,ds:dword ptr[st_spans+esi] |
|
mov ds:dword ptr[espan_t_pnext+ebp],eax ; span->pnext = surf->spans; |
|
mov ds:dword ptr[st_spans+esi],ebp ; surf->spans = span; |
|
add ebp,offset espan_t_size |
|
|
|
LInsertAndExit: |
|
; insert before surf2 |
|
mov ds:dword ptr[st_next+edi],esi ; surf->next = surf2; |
|
mov eax,ds:dword ptr[st_prev+esi] |
|
mov ds:dword ptr[st_prev+edi],eax ; surf->prev = surf2->prev; |
|
mov ds:dword ptr[st_prev+esi],edi ; surf2->prev = surf; |
|
mov ds:dword ptr[st_next+eax],edi ; surf2->prev->next = surf; |
|
|
|
; --------------------------------------------------------------- |
|
; leading edge done |
|
; --------------------------------------------------------------- |
|
|
|
; --------------------------------------------------------------- |
|
; see if there are any more edges |
|
; --------------------------------------------------------------- |
|
|
|
Lgs_nextedge: |
|
mov ebx,ds:dword ptr[et_next+ebx] |
|
cmp ebx,offset _edge_tail |
|
jnz Lgs_edgeloop |
|
|
|
; clean up at the right edge |
|
Lgs_lastspan: |
|
|
|
; now that we've reached the right edge of the screen, we're done with any |
|
; unfinished surfaces, so emit a span for whatever's on top |
|
mov esi,ds:dword ptr[12345678h] ; surfaces[1].st_next |
|
LPatch3: |
|
mov eax,ds:dword ptr[_edge_tail_u_shift20] |
|
xor ecx,ecx |
|
mov edx,ds:dword ptr[st_last_u+esi] |
|
sub eax,edx |
|
jle Lgs_resetspanstate |
|
|
|
mov ds:dword ptr[espan_t_u+ebp],edx |
|
mov ds:dword ptr[espan_t_count+ebp],eax |
|
mov eax,ds:dword ptr[_current_iv] |
|
mov ds:dword ptr[espan_t_v+ebp],eax |
|
mov eax,ds:dword ptr[st_spans+esi] |
|
mov ds:dword ptr[espan_t_pnext+ebp],eax |
|
mov ds:dword ptr[st_spans+esi],ebp |
|
add ebp,offset espan_t_size |
|
|
|
; reset spanstate for all surfaces in the surface stack |
|
Lgs_resetspanstate: |
|
mov ds:dword ptr[st_spanstate+esi],ecx |
|
mov esi,ds:dword ptr[st_next+esi] |
|
cmp esi,012345678h ; &surfaces[1] |
|
LPatch4: |
|
jnz Lgs_resetspanstate |
|
|
|
; store the final span_p |
|
mov ds:dword ptr[_span_p],ebp |
|
|
|
pop ebx ; restore register variables |
|
pop esi |
|
pop edi |
|
pop ebp ; restore the caller's stack frame |
|
ret |
|
|
|
|
|
; --------------------------------------------------------------- |
|
; 1/z sorting for bmodels in the same leaf |
|
; --------------------------------------------------------------- |
|
align 4 |
|
Lxl_done: |
|
inc edx |
|
mov ds:dword ptr[st_spanstate+edi],edx |
|
|
|
jmp Lgs_nextedge |
|
|
|
|
|
align 4 |
|
Lzcheck_for_newtop: |
|
mov eax,ds:dword ptr[et_u+ebx] |
|
sub eax,0FFFFFh |
|
mov ds:dword ptr[Ltemp],eax |
|
fild ds:dword ptr[Ltemp] |
|
|
|
fmul ds:dword ptr[float_1_div_0100000h] ; fu = (float)(edge->u - 0xFFFFF) * |
|
; (1.0 / 0x100000); |
|
|
|
fld st(0) ; fu | fu |
|
fmul ds:dword ptr[st_d_zistepu+edi] ; fu*surf->d_zistepu | fu |
|
fld ds:dword ptr[_fv] ; fv | fu*surf->d_zistepu | fu |
|
fmul ds:dword ptr[st_d_zistepv+edi] ; fv*surf->d_zistepv | fu*surf->d_zistepu | fu |
|
fxch st(1) ; fu*surf->d_zistepu | fv*surf->d_zistepv | fu |
|
fadd ds:dword ptr[st_d_ziorigin+edi] ; fu*surf->d_zistepu + surf->d_ziorigin | |
|
; fv*surf->d_zistepv | fu |
|
|
|
fld ds:dword ptr[st_d_zistepu+esi] ; surf2->d_zistepu | |
|
; fu*surf->d_zistepu + surf->d_ziorigin | |
|
; fv*surf->d_zistepv | fu |
|
fmul st(0),st(3) ; fu*surf2->d_zistepu | |
|
; fu*surf->d_zistepu + surf->d_ziorigin | |
|
; fv*surf->d_zistepv | fu |
|
fxch st(1) ; fu*surf->d_zistepu + surf->d_ziorigin | |
|
; fu*surf2->d_zistepu | |
|
; fv*surf->d_zistepv | fu |
|
faddp st(2),st(0) ; fu*surf2->d_zistepu | newzi | fu |
|
|
|
fld ds:dword ptr[_fv] ; fv | fu*surf2->d_zistepu | newzi | fu |
|
fmul ds:dword ptr[st_d_zistepv+esi] ; fv*surf2->d_zistepv | |
|
; fu*surf2->d_zistepu | newzi | fu |
|
fld st(2) ; newzi | fv*surf2->d_zistepv | |
|
; fu*surf2->d_zistepu | newzi | fu |
|
fmul ds:dword ptr[float_point_999] ; newzibottom | fv*surf2->d_zistepv | |
|
; fu*surf2->d_zistepu | newzi | fu |
|
|
|
fxch st(2) ; fu*surf2->d_zistepu | fv*surf2->d_zistepv | |
|
; newzibottom | newzi | fu |
|
fadd ds:dword ptr[st_d_ziorigin+esi] ; fu*surf2->d_zistepu + surf2->d_ziorigin | |
|
; fv*surf2->d_zistepv | newzibottom | newzi | |
|
; fu |
|
faddp st(1),st(0) ; testzi | newzibottom | newzi | fu |
|
fxch st(1) ; newzibottom | testzi | newzi | fu |
|
|
|
; if (newzibottom >= testzi) |
|
; goto newtop; |
|
|
|
fcomp st(1) ; testzi | newzi | fu |
|
|
|
fxch st(1) ; newzi | testzi | fu |
|
fmul ds:dword ptr[float_1_point_001] ; newzitop | testzi | fu |
|
fxch st(1) ; testzi | newzitop | fu |
|
|
|
fnstsw ax |
|
test ah,001h |
|
jz Lnewtop_fpop3 |
|
|
|
; if (newzitop >= testzi) |
|
; { |
|
|
|
fcomp st(1) ; newzitop | fu |
|
fnstsw ax |
|
test ah,045h |
|
jz Lsortloop_fpop2 |
|
|
|
; if (surf->d_zistepu >= surf2->d_zistepu) |
|
; goto newtop; |
|
|
|
fld ds:dword ptr[st_d_zistepu+edi] ; surf->d_zistepu | newzitop | fu |
|
fcomp ds:dword ptr[st_d_zistepu+esi] ; newzitop | fu |
|
fnstsw ax |
|
test ah,001h |
|
jz Lnewtop_fpop2 |
|
|
|
Lsortloop_fpop2: |
|
fstp st(0) ; clear the FP stack |
|
fstp st(0) |
|
mov eax,ds:dword ptr[st_key+edi] |
|
jmp Lsortloop |
|
|
|
|
|
public _R_EdgeCodeEnd |
|
_R_EdgeCodeEnd: |
|
|
|
|
|
;---------------------------------------------------------------------- |
|
; Surface array address code patching routine |
|
;---------------------------------------------------------------------- |
|
|
|
align 4 |
|
public _R_SurfacePatch |
|
_R_SurfacePatch: |
|
|
|
mov eax,ds:dword ptr[_surfaces] |
|
add eax,offset st_size |
|
mov ds:dword ptr[LPatch4-4],eax |
|
|
|
add eax,offset st_next |
|
mov ds:dword ptr[LPatch0-4],eax |
|
mov ds:dword ptr[LPatch2-4],eax |
|
mov ds:dword ptr[LPatch3-4],eax |
|
|
|
ret |
|
|
|
_TEXT ENDS |
|
endif ;id386 |
|
END
|
|
|