r_spr8.pas

delphi编的不错的贪吃蛇

 cmp    al,offset TRANSPARENT_COLOR
 jz     @Lp3
 mov    ds:word ptr[4+ecx],bp
 mov    ds:byte ptr[2+edi],al
@Lp3:
 add    ebp,ds:dword ptr[izistep]
 adc    ebp,0
 add    edx,ds:dword ptr[tstep]
 sbb    eax,eax
 add    ebx,ds:dword ptr[sstep]
 adc    esi,ds:dword ptr[advancetable+4+eax*4]

 cmp    bp,ds:word ptr[6+ecx]
 jl     @Lp4
 mov    al,ds:byte ptr[esi]
 cmp    al,offset TRANSPARENT_COLOR
 jz     @Lp4
 mov    ds:word ptr[6+ecx],bp
 mov    ds:byte ptr[3+edi],al
@Lp4:
 add    ebp,ds:dword ptr[izistep]
 adc    ebp,0
 add    edx,ds:dword ptr[tstep]
 sbb    eax,eax
 add    ebx,ds:dword ptr[sstep]
 adc    esi,ds:dword ptr[advancetable+4+eax*4]

 cmp    bp,ds:word ptr[8+ecx]
 jl     @Lp5
 mov    al,ds:byte ptr[esi]
 cmp    al,offset TRANSPARENT_COLOR
 jz     @Lp5
 mov    ds:word ptr[8+ecx],bp
 mov    ds:byte ptr[4+edi],al
@Lp5:
 add    ebp,ds:dword ptr[izistep]
 adc    ebp,0
 add    edx,ds:dword ptr[tstep]
 sbb    eax,eax
 add    ebx,ds:dword ptr[sstep]
 adc    esi,ds:dword ptr[advancetable+4+eax*4]

//
// start FDIV for end of next segment in flight, so it can overlap
//
 pop    eax
 cmp    eax,8	// more than one segment after this?
 ja     @LSetupNotLast2	// yes

 dec    eax
 jz     @LFDIVInFlight2	// if only one pixel, no need to start an FDIV
 mov    ds:dword ptr[spancountminus1],eax
 fild   ds:dword ptr[spancountminus1]

 fld    ds:dword ptr[_d_zistepu]	// _d_zistepu | spancountminus1
 fmul   st(0),st(1)	// _d_zistepu*scm1 | scm1
 fld    ds:dword ptr[_d_tdivzstepu]	// _d_tdivzstepu | _d_zistepu*scm1 | scm1
 fmul   st(0),st(2)	// _d_tdivzstepu*scm1 | _d_zistepu*scm1 | scm1
 fxch   st(1)	// _d_zistepu*scm1 | _d_tdivzstepu*scm1 | scm1
 faddp  st(3),st(0)	// _d_tdivzstepu*scm1 | scm1
 fxch   st(1)	// scm1 | _d_tdivzstepu*scm1
 fmul   ds:dword ptr[_d_sdivzstepu]	// _d_sdivzstepu*scm1 | _d_tdivzstepu*scm1
 fxch   st(1)	// _d_tdivzstepu*scm1 | _d_sdivzstepu*scm1
 faddp  st(3),st(0)	// _d_sdivzstepu*scm1
 fld    ds:dword ptr[fp_64k]	// 64k | _d_sdivzstepu*scm1
 fxch   st(1)	// _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[zi8stepu]
 fxch   st(2)
 fadd   ds:dword ptr[sdivz8stepu]
 fxch   st(2)
 fld    ds:dword ptr[tdivz8stepu]
 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:
 push   eax

 cmp    bp,ds:word ptr[10+ecx]
 jl     @Lp6
 mov    al,ds:byte ptr[esi]
 cmp    al,offset TRANSPARENT_COLOR
 jz     @Lp6
 mov    ds:word ptr[10+ecx],bp
 mov    ds:byte ptr[5+edi],al
@Lp6:
 add    ebp,ds:dword ptr[izistep]
 adc    ebp,0
 add    edx,ds:dword ptr[tstep]
 sbb    eax,eax
 add    ebx,ds:dword ptr[sstep]
 adc    esi,ds:dword ptr[advancetable+4+eax*4]

 cmp    bp,ds:word ptr[12+ecx]
 jl     @Lp7
 mov    al,ds:byte ptr[esi]
 cmp    al,offset TRANSPARENT_COLOR
 jz     @Lp7
 mov    ds:word ptr[12+ecx],bp
 mov    ds:byte ptr[6+edi],al
@Lp7:
 add    ebp,ds:dword ptr[izistep]
 adc    ebp,0
 add    edx,ds:dword ptr[tstep]
 sbb    eax,eax
 add    ebx,ds:dword ptr[sstep]
 adc    esi,ds:dword ptr[advancetable+4+eax*4]

 cmp    bp,ds:word ptr[14+ecx]
 jl     @Lp8
 mov    al,ds:byte ptr[esi]
 cmp    al,offset TRANSPARENT_COLOR
 jz     @Lp8
 mov    ds:word ptr[14+ecx],bp
 mov    ds:byte ptr[7+edi],al
@Lp8:
 add    ebp,ds:dword ptr[izistep]
 adc    ebp,0
 add    edx,ds:dword ptr[tstep]
 sbb    eax,eax
 add    ebx,ds:dword ptr[sstep]
 adc    esi,ds:dword ptr[advancetable+4+eax*4]

 add    edi,8
 add    ecx,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    ds:dword ptr[pz],ecx
 mov    ds:dword ptr[izi],ebp

 pop    ecx	// retrieve count

//
// determine whether last span or not
//
 cmp    ecx,8	// are there multiple segments remaining?
 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    ebx,ds:dword ptr[_tadjust]
 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,2048
 jl     @LClampLow4
 cmp    eax,ebp
 ja     @LClampHigh4
@LClampReentry4:
 mov    ds:dword ptr[snext],eax

 cmp    ebx,2048
 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-8+ecx*4]	// sstep = (snext - s) / (spancount-1)
 mov    ebp,edx

 mov    eax,ebx
 imul   ds:dword ptr[reciprocal_table-8+ecx*4]	// tstep = (tnext - t) / (spancount-1)

@LSetEntryvec:
//
// set up advancetable
//
 mov    ebx,ds:dword ptr[spr8entryvec_table+ecx*4]
 mov    eax,edx
 push   ebx	// entry point into code for RET later
 mov    ecx,ebp
 sar    ecx,16	// sstep >>= 16;
 mov    ebx,ds:dword ptr[_cachewidth]
 sar    edx,16	// tstep >>= 16;
 jz     @LIsZeroLast
 imul   edx,ebx	// (tstep >> 16) * cachewidth;
@LIsZeroLast:
 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    ds:dword ptr[sstep],ebp
 mov    edx,ecx

 mov    ecx,ds:dword ptr[pz]
 mov    ebp,ds:dword ptr[izi]

 ret	// jump to the number-of-pixels handler

//----------------------------------------

@LNoSteps:
 mov    ecx,ds:dword ptr[pz]
 sub    edi,7	// adjust for hardwired offset
 sub    ecx,14
 jmp    @LEndSpan


@LOnlyOneStep:
 sub    eax,ds:dword ptr[s]
 sub    ebx,ds:dword ptr[t]
 mov    ebp,eax
 mov    edx,ebx
 jmp    @LSetEntryvec

//----------------------------------------

// public Spr8Entry2_8
@Spr8Entry2_8:
 sub    edi,6	// adjust for hardwired offsets
 sub    ecx,12
 mov    al,ds:byte ptr[esi]
 jmp    @LLEntry2_8

//----------------------------------------

// public Spr8Entry3_8
@Spr8Entry3_8:
 sub    edi,5	// adjust for hardwired offsets
 sub    ecx,10
 jmp    @LLEntry3_8

//----------------------------------------

// public Spr8Entry4_8
@Spr8Entry4_8:
 sub    edi,4	// adjust for hardwired offsets
 sub    ecx,8
 jmp    @LLEntry4_8

//----------------------------------------

// public Spr8Entry5_8
@Spr8Entry5_8:
 sub    edi,3	// adjust for hardwired offsets
 sub    ecx,6
 jmp    @LLEntry5_8

//----------------------------------------

// public Spr8Entry6_8
@Spr8Entry6_8:
 sub    edi,2	// adjust for hardwired offsets
 sub    ecx,4
 jmp    @LLEntry6_8

//----------------------------------------

// public Spr8Entry7_8
@Spr8Entry7_8:
 dec    edi	// adjust for hardwired offsets
 sub    ecx,2
 jmp    @LLEntry7_8

//----------------------------------------

// public Spr8Entry8_8
@Spr8Entry8_8:
 cmp    bp,ds:word ptr[ecx]
 jl     @Lp9
 mov    al,ds:byte ptr[esi]
 cmp    al,offset TRANSPARENT_COLOR
 jz     @Lp9
 mov    ds:word ptr[ecx],bp
 mov    ds:byte ptr[edi],al
@Lp9:
 add    ebp,ds:dword ptr[izistep]
 adc    ebp,0
 add    edx,ds:dword ptr[tstep]
 sbb    eax,eax
 add    ebx,ds:dword ptr[sstep]
 adc    esi,ds:dword ptr[advancetable+4+eax*4]
@LLEntry7_8:
 cmp    bp,ds:word ptr[2+ecx]
 jl     @Lp10
 mov    al,ds:byte ptr[esi]
 cmp    al,offset TRANSPARENT_COLOR
 jz     @Lp10
 mov    ds:word ptr[2+ecx],bp
 mov    ds:byte ptr[1+edi],al
@Lp10:
 add    ebp,ds:dword ptr[izistep]
 adc    ebp,0
 add    edx,ds:dword ptr[tstep]
 sbb    eax,eax
 add    ebx,ds:dword ptr[sstep]
 adc    esi,ds:dword ptr[advancetable+4+eax*4]
@LLEntry6_8:
 cmp    bp,ds:word ptr[4+ecx]
 jl     @Lp11
 mov    al,ds:byte ptr[esi]
 cmp    al,offset TRANSPARENT_COLOR
 jz     @Lp11
 mov    ds:word ptr[4+ecx],bp
 mov    ds:byte ptr[2+edi],al
@Lp11:
 add    ebp,ds:dword ptr[izistep]
 adc    ebp,0
 add    edx,ds:dword ptr[tstep]
 sbb    eax,eax
 add    ebx,ds:dword ptr[sstep]
 adc    esi,ds:dword ptr[advancetable+4+eax*4]
@LLEntry5_8:
 cmp    bp,ds:word ptr[6+ecx]
 jl     @Lp12
 mov    al,ds:byte ptr[esi]
 cmp    al,offset TRANSPARENT_COLOR
 jz     @Lp12
 mov    ds:word ptr[6+ecx],bp
 mov    ds:byte ptr[3+edi],al
@Lp12:
 add    ebp,ds:dword ptr[izistep]
 adc    ebp,0
 add    edx,ds:dword ptr[tstep]
 sbb    eax,eax
 add    ebx,ds:dword ptr[sstep]
 adc    esi,ds:dword ptr[advancetable+4+eax*4]
@LLEntry4_8:
 cmp    bp,ds:word ptr[8+ecx]
 jl     @Lp13
 mov    al,ds:byte ptr[esi]
 cmp    al,offset TRANSPARENT_COLOR
 jz     @Lp13
 mov    ds:word ptr[8+ecx],bp
 mov    ds:byte ptr[4+edi],al
@Lp13:
 add    ebp,ds:dword ptr[izistep]
 adc    ebp,0
 add    edx,ds:dword ptr[tstep]
 sbb    eax,eax
 add    ebx,ds:dword ptr[sstep]
 adc    esi,ds:dword ptr[advancetable+4+eax*4]
@LLEntry3_8:
 cmp    bp,ds:word ptr[10+ecx]
 jl     @Lp14
 mov    al,ds:byte ptr[esi]
 cmp    al,offset TRANSPARENT_COLOR
 jz     @Lp14
 mov    ds:word ptr[10+ecx],bp
 mov    ds:byte ptr[5+edi],al
@Lp14:
 add    ebp,ds:dword ptr[izistep]
 adc    ebp,0
 add    edx,ds:dword ptr[tstep]
 sbb    eax,eax
 add    ebx,ds:dword ptr[sstep]
 adc    esi,ds:dword ptr[advancetable+4+eax*4]
@LLEntry2_8:
 cmp    bp,ds:word ptr[12+ecx]
 jl     @Lp15
 mov    al,ds:byte ptr[esi]
 cmp    al,offset TRANSPARENT_COLOR
 jz     @Lp15
 mov    ds:word ptr[12+ecx],bp
 mov    ds:byte ptr[6+edi],al
@Lp15:
 add    ebp,ds:dword ptr[izistep]
 adc    ebp,0
 add    edx,ds:dword ptr[tstep]
 sbb    eax,eax
 add    ebx,ds:dword ptr[sstep]
 adc    esi,ds:dword ptr[advancetable+4+eax*4]

@LEndSpan:
 cmp    bp,ds:word ptr[14+ecx]
 jl     @Lp16
 mov    al,ds:byte ptr[esi]	// load first texel in segment
 cmp    al,offset TRANSPARENT_COLOR
 jz     @Lp16
 mov    ds:word ptr[14+ecx],bp
 mov    ds:byte ptr[7+edi],al
@Lp16:

//
// clear s/z, t/z, 1/z from FP stack
//
 fstp   st(0)
 fstp   st(0)
 fstp   st(0)

 pop    ebx	// restore spans pointer
@LNextSpan:
 add    ebx,offset sspan_t_size	// point to next span
 mov    ecx,ds:dword ptr[sspan_t_count+ebx]
 cmp    ecx,0	// any more spans?
 jg     @LSpanLoop	// yes
 jz     @LNextSpan	// yes, but this one's empty

 pop    ebx	// restore register variables
 pop    esi
 pop    edi
 pop    ebp	// restore the caller's stack frame
end;

procedure FixTables; cdecl;
begin
// Here we will call
end;

{$ENDIF}

initialization

{$IFDEF id386}
  FixTables; // setup tables : spr8entryvec_table
{$ENDIF}

end.