mirror/JurassicParkTrespasser
1
0
Fork 0
mirror of https://github.com/OpenTrespasser/JurassicParkTrespasser.git synced 2024-12-24 17:41:56 +00:00
Code Issues Projects Releases Wiki Activity
master
JurassicParkTrespasser/jp2_pc/Source/Lib/Renderer/Primitives/P5/DrawSubTriangleAlpha.inl

1504 lines
38 KiB
C++
Raw Permalink Blame History

/***********************************************************************************************
*
* Copyright © DreamWorks Interactive, 1997.
*
* Contents:
* Specialized version of the flat shaded alpha primitive
* Optimized for the Pentium Processor
*
***********************************************************************************************
*
* $Log:: /JP2_PC/Source/Lib/Renderer/Primitives/P5/DrawSubTriangleAlpha.cpp $
*
* 7 98.07.17 6:36p Mmouni
* Added new alpha texture primitive.
*
* 6 10/10/97 1:47p Mmouni
* All inner loops are now left to right only, and optimized some.
*
* 5 9/01/97 9:19p Mmouni
* Applied Pentium optimizations and fixed dword alignment problem.
*
* 4 9/01/97 8:02p Rwyatt
*
* 3 8/17/97 9:43p Rwyatt
* Copy of Pro version just to get into assembler, this must be optimized later.
*
* 2 8/17/97 12:19a Rwyatt
* Terrain texturing, added to source safe yet again..
*
* 1 8/17/97 12:18a Rwyatt
* Alpha blend initial implementation
*
***********************************************************************************************/
#include "lib\renderer\LightBlend.hpp"
static uint32 u4AlphaColourMask;
static uint32 u4AlphaColourReference;
//*****************************************************************************************
//
// Solid alhpa colour.
//
void DrawSubtriangle(TAlphaColour* pscan, CDrawPolygon<TAlphaColour>* pdtri)
{
fx_inc = pdtri->pedgeBase->lineIncrement.fxX;
fx_diff = pdtri->pedgeBase->lineIncrement.fxXDifference;
u4AlphaColourMask = u2AlphaColourMask | (u2AlphaColourMask<<16);
u4AlphaColourReference = u2AlphaColourReference | (u2AlphaColourReference<<16);
_asm
{
mov edx,[pdtri]
mov ecx,[pscan]
mov eax,[edx]CDrawPolygonBase.iY
mov edi,[edx]CDrawPolygonBase.iLineStartIndex
// ecx, edi, eax and edx are also set from the loop end.
//--------------------------------------------------------------------------------------
// scan line start
NEXT_SCAN:
and eax,[bEvenScanlinesOnly]
jnz short SKIP_LOOP
mov esi,[ecx]TAlphaColour.fxX.i4Fx
mov eax,[edx]CDrawPolygonBase.fxLineLength.i4Fx
add eax,esi
sar eax,16
sar esi,16
add edi,eax
sub esi,eax
jge short SKIP_LOOP
//--------------------------------------------------------------------------------------
// all scan lines are drawn the same way
add edi,edi
mov eax,gsGlobals.pvScreen
add edi,eax
mov ecx,[u4AlphaColourMask]
mov edx,[u4AlphaColourReference]
lea eax,[edi + esi*2]
test eax,3
jz short N_LOOP
//--------------------------------------------------------------------------------------
// do a single WORD to dword align
mov bx,word ptr[edi + esi*2]
and ebx,ecx
or ebx,edx
and ebx,0x0000ffff
mov al,byte ptr[lbAlphaConstant.au2Colour + ebx*2]
mov ah,byte ptr[lbAlphaConstant.au2Colour + ebx*2 + 1]
mov [edi + esi*2],ax
inc esi // we are now aligned to a DWORD
jz short SKIP_LOOP // are we done?
//--------------------------------------------------------------------------------------
// Main loop does 2 words at a time
N_LOOP:
add esi,2
jge short DONE_SCAN
mov ebx,[edi + esi*2 - 4] // (U1) Read dword
and ebx,ecx // (U1) Apply AlphaColourMask
or ebx,edx // (U1) Apply AlphaColourRefernce
mov eax,ebx // (U1) Copy dword
and ebx,0x0000FFFF // (V0) Mask lower 16 bits
shr eax,16 // (U1) Shift pixel down
xor ecx,ecx // (V0) Clear ecx
mov cl,byte ptr[lbAlphaConstant.au2Colour + ebx*2] // (U1)
mov ch,byte ptr[lbAlphaConstant.au2Colour + ebx*2 + 1] // (U1)
mov bl,byte ptr[lbAlphaConstant.au2Colour + eax*2] // (V0)
mov bh,byte ptr[lbAlphaConstant.au2Colour + eax*2 + 1] // (U1)
shl ebx,16 // (U1) Shift pixel up
or ebx,ecx // (U1) Merge pixels
mov ecx,[u4AlphaColourMask] // (V0) Restore ecx
mov [edi + esi*2 - 4],ebx // (U1) Write dword
jmp short N_LOOP // (V0)
DONE_SCAN:
jz short DWORD_REMAIN
//--------------------------------------------------------------------------------------
// do a single word to finish
mov bx,word ptr[edi + esi*2 - 4]
and ebx,ecx
or ebx,edx
and ebx,0x0000ffff
mov al,byte ptr[lbAlphaConstant.au2Colour + ebx*2]
mov ah,byte ptr[lbAlphaConstant.au2Colour + ebx*2 + 1]
mov [edi + esi*2 - 4],ax
jmp short SKIP_LOOP
//--------------------------------------------------------------------------------------
// do a DWORD to finish
DWORD_REMAIN:
mov ebx,[edi + esi*2 - 4] // Read dword
and ebx,ecx // Apply AlphaColourMask
or ebx,edx // Apply AlphaColourRefernce
mov eax,ebx // Copy dword
and ebx,0x0000FFFF // Mask lower 16 bits
shr eax,16 // Shift pixel down
xor ecx,ecx // Clear ecx
mov cl,byte ptr[lbAlphaConstant.au2Colour + ebx*2]
mov ch,byte ptr[lbAlphaConstant.au2Colour + ebx*2 + 1]
mov bl,byte ptr[lbAlphaConstant.au2Colour + eax*2]
mov bh,byte ptr[lbAlphaConstant.au2Colour + eax*2 + 1]
shl ebx,16 // Shift pixel up
or ebx,ecx // Merge pixels
mov [edi + esi*2 - 4],ebx // Write dword
//--------------------------------------------------------------------------------------
// Loop control an sub pixel correction for edges
SKIP_LOOP:
mov edx,[pdtri]
mov ecx,[pscan]
mov eax,[fx_inc]
mov esi,[ecx]TAlphaColour.fxXDifference
add [ecx]TAlphaColour.fxX,eax
add esi,[fx_diff]
cmp esi,(1<<16)
jz short UFLOW
// greater than or equal to 1 is an overflow
sub esi,(1<<16)
jmp short DONE_Y
UFLOW:
cmp esi,0
jge short DONE_Y
add esi,(1<<16)
DONE_Y:
// calc the new end point and line length
mov [ecx]TAlphaColour.fxXDifference,esi
mov eax,[edx]CDrawPolygonBase.fxLineLength.i4Fx
mov edi,[edx]CDrawPolygonBase.iLineStartIndex
add eax,[edx]CDrawPolygonBase.fxDeltaLineLength.i4Fx
add edi,gsGlobals.u4LinePixels
mov [edx]CDrawPolygonBase.fxLineLength.i4Fx, eax
mov eax,[edx]CDrawPolygonBase.iY
mov esi,[edx]CDrawPolygonBase.iYTo
inc eax
mov [edx]CDrawPolygonBase.iLineStartIndex, edi
mov [edx]CDrawPolygonBase.iY,eax
cmp eax,esi
jl short NEXT_SCAN
}
}
//*****************************************************************************************
//
// Perspective, stipple alpha textured, 16 bit mode.
//
void DrawSubtriangle(TAlphaTexPersp* pscan, CDrawPolygon<TAlphaTexPersp>* pdtri)
{
typedef TAlphaTexPersp::TIndex prevent_internal_compiler_errors;
static void* pvLastClut = 0;
static void* pvLastTexture = 0;
TAlphaTexPersp* plinc = &pdtri->pedgeBase->lineIncrement;
__asm
{
//
// Local copies of edge stepping values.
//
// fx_inc = pdtri->pedgeBase->lineIncrement.fxX;
// fx_diff = pdtri->pedgeBase->lineIncrement.fxXDifference;
// f_inc_uinvz = pdtri->pedgeBase->lineIncrement.indCoord.fUInvZ;
// f_inc_vinvz = pdtri->pedgeBase->lineIncrement.indCoord.fVInvZ;
// f_inc_invz = pdtri->pedgeBase->lineIncrement.indCoord.fInvZ;
//
mov eax,[plinc]
mov esi,[pdtri] // Pointer to polygon object.
mov ecx,[pscan] // Pointer to scanline object.
mov ebx,[eax]TAlphaTexPersp.fxX
mov edx,[eax]TAlphaTexPersp.fxXDifference
mov fx_inc,ebx
mov fx_diff,edx
mov ebx,[eax]TAlphaTexPersp.indCoord.fUInvZ
mov edx,[eax]TAlphaTexPersp.indCoord.fVInvZ
mov f_inc_uinvz,ebx
mov ebx,[eax]TAlphaTexPersp.indCoord.fInvZ
mov f_inc_vinvz,edx
mov f_inc_invz,ebx
//
// Iterate through the scanlines that intersect the subtriangle.
//
Y_LOOP:
push ebp // Save ebp.
// Check to see if we sould skip this scanline.
mov eax,[esi]CDrawPolygonBase.iY
mov ebx,[bEvenScanlinesOnly]
and eax,ebx
jnz END_OF_SCANLINE
// Setup for prespective correction and looping.
//PERSPECTIVE_SCANLINE_PROLOGUE(TAlphaTexPersp)
// Determine the start and end of the scanline.
mov ebx,[ecx]TAlphaTexPersp.fxX.i4Fx
mov eax,[esi]CDrawPolygonBase.fxLineLength.i4Fx
add ebx,eax
mov eax,[ecx]TAlphaTexPersp.fxX.i4Fx
sar ebx,16
mov edx,[esi]CDrawPolygonBase.iLineStartIndex
sar eax,16
add edx,ebx
sub eax,ebx // i_pixel
jge END_OF_SCANLINE
mov [i_screen_index],edx
mov ebx,[ecx]TAlphaTexPersp.fxX.i4Fx // Fractional X.
sar ebx,16 // Integer X.
mov edi,[esi]CDrawPolygonBase.iY // Integer Y.
xor ebx,edi // X xor Y
mov [i_pixel],eax
// Skip over a pixel if ((y xor x) & 1).
test ebx,1
jz NO_SKIP
inc eax // Increment i_pixel
jz END_OF_SCANLINE
// Copy and increment global texture values (16 cycles).
fld fDUInvZEdge // ustep
fmul fInvSubdivideLen
fld fDVInvZEdge // vstep
fmul fInvSubdivideLen
fld fDInvZEdge // zstep
fmul fInvSubdivideLen
fxch st(2) // us vs zs
fadd [ecx]TAlphaTexPersp.indCoord.fUInvZ // u vs zs
fxch st(1)
fadd [ecx]TAlphaTexPersp.indCoord.fVInvZ // v u zs
fxch st(2)
fadd [ecx]TAlphaTexPersp.indCoord.fInvZ // z u v
fxch st(1) // u z v
fstp fGUInvZ
fxch st(1)
fstp fGVInvZ
fstp fGInvZ
mov [i_pixel],eax
jmp short DONE_WITH_SKIP
//---------------------------------------------------------------------------
// Caclulate values for the first correction span, and start the divide for
// the next span.
//
NO_SKIP:
// Copy global texture values.
mov ebx,[ecx]TAlphaTexPersp.indCoord.fUInvZ
mov esi,[ecx]TAlphaTexPersp.indCoord.fVInvZ
mov edi,[ecx]TAlphaTexPersp.indCoord.fInvZ
mov fGUInvZ,ebx
mov fGVInvZ,esi
mov fGInvZ,edi
DONE_WITH_SKIP:
// Copy edge values.
mov ebx,fDUInvZEdge
mov esi,fDVInvZEdge
mov edi,fDInvZEdge
mov fDUInvZScanline,ebx
mov fDVInvZScanline,esi
mov fDInvZScanline,edi
mov ebx,[iSubdivideLen]
// scan line is +ve
add eax,ebx
jle short DONE_DIVIDE_PIXEL
// calc the new +ve ratio
fild [i_pixel]
fld fInvSubdivideLen
fchs
// Subdivision is smaller than iSubdivideLen
fmulp st(1),st(0) // st(0) = (-)fInvSubdivideLen * i_pixel;
fld fDUInvZScanline // U C
xor eax,eax
fmul st(0),st(1) // U*C C
fxch st(1) // C U*C
fld fDVInvZScanline // V C U*C
fxch st(1) // C V U*C
fmul st(1),st(0) // C V*C U*C
// stall(1)
fmul fDInvZScanline // Z*C V*C U*C
fxch st(2) // U*C V*C Z*C
fstp fDUInvZScanline // V*C Z*C
fstp fDVInvZScanline // Z*C
fstp fDInvZScanline
DONE_DIVIDE_PIXEL:
// Get current u, v and z values.
mov [iNextSubdivide],eax
mov ebx,dword ptr[fGInvZ] // f_z = fInverse(fGInvZ);
mov eax,iFI_SIGN_EXPONENT_SUB
sub eax,ebx
and ebx,iFI_MASK_MANTISSA
sar ebx,iSHIFT_MANTISSA
and eax,iFI_MASK_SIGN_EXPONENT
fld [fGUInvZ] // U/Z
add eax,dword ptr[i4InverseMantissa + ebx*4]
mov ebx,[bClampUV]
mov dword ptr[f_z],eax
/* Are we clamping for this polygon */
test ebx,ebx
jz short NO_CLAMP
//---------------------------------------------------------------------------
// Set current texture coordinates (clamped).
fmul [f_z]
fld [fGVInvZ]
fmul [f_z]
fxch st(1)
// stall(1)
fstp [f_u]
// Clamp f_u
mov eax,[f_u]
mov ebx,fTexEdgeTolerance
mov ecx,fTexWidth
cmp eax,ebx
jge short U_NOT_LESS1
mov eax,ebx
U_NOT_LESS1:
cmp eax,ecx
jle short U_NOT_GREATER1
mov eax,ecx
U_NOT_GREATER1:
mov ecx,fTexHeight
mov [f_u],eax
fld [f_u]
fadd [dFastFixed16Conversion]
fxch st(1)
// Clamp f_v
fstp [f_v]
mov eax,[f_v]
cmp eax,ebx
jge short V_NOT_LESS1
mov eax,ebx
V_NOT_LESS1:
cmp eax,ecx
jle short V_NOT_GREATER1
mov eax,ecx
V_NOT_GREATER1:
mov [f_v],eax
fld [f_v]
fadd [dFastFixed16Conversion]
fxch st(1)
fstp [d_temp_a]
fld [fGUInvZ]
fxch st(1)
fstp [d_temp_b]
// Increment u, v and z values.
fadd [fDUInvZScanline]
fld [fGVInvZ]
fadd [fDVInvZScanline]
fxch st(1)
fld [fGInvZ]
fadd [fDInvZScanline]
// Setup esi=uFrac, ecx=vFrac, edx=UVInt for Abrash texture loop.
mov edx,dword ptr[d_temp_a] // U (16.16)
mov eax,dword ptr[d_temp_b] // V (16.16)
sar eax,16 // Integral V
mov ecx,[iTexWidth] // Texture width.
imul eax,ecx // iv*twidth
sar edx,16 // Integral U
mov esi,dword ptr[d_temp_a] // Copy of U
shl esi,16 // UFrac
mov ecx,dword ptr[d_temp_b] // Copy of V
shl ecx,16 // VFrac
shr ebx,1 // Turn into word offset.
add edx,eax // iu + iv*twidth
fstp [fGInvZ]
// Get next u, v and z values.
mov ebx,dword ptr[fGInvZ] // f_next_z = fInverse(fGInvZ);
mov eax,iFI_SIGN_EXPONENT_SUB
sub eax,ebx
and ebx,iFI_MASK_MANTISSA
sar ebx,iSHIFT_MANTISSA
and eax,iFI_MASK_SIGN_EXPONENT
fst [fGUInvZ]
mov ebx,dword ptr[i4InverseMantissa + ebx*4]
mov edi,[i_pixel]
add eax,ebx
mov ebx,[iNextSubdivide]
mov dword ptr[f_next_z],eax
sub edi,ebx
// Set new texture coordinate increments.
fmul [f_next_z]
fxch st(1)
fst [fGVInvZ]
fmul [f_next_z]
fxch st(1)
fstp [fU] // V
// Clamp fU
mov eax,[fU]
mov ebx,fTexEdgeTolerance
mov ebp,fTexWidth
cmp eax,ebx
jge short U_NOT_LESS2
mov eax,ebx
U_NOT_LESS2:
cmp eax,ebp
jle short U_NOT_GREATER2
mov eax,ebp
U_NOT_GREATER2:
mov ebp,fTexHeight
mov [fU],eax
fld [fU] // U,V
fsub [f_u] // U-fu,V
fxch st(1) // V,U-fu
fstp [fV] // U-fu
// Clamp fV
mov eax,[fV]
cmp eax,ebx
jge short V_NOT_LESS2
mov eax,ebx
V_NOT_LESS2:
cmp eax,ebp
jle short V_NOT_GREATER2
mov eax,ebp
V_NOT_GREATER2:
mov [fV],eax
fld [fV] // V U-fu
fsub [f_v] // V-fv,U-fu
fxch st(1) // U,V
fmul float ptr[fInverseIntTable+edi*4] // (C*U),V
fxch st(1) // V,(C*U)
// stall(1)
fmul float ptr[fInverseIntTable+edi*4] // (C*V),(C*U)
fxch st(1) // (C*U),(C*V)
fadd [dFastFixed16Conversion]
fxch st(1)
// stall(1)
fadd [dFastFixed16Conversion]
fxch st(1)
// stall(1)
fstp [d_temp_a]
fstp [d_temp_b]
mov edi,dword ptr[d_temp_a] // uslope
mov eax,dword ptr[d_temp_b] // vslope
sar edi,15 // integer part of uslope
mov ebp,dword ptr[d_temp_a] // uslope again
shl ebp,17 // fractional part of uslope
mov ebx,eax // vslope again
sar eax,15 // integer part of vslope
mov [w2dDeltaTex.uUFrac],ebp // store UFrac
imul eax,[iTexWidth] // ivslope*twidth
shl ebx,17 // fractional part of vslope
mov [w2dDeltaTex.uVFrac],ebx // store VFrac
add edi,eax // ivslope*twidth + iuslope
mov ebp,[iTexWidth] // Load texture width.
mov [w2dDeltaTex.iUVInt+4],edi // store integer stride
add edi,ebp // add twidth to integer stride
mov [w2dDeltaTex.iUVInt],edi // store integer stride + twidth
mov eax,[iNextSubdivide]
jmp CLAMP_DONE
NO_CLAMP:
/*--------------------------------------------------------------------------- */
/* Set current texture coordinates (not clamped). */
fmul [f_z] /* U */
fld [fGVInvZ] /* V/Z U */
fmul [f_z] /* V U */
fxch st(1) /* U V */
/* stall(1) */
fst [f_u]
fadd [dFastFixed16Conversion] /* iU V */
fxch st(1) /* V iU */
fst [f_v]
fadd [dFastFixed16Conversion] /* iV iU */
fxch st(1) /* iU iV */
fstp [d_temp_a] /* iV */
fld [fGUInvZ] /* U/Z iV */
fxch st(1) /* iV U/Z */
fstp [d_temp_b] /* U/Z */
/* Increment u, v and z values. */
fadd [fDUInvZScanline] /* U2/Z */
fld [fGVInvZ]
fadd [fDVInvZScanline] /* V2/Z U2/Z */
fxch st(1) /* U2/Z V2/Z */
fld [fGInvZ] /* 1/Z U2/Z V2/Z */
fadd [fDInvZScanline] /* 1/Z2 U2/Z V2/Z */
/* Setup esi=uFrac, ecx=vFrac, edx=UVInt for Abrash texture loop. */
mov edx,dword ptr[d_temp_a] /* U (16.16) */
mov eax,dword ptr[d_temp_b] /* V (16.16) */
sar eax,16 /* Integral V */
mov ecx,[iTexWidth] /* Texture width. */
shl eax,9 /* iv*twidth */
sar edx,16 /* Integral U */
mov ebp,[u4TextureTileMaskStepU] /* Load mask for integral U */
and edx,ebp /* Mask integral U before adding. */
mov esi,dword ptr[d_temp_a] /* Copy of U */
shl esi,16 /* UFrac */
mov ecx,dword ptr[d_temp_b] /* Copy of V */
shl ecx,16 /* VFrac */
add edx,eax /* iu + iv*twidth */
fstp [fGInvZ]
/* Get next u, v and z values. */
mov ebx,dword ptr[fGInvZ] /* f_next_z = fInverse(fGInvZ); */
mov eax,iFI_SIGN_EXPONENT_SUB
sub eax,ebx
and ebx,iFI_MASK_MANTISSA
sar ebx,iSHIFT_MANTISSA
and eax,iFI_MASK_SIGN_EXPONENT
fst [fGUInvZ]
mov ebx,dword ptr[i4InverseMantissa + ebx*4]
mov edi,[i_pixel]
add eax,ebx
mov ebx,[iNextSubdivide]
mov dword ptr[f_next_z],eax
sub edi,ebx
/* Set new texture coordinate increments. */
fmul [f_next_z] /* U,V/Z */
fxch st(1) /* V/Z,U */
fst [fGVInvZ]
fmul [f_next_z] /* V,U */
fxch st(1) /* U,V */
fst [fU] /* U,V */
fsub [f_u] /* U-fu,V */
fxch st(1) /* V,U-fu */
fst [fV]
fsub [f_v] /* V-fv,U-fu */
fxch st(1) /* U,V */
fmul float ptr[fInverseIntTable+edi*4] /* (C*U),V */
fxch st(1) /* V,(C*U) */
/* stall(1) */
fmul float ptr[fInverseIntTable+edi*4] /* (C*V),(C*U) */
fxch st(1) /* (C*U),(C*V) */
fadd [dFastFixed16Conversion]
fxch st(1)
/* stall(1) */
fadd [dFastFixed16Conversion]
fxch st(1)
/* stall(1) */
fstp [d_temp_a]
fstp [d_temp_b]
mov edi,dword ptr[d_temp_a] /* uslope */
mov eax,dword ptr[d_temp_b] /* vslope */
sar edi,15 /* integer part of uslope */
mov ebp,dword ptr[d_temp_a] /* uslope again */
shl ebp,17 /* fractional part of uslope */
mov ebx,eax /* vslope again */
sar eax,15 /* integer part of vslope */
mov [w2dDeltaTex.uUFrac],ebp /* store UFrac */
shl eax,9 /* ivslope*twidth */
shl ebx,17 /* fractional part of vslope */
mov ebp,[u4TextureTileMaskStepU] /* Load mask for integral U step */
and edi,ebp /* Mask integral U before adding. */
mov [w2dDeltaTex.uVFrac],ebx /* store VFrac */
add edi,eax /* ivslope*twidth + iuslope */
mov ebp,[iTexWidth] /* Load texture width. */
mov [w2dDeltaTex.iUVInt+4],edi /* store integer stride */
add edi,ebp /* add twidth to integer stride */
mov [w2dDeltaTex.iUVInt],edi /* store integer stride + twidth */
mov eax,[iNextSubdivide]
/* --------------------------------------------------------------------------------- */
/* Both clmaped and non-clamped primitives end up here.. */
CLAMP_DONE:
test eax,eax // Next subdivision is zero length?
jz SUBDIVISION_LOOP
// iCacheNextSubdivide = iSetNextDividePixel(iNextSubdivide);
mov edi,[iSubdivideLen]
// scan line is +ve
add eax,edi
jle short DONE_DIVIDE_PIXEL_CACHE
// calc the new +ve ratio
fild iNextSubdivide
fld fInvSubdivideLen
fchs
// Subdivision is smaller than iSubdivideLen
fmulp st(1),st(0) // st(0) = (-)fInvSubdivideLen * i_pixel;
fld fDUInvZEdge // U C
xor eax,eax
fmul st(0),st(1) // U*C C
fxch st(1) // C U*C
fld fDVInvZEdge // V C U*C
fxch st(1) // C V U*C
fmul st(1),st(0) // C V*C U*C
mov [iCacheNextSubdivide],eax
fmul fDInvZEdge // Z*C V*C U*C
fxch st(2) // U*C V*C Z*C
fst fDUInvZScanline
fadd fGUInvZ
fxch st(1)
fst fDVInvZScanline
fadd fGVInvZ
fxch st(2)
fst fDInvZScanline
fadd fGInvZ
fxch st(2)
fstp fGVInvZ
fstp fGUInvZ
fst fGInvZ
fdivr fOne // Start the next division.
jmp SUBDIVISION_LOOP
DONE_DIVIDE_PIXEL_CACHE:
// Copy texture values.
mov ebp,[fDUInvZEdge]
mov ebx,[fDVInvZEdge]
mov edi,[fDInvZEdge]
mov [fDUInvZScanline],ebp
mov [fDVInvZScanline],ebx
mov [fDInvZScanline],edi
fld fDUInvZScanline // U
fadd fGUInvZ
fld fDVInvZScanline // V U
fadd fGVInvZ
fld fDInvZScanline // Z V U
fadd fGInvZ
fxch st(2) // U V Z
fstp fGUInvZ
fstp fGVInvZ
fst fGInvZ
fdivr fOne // Start the next division.
mov [iCacheNextSubdivide],eax
SUBDIVISION_LOOP:
//---------------------------------------------------------------------------
// Start the next subdivision.
// ecx,edx,esi = texture values
//
mov edi,[i_pixel]
mov eax,[iNextSubdivide]
sub edi,eax
//
// eax = i_pixel
// edi = inner loop count
// ecx,edx,esi = texture values
//
mov ebp,gsGlobals.pvScreen // Pointer the screen.
mov ebx,[i_screen_index] // Load scanline offset.
add ebx,eax // Add scanline offset to i_pixel
mov [i_pixel],eax // Save i_pixel.
and edx,[u4TextureTileMask] // Mask for tiling.
xor eax,eax // Clear eax
lea ebx,[ebp+ebx*2] // Base of span in ebx.
mov ebp,[w2dDeltaTex]CWalk2D.uVFrac // Load V fraction step.
mov [pvBaseOfLine],ebx // Save pointer to destination.
mov ebx,[pvTextureBitmap] // Load pointer to texture.
//-----------------------------------------------------------------------
// Draw the scanline.
//
// eax = temp for pixel
// ebx = base of texture map / base of scanline
// ecx = Ufrac
// edx = UVint
// esi = Vfrac
// edi = offset & count
// ebp = vfrac step / v carry
//
INNER_LOOP:
add ecx,ebp // Step V fraction.
mov al,[ebx + edx*2] // Read texture value (low).
sbb ebp,ebp // Get borrow from V fraction step.
mov ah,[ebx + edx*2 + 1] // Read texture value (high).
add esi,[w2dDeltaTex]CWalk2D.uUFrac // Step U fraction.
adc edx,[w2dDeltaTex + ebp*4 + 4]CWalk2D.iUVInt // Integer step + u carry.
mov ebp,[au2AlphaTable] // Conversion table.
cmp eax,0x00004000
jle PIXEL_TRANS
and eax,0x00000fff // Mask colors.
mov ebx,[pvBaseOfLine] // Load pointer to destination.
mov ax,[ebp + eax*2] // Color conversion.
mov [ebx + edi*2],ax // Store pixel.
mov ebx,[pvTextureBitmap] // Load pointer to texture.
PIXEL_TRANS:
and edx,[u4TextureTileMask] // Mask for tiling.
add edi,2 // Step 2 pixels
mov ebp,[w2dDeltaTex]CWalk2D.uVFrac // Load V fraction step.
jl INNER_LOOP
// See if there are any pixels left.
cmp [i_pixel],0
je END_OF_SCANLINE
// Do perspective correction and looping.
//PERSPECTIVE_SCANLINE_EPILOGUE
//----------------------------------------------------------------------------------
// Implement perspective correction.
// stack top contains the result of the divide
// Preserve: ecx,edx,esi
//
mov edi,[iNextSubdivide]
mov eax,[iCacheNextSubdivide]
sub edi,eax
jz short EXIT_BEGIN_NEXT_QUICK_END
fld [fGUInvZ] // U/Z,Z
fxch st(1) // Z,U/Z
fmul st(1),st(0) // Z,U
mov ebx,[bClampUV]
fmul [fGVInvZ] // V,U
/* Are we clamping for this polygon? */
test ebx,ebx
jz short NO_CLAMP_END
//----------------------------------------------------------------------------------
// Clamp U and V
fxch st(1)
fstp [f_u]
fstp [f_v]
mov ebp,[f_u]
mov ebx,[fTexEdgeTolerance]
mov eax,[f_v]
cmp eax,ebx
jge short V_NOT_LESS_END
mov eax,ebx
V_NOT_LESS_END:
cmp ebp,ebx
jge short U_NOT_LESS_END
mov ebp,ebx
U_NOT_LESS_END:
mov ebx,[fTexWidth]
cmp ebp,ebx
jle short U_NOT_GREATER_END
mov ebp,ebx
U_NOT_GREATER_END:
mov ebx,[fTexHeight]
cmp eax,ebx
jle short V_NOT_GREATER_END
mov eax,ebx
V_NOT_GREATER_END:
mov [f_u],ebp
mov [f_v],eax
fld [f_u]
fld [f_v]
//----------------------------------------------------------------------------------
// Initialize walking values
fld st(1) // U,V,U
fsub [fU] // U-fU,V,U
fld st(1) // V,U-fU,V,U
fsub [fV] // V-fV,U-fU,V,U
fxch st(1) // U-fU,V-fV,V,U
fmul float ptr[fInverseIntTable+edi*4] // (U-fU)*C,V-fV,V,U
fxch st(2) // V,V-fV,(U-fU)*C,U
fstp [fV] // V-fV,(U-fU)*C,U
fmul float ptr[fInverseIntTable+edi*4] // (V-fV)*C,(U-fU)*C,U
fxch st(1) // (U-fU)*C,(V-fV)*C,U
fadd [dFastFixed16Conversion] // f(U-fU)*C,(V-fV)*C,U
fxch st(1) // (V-fV)*C,f(U-fU)*C,U
// stall(1)
fadd [dFastFixed16Conversion] // f(V-fV)*C,f(U-fU)*C,U
fxch st(2) // U,f(U-fU)*C,f(V-fV)*C
fstp [fU] // f(U-fU)*C,f(V-fV)*C
fstp [d_temp_a] // f(V-fV)*C
fstp [d_temp_b]
mov edi,dword ptr[d_temp_a] // uslope
mov eax,dword ptr[d_temp_b] // vslope
sar edi,15 // integer part of uslope
mov ebp,dword ptr[d_temp_a] // uslope again
shl ebp,17 // fractional part of uslope
mov ebx,eax // vslope again
sar eax,15 // integer part of vslope
mov [w2dDeltaTex.uUFrac],ebp // store UFrac
imul eax,[iTexWidth] // ivslope*twidth
shl ebx,17 // fractional part of vslope
mov [w2dDeltaTex.uVFrac],ebx // store VFrac
add edi,eax // ivslope*twidth + iuslope
mov ebp,[iTexWidth] // Load texture width.
mov [w2dDeltaTex.iUVInt+4],edi // store integer stride
add edi,ebp // add twidth to integer stride
mov [w2dDeltaTex.iUVInt],edi // store integer stride + twidth
mov eax,[iCacheNextSubdivide]
jmp CLAMP_DONE_END
NO_CLAMP_END:
/*---------------------------------------------------------------------------------- */
/* Initialize walking values */
fld st(1) /* U,V,U */
fsub [fU] /* U-fU,V,U */
fld st(1) /* V,U-fU,V,U */
fsub [fV] /* V-fV,U-fU,V,U */
fxch st(1) /* U-fU,V-fV,V,U */
fmul float ptr[fInverseIntTable+edi*4] /* (U-fU)*C,V-fV,V,U */
fxch st(2) /* V,V-fV,(U-fU)*C,U */
fstp [fV] /* V-fV,(U-fU)*C,U */
fmul float ptr[fInverseIntTable+edi*4] /* (V-fV)*C,(U-fU)*C,U */
fxch st(1) /* (U-fU)*C,(V-fV)*C,U */
fadd [dFastFixed16Conversion] /* f(U-fU)*C,(V-fV)*C,U */
fxch st(1) /* (V-fV)*C,f(U-fU)*C,U */
/* stall(1) */
fadd [dFastFixed16Conversion] /* f(V-fV)*C,f(U-fU)*C,U */
fxch st(2) /* U,f(U-fU)*C,f(V-fV)*C */
fstp [fU] /* f(U-fU)*C,f(V-fV)*C */
fstp [d_temp_a] /* f(V-fV)*C */
fstp [d_temp_b]
mov edi,dword ptr[d_temp_a] /* uslope */
mov eax,dword ptr[d_temp_b] /* vslope */
sar edi,15 /* integer part of uslope */
mov ebp,dword ptr[d_temp_a] /* uslope again */
shl ebp,17 /* fractional part of uslope */
mov ebx,eax /* vslope again */
sar eax,15 /* integer part of vslope */
mov [w2dDeltaTex.uUFrac],ebp /* store UFrac */
shl eax,9 /* ivslope*twidth */
shl ebx,17 /* fractional part of vslope */
mov ebp,[u4TextureTileMaskStepU] /* Load mask for integral U step */
and edi,ebp /* Mask integral U before adding. */
mov [w2dDeltaTex.uVFrac],ebx /* store VFrac */
add edi,eax /* ivslope*twidth + iuslope */
mov ebp,[iTexWidth] /* Load texture width. */
mov [w2dDeltaTex.iUVInt+4],edi /* store integer stride */
add edi,ebp /* add twidth to integer stride */
mov [w2dDeltaTex.iUVInt],edi /* store integer stride + twidth */
mov eax,[iCacheNextSubdivide]
CLAMP_DONE_END:
//----------------------------------------------------------------------------------
// Begin Next Subdivision
mov [iNextSubdivide],eax // eax == iNextSubdivide
mov ebx,[iSubdivideLen]
test eax,eax // Next subdivision is zero length?
jz SUBDIVISION_LOOP
// scan line is +ve
add eax,ebx
jle short DONE_DIVIDE_PIXEL_CACHE_END
// calc the new +ve ratio
fild iNextSubdivide
fld fInvSubdivideLen
fchs
// Subdivision is smaller than iSubdivideLen
fmulp st(1),st(0) // st(0) = (-)fInvSubdivideLen * i_pixel;
fld fDUInvZScanline // U C
xor eax,eax
fmul st(0),st(1) // U*C C
fxch st(1) // C U*C
fld fDVInvZScanline // V C U*C
fxch st(1) // C V U*C
fmul st(1),st(0) // C V*C U*C
mov [iCacheNextSubdivide],eax
fmul fDInvZScanline // Z*C V*C U*C
fxch st(2) // U*C V*C Z*C
fst fDUInvZScanline // U V Z
fadd fGUInvZ
fxch st(1) // V U Z
fst fDVInvZScanline
fadd fGVInvZ
fxch st(2) // Z U V
fst fDInvZScanline
fadd fGInvZ
fxch st(2) // V U Z
fstp fGVInvZ
fstp fGUInvZ
fst fGInvZ
fdivr fOne // Start the next division.
jmp SUBDIVISION_LOOP
DONE_DIVIDE_PIXEL_CACHE_END:
mov [iCacheNextSubdivide],eax
mov ebx,[iNextSubdivide]
cmp eax,ebx
je SUBDIVISION_LOOP
fld fDUInvZScanline // U
fadd fGUInvZ
fld fDVInvZScanline // V U
fadd fGVInvZ
fld fDInvZScanline // Z V U
fadd fGInvZ
fxch st(2) // U V Z
fstp fGUInvZ
fstp fGVInvZ
fst fGInvZ
fdivr fOne // Start the next division.
jmp SUBDIVISION_LOOP
// When the sub divide equals the cached sub-divide we end up here but
// there is an element left on the fp stack. This sould never happen.
EXIT_BEGIN_NEXT_QUICK_END:
// Dump value on stack
fcomp st(0)
jmp SUBDIVISION_LOOP
END_OF_SCANLINE:
pop ebp // Restore ebp.
//
// Increment the base edge.
//
mov esi,[pdtri] // Pointer to polygon object.
mov ecx,[pscan] // Pointer to scanline object.
// Step length, line starting address.
mov eax,[esi]CDrawPolygonBase.fxLineLength.i4Fx
mov ebx,[esi]CDrawPolygonBase.iLineStartIndex
add eax,[esi]CDrawPolygonBase.fxDeltaLineLength.i4Fx
add ebx,[gsGlobals.u4LinePixels]
mov [esi]CDrawPolygonBase.fxLineLength.i4Fx,eax
mov [esi]CDrawPolygonBase.iLineStartIndex,ebx
// Step edge values.
mov eax,[ecx]TAlphaTexPersp.fxX.i4Fx
mov ebx,[ecx]TAlphaTexPersp.fxXDifference.i4Fx
fld [ecx]TAlphaTexPersp.indCoord.fUInvZ
fadd [f_inc_uinvz]
fld [ecx]TAlphaTexPersp.indCoord.fVInvZ
fadd [f_inc_vinvz]
fld [ecx]TAlphaTexPersp.indCoord.fInvZ
fadd [f_inc_invz]
add eax,[fx_inc]
add ebx,[fx_diff]
jge short NO_UNDERFLOW
// Underflow.
add ebx,0x00010000
jmp short BORROW_OR_CARRY
NO_UNDERFLOW:
cmp ebx,0x00010000
jle short NO_OVERFLOW
// Overflow.
sub ebx,0x00010000
jmp short BORROW_OR_CARRY
NO_OVERFLOW:
fstp [ecx]TAlphaTexPersp.indCoord.fInvZ
fstp [ecx]TAlphaTexPersp.indCoord.fVInvZ
fstp [ecx]TAlphaTexPersp.indCoord.fUInvZ
jmp short FINISH_LOOPING
BORROW_OR_CARRY:
fadd [fNegInvZ] // Z V U
fxch st(1) // V Z U
fadd [fNegVInvZ] // V Z U
fxch st(2) // U Z V
fadd [fNegUInvZ] // U Z V
fxch st(1) // Z U V
fstp [ecx]TAlphaTexPersp.indCoord.fInvZ
fstp [ecx]TAlphaTexPersp.indCoord.fUInvZ
fstp [ecx]TAlphaTexPersp.indCoord.fVInvZ
FINISH_LOOPING:
// Y Loop control.
mov [ecx]TAlphaTexPersp.fxX.i4Fx,eax
mov edx,[esi]CDrawPolygonBase.iY
mov [ecx]TAlphaTexPersp.fxXDifference.i4Fx,ebx
inc edx
mov ebx,[esi]CDrawPolygonBase.iYTo
mov [esi]CDrawPolygonBase.iY,edx
cmp edx,ebx
jl Y_LOOP
}
}
//*****************************************************************************************
//
// Linear, stipple alpha textured, 16 bit mode.
//
void DrawSubtriangle(TAlphaTexLinear* pscan, CDrawPolygon<TAlphaTexLinear>* pdtri)
{
typedef TAlphaTexLinear::TIndex prevent_internal_compiler_errors;
static CDrawPolygon<TAlphaTexLinear>* pdtriGlbl;
static TAlphaTexLinear* pscanGlbl;
static CWalk2D w2dDeltaTex2;
TAlphaTexLinear* plinc = &pdtri->pedgeBase->lineIncrement;
__asm
{
push ebp // Save ebp.
mov edi,[plinc] // Pointer to scanline increment.
mov eax,[pscan] // Pointer to scanline.
mov esi,[pdtri] // Pointer to polygon.
//
// Copies of edge stepping values.
//
// fx_inc = pdtri->pedgeBase->lineIncrement.fxX;
// fx_diff = pdtri->pedgeBase->lineIncrement.fxXDifference;
// bf_u_inc = pdtri->pedgeBase->lineIncrement.indCoord.bfU;
// w1d_v_inc = pdtri->pedgeBase->lineIncrement.indCoord.w1dV;
// pscanGlbl = pscan;
// pdtriGlbl = pdtri;
//
mov ebx,[edi]TAlphaTexLinear.fxX
mov ecx,[edi]TAlphaTexLinear.fxXDifference
mov fx_inc,ebx
mov fx_diff,ecx
mov ebx,[edi]TAlphaTexLinear.indCoord.bfU.i4Int
mov ecx,[edi]TAlphaTexLinear.indCoord.bfU.u4Frac
mov bf_u_inc.i4Int,ebx
mov bf_u_inc.u4Frac,ecx
mov ebx,[edi]TAlphaTexLinear.indCoord.w1dV.bfxValue.i4Int
mov ecx,[edi]TAlphaTexLinear.indCoord.w1dV.bfxValue.u4Frac
mov w1d_v_inc.bfxValue.i4Int,ebx
mov w1d_v_inc.bfxValue.u4Frac,ecx
mov pdtriGlbl,esi
mov pscanGlbl,eax
// Compute double step.
mov ebx,[bfDeltaU]UBigFixed.u4Frac
and ebx,0xffff0000
add ebx,ebx
mov [w2dDeltaTex2]CWalk2D.uUFrac,ebx
mov ecx,[bfDeltaU]UBigFixed.i4Int
adc ecx,ecx
and ecx,[u4TextureTileMaskStepU]
mov ebx,[w1dDeltaV]CWalk1D.bfxValue.u4Frac
and ebx,0xffff0000
mov edx,[w1dDeltaV]CWalk1D.bfxValue.i4Int
add edx,edx
add ebx,ebx
mov [w2dDeltaTex2]CWalk2D.uVFrac,ebx
mov ebx,[w1dDeltaV]CWalk1D.iOffsetPerLine
jnc NO_V_CARRY
add edx,ebx
NO_V_CARRY:
add edx,ecx
mov [w2dDeltaTex2 + 4]CWalk2D.iUVInt,edx
add edx,ebx
mov [w2dDeltaTex2]CWalk2D.iUVInt,edx
//
// Iterate through the scanlines that intersect the subtriangle.
//
Y_LOOP:
// Check to see if we should skip this scanline.
mov ecx,[esi]CDrawPolygonBase.iY
mov ebx,[bEvenScanlinesOnly]
and ecx,ebx
jnz END_OF_SCANLINE
// Determine the start and end of the scanline.
mov ebx,[eax]TAlphaTexLinear.fxX.i4Fx
mov ecx,[esi]CDrawPolygonBase.fxLineLength.i4Fx
mov edx,[esi]CDrawPolygonBase.iLineStartIndex
add ebx,ecx
sar ebx,16
mov edi,[eax]TAlphaTexLinear.fxX.i4Fx
sar edi,16
add edx,ebx
sub edi,ebx // i_pixel
jge END_OF_SCANLINE
//
// edi = i_pixel
// edx = i_screen_index
// eax = pointer to scanline
//
mov ebx,[eax]TAlphaTexPersp.fxX.i4Fx // Fractional X.
mov ebp,[esi]CDrawPolygonBase.iY // Integer Y.
sar ebx,16 // Integer X.
mov esi,[eax]TAlphaTexLinear.indCoord.bfU.u4Frac // Ufrac
xor ebp,ebx // XOR with integer X.
mov ebx,gsGlobals.pvScreen // Pointer the screen.
mov ecx,[eax]TAlphaTexLinear.indCoord.w1dV.bfxValue.u4Frac // Vfrac
lea ebx,[ebx+edx*2] // Base of scanline.
mov edx,[eax]TAlphaTexLinear.indCoord.w1dV.bfxValue.i4Int // Vint
mov [pvBaseOfLine],ebx // Save pointer to destination.
mov eax,[eax]TAlphaTexLinear.indCoord.bfU.i4Int // Uint
add edx,eax // Add Uint to Vint
mov ebx,[pvTextureBitmap] // Load pointer to texture.
and edx,[u4TextureTileMask] // Mask for tiling.
// if ((y xor x) & 1) skip a pixel.
test ebp,1
jz NO_SKIP
add ecx,[w2dDeltaTex]CWalk2D.uVFrac // Step V fraction.
sbb ebp,ebp // Get borrow from V fraction step.
add esi,[w2dDeltaTex]CWalk2D.uUFrac // Step U fraction.
adc edx,[w2dDeltaTex + ebp*4 + 4]CWalk2D.iUVInt // Integer step + u carry.
and edx,[u4TextureTileMask] // Mask for tiling.
inc edi
jz END_OF_SCANLINE
NO_SKIP:
xor eax,eax // Clear eax.
mov ebp,[w2dDeltaTex2]CWalk2D.uVFrac // Load V fraction step.
//-----------------------------------------------------------------------
// Draw the scanline.
//
// eax = temp for pixel
// ebx = base of texture map / base of scanline
// ecx = Ufrac
// edx = UVint
// esi = Vfrac
// edi = offset & count
// ebp = vfrac step / v carry
//
INNER_LOOP:
add ecx,ebp // Step V fraction.
mov al,[ebx + edx*2] // Read texture value (low).
sbb ebp,ebp // Get borrow from V fraction step.
mov ah,[ebx + edx*2 + 1] // Read texture value (high).
add esi,[w2dDeltaTex2]CWalk2D.uUFrac // Step U fraction.
adc edx,[w2dDeltaTex2 + ebp*4 + 4]CWalk2D.iUVInt // Integer step + u carry.
mov ebp,[au2AlphaTable] // Conversion table.
cmp eax,0x00004000
jle PIXEL_TRANS
and eax,0x00000fff // Mask colors.
mov ebx,[pvBaseOfLine] // Load pointer to destination.
mov ax,[ebp + eax*2] // Color conversion.
mov [ebx + edi*2],ax // Store pixel.
mov ebx,[pvTextureBitmap] // Load pointer to texture.
PIXEL_TRANS:
and edx,[u4TextureTileMask] // Mask for tiling.
add edi,2 // Step 2 pixels
mov ebp,[w2dDeltaTex2]CWalk2D.uVFrac // Load V fraction step.
jl INNER_LOOP
END_OF_SCANLINE:
mov eax,[pscanGlbl]
mov ebp,bf_u_inc.i4Int
// AGI on eax.
mov ecx,[eax]TAlphaTexLinear.indCoord.bfU.u4Frac
mov edx,[eax]TAlphaTexLinear.indCoord.bfU.i4Int
mov edi,[eax]TAlphaTexLinear.indCoord.w1dV.bfxValue.i4Int
mov esi,[eax]TAlphaTexLinear.indCoord.w1dV.bfxValue.u4Frac
add edi,w1d_v_inc.bfxValue.i4Int
add ecx,bf_u_inc.u4Frac
adc edx,ebp
mov ebp,w1d_v_inc.bfxValue.u4Frac
add esi,ebp
jnc short NO_VFRAC_CARRY
add edi,[eax]TAlphaTexLinear.indCoord.w1dV.iOffsetPerLine
NO_VFRAC_CARRY:
mov ebx,[eax]TAlphaTexLinear.fxXDifference
mov ebp,[fx_diff]
add ebx,ebp
jge short NO_UNDERFLOW
// Undeflow of fxXDifference.
add ebx,0x00010000
mov ebp,bfNegDU.i4Int
add edi,w1dNegDV.bfxValue.i4Int
add ecx,bfNegDU.u4Frac
adc edx,ebp
mov ebp,w1dNegDV.bfxValue.u4Frac
add esi,ebp
jnc short EDGE_DONE
add edi,[eax]TAlphaTexLinear.indCoord.w1dV.iOffsetPerLine
jmp short EDGE_DONE
NO_UNDERFLOW:
cmp ebx,0x00010000
jl short EDGE_DONE
// Overflow of fxXDifference.
sub ebx,0x00010000
mov ebp,bfNegDU.i4Int
add edi,w1dNegDV.bfxValue.i4Int
add ecx,bfNegDU.u4Frac
adc edx,ebp
mov ebp,w1dNegDV.bfxValue.u4Frac
add esi,ebp
jnc short EDGE_DONE
add edi,[eax]TAlphaTexLinear.indCoord.w1dV.iOffsetPerLine
EDGE_DONE:
// Store modified variables and do looping.
mov [eax]TAlphaTexLinear.indCoord.w1dV.bfxValue.u4Frac,esi
mov [eax]TAlphaTexLinear.indCoord.w1dV.bfxValue.i4Int,edi
mov [eax]TAlphaTexLinear.fxXDifference,ebx
mov esi,[pdtriGlbl] // Pointer to polygon object.
mov [eax]TAlphaTexLinear.indCoord.bfU.u4Frac,ecx
mov [eax]TAlphaTexLinear.indCoord.bfU.i4Int,edx
// Step length, line starting address.
mov ebx,[esi]CDrawPolygonBase.fxLineLength.i4Fx
mov ecx,[esi]CDrawPolygonBase.iLineStartIndex
add ebx,[esi]CDrawPolygonBase.fxDeltaLineLength.i4Fx
add ecx,[gsGlobals.u4LinePixels]
mov [esi]CDrawPolygonBase.fxLineLength.i4Fx,ebx
mov [esi]CDrawPolygonBase.iLineStartIndex,ecx
mov ecx,[eax]TAlphaTexLinear.fxX
mov ebp,[fx_inc]
add ecx,ebp
mov edx,[esi]CDrawPolygonBase.iY
mov [eax]TAlphaTexLinear.fxX,ecx
inc edx
mov ebx,[esi]CDrawPolygonBase.iYTo
mov [esi]CDrawPolygonBase.iY,edx
cmp edx,ebx
jl Y_LOOP
pop ebp
}
}
Reference in New Issue View Git Blame Copy Permalink