Source to 321/ref_soft/r_edgea.asm


Enter a symbol's name here to quickly find it.

 .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