Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Tree: 372afde46e
Fetching contributors…

Cannot retrieve contributors at this time

1235 lines (1057 sloc) 30.058 kB
.386P
.model FLAT
;
; d_draw16.s
; x86 assembly-language horizontal 8-bpp span-drawing code, with 16-pixel
; subdivision.
;
include qasm.inc
include d_if.inc
if id386
;----------------------------------------------------------------------
; 8-bpp horizontal span drawing code for polygons, with no transparency and
; 16-pixel subdivision.
;
; Assumes there is at least one span in pspans, and that every span
; contains at least one pixel
;----------------------------------------------------------------------
_DATA SEGMENT
_DATA ENDS
_TEXT SEGMENT
; out-of-line, rarely-needed clamping code
LClampHigh0:
mov esi,ds:dword ptr[_bbextents]
jmp LClampReentry0
LClampHighOrLow0:
jg LClampHigh0
xor esi,esi
jmp LClampReentry0
LClampHigh1:
mov edx,ds:dword ptr[_bbextentt]
jmp LClampReentry1
LClampHighOrLow1:
jg LClampHigh1
xor edx,edx
jmp LClampReentry1
LClampLow2:
mov ebp,4096
jmp LClampReentry2
LClampHigh2:
mov ebp,ds:dword ptr[_bbextents]
jmp LClampReentry2
LClampLow3:
mov ecx,4096
jmp LClampReentry3
LClampHigh3:
mov ecx,ds:dword ptr[_bbextentt]
jmp LClampReentry3
LClampLow4:
mov eax,4096
jmp LClampReentry4
LClampHigh4:
mov eax,ds:dword ptr[_bbextents]
jmp LClampReentry4
LClampLow5:
mov ebx,4096
jmp LClampReentry5
LClampHigh5:
mov ebx,ds:dword ptr[_bbextentt]
jmp LClampReentry5
pspans equ 4+16
align 4
public _D_DrawSpans16
_D_DrawSpans16:
push ebp ; preserve caller's stack frame
push edi
push esi ; preserve register variables
push ebx
;
; set up scaled-by-16 steps, for 16-long segments; also set up cacheblock
; and span list pointers
;
; TODO: any overlap from rearranging?
fld ds:dword ptr[_d_sdivzstepu]
fmul ds:dword ptr[fp_16]
mov edx,ds:dword ptr[_cacheblock]
fld ds:dword ptr[_d_tdivzstepu]
fmul ds:dword ptr[fp_16]
mov ebx,ds:dword ptr[pspans+esp] ; point to the first span descriptor
fld ds:dword ptr[_d_zistepu]
fmul ds:dword ptr[fp_16]
mov ds:dword ptr[pbase],edx ; pbase = cacheblock
fstp ds:dword ptr[zi16stepu]
fstp ds:dword ptr[tdivz16stepu]
fstp ds:dword ptr[sdivz16stepu]
LSpanLoop:
;
; set up the initial s/z, t/z, and 1/z on the FP stack, and generate the
; initial s and t values
;
; FIXME: pipeline FILD?
fild ds:dword ptr[espan_t_v+ebx]
fild ds:dword ptr[espan_t_u+ebx]
fld st(1) ; dv | du | dv
fmul ds:dword ptr[_d_sdivzstepv] ; dv*d_sdivzstepv | du | dv
fld st(1) ; du | dv*d_sdivzstepv | du | dv
fmul ds:dword ptr[_d_sdivzstepu] ; du*d_sdivzstepu | dv*d_sdivzstepv | du | dv
fld st(2) ; du | du*d_sdivzstepu | dv*d_sdivzstepv | du | dv
fmul ds:dword ptr[_d_tdivzstepu] ; du*d_tdivzstepu | du*d_sdivzstepu |
; dv*d_sdivzstepv | du | dv
fxch st(1) ; du*d_sdivzstepu | du*d_tdivzstepu |
; dv*d_sdivzstepv | du | dv
faddp st(2),st(0) ; du*d_tdivzstepu |
; du*d_sdivzstepu + dv*d_sdivzstepv | du | dv
fxch st(1) ; du*d_sdivzstepu + dv*d_sdivzstepv |
; du*d_tdivzstepu | du | dv
fld st(3) ; dv | du*d_sdivzstepu + dv*d_sdivzstepv |
; du*d_tdivzstepu | du | dv
fmul ds:dword ptr[_d_tdivzstepv] ; dv*d_tdivzstepv |
; du*d_sdivzstepu + dv*d_sdivzstepv |
; du*d_tdivzstepu | du | dv
fxch st(1) ; du*d_sdivzstepu + dv*d_sdivzstepv |
; dv*d_tdivzstepv | du*d_tdivzstepu | du | dv
fadd ds:dword ptr[_d_sdivzorigin] ; sdivz = d_sdivzorigin + dv*d_sdivzstepv +
; du*d_sdivzstepu; stays in %st(2) at end
fxch st(4) ; dv | dv*d_tdivzstepv | du*d_tdivzstepu | du |
; s/z
fmul ds:dword ptr[_d_zistepv] ; dv*d_zistepv | dv*d_tdivzstepv |
; du*d_tdivzstepu | du | s/z
fxch st(1) ; dv*d_tdivzstepv | dv*d_zistepv |
; du*d_tdivzstepu | du | s/z
faddp st(2),st(0) ; dv*d_zistepv |
; dv*d_tdivzstepv + du*d_tdivzstepu | du | s/z
fxch st(2) ; du | dv*d_tdivzstepv + du*d_tdivzstepu |
; dv*d_zistepv | s/z
fmul ds:dword ptr[_d_zistepu] ; du*d_zistepu |
; dv*d_tdivzstepv + du*d_tdivzstepu |
; dv*d_zistepv | s/z
fxch st(1) ; dv*d_tdivzstepv + du*d_tdivzstepu |
; du*d_zistepu | dv*d_zistepv | s/z
fadd ds:dword ptr[_d_tdivzorigin] ; tdivz = d_tdivzorigin + dv*d_tdivzstepv +
; du*d_tdivzstepu; stays in %st(1) at end
fxch st(2) ; dv*d_zistepv | du*d_zistepu | t/z | s/z
faddp st(1),st(0) ; dv*d_zistepv + du*d_zistepu | t/z | s/z
fld ds:dword ptr[fp_64k] ; fp_64k | dv*d_zistepv + du*d_zistepu | t/z | s/z
fxch st(1) ; dv*d_zistepv + du*d_zistepu | fp_64k | t/z | s/z
fadd ds:dword ptr[_d_ziorigin] ; zi = d_ziorigin + dv*d_zistepv +
; du*d_zistepu; stays in %st(0) at end
; 1/z | fp_64k | t/z | s/z
;
; calculate and clamp s & t
;
fdiv st(1),st(0) ; 1/z | z*64k | t/z | s/z
;
; point %edi to the first pixel in the span
;
mov ecx,ds:dword ptr[_d_viewbuffer]
mov eax,ds:dword ptr[espan_t_v+ebx]
mov ds:dword ptr[pspantemp],ebx ; preserve spans pointer
mov edx,ds:dword ptr[_tadjust]
mov esi,ds:dword ptr[_sadjust]
mov edi,ds:dword ptr[_d_scantable+eax*4] ; v * screenwidth
add edi,ecx
mov ecx,ds:dword ptr[espan_t_u+ebx]
add edi,ecx ; pdest = &pdestspan[scans->u];
mov ecx,ds:dword ptr[espan_t_count+ebx]
;
; now start the FDIV for the end of the span
;
cmp ecx,16
ja LSetupNotLast1
dec ecx
jz LCleanup1 ; if only one pixel, no need to start an FDIV
mov ds:dword ptr[spancountminus1],ecx
; finish up the s and t calcs
fxch st(1) ; z*64k | 1/z | t/z | s/z
fld st(0) ; z*64k | z*64k | 1/z | t/z | s/z
fmul st(0),st(4) ; s | z*64k | 1/z | t/z | s/z
fxch st(1) ; z*64k | s | 1/z | t/z | s/z
fmul st(0),st(3) ; t | s | 1/z | t/z | s/z
fxch st(1) ; s | t | 1/z | t/z | s/z
fistp ds:dword ptr[s] ; 1/z | t | t/z | s/z
fistp ds:dword ptr[t] ; 1/z | t/z | s/z
fild ds:dword ptr[spancountminus1]
fld ds:dword ptr[_d_tdivzstepu] ; C(d_tdivzstepu) | spancountminus1
fld ds:dword ptr[_d_zistepu] ; C(d_zistepu) | C(d_tdivzstepu) | spancountminus1
fmul st(0),st(2) ; C(d_zistepu)*scm1 | C(d_tdivzstepu) | scm1
fxch st(1) ; C(d_tdivzstepu) | C(d_zistepu)*scm1 | scm1
fmul st(0),st(2) ; C(d_tdivzstepu)*scm1 | C(d_zistepu)*scm1 | scm1
fxch st(2) ; scm1 | C(d_zistepu)*scm1 | C(d_tdivzstepu)*scm1
fmul ds:dword ptr[_d_sdivzstepu] ; C(d_sdivzstepu)*scm1 | C(d_zistepu)*scm1 |
; C(d_tdivzstepu)*scm1
fxch st(1) ; C(d_zistepu)*scm1 | C(d_sdivzstepu)*scm1 |
; C(d_tdivzstepu)*scm1
faddp st(3),st(0) ; C(d_sdivzstepu)*scm1 | C(d_tdivzstepu)*scm1
fxch st(1) ; C(d_tdivzstepu)*scm1 | C(d_sdivzstepu)*scm1
faddp st(3),st(0) ; C(d_sdivzstepu)*scm1
faddp st(3),st(0)
fld ds:dword ptr[fp_64k]
fdiv st(0),st(1) ; this is what we've gone to all this trouble to
; overlap
jmp LFDIVInFlight1
LCleanup1:
; finish up the s and t calcs
fxch st(1) ; z*64k | 1/z | t/z | s/z
fld st(0) ; z*64k | z*64k | 1/z | t/z | s/z
fmul st(0),st(4) ; s | z*64k | 1/z | t/z | s/z
fxch st(1) ; z*64k | s | 1/z | t/z | s/z
fmul st(0),st(3) ; t | s | 1/z | t/z | s/z
fxch st(1) ; s | t | 1/z | t/z | s/z
fistp ds:dword ptr[s] ; 1/z | t | t/z | s/z
fistp ds:dword ptr[t] ; 1/z | t/z | s/z
jmp LFDIVInFlight1
align 4
LSetupNotLast1:
; finish up the s and t calcs
fxch st(1) ; z*64k | 1/z | t/z | s/z
fld st(0) ; z*64k | z*64k | 1/z | t/z | s/z
fmul st(0),st(4) ; s | z*64k | 1/z | t/z | s/z
fxch st(1) ; z*64k | s | 1/z | t/z | s/z
fmul st(0),st(3) ; t | s | 1/z | t/z | s/z
fxch st(1) ; s | t | 1/z | t/z | s/z
fistp ds:dword ptr[s] ; 1/z | t | t/z | s/z
fistp ds:dword ptr[t] ; 1/z | t/z | s/z
fadd ds:dword ptr[zi16stepu]
fxch st(2)
fadd ds:dword ptr[sdivz16stepu]
fxch st(2)
fld ds:dword ptr[tdivz16stepu]
faddp st(2),st(0)
fld ds:dword ptr[fp_64k]
fdiv st(0),st(1) ; z = 1/1/z
; this is what we've gone to all this trouble to
; overlap
LFDIVInFlight1:
add esi,ds:dword ptr[s]
add edx,ds:dword ptr[t]
mov ebx,ds:dword ptr[_bbextents]
mov ebp,ds:dword ptr[_bbextentt]
cmp esi,ebx
ja LClampHighOrLow0
LClampReentry0:
mov ds:dword ptr[s],esi
mov ebx,ds:dword ptr[pbase]
shl esi,16
cmp edx,ebp
mov ds:dword ptr[sfracf],esi
ja LClampHighOrLow1
LClampReentry1:
mov ds:dword ptr[t],edx
mov esi,ds:dword ptr[s] ; sfrac = scans->sfrac;
shl edx,16
mov eax,ds:dword ptr[t] ; tfrac = scans->tfrac;
sar esi,16
mov ds:dword ptr[tfracf],edx
;
; calculate the texture starting address
;
sar eax,16
mov edx,ds:dword ptr[_cachewidth]
imul eax,edx ; (tfrac >> 16) * cachewidth
add esi,ebx
add esi,eax ; psource = pbase + (sfrac >> 16) +
; ((tfrac >> 16) * cachewidth);
;
; determine whether last span or not
;
cmp ecx,16
jna LLastSegment
;
; not the last segment; do full 16-wide segment
;
LNotLastSegment:
;
; advance s/z, t/z, and 1/z, and calculate s & t at end of span and steps to
; get there
;
; pick up after the FDIV that was left in flight previously
fld st(0) ; duplicate it
fmul st(0),st(4) ; s = s/z * z
fxch st(1)
fmul st(0),st(3) ; t = t/z * z
fxch st(1)
fistp ds:dword ptr[snext]
fistp ds:dword ptr[tnext]
mov eax,ds:dword ptr[snext]
mov edx,ds:dword ptr[tnext]
mov bl,ds:byte ptr[esi] ; get first source texel
sub ecx,16 ; count off this segments' pixels
mov ebp,ds:dword ptr[_sadjust]
mov ds:dword ptr[counttemp],ecx ; remember count of remaining pixels
mov ecx,ds:dword ptr[_tadjust]
mov ds:byte ptr[edi],bl ; store first dest pixel
add ebp,eax
add ecx,edx
mov eax,ds:dword ptr[_bbextents]
mov edx,ds:dword ptr[_bbextentt]
cmp ebp,4096
jl LClampLow2
cmp ebp,eax
ja LClampHigh2
LClampReentry2:
cmp ecx,4096
jl LClampLow3
cmp ecx,edx
ja LClampHigh3
LClampReentry3:
mov ds:dword ptr[snext],ebp
mov ds:dword ptr[tnext],ecx
sub ebp,ds:dword ptr[s]
sub ecx,ds:dword ptr[t]
;
; set up advancetable
;
mov eax,ecx
mov edx,ebp
sar eax,20 ; tstep >>= 16;
jz LZero
sar edx,20 ; sstep >>= 16;
mov ebx,ds:dword ptr[_cachewidth]
imul eax,ebx
jmp LSetUp1
LZero:
sar edx,20 ; sstep >>= 16;
mov ebx,ds:dword ptr[_cachewidth]
LSetUp1:
add eax,edx ; add in sstep
; (tstep >> 16) * cachewidth + (sstep >> 16);
mov edx,ds:dword ptr[tfracf]
mov ds:dword ptr[advancetable+4],eax ; advance base in t
add eax,ebx ; ((tstep >> 16) + 1) * cachewidth +
; (sstep >> 16);
shl ebp,12 ; left-justify sstep fractional part
mov ebx,ds:dword ptr[sfracf]
shl ecx,12 ; left-justify tstep fractional part
mov ds:dword ptr[advancetable],eax ; advance extra in t
mov ds:dword ptr[tstep],ecx
add edx,ecx ; advance tfrac fractional part by tstep frac
sbb ecx,ecx ; turn tstep carry into -1 (0 if none)
add ebx,ebp ; advance sfrac fractional part by sstep frac
adc esi,ds:dword ptr[advancetable+4+ecx*4] ; point to next source texel
add edx,ds:dword ptr[tstep]
sbb ecx,ecx
mov al,ds:byte ptr[esi]
add ebx,ebp
mov ds:byte ptr[1+edi],al
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
sbb ecx,ecx
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
sbb ecx,ecx
mov ds:byte ptr[2+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
sbb ecx,ecx
mov ds:byte ptr[3+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
sbb ecx,ecx
mov ds:byte ptr[4+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
sbb ecx,ecx
mov ds:byte ptr[5+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
sbb ecx,ecx
mov ds:byte ptr[6+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
sbb ecx,ecx
mov ds:byte ptr[7+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
;
; start FDIV for end of next segment in flight, so it can overlap
;
mov ecx,ds:dword ptr[counttemp]
cmp ecx,16 ; more than one segment after this?
ja LSetupNotLast2 ; yes
dec ecx
jz LFDIVInFlight2 ; if only one pixel, no need to start an FDIV
mov ds:dword ptr[spancountminus1],ecx
fild ds:dword ptr[spancountminus1]
fld ds:dword ptr[_d_zistepu] ; C(d_zistepu) | spancountminus1
fmul st(0),st(1) ; C(d_zistepu)*scm1 | scm1
fld ds:dword ptr[_d_tdivzstepu] ; C(d_tdivzstepu) | C(d_zistepu)*scm1 | scm1
fmul st(0),st(2) ; C(d_tdivzstepu)*scm1 | C(d_zistepu)*scm1 | scm1
fxch st(1) ; C(d_zistepu)*scm1 | C(d_tdivzstepu)*scm1 | scm1
faddp st(3),st(0) ; C(d_tdivzstepu)*scm1 | scm1
fxch st(1) ; scm1 | C(d_tdivzstepu)*scm1
fmul ds:dword ptr[_d_sdivzstepu] ; C(d_sdivzstepu)*scm1 | C(d_tdivzstepu)*scm1
fxch st(1) ; C(d_tdivzstepu)*scm1 | C(d_sdivzstepu)*scm1
faddp st(3),st(0) ; C(d_sdivzstepu)*scm1
fld ds:dword ptr[fp_64k] ; 64k | C(d_sdivzstepu)*scm1
fxch st(1) ; C(d_sdivzstepu)*scm1 | 64k
faddp st(4),st(0) ; 64k
fdiv st(0),st(1) ; this is what we've gone to all this trouble to
; overlap
jmp LFDIVInFlight2
align 4
LSetupNotLast2:
fadd ds:dword ptr[zi16stepu]
fxch st(2)
fadd ds:dword ptr[sdivz16stepu]
fxch st(2)
fld ds:dword ptr[tdivz16stepu]
faddp st(2),st(0)
fld ds:dword ptr[fp_64k]
fdiv st(0),st(1) ; z = 1/1/z
; this is what we've gone to all this trouble to
; overlap
LFDIVInFlight2:
mov ds:dword ptr[counttemp],ecx
add edx,ds:dword ptr[tstep]
sbb ecx,ecx
mov ds:byte ptr[8+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
sbb ecx,ecx
mov ds:byte ptr[9+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
sbb ecx,ecx
mov ds:byte ptr[10+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
sbb ecx,ecx
mov ds:byte ptr[11+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
sbb ecx,ecx
mov ds:byte ptr[12+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
sbb ecx,ecx
mov ds:byte ptr[13+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
sbb ecx,ecx
mov ds:byte ptr[14+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edi,16
mov ds:dword ptr[tfracf],edx
mov edx,ds:dword ptr[snext]
mov ds:dword ptr[sfracf],ebx
mov ebx,ds:dword ptr[tnext]
mov ds:dword ptr[s],edx
mov ds:dword ptr[t],ebx
mov ecx,ds:dword ptr[counttemp] ; retrieve count
;
; determine whether last span or not
;
cmp ecx,16 ; are there multiple segments remaining?
mov ds:byte ptr[-1+edi],al
ja LNotLastSegment ; yes
;
; last segment of scan
;
LLastSegment:
;
; advance s/z, t/z, and 1/z, and calculate s & t at end of span and steps to
; get there. The number of pixels left is variable, and we want to land on the
; last pixel, not step one past it, so we can't run into arithmetic problems
;
test ecx,ecx
jz LNoSteps ; just draw the last pixel and we're done
; pick up after the FDIV that was left in flight previously
fld st(0) ; duplicate it
fmul st(0),st(4) ; s = s/z * z
fxch st(1)
fmul st(0),st(3) ; t = t/z * z
fxch st(1)
fistp ds:dword ptr[snext]
fistp ds:dword ptr[tnext]
mov al,ds:byte ptr[esi] ; load first texel in segment
mov ebx,ds:dword ptr[_tadjust]
mov ds:byte ptr[edi],al ; store first pixel in segment
mov eax,ds:dword ptr[_sadjust]
add eax,ds:dword ptr[snext]
add ebx,ds:dword ptr[tnext]
mov ebp,ds:dword ptr[_bbextents]
mov edx,ds:dword ptr[_bbextentt]
cmp eax,4096
jl LClampLow4
cmp eax,ebp
ja LClampHigh4
LClampReentry4:
mov ds:dword ptr[snext],eax
cmp ebx,4096
jl LClampLow5
cmp ebx,edx
ja LClampHigh5
LClampReentry5:
cmp ecx,1 ; don't bother
je LOnlyOneStep ; if two pixels in segment, there's only one step,
; of the segment length
sub eax,ds:dword ptr[s]
sub ebx,ds:dword ptr[t]
add eax,eax ; convert to 15.17 format so multiply by 1.31
add ebx,ebx ; reciprocal yields 16.48
imul ds:dword ptr[reciprocal_table_16-8+ecx*4] ; sstep = (snext - s) /
; (spancount-1)
mov ebp,edx
mov eax,ebx
imul ds:dword ptr[reciprocal_table_16-8+ecx*4] ; tstep = (tnext - t) /
; (spancount-1)
LSetEntryvec:
;
; set up advancetable
;
mov ebx,ds:dword ptr[entryvec_table_16+ecx*4]
mov eax,edx
mov ds:dword ptr[jumptemp],ebx ; entry point into code for RET later
mov ecx,ebp
sar edx,16 ; tstep >>= 16;
mov ebx,ds:dword ptr[_cachewidth]
sar ecx,16 ; sstep >>= 16;
imul edx,ebx
add edx,ecx ; add in sstep
; (tstep >> 16) * cachewidth + (sstep >> 16);
mov ecx,ds:dword ptr[tfracf]
mov ds:dword ptr[advancetable+4],edx ; advance base in t
add edx,ebx ; ((tstep >> 16) + 1) * cachewidth +
; (sstep >> 16);
shl ebp,16 ; left-justify sstep fractional part
mov ebx,ds:dword ptr[sfracf]
shl eax,16 ; left-justify tstep fractional part
mov ds:dword ptr[advancetable],edx ; advance extra in t
mov ds:dword ptr[tstep],eax
mov edx,ecx
add edx,eax
sbb ecx,ecx
add ebx,ebp
adc esi,ds:dword ptr[advancetable+4+ecx*4]
jmp dword ptr[jumptemp] ; jump to the number-of-pixels handler
;----------------------------------------
LNoSteps:
mov al,ds:byte ptr[esi] ; load first texel in segment
sub edi,15 ; adjust for hardwired offset
jmp LEndSpan
LOnlyOneStep:
sub eax,ds:dword ptr[s]
sub ebx,ds:dword ptr[t]
mov ebp,eax
mov edx,ebx
jmp LSetEntryvec
;----------------------------------------
public Entry2_16, Entry3_16, Entry4_16, Entry5_16
public Entry6_16, Entry7_16, Entry8_16, Entry9_16
public Entry10_16, Entry11_16, Entry12_16, Entry13_16
public Entry14_16, Entry15_16, Entry16_16
Entry2_16:
sub edi,14 ; adjust for hardwired offsets
mov al,ds:byte ptr[esi]
jmp LEntry2_16
;----------------------------------------
Entry3_16:
sub edi,13 ; adjust for hardwired offsets
add edx,eax
mov al,ds:byte ptr[esi]
sbb ecx,ecx
add ebx,ebp
adc esi,ds:dword ptr[advancetable+4+ecx*4]
jmp LEntry3_16
;----------------------------------------
Entry4_16:
sub edi,12 ; adjust for hardwired offsets
add edx,eax
mov al,ds:byte ptr[esi]
sbb ecx,ecx
add ebx,ebp
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
jmp LEntry4_16
;----------------------------------------
Entry5_16:
sub edi,11 ; adjust for hardwired offsets
add edx,eax
mov al,ds:byte ptr[esi]
sbb ecx,ecx
add ebx,ebp
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
jmp LEntry5_16
;----------------------------------------
Entry6_16:
sub edi,10 ; adjust for hardwired offsets
add edx,eax
mov al,ds:byte ptr[esi]
sbb ecx,ecx
add ebx,ebp
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
jmp LEntry6_16
;----------------------------------------
Entry7_16:
sub edi,9 ; adjust for hardwired offsets
add edx,eax
mov al,ds:byte ptr[esi]
sbb ecx,ecx
add ebx,ebp
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
jmp LEntry7_16
;----------------------------------------
Entry8_16:
sub edi,8 ; adjust for hardwired offsets
add edx,eax
mov al,ds:byte ptr[esi]
sbb ecx,ecx
add ebx,ebp
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
jmp LEntry8_16
;----------------------------------------
Entry9_16:
sub edi,7 ; adjust for hardwired offsets
add edx,eax
mov al,ds:byte ptr[esi]
sbb ecx,ecx
add ebx,ebp
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
jmp LEntry9_16
;----------------------------------------
Entry10_16:
sub edi,6 ; adjust for hardwired offsets
add edx,eax
mov al,ds:byte ptr[esi]
sbb ecx,ecx
add ebx,ebp
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
jmp LEntry10_16
;----------------------------------------
Entry11_16:
sub edi,5 ; adjust for hardwired offsets
add edx,eax
mov al,ds:byte ptr[esi]
sbb ecx,ecx
add ebx,ebp
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
jmp LEntry11_16
;----------------------------------------
Entry12_16:
sub edi,4 ; adjust for hardwired offsets
add edx,eax
mov al,ds:byte ptr[esi]
sbb ecx,ecx
add ebx,ebp
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
jmp LEntry12_16
;----------------------------------------
Entry13_16:
sub edi,3 ; adjust for hardwired offsets
add edx,eax
mov al,ds:byte ptr[esi]
sbb ecx,ecx
add ebx,ebp
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
jmp LEntry13_16
;----------------------------------------
Entry14_16:
sub edi,2 ; adjust for hardwired offsets
add edx,eax
mov al,ds:byte ptr[esi]
sbb ecx,ecx
add ebx,ebp
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
jmp LEntry14_16
;----------------------------------------
Entry15_16:
dec edi ; adjust for hardwired offsets
add edx,eax
mov al,ds:byte ptr[esi]
sbb ecx,ecx
add ebx,ebp
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
jmp LEntry15_16
;----------------------------------------
Entry16_16:
add edx,eax
mov al,ds:byte ptr[esi]
sbb ecx,ecx
add ebx,ebp
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
sbb ecx,ecx
mov ds:byte ptr[1+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
LEntry15_16:
sbb ecx,ecx
mov ds:byte ptr[2+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
LEntry14_16:
sbb ecx,ecx
mov ds:byte ptr[3+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
LEntry13_16:
sbb ecx,ecx
mov ds:byte ptr[4+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
LEntry12_16:
sbb ecx,ecx
mov ds:byte ptr[5+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
LEntry11_16:
sbb ecx,ecx
mov ds:byte ptr[6+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
LEntry10_16:
sbb ecx,ecx
mov ds:byte ptr[7+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
LEntry9_16:
sbb ecx,ecx
mov ds:byte ptr[8+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
LEntry8_16:
sbb ecx,ecx
mov ds:byte ptr[9+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
LEntry7_16:
sbb ecx,ecx
mov ds:byte ptr[10+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
LEntry6_16:
sbb ecx,ecx
mov ds:byte ptr[11+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
LEntry5_16:
sbb ecx,ecx
mov ds:byte ptr[12+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
add edx,ds:dword ptr[tstep]
LEntry4_16:
sbb ecx,ecx
mov ds:byte ptr[13+edi],al
add ebx,ebp
mov al,ds:byte ptr[esi]
adc esi,ds:dword ptr[advancetable+4+ecx*4]
LEntry3_16:
mov ds:byte ptr[14+edi],al
mov al,ds:byte ptr[esi]
LEntry2_16:
LEndSpan:
;
; clear s/z, t/z, 1/z from FP stack
;
fstp st(0)
fstp st(0)
fstp st(0)
mov ebx,ds:dword ptr[pspantemp] ; restore spans pointer
mov ebx,ds:dword ptr[espan_t_pnext+ebx] ; point to next span
test ebx,ebx ; any more spans?
mov ds:byte ptr[15+edi],al
jnz LSpanLoop ; more spans
pop ebx ; restore register variables
pop esi
pop edi
pop ebp ; restore the caller's stack frame
ret
;----------------------------------------------------------------------
; 8-bpp horizontal span z drawing codefor polygons, with no transparency.
;
; Assumes there is at least one span in pzspans, and that every span
; contains at least one pixel
;----------------------------------------------------------------------
; z-clamp on a non-negative gradient span
LClamp:
mov edx,040000000h
xor ebx,ebx
fstp st(0)
jmp LZDraw
; z-clamp on a negative gradient span
LClampNeg:
mov edx,040000000h
xor ebx,ebx
fstp st(0)
jmp LZDrawNeg
pzspans equ 4+16
public _D_DrawZSpans
_D_DrawZSpans:
push ebp ; preserve caller's stack frame
push edi
push esi ; preserve register variables
push ebx
fld ds:dword ptr[_d_zistepu]
mov eax,ds:dword ptr[_d_zistepu]
mov esi,ds:dword ptr[pzspans+esp]
test eax,eax
jz LFNegSpan
fmul ds:dword ptr[Float2ToThe31nd]
fistp ds:dword ptr[izistep] ; note: we are relying on FP exceptions being turned
; off here to avoid range problems
mov ebx,ds:dword ptr[izistep] ; remains loaded for all spans
LFSpanLoop:
; set up the initial 1/z value
fild ds:dword ptr[espan_t_v+esi]
fild ds:dword ptr[espan_t_u+esi]
mov ecx,ds:dword ptr[espan_t_v+esi]
mov edi,ds:dword ptr[_d_pzbuffer]
fmul ds:dword ptr[_d_zistepu]
fxch st(1)
fmul ds:dword ptr[_d_zistepv]
fxch st(1)
fadd ds:dword ptr[_d_ziorigin]
imul ecx,ds:dword ptr[_d_zrowbytes]
faddp st(1),st(0)
; clamp if z is nearer than 2 (1/z > 0.5)
fcom ds:dword ptr[float_point5]
add edi,ecx
mov edx,ds:dword ptr[espan_t_u+esi]
add edx,edx ; word count
mov ecx,ds:dword ptr[espan_t_count+esi]
add edi,edx ; pdest = &pdestspan[scans->u];
push esi ; preserve spans pointer
fnstsw ax
test ah,045h
jz LClamp
fmul ds:dword ptr[Float2ToThe31nd]
fistp ds:dword ptr[izi] ; note: we are relying on FP exceptions being turned
; off here to avoid problems when the span is closer
; than 1/(2**31)
mov edx,ds:dword ptr[izi]
; at this point:
; %ebx = izistep
; %ecx = count
; %edx = izi
; %edi = pdest
LZDraw:
; do a single pixel up front, if necessary to dword align the destination
test edi,2
jz LFMiddle
mov eax,edx
add edx,ebx
shr eax,16
dec ecx
mov ds:word ptr[edi],ax
add edi,2
; do middle a pair of aligned dwords at a time
LFMiddle:
push ecx
shr ecx,1 ; count / 2
jz LFLast ; no aligned dwords to do
shr ecx,1 ; (count / 2) / 2
jnc LFMiddleLoop ; even number of aligned dwords to do
mov eax,edx
add edx,ebx
shr eax,16
mov esi,edx
add edx,ebx
and esi,0FFFF0000h
or eax,esi
mov ds:dword ptr[edi],eax
add edi,4
and ecx,ecx
jz LFLast
LFMiddleLoop:
mov eax,edx
add edx,ebx
shr eax,16
mov esi,edx
add edx,ebx
and esi,0FFFF0000h
or eax,esi
mov ebp,edx
mov ds:dword ptr[edi],eax
add edx,ebx
shr ebp,16
mov esi,edx
add edx,ebx
and esi,0FFFF0000h
or ebp,esi
mov ds:dword ptr[4+edi],ebp ; FIXME: eliminate register contention
add edi,8
dec ecx
jnz LFMiddleLoop
LFLast:
pop ecx ; retrieve count
pop esi ; retrieve span pointer
; do the last, unaligned pixel, if there is one
and ecx,1 ; is there an odd pixel left to do?
jz LFSpanDone ; no
shr edx,16
mov ds:word ptr[edi],dx ; do the final pixel's z
LFSpanDone:
mov esi,ds:dword ptr[espan_t_pnext+esi]
test esi,esi
jnz LFSpanLoop
jmp LFDone
LFNegSpan:
fmul ds:dword ptr[FloatMinus2ToThe31nd]
fistp ds:dword ptr[izistep] ; note: we are relying on FP exceptions being turned
; off here to avoid range problems
mov ebx,ds:dword ptr[izistep] ; remains loaded for all spans
LFNegSpanLoop:
; set up the initial 1/z value
fild ds:dword ptr[espan_t_v+esi]
fild ds:dword ptr[espan_t_u+esi]
mov ecx,ds:dword ptr[espan_t_v+esi]
mov edi,ds:dword ptr[_d_pzbuffer]
fmul ds:dword ptr[_d_zistepu]
fxch st(1)
fmul ds:dword ptr[_d_zistepv]
fxch st(1)
fadd ds:dword ptr[_d_ziorigin]
imul ecx,ds:dword ptr[_d_zrowbytes]
faddp st(1),st(0)
; clamp if z is nearer than 2 (1/z > 0.5)
fcom ds:dword ptr[float_point5]
add edi,ecx
mov edx,ds:dword ptr[espan_t_u+esi]
add edx,edx ; word count
mov ecx,ds:dword ptr[espan_t_count+esi]
add edi,edx ; pdest = &pdestspan[scans->u];
push esi ; preserve spans pointer
fnstsw ax
test ah,045h
jz LClampNeg
fmul ds:dword ptr[Float2ToThe31nd]
fistp ds:dword ptr[izi] ; note: we are relying on FP exceptions being turned
; off here to avoid problems when the span is closer
; than 1/(2**31)
mov edx,ds:dword ptr[izi]
; at this point:
; %ebx = izistep
; %ecx = count
; %edx = izi
; %edi = pdest
LZDrawNeg:
; do a single pixel up front, if necessary to dword align the destination
test edi,2
jz LFNegMiddle
mov eax,edx
sub edx,ebx
shr eax,16
dec ecx
mov ds:word ptr[edi],ax
add edi,2
; do middle a pair of aligned dwords at a time
LFNegMiddle:
push ecx
shr ecx,1 ; count / 2
jz LFNegLast ; no aligned dwords to do
shr ecx,1 ; (count / 2) / 2
jnc LFNegMiddleLoop ; even number of aligned dwords to do
mov eax,edx
sub edx,ebx
shr eax,16
mov esi,edx
sub edx,ebx
and esi,0FFFF0000h
or eax,esi
mov ds:dword ptr[edi],eax
add edi,4
and ecx,ecx
jz LFNegLast
LFNegMiddleLoop:
mov eax,edx
sub edx,ebx
shr eax,16
mov esi,edx
sub edx,ebx
and esi,0FFFF0000h
or eax,esi
mov ebp,edx
mov ds:dword ptr[edi],eax
sub edx,ebx
shr ebp,16
mov esi,edx
sub edx,ebx
and esi,0FFFF0000h
or ebp,esi
mov ds:dword ptr[4+edi],ebp ; FIXME: eliminate register contention
add edi,8
dec ecx
jnz LFNegMiddleLoop
LFNegLast:
pop ecx ; retrieve count
pop esi ; retrieve span pointer
; do the last, unaligned pixel, if there is one
and ecx,1 ; is there an odd pixel left to do?
jz LFNegSpanDone ; no
shr edx,16
mov ds:word ptr[edi],dx ; do the final pixel's z
LFNegSpanDone:
mov esi,ds:dword ptr[espan_t_pnext+esi]
test esi,esi
jnz LFNegSpanLoop
LFDone:
pop ebx ; restore register variables
pop esi
pop edi
pop ebp ; restore the caller's stack frame
ret
_TEXT ENDS
endif ;id386
END
Jump to Line
Something went wrong with that request. Please try again.