mirror/JurassicParkTrespasser
1
0
Fork 0
mirror of https://github.com/OpenTrespasser/JurassicParkTrespasser.git synced 2024-12-20 07:31:56 +00:00
Code Issues Projects Releases Wiki Activity
master
JurassicParkTrespasser/jp2_pc/Source/Lib/Renderer/Primitives/AMDK6/DrawSubTriangleTexEx.inl

1781 lines
46 KiB
C++
Raw Permalink Blame History

/***********************************************************************************************
*
* Copyright © DreamWorks Interactive, 1997.
*
* Contents:
* Specialized (non-template) versions of the DrawSubtriangle function.
* Optimized for the AMD K6-3D Processor
*
***********************************************************************************************
*
* $Log:: /JP2_PC/Source/Lib/Renderer/Primitives/AMDK6/DrawSubTriangleTexEx.cpp $
*
* 7 10/01/98 12:41a Asouth
* Added #ifdefs for MW build; explicit scope of fixed
*
* 6 3/12/98 7:02p Mmouni
* Solid primitives now write aligned quadwords.
*
* 5 97.11.04 10:59p Mmouni
* Linear version of primitives now use 3dx/mmx.
*
* 4 97.10.30 1:40p Mmouni
* All perspective sub-triangle routines are now 3DX/MMX.
*
* 3 97.10.27 1:25p Mmouni
* Initial K6-3D version, copied from the Pentium versions.
*
* 9 97.10.22 7:11p Mmouni
* Moved code that makes copies of edge values into assembly.
*
* 8 10/10/97 1:47p Mmouni
* All inner loops are now left to right only, and optimized some.
*
* 7 9/30/97 9:33p Mmouni
* All routines now have optimized y-loops.
*
* 6 9/29/97 11:51a Mmouni
* Now has seperate left to right and right to left perspective loops.
*
* 5 9/15/97 2:10p Mmouni
* Optimized inner loops (not final yet).
*
* 4 9/01/97 8:03p Rwyatt
* ANDs added to enable tiling
*
* 3 97/07/18 3:30p Pkeet
* Removed use of the 'b_right' parameter from DrawSubTriangle.
*
* 2 7/14/97 12:36p Rwyatt
* Checkled in so Scott can move them....
*
* 1 7/07/97 11:26p Rwyatt
* Initial Implementation of Pentium Specifics
*
***********************************************************************************************
***********************************************************************************************
*
* 10 6/15/97 1:31a Bbell
* Removed unnecessary include.
*
* 9 97/06/12 5:56p Pkeet
* Added capability to render only every other scanline and to double the number of scanlines.
*
* 8 97/06/11 4:38p Pkeet
* Fixed warnings.
*
* 7 97/06/11 4:07p Pkeet
* Added linear optimizations.
*
* 6 97/06/11 3:44p Pkeet
* Optimized transparency perspective correct.
*
* 5 97/06/11 2:34p Pkeet
* Assembly optimizations on the perspective non-transparent version.
*
* 4 97/06/11 12:41p Pkeet
* Put inner loop into assembly.
*
* 3 97/06/11 11:55a Pkeet
* Reorganized C++ code.
*
* 2 97/06/10 11:02p Pkeet
* Cleaned up the C++ versions a bit.
*
* 1 97/06/10 9:11p Pkeet
* Initial C++ version.
*
**********************************************************************************************/
#include "Common.hpp"
#include "Lib/View/Raster.hpp"
#include "Lib/Renderer/Primitives/DrawTriangle.hpp"
// Put this stuff in a seperate section for alignment.
#pragma code_seg("StriTex")
//*****************************************************************************************
//
// Perspective texture mapped with transparency for 16 bit mode.
//
void DrawSubtriangle(TTexturePerspTrans* pscan, CDrawPolygon<TTexturePerspTrans>* pdtri)
{
typedef TTexturePerspTrans::TIndex prevent_internal_compiler_errors;
::fixed fx_inc;
::fixed fx_diff;
TTexturePerspTrans* plinc = &pdtri->pedgeBase->lineIncrement;
__asm
{
// Get ready to do MMX/3DX.
femms
//
// 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]TTexturePerspTrans.fxX
mov edx,[eax]TTexturePerspTrans.fxXDifference
mov fx_inc,ebx
movq mm0,[eax]TTexturePerspTrans.indCoord.fUInvZ
mov fx_diff,edx
mov ebx,[eax]TTexturePerspTrans.indCoord.fInvZ
movq [tvEdgeStep.UInvZ],mm0
mov [tvEdgeStep.InvZ],ebx
//
// Setup:
// QWORD qMFactor = width,1,width,1
// Load global texture values.
//
movd mm3,[iTexWidth] // 0,0,0,Width
movd mm4,[u4OneOne] // 0,0,1,1
punpcklwd mm3,mm3 // 0,0,Width,Width
punpcklwd mm4,mm3 // Width,1,Width,1
movq mm0,[ecx]TTexturePerspTrans.indCoord.fUInvZ // mm0 = (V/Z,U/Z)
movq [qMFactor],mm4 // Save mfactor
movd mm1,[ecx]TTexturePerspTrans.indCoord.fInvZ // mm1 = (?,1/Z)
//
// Iterate through the scanlines that intersect the subtriangle.
//
// esi,ecx,mm0,mm1 setup.
//
Y_LOOP:
mov eax,[esi]CDrawPolygonBase.iY
mov ebx,[bEvenScanlinesOnly]
// Check to see if we sould skip this scanline.
and eax,ebx
jnz END_OF_SCANLINE
//
// Setup for prespective correction and looping.
#ifdef __MWERKS__
#define SLTYPE TTexturePerspTrans
#include "psprologue3.inl"
#else
PERSPECTIVE_SCANLINE_PROLOGUE_3DX(TTexturePerspTrans)
#endif
SUBDIVISION_LOOP:
//---------------------------------------------------------------------------
// Draw the subdivision.
//
// mm6,mm7 = texture values.
//
// Setup registers:
//
// eax = texel_index2 ebx = texel_index2
// ecx = clut_base_pointer edx = dest_base_ptr
// esi = texture_base_ptr edi = pixel_offset & count
// ebp = base pointer
//
// mm0 = temp mm1 = temp
// mm2 = mfactor mm3 = uvmask
// mm4 = ??? mm5 = ???
// mm6 = uvslope mm7 = uv (stepped once)
//
movq mm0,mm7 // Copy U1,V1
paddd mm7,mm6 // Step U,V
movq mm3,[qUVMasks] // Load texture masks
psrad mm0,16 // Shift for integer U1,V1
movq mm2,[qMFactor] // Load texture multipliers
movq mm1,mm7 // Copy U2,V2
psrad mm1,16 // Shift for integer U2,V2
mov ecx,[pvClutConversion] // Load clut pointer.
packssdw mm0,mm1 // Pack integer texture values
sub esi,4 // Hack to force SIB + offset in loop
pand mm0,mm3 // Mask for tiling
sub ecx,4 // Hack to force SIB + offset in loop
pmaddwd mm0,mm2 // Compute texture indicies.
//
// Make sure we have more than 2 pixels left.
//
add edi,2
jl short INNER_LOOP_2P
jmp FINISH_REMAINDER
// Align start of loop to 1? past the beginning of a cache line.
ALIGN 16
nop
//
// Do two pixels at a time.
//
// mm0 = packed & masked U1,V1,U2,V2
// mm7 is stepped once.
//
INNER_LOOP_2P:
movq [qIndexTemp],mm0 // Save texture indicies.
paddd mm7,mm6 // Step U,V
mov eax,dword ptr[qIndexTemp] // Get texture index 1
movq mm0,mm7 // Copy U1,V1
mov ebx,dword ptr[qIndexTemp + 4] // Get texture index 2
psrad mm0,16 // Shift for integer U1,V1
movzx eax,byte ptr[esi + eax + 4] // Lookup texel 1
paddd mm7,mm6 // Step U,V
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 2
movq mm1,mm7 // Copy U2,V2
psrad mm1,16 // Shift for integer U2,V2
packssdw mm0,mm1 // Pack integer texture values.
test eax,eax // Test for transparency.
jz short PIXEL1_TRANSPARENT
mov ax,[ecx + eax*2 + 4] // Clut lookup for p1
mov [edx + edi*2 - 4],ax // Store pixel 1
PIXEL1_TRANSPARENT:
pand mm0,mm3 // Mask for tiling
test ebx,ebx // Test for transparency.
pmaddwd mm0,mm2 // Compute texture indicies.
jz short PIXEL2_TRANSPARENT
mov bx,word ptr[ecx + ebx*2 + 4] // Clut lookup for p2
mov [edx + edi*2 - 2],bx // Store pixel 2
PIXEL2_TRANSPARENT:
add edi,2 // Inrcement index by 2
jl short INNER_LOOP_2P // Loop (while >2 pixels)
FINISH_REMAINDER:
//
// One pixel (edi == 1) or two pixels (edi == 0) left.
//
jnz short ONE_PIXEL_LEFT
//
// Two pixels left, only step texture co-ordinates once.
//
movq [qIndexTemp],mm0 // Save texture indicies.
paddd mm7,mm6 // Step U,V
mov eax,dword ptr[qIndexTemp] // Get texture index 1
mov ebx,dword ptr[qIndexTemp + 4] // Get texture index 2
movzx eax,byte ptr[esi + eax + 4] // Lookup texel 1
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 2
test eax,eax // Test for transparency.
jz short PIXEL1_TRANSPARENT_END
mov ax,[ecx + eax*2 + 4] // Clut lookup for p1
mov [edx + edi*2 - 4],ax // Store pixel 1
PIXEL1_TRANSPARENT_END:
test ebx,ebx // Test for transparency.
jz short PIXEL2_TRANSPARENT_END
mov bx,[ecx + ebx*2 + 4] // Clut lookup for p2
mov [edx + edi*2 - 2],bx // Store pixel 2
PIXEL2_TRANSPARENT_END:
mov eax,[i_pixel] // Load remaining length.
jmp short END_OF_SPAN
ONE_PIXEL_LEFT:
//
// One pixel left, don't step texture co-ordinates.
//
movq [qIndexTemp],mm0 // Save texture indicies.
mov ebx,dword ptr[qIndexTemp] // Get texture index 1
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
mov eax,[i_pixel] // Load remaining length.
test ebx,ebx // Test for transparency.
jz short END_OF_SPAN
mov bx,[ecx + ebx*2 + 4] // Clut lookup for p1
mov [edx + edi*2 - 4],bx // Store pixel 1
END_OF_SPAN:
// See if there are any pixels left.
cmp eax,0
jz short END_OF_SCANLINE
//
// Do perspective correction for next span.
#ifdef __MWERKS__
#include "psepilogue3.inl"
#else
PERSPECTIVE_SCANLINE_EPILOGUE_3DX
#endif
jmp SUBDIVISION_LOOP
END_OF_SCANLINE:
//
// Increment the base edge.
//
mov esi,[pdtri] // Pointer to polygon object.
mov ecx,[pscan] // Pointer to scanline object.
// Step length, line starting address.
mov edx,[esi]CDrawPolygonBase.fxLineLength.i4Fx
mov edi,[esi]CDrawPolygonBase.iLineStartIndex
add edx,[esi]CDrawPolygonBase.fxDeltaLineLength.i4Fx
add edi,gsGlobals.u4LinePixels
mov eax,[ecx]TTexturePerspTrans.fxX.i4Fx
mov [esi]CDrawPolygonBase.fxLineLength.i4Fx,edx
mov ebx,[ecx]TTexturePerspTrans.fxXDifference.i4Fx
mov [esi]CDrawPolygonBase.iLineStartIndex,edi
// Step edge values.
movq mm0,[ecx]TTexturePerspTrans.indCoord.fUInvZ
movq mm2,[tvEdgeStep.UInvZ]
movd mm1,[ecx]TTexturePerspTrans.indCoord.fInvZ
movd mm3,[tvEdgeStep.InvZ]
pfadd (m0,m2)
mov edi,[fx_diff]
pfadd (m1,m3)
add eax,[fx_inc]
add ebx,edi
jge short NO_UNDERFLOW
// Underflow.
// Add borrow/carry adjustments to U,V,Z.
movq mm2,[tvNegAdj.UInvZ]
add ebx,0x00010000
movd mm3,[tvNegAdj.InvZ]
pfadd (m0,m2)
pfadd (m1,m3)
jmp short FINISH_LOOPING
NO_UNDERFLOW:
cmp ebx,0x00010000
jl short FINISH_LOOPING
// Overflow.
// Add borrow/carry adjustments to U,V,Z.
movq mm2,[tvNegAdj.UInvZ]
sub ebx,0x00010000
movd mm3,[tvNegAdj.InvZ]
pfadd (m0,m2)
pfadd (m1,m3)
FINISH_LOOPING:
// Save values and Y Loop control.
movq [ecx]TTexturePerspTrans.indCoord.fUInvZ,mm0
movd [ecx]TTexturePerspTrans.indCoord.fInvZ,mm1
mov [ecx]TTexturePerspTrans.fxX.i4Fx,eax
mov edx,[esi]CDrawPolygonBase.iY
mov [ecx]TTexturePerspTrans.fxXDifference.i4Fx,ebx
mov ebx,[esi]CDrawPolygonBase.iYTo
inc edx
mov [esi]CDrawPolygonBase.iY,edx
cmp edx,ebx
jl Y_LOOP
// Done with MMX/3DX.
femms
}
}
//*****************************************************************************************
//
// Perspective texture mapped with no transparency for 16 bit mode.
//
void DrawSubtriangle(TTexturePersp* pscan, CDrawPolygon<TTexturePersp>* pdtri)
{
typedef TTexturePersp::TIndex prevent_internal_compiler_errors;
::fixed fx_inc;
::fixed fx_diff;
TTexturePersp* plinc = &pdtri->pedgeBase->lineIncrement;
__asm
{
// Get ready to do MMX/3DX.
femms
//
// 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]TTexturePersp.fxX
mov edx,[eax]TTexturePersp.fxXDifference
mov fx_inc,ebx
movq mm0,[eax]TTexturePersp.indCoord.fUInvZ
mov fx_diff,edx
mov ebx,[eax]TTexturePersp.indCoord.fInvZ
movq [tvEdgeStep.UInvZ],mm0
mov [tvEdgeStep.InvZ],ebx
//
// Setup:
// QWORD qMFactor = width,1,width,1
// Load global texture values.
//
movd mm3,[iTexWidth] // 0,0,0,Width
movd mm4,[u4OneOne] // 0,0,1,1
punpcklwd mm3,mm3 // 0,0,Width,Width
punpcklwd mm4,mm3 // Width,1,Width,1
movq mm0,[ecx]TTexturePersp.indCoord.fUInvZ // mm0 = (V/Z,U/Z)
movq [qMFactor],mm4 // Save mfactor
movd mm1,[ecx]TTexturePersp.indCoord.fInvZ // mm1 = (?,1/Z)
//
// Iterate through the scanlines that intersect the subtriangle.
//
// esi,ecx,mm0,mm1 setup.
//
Y_LOOP:
mov eax,[esi]CDrawPolygonBase.iY
mov ebx,[bEvenScanlinesOnly]
// Check to see if we sould skip this scanline.
and eax,ebx
jnz END_OF_SCANLINE
//
// Setup for prespective correction and looping.
#ifdef __MWERKS__
#define SLTYPE TTexturePersp
#include "psprologue3.inl"
#else
PERSPECTIVE_SCANLINE_PROLOGUE_3DX(TTexturePersp)
#endif
SUBDIVISION_LOOP:
//---------------------------------------------------------------------------
// Draw the subdivision.
//
// mm6,mm7 = texture values.
//
// Setup registers:
//
// eax = texel_index2 ebx = texel_index2
// ecx = clut_base_pointer edx = dest_base_ptr
// esi = texture_base_ptr edi = pixel_offset & count
// ebp = base pointer
//
// mm0 = temp mm1 = temp
// mm2 = mfactor mm3 = uvmask
// mm4 = ??? mm5 = ???
// mm6 = uvslope mm7 = uv (stepped once)
//
movq mm0,mm7 // Copy U1,V1
paddd mm7,mm6 // Step U,V
movq mm3,[qUVMasks] // Load texture masks
psrad mm0,16 // Shift for integer U1,V1
movq mm2,[qMFactor] // Load texture multipliers
movq mm1,mm7 // Copy U2,V2
psrad mm1,16 // Shift for integer U2,V2
mov ecx,[pvClutConversion] // Load clut pointer.
packssdw mm0,mm1 // Pack integer texture values
sub esi,4 // Hack to force SIB + offset in loop
pand mm0,mm3 // Mask for tiling
sub ecx,4 // Hack to force SIB + offset in loop
pmaddwd mm0,mm2 // Compute texture indicies.
//
// Align to a quadword boundry.
//
lea eax,[edx + edi*2]
and eax,3
jz ALIGNED2
inc edi // One pixel left?
jz ONE_PIXEL_LEFT
//
// Do one pixel for alignment.
//
movq [qIndexTemp],mm0 // Save texture indicies.
paddd mm7,mm6 // Step U,V
mov ebx,dword ptr[qIndexTemp] // Get texture index 1
movq mm0,mm7 // Copy U1,V1
psrad mm0,16 // Shift for integer U1,V1
packssdw mm1,mm0 // Pack integer texture values.
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
movq mm0,mm1 // Put values back into mm0
pand mm0,mm3 // Mask for tiling
pmaddwd mm0,mm2 // Compute texture indicies.
movzx ebx,word ptr[ecx + ebx*2 + 4] // Clut lookup for pixel 1
lea eax,[edx + edi*2]
mov [edx + edi*2 - 2],bx // Store pixel
ALIGNED2:
and eax,7
jz ALIGNED4
add edi,2 // Two pixels left?
jge FINISH_REMAINDER2
//
// Do two pixels for alignment.
//
movq [qIndexTemp],mm0 // Save texture indicies.
paddd mm7,mm6 // Step U,V
mov eax,dword ptr[qIndexTemp + 4] // Get texture index 2
movq mm0,mm7 // Copy U1,V1
mov ebx,dword ptr[qIndexTemp] // Get texture index 1
psrad mm0,16 // Shift for integer U1,V1
movzx eax,byte ptr[esi + eax + 4] // Lookup texel 2
paddd mm7,mm6 // Step U,V
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
movq mm1,mm7 // Copy U2,V2
psrad mm1,16 // Shift for integer U2,V2
packssdw mm0,mm1 // Pack integer texture values.
movzx eax,word ptr[ecx + eax*2 + 4] // Clut lookup for pixel 1
pand mm0,mm3 // Mask for tiling
movzx ebx,word ptr[ecx + ebx*2 + 4] // Clut lookup for pixel 2
pmaddwd mm0,mm2 // Compute texture indicies.
shl eax,16 // Shift pixel 2 up.
or ebx,eax // Combine pixels.
mov [edx + edi*2 - 4],ebx // Store pixels
ALIGNED4:
add edi,4
jl short INNER_LOOP_4P // Four pixles left?
jmp FINISH_REMAINDER4
// Align start of loop to 0 past the beginning of a cache line.
ALIGN 16
//
// Do four pixels at a time.
//
// mm0 = packed & masked U1,V1,U2,V2
// mm7 is stepped once.
//
INNER_LOOP_4P:
movq [qIndexTemp],mm0 // Save texture indicies.
paddd mm7,mm6 // Step U,V
mov eax,dword ptr[qIndexTemp + 4] // Get texture index 2
movq mm0,mm7 // Copy U1,V1
mov ebx,dword ptr[qIndexTemp] // Get texture index 1
psrad mm0,16 // Shift for integer U1,V1
movzx eax,byte ptr[esi + eax + 4] // Lookup texel 2
paddd mm7,mm6 // Step U,V
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
movq mm1,mm7 // Copy U2,V2
psrad mm1,16 // Shift for integer U2,V2
packssdw mm0,mm1 // Pack integer texture values.
movzx eax,word ptr[ecx + eax*2 + 4] // Clut lookup for pixel 2
pand mm0,mm3 // Mask for tiling
movzx ebx,word ptr[ecx + ebx*2 + 4] // Clut lookup for pixel 1
pmaddwd mm0,mm2 // Compute texture indicies.
shl eax,16 // Shift second pixel up.
movq [qIndexTemp],mm0 // Save texture indicies.
or ebx,eax // Combine 2 pixels.
movd mm4,ebx // Put in MMX register.
mov eax,dword ptr[qIndexTemp + 4] // Get texture index 2
paddd mm7,mm6 // Step U,V
mov ebx,dword ptr[qIndexTemp] // Get texture index 1
movq mm0,mm7 // Copy U1,V1
movzx eax,byte ptr[esi + eax + 4] // Lookup texel 2
psrad mm0,16 // Shift for integer U1,V1
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
paddd mm7,mm6 // Step U,V
movq mm1,mm7 // Copy U2,V2
psrad mm1,16 // Shift for integer U2,V2
movzx eax,word ptr[ecx + eax*2 + 4] // Clut lookup for pixel 2
packssdw mm0,mm1 // Pack integer texture values.
movzx ebx,word ptr[ecx + ebx*2 + 4] // Clut lookup for pixel 1
pand mm0,mm3 // Mask for tiling
shl eax,16 // Shift second pixel up.
pmaddwd mm0,mm2 // Compute texture indicies.
or ebx,eax // Combine 2 pixels.
movd mm1,ebx // Put in MMX register.
punpckldq mm4,mm1 // Combine all four pixels.
movq [edx + edi*2 - 8],mm4 // Store 4 pixels
add edi,4 // Inrcement index by 4
jl INNER_LOOP_4P // Loop (while >4 pixels)
FINISH_REMAINDER4:
//
// One (edi == 3), two (edi == 2), three (edi == 1) or four (edi == 0) pixels left.
//
jnz THREE_OR_LESS
//
// Four pixels left, step co-ordinates 3 times.
//
movq [qIndexTemp],mm0 // Save texture indicies.
paddd mm7,mm6 // Step U,V
mov eax,dword ptr[qIndexTemp + 4] // Get texture index 2
movq mm0,mm7 // Copy U1,V1
mov ebx,dword ptr[qIndexTemp] // Get texture index 1
psrad mm0,16 // Shift for integer U1,V1
movzx eax,byte ptr[esi + eax + 4] // Lookup texel 2
paddd mm7,mm6 // Step U,V
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
movq mm1,mm7 // Copy U2,V2
psrad mm1,16 // Shift for integer U2,V2
packssdw mm0,mm1 // Pack integer texture values.
movzx eax,word ptr[ecx + eax*2 + 4] // Clut lookup for pixel 2
pand mm0,mm3 // Mask for tiling
movzx ebx,word ptr[ecx + ebx*2 + 4] // Clut lookup for pixel 1
pmaddwd mm0,mm2 // Compute texture indicies.
shl eax,16 // Shift second pixel up.
movq [qIndexTemp],mm0 // Save texture indicies.
or ebx,eax // Combine 2 pixels.
movd mm4,ebx // Put in MMX register.
mov eax,dword ptr[qIndexTemp + 4] // Get texture index 2
paddd mm7,mm6 // Step U,V
mov ebx,dword ptr[qIndexTemp] // Get texture index 1
movzx eax,byte ptr[esi + eax + 4] // Lookup texel 2
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
movzx eax,word ptr[ecx + eax*2 + 4] // Clut lookup for pixel 2
movzx ebx,word ptr[ecx + ebx*2 + 4] // Clut lookup for pixel 1
shl eax,16 // Shift second pixel up.
or ebx,eax // Combine 2 pixels.
movd mm1,ebx // Put in MMX register.
punpckldq mm4,mm1 // Combine all four pixels.
movq [edx - 8],mm4 // Store 4 pixels
mov eax,[i_pixel] // Load remaining length.
jmp END_OF_SPAN
THREE_OR_LESS:
sub edi,2
jge FINISH_REMAINDER2
//
// Three pixels left, step co-ordinates twice.
//
movq [qIndexTemp],mm0 // Save texture indicies.
paddd mm7,mm6 // Step U,V
mov eax,dword ptr[qIndexTemp + 4] // Get texture index 2
movq mm0,mm7 // Copy U1,V1
mov ebx,dword ptr[qIndexTemp] // Get texture index 1
psrad mm0,16 // Shift for integer U1,V1
movzx eax,byte ptr[esi + eax + 4] // Lookup texel 2
paddd mm7,mm6 // Step U,V
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
movq mm1,mm7 // Copy U2,V2
psrad mm1,16 // Shift for integer U2,V2
packssdw mm0,mm1 // Pack integer texture values.
movzx eax,word ptr[ecx + eax*2 + 4] // Clut lookup for pixel 1
pand mm0,mm3 // Mask for tiling
movzx ebx,word ptr[ecx + ebx*2 + 4] // Clut lookup for pixel 2
pmaddwd mm0,mm2 // Compute texture indicies.
shl eax,16 // Shift pixel 2 up.
or ebx,eax // Combine pixels.
mov [edx - 6],ebx // Store pixels
movd ebx,mm0 // Get texture index 1
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
mov eax,[i_pixel] // Load remaining length.
mov bx,word ptr[ecx + ebx*2 + 4] // Clut lookup for p1
mov [edx - 2],bx // Store pixel 1
jmp short END_OF_SPAN
FINISH_REMAINDER2:
//
// One pixel (edi == 1) or two pixels (edi == 0) left.
//
jnz ONE_PIXEL_LEFT
//
// Two pixels left, only step texture co-ordinates once.
//
movq [qIndexTemp],mm0 // Save texture indicies.
paddd mm7,mm6 // Step U,V
mov eax,dword ptr[qIndexTemp + 4] // Get texture index 2
mov ebx,dword ptr[qIndexTemp] // Get texture index 1
movzx eax,byte ptr[esi + eax + 4] // Lookup texel 2
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
movzx eax,word ptr[ecx + eax*2 + 4] // Clut lookup for pixel 2
movzx ebx,word ptr[ecx + ebx*2 + 4] // Clut lookup for pixel 1
shl eax,16 // Shift pixel 2 up.
or ebx,eax // Combine pixels.
mov [edx - 4],ebx // Store pixels
mov eax,[i_pixel] // Load remaining length.
jmp short END_OF_SPAN
ONE_PIXEL_LEFT:
//
// One pixel left, don't step texture co-ordinates.
//
movd ebx,mm0 // Get texture index 1
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
mov eax,[i_pixel] // Load remaining length.
mov bx,word ptr[ecx + ebx*2 + 4] // Clut lookup for p1
mov [edx - 2],bx // Store pixel 1
END_OF_SPAN:
// See if there are any pixels left.
cmp eax,0
jz short END_OF_SCANLINE
//
// Do perspective correction for next span.
#ifdef __MWERKS__
#include "psepilogue3.inl"
#else
PERSPECTIVE_SCANLINE_EPILOGUE_3DX
#endif
jmp SUBDIVISION_LOOP
END_OF_SCANLINE:
//
// Increment the base edge.
//
mov esi,[pdtri] // Pointer to polygon object.
mov ecx,[pscan] // Pointer to scanline object.
// Step length, line starting address.
mov edx,[esi]CDrawPolygonBase.fxLineLength.i4Fx
mov edi,[esi]CDrawPolygonBase.iLineStartIndex
add edx,[esi]CDrawPolygonBase.fxDeltaLineLength.i4Fx
add edi,gsGlobals.u4LinePixels
mov eax,[ecx]TTexturePersp.fxX.i4Fx
mov [esi]CDrawPolygonBase.fxLineLength.i4Fx,edx
mov ebx,[ecx]TTexturePersp.fxXDifference.i4Fx
mov [esi]CDrawPolygonBase.iLineStartIndex,edi
// Step edge values.
movq mm0,[ecx]TTexturePersp.indCoord.fUInvZ
movq mm2,[tvEdgeStep.UInvZ]
movd mm1,[ecx]TTexturePersp.indCoord.fInvZ
movd mm3,[tvEdgeStep.InvZ]
pfadd (m0,m2)
mov edi,[fx_diff]
pfadd (m1,m3)
add eax,[fx_inc]
add ebx,edi
jge short NO_UNDERFLOW
// Underflow.
// Add borrow/carry adjustments to U,V,Z.
movq mm2,[tvNegAdj.UInvZ]
add ebx,0x00010000
movd mm3,[tvNegAdj.InvZ]
pfadd (m0,m2)
pfadd (m1,m3)
jmp short FINISH_LOOPING
NO_UNDERFLOW:
cmp ebx,0x00010000
jl short FINISH_LOOPING
// Overflow.
// Add borrow/carry adjustments to U,V,Z.
movq mm2,[tvNegAdj.UInvZ]
sub ebx,0x00010000
movd mm3,[tvNegAdj.InvZ]
pfadd (m0,m2)
pfadd (m1,m3)
FINISH_LOOPING:
// Save values and Y Loop control.
movq [ecx]TTexturePersp.indCoord.fUInvZ,mm0
movd [ecx]TTexturePersp.indCoord.fInvZ,mm1
mov [ecx]TTexturePersp.fxX.i4Fx,eax
mov edx,[esi]CDrawPolygonBase.iY
mov [ecx]TTexturePersp.fxXDifference.i4Fx,ebx
mov ebx,[esi]CDrawPolygonBase.iYTo
inc edx
mov [esi]CDrawPolygonBase.iY,edx
cmp edx,ebx
jl Y_LOOP
// Done with MMX/3DX.
femms
}
}
//*****************************************************************************************
//
// Linear texture mapped with transparency in 16 bit mode.
//
void DrawSubtriangle(TTextureLinearTrans* pscan, CDrawPolygon<TTextureLinearTrans>* pdtri)
{
typedef TTextureLinearTrans::TIndex prevent_internal_compiler_errors;
static CDrawPolygon<TTextureLinearTrans>* pdtriGlbl;
static TTextureLinearTrans* pscanGlbl;
static PackedFloatUV pf_texture_inc;
TTextureLinearTrans* plinc = &pdtri->pedgeBase->lineIncrement;
__asm
{
// Get ready to do MMX/3DX.
femms
mov edi,[plinc] // Pointer to scanline increment.
mov esi,[pdtri] // Pointer to polygon object.
mov eax,[pscan] // Pointer to scanline object.
mov pdtriGlbl,esi
//
// Local copies of edge stepping values.
//
// fx_inc = pdtri->pedgeBase->lineIncrement.fxX;
// fx_diff = pdtri->pedgeBase->lineIncrement.fxXDifference;
// pf_texture_inc = pdtri->pedgeBase->lineIncrement.indCoord.pfIndex;
// pdtriGlbl = pdtri;
// pscanGlbl = pscan;
// fx_gour_inc = pdtri->pedgeBase->lineIncrement.gourIntensity.fxIntensity;
//
mov ebx,[edi]TTextureLinearTrans.fxX
mov pscanGlbl,eax
mov ecx,[edi]TTextureLinearTrans.fxXDifference
mov fx_inc,ebx
movq mm0,[edi]TTextureLinearTrans.indCoord.pfIndex
mov fx_diff,ecx
movq [pf_texture_inc],mm0
//
// Setup:
//
// mm2 = qMFactor = width,1,width,1
// mm3 = qUVMasks
// mm6 = uvslope
//
movd mm0,[iTexWidth] // 0,0,0,Width
movd mm2,[u4OneOne] // 0,0,1,1
movq mm3,[qUVMasks] // Load texture masks
punpcklwd mm0,mm0 // 0,0,Width,Width
movq mm6,[pfxDeltaTex] // Load texture slopes.
punpcklwd mm2,mm0 // Width,1,Width,1
movq mm7,[eax]TTextureLinearTrans.indCoord.pfIndex
//
// Iterate through the scanlines that intersect the subtriangle.
//
Y_LOOP:
mov ebx,[bEvenScanlinesOnly]
mov edx,[esi]CDrawPolygonBase.iY
// Check for odd scan lines here and skip if even
and edx,ebx
jnz short END_OF_SCANLINE
mov ebx,[eax]TTextureLinearTrans.fxX.i4Fx
mov ecx,[esi]CDrawPolygonBase.fxLineLength.i4Fx
mov edi,ebx
mov edx,gsGlobals.pvScreen
add ebx,ecx
sar edi,16
mov ecx,[esi]CDrawPolygonBase.iLineStartIndex
sar ebx,16
add ecx,ebx
lea edx,[edx + ecx*2]
sub edi,ebx
jge short END_OF_SCANLINE // no pixels to draw
//---------------------------------------------------------------------------
// Draw the scanline.
//
// mm6,mm7 = texture values.
//
// Setup registers:
//
// eax = texel_index2 ebx = texel_index2
// ecx = clut_base_pointer edx = dest_base_ptr
// esi = texture_base_ptr edi = pixel_offset & count
// ebp = base pointer
//
// mm0 = temp mm1 = temp
// mm2 = mfactor mm3 = uvmask
// mm6 = uvslope mm7 = uv (stepped once)
//
pf2id (m7,m7) // Convert texture values to 16.16 fixed.
mov esi,[pvTextureBitmap] // Load texture ponter.
movq mm0,mm7 // Copy U1,V1
paddd mm7,mm6 // Step U,V
psrad mm0,16 // Shift for integer U1,V1
movq mm1,mm7 // Copy U2,V2
psrad mm1,16 // Shift for integer U2,V2
mov ecx,[pvClutConversion] // Load clut pointer.
packssdw mm0,mm1 // Pack integer texture values
sub esi,4 // Hack to force SIB + offset in loop
pand mm0,mm3 // Mask for tiling
pmaddwd mm0,mm2 // Compute texture indicies.
//
// Make sure we have more than 2 pixels left.
//
add edi,2
jl short INNER_LOOP_2P
jmp FINISH_REMAINDER
// Align start of loop to 1 (or 17) past the beginning of a cache line.
ALIGN 16
nop
//
// Do two pixels at a time.
//
// mm0 = packed & masked U1,V1,U2,V2
// mm7 is stepped once.
//
INNER_LOOP_2P:
movq [qIndexTemp],mm0 // Save texture indicies.
paddd mm7,mm6 // Step U,V
mov eax,dword ptr[qIndexTemp] // Get texture index 1
movq mm0,mm7 // Copy U1,V1
mov ebx,dword ptr[qIndexTemp + 4] // Get texture index 2
psrad mm0,16 // Shift for integer U1,V1
movzx eax,byte ptr[esi + eax + 4] // Lookup texel 1
paddd mm7,mm6 // Step U,V
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 2
movq mm1,mm7 // Copy U2,V2
psrad mm1,16 // Shift for integer U2,V2
packssdw mm0,mm1 // Pack integer texture values.
test eax,eax // Test for transparency.
jz short PIXEL1_TRANSPARENT
mov ax,[ecx + eax*2] // Clut lookup for p1
mov [edx + edi*2 - 4],ax // Store pixel 1
PIXEL1_TRANSPARENT:
pand mm0,mm3 // Mask for tiling
test ebx,ebx // Test for transparency.
pmaddwd mm0,mm2 // Compute texture indicies.
jz short PIXEL2_TRANSPARENT
mov bx,word ptr[ecx + ebx*2] // Clut lookup for p2
mov [edx + edi*2 - 2],bx // Store pixel 2
PIXEL2_TRANSPARENT:
add edi,2 // Inrcement index by 2
jl short INNER_LOOP_2P // Loop (while >2 pixels)
FINISH_REMAINDER:
//
// One pixel (edi == 1) or two pixels (edi == 0) left.
//
jnz short ONE_PIXEL_LEFT
//
// Two pixels left, only step texture co-ordinates once.
//
movq [qIndexTemp],mm0 // Save texture indicies.
mov eax,dword ptr[qIndexTemp] // Get texture index 1
mov ebx,dword ptr[qIndexTemp + 4] // Get texture index 2
movzx eax,byte ptr[esi + eax + 4] // Lookup texel 1
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 2
test eax,eax // Test for transparency.
jz short PIXEL1_TRANSPARENT_END
mov ax,[ecx + eax*2] // Clut lookup for p1
mov [edx + edi*2 - 4],ax // Store pixel 1
PIXEL1_TRANSPARENT_END:
test ebx,ebx // Test for transparency.
jz short END_OF_SCANLINE
mov bx,[ecx + ebx*2] // Clut lookup for p2
mov [edx + edi*2 - 2],bx // Store pixel 2
jmp short END_OF_SCANLINE
ONE_PIXEL_LEFT:
//
// One pixel left, don't step texture co-ordinates.
//
movq [qIndexTemp],mm0 // Save texture indicies.
mov ebx,dword ptr[qIndexTemp] // Get texture index 1
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
test ebx,ebx // Test for transparency.
jz short END_OF_SCANLINE
mov bx,[ecx + ebx*2] // Clut lookup for p1
mov [edx + edi*2 - 4],bx // Store pixel 1
// -------------------------------------------------------------------------
// Increment the base edge.
//
END_OF_SCANLINE:
mov eax,[pscanGlbl]
movq mm1,[pf_texture_inc]
movq mm7,[eax]TTextureLinearTrans.indCoord.pfIndex
mov ebx,[eax]TTextureLinearTrans.fxXDifference
pfadd (m7,m1)
add ebx,[fx_diff]
jge short NO_UNDERFLOW
// Undeflow of fxXDifference.
add ebx,0x00010000
movq mm1,[pfNegD]
pfadd (m7,m1)
jmp short EDGE_DONE
NO_UNDERFLOW:
cmp ebx,0x00010000
jl short EDGE_DONE
// Overflow of fxXDifference.
sub ebx,0x00010000
movq mm1,[pfNegD]
pfadd (m7,m1)
EDGE_DONE:
// Store modified variables and do looping.
// Step length, line starting address.
mov esi,[pdtriGlbl]
mov [eax]TTextureLinearTrans.fxXDifference,ebx
movq [eax]TTextureLinearTrans.indCoord.pfIndex,mm7
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]TTextureLinearTrans.fxX
mov edx,[fx_inc]
add ecx,edx
mov edx,[esi]CDrawPolygonBase.iY
mov [eax]TTextureLinearTrans.fxX,ecx
inc edx
mov ebx,[esi]CDrawPolygonBase.iYTo
mov [esi]CDrawPolygonBase.iY,edx
cmp edx,ebx
jl Y_LOOP
// Done with MMX/3DX.
femms
}
}
//*****************************************************************************************
//
// Linear texture mapped with no transparency in 16 bit mode.
//
void DrawSubtriangle(TTextureLinear* pscan, CDrawPolygon<TTextureLinear>* pdtri)
{
typedef TTextureLinear::TIndex prevent_internal_compiler_errors;
static CDrawPolygon<TTextureLinear>* pdtriGlbl;
static TTextureLinear* pscanGlbl;
static PackedFloatUV pf_texture_inc;
TTextureLinear* plinc = &pdtri->pedgeBase->lineIncrement;
__asm
{
// Get ready to do MMX/3DX.
femms
mov edi,[plinc] // Pointer to scanline increment.
mov esi,[pdtri] // Pointer to polygon object.
mov eax,[pscan] // Pointer to scanline object.
mov pdtriGlbl,esi
//
// Local copies of edge stepping values.
//
// fx_inc = pdtri->pedgeBase->lineIncrement.fxX;
// fx_diff = pdtri->pedgeBase->lineIncrement.fxXDifference;
// pf_texture_inc = pdtri->pedgeBase->lineIncrement.indCoord.pfIndex;
// pdtriGlbl = pdtri;
// pscanGlbl = pscan;
// fx_gour_inc = pdtri->pedgeBase->lineIncrement.gourIntensity.fxIntensity;
//
mov ebx,[edi]TTextureLinear.fxX
mov pscanGlbl,eax
mov ecx,[edi]TTextureLinear.fxXDifference
mov fx_inc,ebx
movq mm0,[edi]TTextureLinear.indCoord.pfIndex
mov fx_diff,ecx
movq [pf_texture_inc],mm0
//
// Setup:
//
// mm2 = qMFactor = width,1,width,1
// mm3 = qUVMasks
// mm6 = uvslope
//
movd mm0,[iTexWidth] // 0,0,0,Width
movd mm2,[u4OneOne] // 0,0,1,1
movq mm3,[qUVMasks] // Load texture masks
punpcklwd mm0,mm0 // 0,0,Width,Width
movq mm6,[pfxDeltaTex] // Load texture slopes.
punpcklwd mm2,mm0 // Width,1,Width,1
movq mm7,[eax]TTextureLinear.indCoord.pfIndex
//
// Iterate through the scanlines that intersect the subtriangle.
//
Y_LOOP:
mov ebx,[bEvenScanlinesOnly]
mov edx,[esi]CDrawPolygonBase.iY
// Check for odd scan lines here and skip if even
and edx,ebx
jnz short END_OF_SCANLINE
mov ebx,[eax]TTextureLinear.fxX.i4Fx
mov ecx,[esi]CDrawPolygonBase.fxLineLength.i4Fx
mov edi,ebx
mov edx,gsGlobals.pvScreen
add ebx,ecx
sar edi,16
mov ecx,[esi]CDrawPolygonBase.iLineStartIndex
sar ebx,16
add ecx,ebx
lea edx,[edx + ecx*2]
sub edi,ebx
jge short END_OF_SCANLINE // no pixels to draw
//---------------------------------------------------------------------------
// Draw the scanline.
//
// mm6,mm7 = texture values.
//
// Setup registers:
//
// eax = texel_index2 ebx = texel_index2
// ecx = clut_base_pointer edx = dest_base_ptr
// esi = texture_base_ptr edi = pixel_offset & count
// ebp = base pointer
//
// mm0 = temp mm1 = temp
// mm2 = mfactor mm3 = uvmask
// mm6 = uvslope mm7 = uv (stepped once)
//
pf2id (m7,m7) // Convert texture values to 16.16 fixed.
mov esi,[pvTextureBitmap] // Load texture ponter.
movq mm0,mm7 // Copy U1,V1
paddd mm7,mm6 // Step U,V
psrad mm0,16 // Shift for integer U1,V1
movq mm1,mm7 // Copy U2,V2
psrad mm1,16 // Shift for integer U2,V2
mov ecx,[pvClutConversion] // Load clut pointer.
packssdw mm0,mm1 // Pack integer texture values
sub esi,4 // Hack to force SIB + offset in loop
pand mm0,mm3 // Mask for tiling
sub ecx,4 // Hack to force SIB + offset in loop
pmaddwd mm0,mm2 // Compute texture indicies.
//
// Align to a quadword boundry.
//
lea eax,[edx + edi*2]
and eax,3
jz ALIGNED2
inc edi // One pixel left?
jz ONE_PIXEL_LEFT
//
// Do one pixel for alignment.
//
movq [qIndexTemp],mm0 // Save texture indicies.
paddd mm7,mm6 // Step U,V
mov ebx,dword ptr[qIndexTemp] // Get texture index 1
movq mm0,mm7 // Copy U1,V1
psrad mm0,16 // Shift for integer U1,V1
packssdw mm1,mm0 // Pack integer texture values.
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
movq mm0,mm1 // Put values back into mm0
pand mm0,mm3 // Mask for tiling
pmaddwd mm0,mm2 // Compute texture indicies.
movzx ebx,word ptr[ecx + ebx*2 + 4] // Clut lookup for pixel 1
lea eax,[edx + edi*2]
mov [edx + edi*2 - 2],bx // Store pixel
ALIGNED2:
and eax,7
jz ALIGNED4
add edi,2 // Two pixels left?
jge FINISH_REMAINDER2
//
// Do two pixels for alignment.
//
movq [qIndexTemp],mm0 // Save texture indicies.
paddd mm7,mm6 // Step U,V
mov eax,dword ptr[qIndexTemp + 4] // Get texture index 2
movq mm0,mm7 // Copy U1,V1
mov ebx,dword ptr[qIndexTemp] // Get texture index 1
psrad mm0,16 // Shift for integer U1,V1
movzx eax,byte ptr[esi + eax + 4] // Lookup texel 2
paddd mm7,mm6 // Step U,V
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
movq mm1,mm7 // Copy U2,V2
psrad mm1,16 // Shift for integer U2,V2
packssdw mm0,mm1 // Pack integer texture values.
movzx eax,word ptr[ecx + eax*2 + 4] // Clut lookup for pixel 1
pand mm0,mm3 // Mask for tiling
movzx ebx,word ptr[ecx + ebx*2 + 4] // Clut lookup for pixel 2
pmaddwd mm0,mm2 // Compute texture indicies.
shl eax,16 // Shift pixel 2 up.
or ebx,eax // Combine pixels.
mov [edx + edi*2 - 4],ebx // Store pixels
ALIGNED4:
add edi,4
jl short INNER_LOOP_4P // Four pixles left?
jmp FINISH_REMAINDER4
// Align start of loop to 0 past the beginning of a cache line.
ALIGN 16
nop
ALIGN 16
//
// Do four pixels at a time.
//
// mm0 = packed & masked U1,V1,U2,V2
// mm7 is stepped once.
//
INNER_LOOP_4P:
movq [qIndexTemp],mm0 // Save texture indicies.
paddd mm7,mm6 // Step U,V
mov eax,dword ptr[qIndexTemp + 4] // Get texture index 2
movq mm0,mm7 // Copy U1,V1
mov ebx,dword ptr[qIndexTemp] // Get texture index 1
psrad mm0,16 // Shift for integer U1,V1
movzx eax,byte ptr[esi + eax + 4] // Lookup texel 2
paddd mm7,mm6 // Step U,V
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
movq mm1,mm7 // Copy U2,V2
psrad mm1,16 // Shift for integer U2,V2
packssdw mm0,mm1 // Pack integer texture values.
movzx eax,word ptr[ecx + eax*2 + 4] // Clut lookup for pixel 2
pand mm0,mm3 // Mask for tiling
movzx ebx,word ptr[ecx + ebx*2 + 4] // Clut lookup for pixel 1
pmaddwd mm0,mm2 // Compute texture indicies.
shl eax,16 // Shift second pixel up.
movq [qIndexTemp],mm0 // Save texture indicies.
or ebx,eax // Combine 2 pixels.
movd mm4,ebx // Put in MMX register.
mov eax,dword ptr[qIndexTemp + 4] // Get texture index 2
paddd mm7,mm6 // Step U,V
mov ebx,dword ptr[qIndexTemp] // Get texture index 1
movq mm0,mm7 // Copy U1,V1
movzx eax,byte ptr[esi + eax + 4] // Lookup texel 2
psrad mm0,16 // Shift for integer U1,V1
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
paddd mm7,mm6 // Step U,V
movq mm1,mm7 // Copy U2,V2
psrad mm1,16 // Shift for integer U2,V2
movzx eax,word ptr[ecx + eax*2 + 4] // Clut lookup for pixel 2
packssdw mm0,mm1 // Pack integer texture values.
movzx ebx,word ptr[ecx + ebx*2 + 4] // Clut lookup for pixel 1
pand mm0,mm3 // Mask for tiling
shl eax,16 // Shift second pixel up.
pmaddwd mm0,mm2 // Compute texture indicies.
or ebx,eax // Combine 2 pixels.
movd mm1,ebx // Put in MMX register.
punpckldq mm4,mm1 // Combine all four pixels.
movq [edx + edi*2 - 8],mm4 // Store 4 pixels
add edi,4 // Inrcement index by 4
jl INNER_LOOP_4P // Loop (while >4 pixels)
FINISH_REMAINDER4:
//
// One (edi == 3), two (edi == 2), three (edi == 1) or four (edi == 0) pixels left.
//
jnz THREE_OR_LESS
//
// Four pixels left, don't step texture co-ordinates.
//
movq [qIndexTemp],mm0 // Save texture indicies.
paddd mm7,mm6 // Step U,V
mov eax,dword ptr[qIndexTemp + 4] // Get texture index 2
movq mm0,mm7 // Copy U1,V1
mov ebx,dword ptr[qIndexTemp] // Get texture index 1
psrad mm0,16 // Shift for integer U1,V1
movzx eax,byte ptr[esi + eax + 4] // Lookup texel 2
paddd mm7,mm6 // Step U,V
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
movq mm1,mm7 // Copy U2,V2
psrad mm1,16 // Shift for integer U2,V2
packssdw mm0,mm1 // Pack integer texture values.
movzx eax,word ptr[ecx + eax*2 + 4] // Clut lookup for pixel 2
pand mm0,mm3 // Mask for tiling
movzx ebx,word ptr[ecx + ebx*2 + 4] // Clut lookup for pixel 1
pmaddwd mm0,mm2 // Compute texture indicies.
shl eax,16 // Shift second pixel up.
movq [qIndexTemp],mm0 // Save texture indicies.
or ebx,eax // Combine 2 pixels.
movd mm4,ebx // Put in MMX register.
mov eax,dword ptr[qIndexTemp + 4] // Get texture index 2
mov ebx,dword ptr[qIndexTemp] // Get texture index 1
movzx eax,byte ptr[esi + eax + 4] // Lookup texel 2
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
movzx eax,word ptr[ecx + eax*2 + 4] // Clut lookup for pixel 2
movzx ebx,word ptr[ecx + ebx*2 + 4] // Clut lookup for pixel 1
shl eax,16 // Shift second pixel up.
or ebx,eax // Combine 2 pixels.
movd mm1,ebx // Put in MMX register.
punpckldq mm4,mm1 // Combine all four pixels.
movq [edx - 8],mm4 // Store 4 pixels
jmp END_OF_SCANLINE
THREE_OR_LESS:
sub edi,2
jge FINISH_REMAINDER2
//
// Three pixels left, don't step texture co-ordinates.
//
movq [qIndexTemp],mm0 // Save texture indicies.
paddd mm7,mm6 // Step U,V
mov eax,dword ptr[qIndexTemp + 4] // Get texture index 2
movq mm0,mm7 // Copy U1,V1
mov ebx,dword ptr[qIndexTemp] // Get texture index 1
psrad mm0,16 // Shift for integer U1,V1
movzx eax,byte ptr[esi + eax + 4] // Lookup texel 2
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
packssdw mm0,mm0 // Pack integer texture values.
movzx eax,word ptr[ecx + eax*2 + 4] // Clut lookup for pixel 1
pand mm0,mm3 // Mask for tiling
movzx ebx,word ptr[ecx + ebx*2 + 4] // Clut lookup for pixel 2
pmaddwd mm0,mm2 // Compute texture indicies.
shl eax,16 // Shift pixel 2 up.
or ebx,eax // Combine pixels.
mov [edx - 6],ebx // Store pixels
movd ebx,mm0 // Get texture index 1
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
mov bx,word ptr[ecx + ebx*2 + 4] // Clut lookup for p1
mov [edx - 2],bx // Store pixel 1
jmp short END_OF_SCANLINE
FINISH_REMAINDER2:
//
// One pixel (edi == 1) or two pixels (edi == 0) left.
//
jnz ONE_PIXEL_LEFT
//
// Two pixels left, don't step texture co-ordinates.
//
movq [qIndexTemp],mm0 // Save texture indicies.
mov eax,dword ptr[qIndexTemp + 4] // Get texture index 2
mov ebx,dword ptr[qIndexTemp] // Get texture index 1
movzx eax,byte ptr[esi + eax + 4] // Lookup texel 2
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
movzx eax,word ptr[ecx + eax*2 + 4] // Clut lookup for pixel 2
movzx ebx,word ptr[ecx + ebx*2 + 4] // Clut lookup for pixel 1
shl eax,16 // Shift pixel 2 up.
or ebx,eax // Combine pixels.
mov [edx - 4],ebx // Store pixels
jmp short END_OF_SCANLINE
ONE_PIXEL_LEFT:
//
// One pixel left, don't step texture co-ordinates.
//
movd ebx,mm0 // Get texture index 1
movzx ebx,byte ptr[esi + ebx + 4] // Lookup texel 1
mov eax,[i_pixel] // Load remaining length.
mov bx,word ptr[ecx + ebx*2 + 4] // Clut lookup for p1
mov [edx - 2],bx // Store pixel 1
// -------------------------------------------------------------------------
// Increment the base edge.
//
END_OF_SCANLINE:
mov eax,[pscanGlbl]
movq mm1,[pf_texture_inc]
movq mm7,[eax]TTextureLinear.indCoord.pfIndex
mov ebx,[eax]TTextureLinear.fxXDifference
pfadd (m7,m1)
add ebx,[fx_diff]
jge short NO_UNDERFLOW
// Undeflow of fxXDifference.
add ebx,0x00010000
movq mm1,[pfNegD]
pfadd (m7,m1)
jmp short EDGE_DONE
NO_UNDERFLOW:
cmp ebx,0x00010000
jl short EDGE_DONE
// Overflow of fxXDifference.
sub ebx,0x00010000
movq mm1,[pfNegD]
pfadd (m7,m1)
EDGE_DONE:
// Store modified variables and do looping.
// Step length, line starting address.
mov esi,[pdtriGlbl]
mov [eax]TTextureLinear.fxXDifference,ebx
movq [eax]TTextureLinear.indCoord.pfIndex,mm7
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]TTextureLinear.fxX
mov edx,[fx_inc]
add ecx,edx
mov edx,[esi]CDrawPolygonBase.iY
mov [eax]TTextureLinear.fxX,ecx
inc edx
mov ebx,[esi]CDrawPolygonBase.iYTo
mov [esi]CDrawPolygonBase.iY,edx
cmp edx,ebx
jl Y_LOOP
// Done with MMX/3DX.
femms
}
}
// Restore default section.
#pragma code_seg()
Reference in New Issue View Git Blame Copy Permalink