mirror of
https://github.com/mupen64plus/mupen64plus-oldsvn.git
synced 2025-04-02 10:52:35 -04:00
edcef05047
one pointer arithmetic one in TextureFilters.cpp (see tracker). Once that is fixed Issue 24 in current form can be closed. Testing done: Code compiles for normal and debug use without any -Wall warnings and seems to yield the same results and previous svn on my r300.
2075 lines
60 KiB
C++
2075 lines
60 KiB
C++
/*
|
|
Copyright (C) 2003 Rice1964
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
#include "liblinux/BMGLibPNG.h"
|
|
|
|
extern FiddledVtx * g_pVtxBase;
|
|
CRender * CRender::g_pRender=NULL;
|
|
int CRender::gRenderReferenceCount=0;
|
|
|
|
XMATRIX reverseXY(-1,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,1);
|
|
XMATRIX reverseY(1,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,1);
|
|
extern char* right (char * src, int nchars);
|
|
|
|
//========================================================================
|
|
CRender * CRender::GetRender(void)
|
|
{
|
|
if( CRender::g_pRender == NULL )
|
|
{
|
|
ErrorMsg("g_pRender is NULL");
|
|
exit(0);
|
|
}
|
|
else
|
|
return CRender::g_pRender;
|
|
}
|
|
bool CRender::IsAvailable()
|
|
{
|
|
return CRender::g_pRender != NULL;
|
|
}
|
|
|
|
CRender::CRender() :
|
|
m_fScreenViewportMultX(2.0f),
|
|
m_fScreenViewportMultY(2.0f),
|
|
|
|
m_dwTexturePerspective(FALSE),
|
|
m_bAlphaTestEnable(FALSE),
|
|
m_bZUpdate(FALSE),
|
|
m_bZCompare(FALSE),
|
|
m_dwZBias(0),
|
|
|
|
m_dwMinFilter(FILTER_POINT),
|
|
m_dwMagFilter(FILTER_POINT),
|
|
m_dwAlpha(0xFF),
|
|
m_Mux(0),
|
|
m_bBlendModeValid(FALSE)
|
|
{
|
|
int i;
|
|
InitRenderBase();
|
|
|
|
for( i=0; i<MAX_TEXTURES; i++ )
|
|
{
|
|
g_textures[i].m_lpsTexturePtr = NULL;
|
|
g_textures[i].m_pCTexture = NULL;
|
|
|
|
g_textures[i].m_dwTileWidth = 64; // Value doesn't really matter, as tex not set
|
|
g_textures[i].m_dwTileHeight = 64;
|
|
g_textures[i].m_fTexWidth = 64.0f; // Value doesn't really matter, as tex not set
|
|
g_textures[i].m_fTexHeight = 64.0f;
|
|
g_textures[i].pTextureEntry = NULL;
|
|
|
|
TileUFlags[i] = TileVFlags[i] = TEXTURE_UV_FLAG_CLAMP;
|
|
}
|
|
|
|
|
|
//for( i=0; i<MAX_VERTS; i++)
|
|
//{
|
|
// g_dwVtxFlags[i] = 0;
|
|
//}
|
|
|
|
m_pColorCombiner = CDeviceBuilder::GetBuilder()->CreateColorCombiner(this);
|
|
m_pColorCombiner->Initialize();
|
|
|
|
m_pAlphaBlender = CDeviceBuilder::GetBuilder()->CreateAlphaBlender(this);
|
|
|
|
}
|
|
|
|
CRender::~CRender()
|
|
{
|
|
if( m_pColorCombiner != NULL )
|
|
{
|
|
CDeviceBuilder::GetBuilder()->DeleteColorCombiner();
|
|
m_pColorCombiner = NULL;
|
|
}
|
|
|
|
if( m_pAlphaBlender != NULL )
|
|
{
|
|
CDeviceBuilder::GetBuilder()->DeleteAlphaBlender();
|
|
m_pAlphaBlender = NULL;
|
|
}
|
|
}
|
|
|
|
void CRender::ResetMatrices()
|
|
{
|
|
Matrix mat;
|
|
|
|
mat.m[0][1] = mat.m[0][2] = mat.m[0][3] =
|
|
mat.m[1][0] = mat.m[1][2] = mat.m[1][3] =
|
|
mat.m[2][0] = mat.m[2][1] = mat.m[2][3] =
|
|
mat.m[3][0] = mat.m[3][1] = mat.m[3][2] = 0.0f;
|
|
|
|
mat.m[0][0] = mat.m[1][1] = mat.m[2][2] = mat.m[3][3] = 1.0f;
|
|
|
|
gRSP.projectionMtxTop = 0;
|
|
gRSP.modelViewMtxTop = 0;
|
|
gRSP.projectionMtxs[0] = mat;
|
|
gRSP.modelviewMtxs[0] = mat;
|
|
|
|
gRSP.bMatrixIsUpdated = true;
|
|
gRSP.bWorldMatrixIsUpdated = true;
|
|
UpdateCombinedMatrix();
|
|
}
|
|
|
|
void CRender::SetProjection(const Matrix & mat, bool bPush, bool bReplace)
|
|
{
|
|
if (bPush)
|
|
{
|
|
if (gRSP.projectionMtxTop >= (RICE_MATRIX_STACK-1))
|
|
{
|
|
TRACE0("Pushing past proj stack limits!");
|
|
}
|
|
else
|
|
gRSP.projectionMtxTop++;
|
|
|
|
if (bReplace)
|
|
{
|
|
// Load projection matrix
|
|
gRSP.projectionMtxs[gRSP.projectionMtxTop] = mat;
|
|
}
|
|
else
|
|
{
|
|
gRSP.projectionMtxs[gRSP.projectionMtxTop] = mat * gRSP.projectionMtxs[gRSP.projectionMtxTop-1];
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if (bReplace)
|
|
{
|
|
// Load projection matrix
|
|
gRSP.projectionMtxs[gRSP.projectionMtxTop] = mat;
|
|
}
|
|
else
|
|
{
|
|
gRSP.projectionMtxs[gRSP.projectionMtxTop] = mat * gRSP.projectionMtxs[gRSP.projectionMtxTop];
|
|
}
|
|
|
|
}
|
|
|
|
gRSP.bMatrixIsUpdated = true;
|
|
|
|
DumpMatrix(mat,"Set Projection Matrix");
|
|
}
|
|
|
|
bool mtxPopUpError = false;
|
|
void CRender::SetWorldView(const Matrix & mat, bool bPush, bool bReplace)
|
|
{
|
|
if (bPush)
|
|
{
|
|
if (gRSP.modelViewMtxTop >= (RICE_MATRIX_STACK-1))
|
|
DebuggerAppendMsg("Pushing past modelview stack limits! %s", bReplace?"Load":"Mul");
|
|
else
|
|
gRSP.modelViewMtxTop++;
|
|
|
|
// We should store the current projection matrix...
|
|
if (bReplace)
|
|
{
|
|
// Load projection matrix
|
|
gRSP.modelviewMtxs[gRSP.modelViewMtxTop] = mat;
|
|
}
|
|
else // Multiply projection matrix
|
|
{
|
|
gRSP.modelviewMtxs[gRSP.modelViewMtxTop] = mat * gRSP.modelviewMtxs[gRSP.modelViewMtxTop-1];
|
|
}
|
|
}
|
|
else // NoPush
|
|
{
|
|
if (bReplace)
|
|
{
|
|
// Load projection matrix
|
|
gRSP.modelviewMtxs[gRSP.modelViewMtxTop] = mat;
|
|
}
|
|
else
|
|
{
|
|
// Multiply projection matrix
|
|
gRSP.modelviewMtxs[gRSP.modelViewMtxTop] = mat * gRSP.modelviewMtxs[gRSP.modelViewMtxTop];
|
|
}
|
|
}
|
|
|
|
gRSPmodelViewTop = gRSP.modelviewMtxs[gRSP.modelViewMtxTop];
|
|
if( options.enableHackForGames == HACK_REVERSE_XY_COOR )
|
|
{
|
|
gRSPmodelViewTop = gRSPmodelViewTop * reverseXY;
|
|
}
|
|
if( options.enableHackForGames == HACK_REVERSE_Y_COOR )
|
|
{
|
|
gRSPmodelViewTop = gRSPmodelViewTop * reverseY;
|
|
}
|
|
MatrixTranspose(&gRSPmodelViewTopTranspose, &gRSPmodelViewTop);
|
|
|
|
gRSP.bMatrixIsUpdated = true;
|
|
gRSP.bWorldMatrixIsUpdated = true;
|
|
|
|
DumpMatrix(mat,"Set WorldView Matrix");
|
|
}
|
|
|
|
|
|
void CRender::PopWorldView()
|
|
{
|
|
if (gRSP.modelViewMtxTop > 0)
|
|
{
|
|
gRSP.modelViewMtxTop--;
|
|
gRSPmodelViewTop = gRSP.modelviewMtxs[gRSP.modelViewMtxTop];
|
|
if( options.enableHackForGames == HACK_REVERSE_XY_COOR )
|
|
{
|
|
gRSPmodelViewTop = gRSPmodelViewTop * reverseXY;
|
|
}
|
|
if( options.enableHackForGames == HACK_REVERSE_Y_COOR )
|
|
{
|
|
gRSPmodelViewTop = gRSPmodelViewTop * reverseY;
|
|
}
|
|
MatrixTranspose(&gRSPmodelViewTopTranspose, &gRSPmodelViewTop);
|
|
gRSP.bMatrixIsUpdated = true;
|
|
gRSP.bWorldMatrixIsUpdated = true;
|
|
}
|
|
else
|
|
{
|
|
#ifdef _DEBUG
|
|
if( pauseAtNext )
|
|
TRACE0("Popping past worldview stack limits");
|
|
#endif
|
|
mtxPopUpError = true;
|
|
}
|
|
}
|
|
|
|
|
|
Matrix & CRender::GetWorldProjectMatrix(void)
|
|
{
|
|
return gRSPworldProject;
|
|
}
|
|
|
|
void CRender::SetWorldProjectMatrix(Matrix &mtx)
|
|
{
|
|
#ifdef _DEBUG
|
|
if( pauseAtNext && (eventToPause == NEXT_TRIANGLE || eventToPause == NEXT_FLUSH_TRI || eventToPause == NEXT_MATRIX_CMD ) )
|
|
{
|
|
uint32 dwPC = gDlistStack[gDlistStackPointer].pc-8;
|
|
DebuggerAppendMsg("Force Matrix: pc=%08X", dwPC);
|
|
DumpMatrix(mtx, "Force Matrix, loading new world-project matrix");
|
|
}
|
|
#endif
|
|
gRSPworldProject = mtx;
|
|
|
|
gRSP.bMatrixIsUpdated = false;
|
|
gRSP.bCombinedMatrixIsUpdated = true;
|
|
}
|
|
|
|
void CRender::SetMux(uint32 dwMux0, uint32 dwMux1)
|
|
{
|
|
uint64 tempmux = (((uint64)dwMux0) << 32) | (uint64)dwMux1;
|
|
if( m_Mux != tempmux )
|
|
{
|
|
m_Mux = tempmux;
|
|
m_bBlendModeValid = FALSE;
|
|
m_pColorCombiner->UpdateCombiner(dwMux0, dwMux1);
|
|
}
|
|
}
|
|
|
|
|
|
void CRender::SetCombinerAndBlender()
|
|
{
|
|
InitOtherModes();
|
|
|
|
if( g_curRomInfo.bDisableBlender )
|
|
m_pAlphaBlender->DisableAlphaBlender();
|
|
else if( currentRomOptions.bNormalBlender )
|
|
m_pAlphaBlender->NormalAlphaBlender();
|
|
else
|
|
m_pAlphaBlender->InitBlenderMode();
|
|
|
|
m_pColorCombiner->InitCombinerMode();
|
|
}
|
|
|
|
void CRender::RenderReset()
|
|
{
|
|
UpdateClipRectangle();
|
|
ResetMatrices();
|
|
SetZBias(0);
|
|
gRSP.numVertices = 0;
|
|
gRSP.maxVertexID = 0;
|
|
gRSP.curTile = 0;
|
|
gRSP.fTexScaleX = 1/32.0f;;
|
|
gRSP.fTexScaleY = 1/32.0f;
|
|
}
|
|
|
|
bool CRender::FillRect(LONG nX0, LONG nY0, LONG nX1, LONG nY1, uint32 dwColor)
|
|
{
|
|
LOG_UCODE("FillRect: X0=%d, Y0=%d, X1=%d, Y1=%d, Color=0x%8X", nX0, nY0, nX1, nY1, dwColor);
|
|
|
|
if(g_CI.dwSize != TXT_SIZE_16b && frameBufferOptions.bIgnore)
|
|
{ return true; }
|
|
|
|
if(status.bHandleN64RenderTexture && !status.bDirectWriteIntoRDRAM)
|
|
{ status.bFrameBufferIsDrawn = true; }
|
|
|
|
if(status.bVIOriginIsUpdated == true &&
|
|
currentRomOptions.screenUpdateSetting==SCREEN_UPDATE_AT_1ST_PRIMITIVE)
|
|
{
|
|
status.bVIOriginIsUpdated=false;
|
|
CGraphicsContext::Get()->UpdateFrame();
|
|
DEBUGGER_PAUSE_AND_DUMP_NO_UPDATE(NEXT_SET_CIMG,
|
|
{DebuggerAppendMsg("Screen Update at 1st FillRectangle");});
|
|
}
|
|
|
|
if( status.bCIBufferIsRendered && status.bVIOriginIsUpdated == true && currentRomOptions.screenUpdateSetting==SCREEN_UPDATE_BEFORE_SCREEN_CLEAR )
|
|
{
|
|
if( (nX0==0 && nY0 == 0 && ((int)nX1 == g_CI.dwWidth ||
|
|
nX1 == g_CI.dwWidth-1) ) || (nX0==gRDP.scissor.left && nY0 == gRDP.scissor.top
|
|
&& (nX1 == gRDP.scissor.right || nX1 == gRDP.scissor.right-1)) ||
|
|
((nX0+nX1 == (int)g_CI.dwWidth || nX0+nX1 == (int)g_CI.dwWidth-1 || nX0+nX1 ==
|
|
gRDP.scissor.left+gRDP.scissor.right || nX0+nX1 ==
|
|
gRDP.scissor.left+gRDP.scissor.right-1) && (nY0 == gRDP.scissor.top || nY0 == 0 ||
|
|
nY0+nY1 == gRDP.scissor.top+gRDP.scissor.bottom || nY0+nY1 ==
|
|
gRDP.scissor.top+gRDP.scissor.bottom-1 ) ))
|
|
{
|
|
status.bVIOriginIsUpdated=false;
|
|
CGraphicsContext::Get()->UpdateFrame();
|
|
DEBUGGER_PAUSE_AND_DUMP_NO_UPDATE(NEXT_SET_CIMG,{DebuggerAppendMsg("Screen Update Before Screen Clear");});
|
|
}
|
|
}
|
|
|
|
|
|
SetFillMode(RICE_FILLMODE_SOLID);
|
|
|
|
bool res=true;
|
|
|
|
/*
|
|
// I don't know why this does not work for OpenGL
|
|
if( gRDP.otherMode.cycle_type == CYCLE_TYPE_FILL && nX0 == 0 && nY0 == 0 && ((nX1==windowSetting.uViWidth && nY1==windowSetting.uViHeight)||(nX1==windowSetting.uViWidth-1 && nY1==windowSetting.uViHeight-1)) )
|
|
{
|
|
CGraphicsContext::g_pGraphicsContext->Clear(CLEAR_COLOR_BUFFER,dwColor);
|
|
}
|
|
else
|
|
*/
|
|
{
|
|
//BOOL m_savedZBufferFlag = gRSP.bZBufferEnabled; // Save ZBuffer state
|
|
ZBufferEnable( FALSE );
|
|
|
|
m_fillRectVtx[0].x = ViewPortTranslatei_x(nX0);
|
|
m_fillRectVtx[0].y = ViewPortTranslatei_y(nY0);
|
|
m_fillRectVtx[1].x = ViewPortTranslatei_x(nX1);
|
|
m_fillRectVtx[1].y = ViewPortTranslatei_y(nY1);
|
|
|
|
SetCombinerAndBlender();
|
|
|
|
if( gRDP.otherMode.cycle_type >= CYCLE_TYPE_COPY )
|
|
{
|
|
ZBufferEnable(FALSE);
|
|
}
|
|
else
|
|
{
|
|
//dwColor = PostProcessDiffuseColor(0);
|
|
dwColor = PostProcessDiffuseColor(gRDP.primitiveColor);
|
|
}
|
|
|
|
float depth = (gRDP.otherMode.depth_source == 1 ? gRDP.fPrimitiveDepth : 0 );
|
|
|
|
ApplyRDPScissor();
|
|
TurnFogOnOff(false);
|
|
res = RenderFillRect(dwColor, depth);
|
|
TurnFogOnOff(gRSP.bFogEnabled);
|
|
|
|
if( gRDP.otherMode.cycle_type >= CYCLE_TYPE_COPY )
|
|
{
|
|
ZBufferEnable(gRSP.bZBufferEnabled);
|
|
}
|
|
}
|
|
|
|
if( options.bWinFrameMode ) SetFillMode(RICE_FILLMODE_WINFRAME );
|
|
|
|
DEBUGGER_PAUSE_AND_DUMP_COUNT_N( NEXT_FILLRECT, {DebuggerAppendMsg("FillRect: X0=%d, Y0=%d, X1=%d, Y1=%d, Color=0x%08X", nX0, nY0, nX1, nY1, dwColor);
|
|
DebuggerAppendMsg("Pause after FillRect: Color=%08X\n", dwColor);if( logCombiners ) m_pColorCombiner->DisplayMuxString();});
|
|
DEBUGGER_PAUSE_AND_DUMP_COUNT_N( NEXT_FLUSH_TRI, {DebuggerAppendMsg("FillRect: X0=%d, Y0=%d, X1=%d, Y1=%d, Color=0x%08X", nX0, nY0, nX1, nY1, dwColor);
|
|
DebuggerAppendMsg("Pause after FillRect: Color=%08X\n", dwColor);if( logCombiners ) m_pColorCombiner->DisplayMuxString();});
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
bool CRender::Line3D(uint32 dwV0, uint32 dwV1, uint32 dwWidth)
|
|
{
|
|
LOG_UCODE("Line3D: Vtx0=%d, Vtx1=%d, Width=%d", dwV0, dwV1, dwWidth);
|
|
if( !status.bCIBufferIsRendered ) g_pFrameBufferManager->ActiveTextureBuffer();
|
|
|
|
m_line3DVtx[0].z = (g_vecProjected[dwV0].z + 1.0f) * 0.5f;
|
|
m_line3DVtx[1].z = (g_vecProjected[dwV1].z + 1.0f) * 0.5f;
|
|
|
|
if( m_line3DVtx[0].z != m_line3DVtx[1].z )
|
|
return false;
|
|
|
|
if( status.bHandleN64RenderTexture && !status.bDirectWriteIntoRDRAM ) status.bFrameBufferIsDrawn = true;
|
|
if( status.bHandleN64RenderTexture )
|
|
{
|
|
g_pRenderTextureInfo->maxUsedHeight = g_pRenderTextureInfo->N64Height;
|
|
if( status.bHandleN64RenderTexture && !status.bDirectWriteIntoRDRAM )
|
|
{
|
|
status.bFrameBufferIsDrawn = true;
|
|
status.bFrameBufferDrawnByTriangles = true;
|
|
}
|
|
}
|
|
|
|
m_line3DVtx[0].x = ViewPortTranslatef_x(g_vecProjected[dwV0].x);
|
|
m_line3DVtx[0].y = ViewPortTranslatef_y(g_vecProjected[dwV0].y);
|
|
m_line3DVtx[0].rhw = g_vecProjected[dwV0].w;
|
|
m_line3DVtx[0].dcDiffuse = PostProcessDiffuseColor(g_dwVtxDifColor[dwV0]);
|
|
m_line3DVtx[0].dcSpecular = PostProcessSpecularColor();
|
|
|
|
m_line3DVtx[1].x = ViewPortTranslatef_x(g_vecProjected[dwV1].x);
|
|
m_line3DVtx[1].y = ViewPortTranslatef_y(g_vecProjected[dwV1].y);
|
|
m_line3DVtx[1].rhw = g_vecProjected[dwV1].w;
|
|
m_line3DVtx[1].dcDiffuse = PostProcessDiffuseColor(g_dwVtxDifColor[dwV1]);
|
|
m_line3DVtx[1].dcSpecular = m_line3DVtx[0].dcSpecular;
|
|
|
|
float width = dwWidth*0.5f+1.5f;
|
|
|
|
if( m_line3DVtx[0].y == m_line3DVtx[1].y )
|
|
{
|
|
m_line3DVector[0].x = m_line3DVector[1].x = m_line3DVtx[0].x;
|
|
m_line3DVector[2].x = m_line3DVector[3].x = m_line3DVtx[1].x;
|
|
|
|
m_line3DVector[0].y = m_line3DVector[2].y = m_line3DVtx[0].y-width/2*windowSetting.fMultY;
|
|
m_line3DVector[1].y = m_line3DVector[3].y = m_line3DVtx[0].y+width/2*windowSetting.fMultY;
|
|
}
|
|
else
|
|
{
|
|
m_line3DVector[0].y = m_line3DVector[1].y = m_line3DVtx[0].y;
|
|
m_line3DVector[2].y = m_line3DVector[3].y = m_line3DVtx[1].y;
|
|
|
|
m_line3DVector[0].x = m_line3DVector[2].x = m_line3DVtx[0].x-width/2*windowSetting.fMultX;
|
|
m_line3DVector[1].x = m_line3DVector[3].x = m_line3DVtx[0].x+width/2*windowSetting.fMultX;
|
|
}
|
|
|
|
SetCombinerAndBlender();
|
|
|
|
bool res=RenderLine3D();
|
|
|
|
DEBUGGER_PAUSE_AND_DUMP_COUNT_N(NEXT_FLUSH_TRI, {
|
|
DebuggerAppendMsg("Pause after Line3D: v%d(%f,%f,%f), v%d(%f,%f,%f), Width=%d\n", dwV0, m_line3DVtx[0].x, m_line3DVtx[0].y, m_line3DVtx[0].z,
|
|
dwV1, m_line3DVtx[1].x, m_line3DVtx[1].y, m_line3DVtx[1].z, dwWidth);
|
|
});
|
|
|
|
DEBUGGER_PAUSE_AND_DUMP_COUNT_N(NEXT_OBJ_TXT_CMD, {
|
|
DebuggerAppendMsg("Pause after Line3D: v%d(%f,%f,%f), v%d(%f,%f,%f), Width=%d\n", dwV0, m_line3DVtx[0].x, m_line3DVtx[0].y, m_line3DVtx[0].z,
|
|
dwV1, m_line3DVtx[1].x, m_line3DVtx[1].y, m_line3DVtx[1].z, dwWidth);
|
|
});
|
|
|
|
return res;
|
|
}
|
|
|
|
bool CRender::RemapTextureCoordinate
|
|
(float t0, float t1, uint32 tileWidth, uint32 mask, float textureWidth, float &u0, float &u1)
|
|
{
|
|
int s0 = (int)t0;
|
|
int s1 = (int)t1;
|
|
int width = mask>0 ? (1<<mask) : tileWidth;
|
|
if( width == 0 ) return false;
|
|
|
|
int divs0 = s0/width; if( divs0*width > s0 ) divs0--;
|
|
int divs1 = s1/width; if( divs1*width > s1 ) divs1--;
|
|
|
|
if( divs0 == divs1 )
|
|
{
|
|
s0 -= divs0*width;
|
|
s1 -= divs1*width;
|
|
//if( s0 > s1 )
|
|
// s0++;
|
|
//else if( s1 > s0 )
|
|
// s1++;
|
|
u0 = s0/textureWidth;
|
|
u1 = s1/textureWidth;
|
|
|
|
return true;
|
|
}
|
|
else if( divs0+1 == divs1 && s0%width==0 && s1%width == 0 )
|
|
{
|
|
u0 = 0;
|
|
u1 = tileWidth/textureWidth;
|
|
return true;
|
|
}
|
|
else if( divs0 == divs1+1 && s0%width==0 && s1%width == 0 )
|
|
{
|
|
u1 = 0;
|
|
u0 = tileWidth/textureWidth;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
//if( s0 > s1 )
|
|
//{
|
|
//s0++;
|
|
// u0 = s0/textureWidth;
|
|
//}
|
|
//else if( s1 > s0 )
|
|
//{
|
|
//s1++;
|
|
// u1 = s1/textureWidth;
|
|
//}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool CRender::TexRect(LONG nX0, LONG nY0, LONG nX1, LONG nY1, float fS0, float fT0, float fScaleS, float fScaleT, bool colorFlag, uint32 diffuseColor)
|
|
{
|
|
if( options.enableHackForGames == HACK_FOR_DUKE_NUKEM )
|
|
{
|
|
colorFlag = true;
|
|
diffuseColor = 0;
|
|
}
|
|
|
|
if( status.bVIOriginIsUpdated == true && currentRomOptions.screenUpdateSetting==SCREEN_UPDATE_AT_1ST_PRIMITIVE )
|
|
{
|
|
status.bVIOriginIsUpdated=false;
|
|
CGraphicsContext::Get()->UpdateFrame();
|
|
DEBUGGER_PAUSE_AND_DUMP_NO_UPDATE(NEXT_SET_CIMG,{DebuggerAppendMsg("Screen Update at 1st textRect");});
|
|
}
|
|
|
|
if( options.enableHackForGames == HACK_FOR_BANJO_TOOIE )
|
|
{
|
|
// Hack for Banjo shadow in Banjo Tooie
|
|
if( g_TI.dwWidth == g_CI.dwWidth && g_TI.dwFormat == TXT_FMT_CI && g_TI.dwSize == TXT_SIZE_8b )
|
|
{
|
|
if( nX0 == fS0 && nY0 == fT0 )//&& nX0 > 90 && nY0 > 130 && nX1-nX0 > 80 && nY1-nY0 > 20 )
|
|
{
|
|
// Skip the text rect
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( status.bN64IsDrawingTextureBuffer )
|
|
{
|
|
if( frameBufferOptions.bIgnore || ( frameBufferOptions.bIgnoreRenderTextureIfHeightUnknown && newRenderTextureInfo.knownHeight == 0 ) )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
PrepareTextures();
|
|
|
|
if( status.bHandleN64RenderTexture && g_pRenderTextureInfo->CI_Info.dwSize == TXT_SIZE_8b )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if( !IsTextureEnabled() && gRDP.otherMode.cycle_type != CYCLE_TYPE_COPY )
|
|
{
|
|
FillRect(nX0, nY0, nX1, nY1, gRDP.primitiveColor);
|
|
return true;
|
|
}
|
|
|
|
|
|
if( IsUsedAsDI(g_CI.dwAddr) && !status.bHandleN64RenderTexture )
|
|
{
|
|
status.bFrameBufferIsDrawn = true;
|
|
}
|
|
|
|
if( status.bHandleN64RenderTexture && !status.bDirectWriteIntoRDRAM ) status.bFrameBufferIsDrawn = true;
|
|
|
|
LOG_UCODE("TexRect: X0=%d, Y0=%d, X1=%d, Y1=%d,\n\t\tfS0=%f, fT0=%f, ScaleS=%f, ScaleT=%f ",
|
|
nX0, nY0, nX1, nY1, fS0, fT0, fScaleS, fScaleT);
|
|
|
|
if( options.bEnableHacks )
|
|
{
|
|
// Goldeneye HACK
|
|
if( options.bEnableHacks && nY1 - nY0 < 2 )
|
|
nY1 = nY1+2;
|
|
|
|
//// Text edge hack
|
|
else if( gRDP.otherMode.cycle_type == CYCLE_TYPE_1 && fScaleS == 1 && fScaleT == 1 &&
|
|
(int)g_textures[gRSP.curTile].m_dwTileWidth == nX1-nX0+1 && (int)g_textures[gRSP.curTile].m_dwTileHeight == nY1-nY0+1 &&
|
|
g_textures[gRSP.curTile].m_dwTileWidth%2 == 0 && g_textures[gRSP.curTile].m_dwTileHeight%2 == 0 )
|
|
{
|
|
nY1++;
|
|
nX1++;
|
|
}
|
|
else if( g_curRomInfo.bIncTexRectEdge )
|
|
{
|
|
nX1++;
|
|
nY1++;
|
|
}
|
|
}
|
|
|
|
|
|
// Scale to Actual texture coords
|
|
// The two cases are to handle the oversized textures hack on voodoos
|
|
|
|
SetCombinerAndBlender();
|
|
|
|
|
|
if( gRDP.otherMode.cycle_type >= CYCLE_TYPE_COPY || !gRDP.otherMode.z_cmp )
|
|
{
|
|
ZBufferEnable(FALSE);
|
|
}
|
|
|
|
BOOL accurate = currentRomOptions.bAccurateTextureMapping;
|
|
|
|
CTexture *surf = g_textures[gRSP.curTile].m_pCTexture;
|
|
RenderTexture &tex0 = g_textures[gRSP.curTile];
|
|
Tile &tile0 = gRDP.tiles[gRSP.curTile];
|
|
|
|
float widthDiv = tex0.m_fTexWidth;
|
|
float heightDiv = tex0.m_fTexHeight;
|
|
float t0u0;
|
|
if( options.enableHackForGames == HACK_FOR_ALL_STAR_BASEBALL || options.enableHackForGames == HACK_FOR_MLB )
|
|
{
|
|
t0u0 = (fS0 -tile0.fhilite_sl);
|
|
}
|
|
else
|
|
{
|
|
t0u0 = (fS0 * tile0.fShiftScaleS -tile0.fhilite_sl);
|
|
}
|
|
|
|
float t0u1;
|
|
if( accurate && gRDP.otherMode.cycle_type >= CYCLE_TYPE_COPY )
|
|
{
|
|
t0u1 = t0u0 + (fScaleS * (nX1 - nX0 - 1))*tile0.fShiftScaleS;
|
|
}
|
|
else
|
|
{
|
|
t0u1 = t0u0 + (fScaleS * (nX1 - nX0))*tile0.fShiftScaleS;
|
|
}
|
|
|
|
|
|
if( status.UseLargerTile[0] )
|
|
{
|
|
m_texRectTex1UV[0].u = (t0u0+status.LargerTileRealLeft[0])/widthDiv;
|
|
m_texRectTex1UV[1].u = (t0u1+status.LargerTileRealLeft[0])/widthDiv;
|
|
}
|
|
else
|
|
{
|
|
m_texRectTex1UV[0].u = t0u0/widthDiv;
|
|
m_texRectTex1UV[1].u = t0u1/widthDiv;
|
|
if( accurate && !tile0.bMirrorS && RemapTextureCoordinate(t0u0, t0u1, tex0.m_dwTileWidth, tile0.dwMaskS, widthDiv, m_texRectTex1UV[0].u, m_texRectTex1UV[1].u) )
|
|
SetTextureUFlag(TEXTURE_UV_FLAG_CLAMP, gRSP.curTile);
|
|
}
|
|
|
|
float t0v0;
|
|
if( options.enableHackForGames == HACK_FOR_ALL_STAR_BASEBALL || options.enableHackForGames == HACK_FOR_MLB )
|
|
{
|
|
t0v0 = (fT0 -tile0.fhilite_tl);
|
|
}
|
|
else
|
|
{
|
|
t0v0 = (fT0 * tile0.fShiftScaleT -tile0.fhilite_tl);
|
|
}
|
|
|
|
float t0v1;
|
|
if ( accurate && gRDP.otherMode.cycle_type >= CYCLE_TYPE_COPY)
|
|
{
|
|
t0v1 = t0v0 + (fScaleT * (nY1 - nY0-1))*tile0.fShiftScaleT;
|
|
}
|
|
else
|
|
{
|
|
t0v1 = t0v0 + (fScaleT * (nY1 - nY0))*tile0.fShiftScaleT;
|
|
}
|
|
|
|
m_texRectTex1UV[0].v = t0v0/heightDiv;
|
|
m_texRectTex1UV[1].v = t0v1/heightDiv;
|
|
if( accurate && !tile0.bMirrorT && RemapTextureCoordinate(t0v0, t0v1, tex0.m_dwTileHeight, tile0.dwMaskT, heightDiv, m_texRectTex1UV[0].v, m_texRectTex1UV[1].v) )
|
|
SetTextureVFlag(TEXTURE_UV_FLAG_CLAMP, gRSP.curTile);
|
|
|
|
COLOR speColor = PostProcessSpecularColor();
|
|
COLOR difColor;
|
|
if( colorFlag )
|
|
difColor = PostProcessDiffuseColor(diffuseColor);
|
|
else
|
|
//difColor = PostProcessDiffuseColor(0);
|
|
difColor = PostProcessDiffuseColor(gRDP.primitiveColor);
|
|
|
|
g_texRectTVtx[0].x = ViewPortTranslatei_x(nX0);
|
|
g_texRectTVtx[0].y = ViewPortTranslatei_y(nY0);
|
|
g_texRectTVtx[0].dcDiffuse = difColor;
|
|
g_texRectTVtx[0].dcSpecular = speColor;
|
|
|
|
g_texRectTVtx[1].x = ViewPortTranslatei_x(nX1);
|
|
g_texRectTVtx[1].y = ViewPortTranslatei_y(nY0);
|
|
g_texRectTVtx[1].dcDiffuse = difColor;
|
|
g_texRectTVtx[1].dcSpecular = speColor;
|
|
|
|
g_texRectTVtx[2].x = ViewPortTranslatei_x(nX1);
|
|
g_texRectTVtx[2].y = ViewPortTranslatei_y(nY1);
|
|
g_texRectTVtx[2].dcDiffuse = difColor;
|
|
g_texRectTVtx[2].dcSpecular = speColor;
|
|
|
|
g_texRectTVtx[3].x = ViewPortTranslatei_x(nX0);
|
|
g_texRectTVtx[3].y = ViewPortTranslatei_y(nY1);
|
|
g_texRectTVtx[3].dcDiffuse = difColor;
|
|
g_texRectTVtx[3].dcSpecular = speColor;
|
|
|
|
float depth = (gRDP.otherMode.depth_source == 1 ? gRDP.fPrimitiveDepth : 0 );
|
|
|
|
g_texRectTVtx[0].z = g_texRectTVtx[1].z = g_texRectTVtx[2].z = g_texRectTVtx[3].z = depth;
|
|
g_texRectTVtx[0].rhw = g_texRectTVtx[1].rhw = g_texRectTVtx[2].rhw = g_texRectTVtx[3].rhw = 1;
|
|
|
|
if( IsTexel1Enable() )
|
|
{
|
|
surf = g_textures[(gRSP.curTile+1)&7].m_pCTexture;
|
|
RenderTexture &tex1 = g_textures[(gRSP.curTile+1)&7];
|
|
Tile &tile1 = gRDP.tiles[(gRSP.curTile+1)&7];
|
|
|
|
widthDiv = tex1.m_fTexWidth;
|
|
heightDiv = tex1.m_fTexHeight;
|
|
//if( tile1.dwMaskS == 0 ) widthDiv = tile1.dwWidth;
|
|
//if( tile1.dwMaskT == 0 ) heightDiv = tile1.dwHeight;
|
|
|
|
float t0u0 = fS0 * tile1.fShiftScaleS -tile1.fhilite_sl;
|
|
float t0v0 = fT0 * tile1.fShiftScaleT -tile1.fhilite_tl;
|
|
float t0u1;
|
|
float t0v1;
|
|
if ( accurate && gRDP.otherMode.cycle_type >= CYCLE_TYPE_COPY)
|
|
{
|
|
t0u1 = t0u0 + (fScaleS * (nX1 - nX0 - 1))*tile1.fShiftScaleS;
|
|
t0v1 = t0v0 + (fScaleT * (nY1 - nY0 - 1))*tile1.fShiftScaleT;
|
|
}
|
|
else
|
|
{
|
|
t0u1 = t0u0 + (fScaleS * (nX1 - nX0))*tile1.fShiftScaleS;
|
|
t0v1 = t0v0 + (fScaleT * (nY1 - nY0))*tile1.fShiftScaleT;
|
|
}
|
|
|
|
if( status.UseLargerTile[1] )
|
|
{
|
|
m_texRectTex2UV[0].u = (t0u0+status.LargerTileRealLeft[1])/widthDiv;
|
|
m_texRectTex2UV[1].u = (t0u1+status.LargerTileRealLeft[1])/widthDiv;
|
|
}
|
|
else
|
|
{
|
|
m_texRectTex2UV[0].u = t0u0/widthDiv;
|
|
m_texRectTex2UV[1].u = t0u1/widthDiv;
|
|
if( accurate && !tile1.bMirrorS && RemapTextureCoordinate(t0u0, t0u1, tex1.m_dwTileWidth, tile1.dwMaskS, widthDiv, m_texRectTex2UV[0].u, m_texRectTex2UV[1].u) )
|
|
SetTextureUFlag(TEXTURE_UV_FLAG_CLAMP, (gRSP.curTile+1)&7);
|
|
}
|
|
|
|
m_texRectTex2UV[0].v = t0v0/heightDiv;
|
|
m_texRectTex2UV[1].v = t0v1/heightDiv;
|
|
|
|
if( accurate && !tile1.bMirrorT && RemapTextureCoordinate(t0v0, t0v1, tex1.m_dwTileHeight, tile1.dwMaskT, heightDiv, m_texRectTex2UV[0].v, m_texRectTex2UV[1].v) )
|
|
SetTextureVFlag(TEXTURE_UV_FLAG_CLAMP, (gRSP.curTile+1)&7);
|
|
|
|
SetVertexTextureUVCoord(g_texRectTVtx[0], m_texRectTex1UV[0].u, m_texRectTex1UV[0].v, m_texRectTex2UV[0].u, m_texRectTex2UV[0].v);
|
|
SetVertexTextureUVCoord(g_texRectTVtx[1], m_texRectTex1UV[1].u, m_texRectTex1UV[0].v, m_texRectTex2UV[1].u, m_texRectTex2UV[0].v);
|
|
SetVertexTextureUVCoord(g_texRectTVtx[2], m_texRectTex1UV[1].u, m_texRectTex1UV[1].v, m_texRectTex2UV[1].u, m_texRectTex2UV[1].v);
|
|
SetVertexTextureUVCoord(g_texRectTVtx[3], m_texRectTex1UV[0].u, m_texRectTex1UV[1].v, m_texRectTex2UV[0].u, m_texRectTex2UV[1].v);
|
|
}
|
|
else
|
|
{
|
|
SetVertexTextureUVCoord(g_texRectTVtx[0], m_texRectTex1UV[0].u, m_texRectTex1UV[0].v);
|
|
SetVertexTextureUVCoord(g_texRectTVtx[1], m_texRectTex1UV[1].u, m_texRectTex1UV[0].v);
|
|
SetVertexTextureUVCoord(g_texRectTVtx[2], m_texRectTex1UV[1].u, m_texRectTex1UV[1].v);
|
|
SetVertexTextureUVCoord(g_texRectTVtx[3], m_texRectTex1UV[0].u, m_texRectTex1UV[1].v);
|
|
}
|
|
|
|
|
|
bool res;
|
|
TurnFogOnOff(false);
|
|
if( TileUFlags[gRSP.curTile]==TEXTURE_UV_FLAG_CLAMP && TileVFlags[gRSP.curTile]==TEXTURE_UV_FLAG_CLAMP && options.forceTextureFilter == FORCE_DEFAULT_FILTER )
|
|
{
|
|
TextureFilter dwFilter = m_dwMagFilter;
|
|
m_dwMagFilter = m_dwMinFilter = FILTER_LINEAR;
|
|
ApplyTextureFilter();
|
|
ApplyRDPScissor();
|
|
res = RenderTexRect();
|
|
m_dwMagFilter = m_dwMinFilter = dwFilter;
|
|
ApplyTextureFilter();
|
|
}
|
|
else if( fScaleS >= 1 && fScaleT >= 1 && options.forceTextureFilter == FORCE_DEFAULT_FILTER )
|
|
{
|
|
TextureFilter dwFilter = m_dwMagFilter;
|
|
m_dwMagFilter = m_dwMinFilter = FILTER_POINT;
|
|
ApplyTextureFilter();
|
|
ApplyRDPScissor();
|
|
res = RenderTexRect();
|
|
m_dwMagFilter = m_dwMinFilter = dwFilter;
|
|
ApplyTextureFilter();
|
|
}
|
|
else
|
|
{
|
|
ApplyRDPScissor();
|
|
res = RenderTexRect();
|
|
}
|
|
TurnFogOnOff(gRSP.bFogEnabled);
|
|
|
|
if( gRDP.otherMode.cycle_type >= CYCLE_TYPE_COPY || !gRDP.otherMode.z_cmp )
|
|
{
|
|
ZBufferEnable(gRSP.bZBufferEnabled);
|
|
}
|
|
|
|
DEBUGGER_PAUSE_AT_COND_AND_DUMP_COUNT_N((eventToPause == NEXT_FLUSH_TRI || eventToPause == NEXT_TEXTRECT), {
|
|
DebuggerAppendMsg("TexRect: tile=%d, X0=%d, Y0=%d, X1=%d, Y1=%d,\nfS0=%f, fT0=%f, ScaleS=%f, ScaleT=%f\n",
|
|
gRSP.curTile, nX0, nY0, nX1, nY1, fS0, fT0, fScaleS, fScaleT);
|
|
DebuggerAppendMsg(" : x0=%f, y0=%f, x1=%f, y1=%f\n", g_texRectTVtx[0].x, g_texRectTVtx[0].y, g_texRectTVtx[2].x, g_texRectTVtx[2].y);
|
|
DebuggerAppendMsg(" Tex0: u0=%f, v0=%f, u1=%f, v1=%f\n", m_texRectTex1UV[0].u, m_texRectTex1UV[0].v, m_texRectTex1UV[1].u, m_texRectTex1UV[1].v);
|
|
if( IsTexel1Enable() )
|
|
{
|
|
DebuggerAppendMsg(" Tex1: u0=%f, v0=%f, u1=%f, v1=%f\n", m_texRectTex2UV[0].u, m_texRectTex2UV[0].v, m_texRectTex2UV[1].u, m_texRectTex2UV[1].v);
|
|
}
|
|
DebuggerAppendMsg("color=%08X, %08X\n", g_texRectTVtx[0].dcDiffuse, g_texRectTVtx[0].dcSpecular);
|
|
DebuggerAppendMsg("Pause after TexRect\n");
|
|
if( logCombiners ) m_pColorCombiner->DisplayMuxString();
|
|
});
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
bool CRender::TexRectFlip(LONG nX0, LONG nY0, LONG nX1, LONG nY1, float fS0, float fT0, float fS1, float fT1)
|
|
{
|
|
LOG_UCODE("TexRectFlip: X0=%d, Y0=%d, X1=%d, Y1=%d,\n\t\tfS0=%f, fT0=%f, fS1=%f, fT1=%f ",
|
|
nX0, nY0, nX1, nY1, fS0, fT0, fS1, fT1);
|
|
|
|
if( status.bHandleN64RenderTexture && !status.bDirectWriteIntoRDRAM )
|
|
{
|
|
status.bFrameBufferIsDrawn = true;
|
|
status.bFrameBufferDrawnByTriangles = true;
|
|
}
|
|
|
|
PrepareTextures();
|
|
|
|
// Save ZBuffer state
|
|
m_savedZBufferFlag = gRSP.bZBufferEnabled;
|
|
if( gRDP.otherMode.depth_source == 0 ) ZBufferEnable( FALSE );
|
|
|
|
float widthDiv = g_textures[gRSP.curTile].m_fTexWidth;
|
|
float heightDiv = g_textures[gRSP.curTile].m_fTexHeight;
|
|
|
|
//Tile &tile0 = gRDP.tiles[gRSP.curTile];
|
|
|
|
float t0u0 = fS0 / widthDiv;
|
|
float t0v0 = fT0 / heightDiv;
|
|
|
|
float t0u1 = (fS1 - fS0)/ widthDiv + t0u0;
|
|
float t0v1 = (fT1 - fT0)/ heightDiv + t0v0;
|
|
|
|
float depth = (gRDP.otherMode.depth_source == 1 ? gRDP.fPrimitiveDepth : 0 );
|
|
|
|
if( t0u0 >= 0 && t0u1 <= 1 && t0u1 >= t0u0 ) SetTextureUFlag(TEXTURE_UV_FLAG_CLAMP, gRSP.curTile);
|
|
if( t0v0 >= 0 && t0v1 <= 1 && t0v1 >= t0v0 ) SetTextureVFlag(TEXTURE_UV_FLAG_CLAMP, gRSP.curTile);
|
|
|
|
SetCombinerAndBlender();
|
|
|
|
COLOR speColor = PostProcessSpecularColor();
|
|
COLOR difColor = PostProcessDiffuseColor(gRDP.primitiveColor);
|
|
|
|
// Same as TexRect, but with texcoords 0,2 swapped
|
|
g_texRectTVtx[0].x = ViewPortTranslatei_x(nX0);
|
|
g_texRectTVtx[0].y = ViewPortTranslatei_y(nY0);
|
|
g_texRectTVtx[0].dcDiffuse = difColor;
|
|
g_texRectTVtx[0].dcSpecular = speColor;
|
|
|
|
g_texRectTVtx[1].x = ViewPortTranslatei_x(nX1);
|
|
g_texRectTVtx[1].y = ViewPortTranslatei_y(nY0);
|
|
g_texRectTVtx[1].dcDiffuse = difColor;
|
|
g_texRectTVtx[1].dcSpecular = speColor;
|
|
|
|
g_texRectTVtx[2].x = ViewPortTranslatei_x(nX1);
|
|
g_texRectTVtx[2].y = ViewPortTranslatei_y(nY1);
|
|
g_texRectTVtx[2].dcDiffuse = difColor;
|
|
g_texRectTVtx[2].dcSpecular = speColor;
|
|
|
|
g_texRectTVtx[3].x = ViewPortTranslatei_x(nX0);
|
|
g_texRectTVtx[3].y = ViewPortTranslatei_y(nY1);
|
|
g_texRectTVtx[3].dcDiffuse = difColor;
|
|
g_texRectTVtx[3].dcSpecular = speColor;
|
|
|
|
g_texRectTVtx[0].z = g_texRectTVtx[1].z = g_texRectTVtx[2].z = g_texRectTVtx[3].z = depth;
|
|
g_texRectTVtx[0].rhw = g_texRectTVtx[1].rhw = g_texRectTVtx[2].rhw = g_texRectTVtx[3].rhw = 1.0f;
|
|
|
|
SetVertexTextureUVCoord(g_texRectTVtx[0], t0u0, t0v0);
|
|
SetVertexTextureUVCoord(g_texRectTVtx[1], t0u0, t0v1);
|
|
SetVertexTextureUVCoord(g_texRectTVtx[2], t0u1, t0v1);
|
|
SetVertexTextureUVCoord(g_texRectTVtx[3], t0u1, t0v0);
|
|
|
|
TurnFogOnOff(false);
|
|
ApplyRDPScissor();
|
|
bool res = RenderTexRect();
|
|
|
|
TurnFogOnOff(gRSP.bFogEnabled);
|
|
|
|
// Restore state
|
|
ZBufferEnable( m_savedZBufferFlag );
|
|
|
|
DEBUGGER_PAUSE_AT_COND_AND_DUMP_COUNT_N((eventToPause == NEXT_FLUSH_TRI || eventToPause == NEXT_TEXTRECT), {
|
|
DebuggerAppendMsg("TexRectFlip: tile=%d, X0=%d, Y0=%d, X1=%d, Y1=%d,\nfS0=%f, fT0=%f, nfS1=%f, fT1=%f\n",
|
|
gRSP.curTile, nX0, nY0, nX1, nY1, fS0, fT0, fS1, fT1);
|
|
DebuggerAppendMsg(" : x0=%f, y0=%f, x1=%f, y1=%f\n", g_texRectTVtx[0].x, g_texRectTVtx[0].y, g_texRectTVtx[2].x, g_texRectTVtx[2].y);
|
|
DebuggerAppendMsg(" Tex0: u0=%f, v0=%f, u1=%f, v1=%f\n", g_texRectTVtx[0].tcord[0].u, g_texRectTVtx[0].tcord[0].v, g_texRectTVtx[2].tcord[0].u, g_texRectTVtx[2].tcord[0].v);
|
|
TRACE0("Pause after TexRectFlip\n");
|
|
if( logCombiners ) m_pColorCombiner->DisplayMuxString();
|
|
});
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
void CRender::StartDrawSimple2DTexture(float x0, float y0, float x1, float y1, float u0, float v0, float u1, float v1, COLOR dif, COLOR spe, float z, float rhw)
|
|
{
|
|
g_texRectTVtx[0].x = ViewPortTranslatei_x(x0); // << Error here, shouldn't divid by 4
|
|
g_texRectTVtx[0].y = ViewPortTranslatei_y(y0);
|
|
g_texRectTVtx[0].dcDiffuse = dif;
|
|
g_texRectTVtx[0].dcSpecular = spe;
|
|
g_texRectTVtx[0].tcord[0].u = u0;
|
|
g_texRectTVtx[0].tcord[0].v = v0;
|
|
|
|
|
|
g_texRectTVtx[1].x = ViewPortTranslatei_x(x1);
|
|
g_texRectTVtx[1].y = ViewPortTranslatei_y(y0);
|
|
g_texRectTVtx[1].dcDiffuse = dif;
|
|
g_texRectTVtx[1].dcSpecular = spe;
|
|
g_texRectTVtx[1].tcord[0].u = u1;
|
|
g_texRectTVtx[1].tcord[0].v = v0;
|
|
|
|
g_texRectTVtx[2].x = ViewPortTranslatei_x(x1);
|
|
g_texRectTVtx[2].y = ViewPortTranslatei_y(y1);
|
|
g_texRectTVtx[2].dcDiffuse = dif;
|
|
g_texRectTVtx[2].dcSpecular = spe;
|
|
g_texRectTVtx[2].tcord[0].u = u1;
|
|
g_texRectTVtx[2].tcord[0].v = v1;
|
|
|
|
g_texRectTVtx[3].x = ViewPortTranslatei_x(x0);
|
|
g_texRectTVtx[3].y = ViewPortTranslatei_y(y1);
|
|
g_texRectTVtx[3].dcDiffuse = dif;
|
|
g_texRectTVtx[3].dcSpecular = spe;
|
|
g_texRectTVtx[3].tcord[0].u = u0;
|
|
g_texRectTVtx[3].tcord[0].v = v1;
|
|
|
|
RenderTexture &txtr = g_textures[0];
|
|
if( txtr.pTextureEntry && txtr.pTextureEntry->txtrBufIdx > 0 )
|
|
{
|
|
RenderTextureInfo &info = gRenderTextureInfos[txtr.pTextureEntry->txtrBufIdx-1];
|
|
g_texRectTVtx[0].tcord[0].u *= info.scaleX;
|
|
g_texRectTVtx[0].tcord[0].v *= info.scaleY;
|
|
g_texRectTVtx[1].tcord[0].u *= info.scaleX;
|
|
g_texRectTVtx[1].tcord[0].v *= info.scaleY;
|
|
g_texRectTVtx[2].tcord[0].u *= info.scaleX;
|
|
g_texRectTVtx[2].tcord[0].v *= info.scaleY;
|
|
g_texRectTVtx[3].tcord[0].u *= info.scaleX;
|
|
g_texRectTVtx[3].tcord[0].v *= info.scaleY;
|
|
}
|
|
|
|
g_texRectTVtx[0].z = g_texRectTVtx[1].z = g_texRectTVtx[2].z = g_texRectTVtx[3].z = z;
|
|
g_texRectTVtx[0].rhw = g_texRectTVtx[1].rhw = g_texRectTVtx[2].rhw = g_texRectTVtx[3].rhw = rhw;
|
|
}
|
|
|
|
void CRender::StartDrawSimpleRect(LONG nX0, LONG nY0, LONG nX1, LONG nY1, uint32 dwColor, float depth, float rhw)
|
|
{
|
|
m_simpleRectVtx[0].x = ViewPortTranslatei_x(nX0);
|
|
m_simpleRectVtx[1].x = ViewPortTranslatei_x(nX1);
|
|
m_simpleRectVtx[0].y = ViewPortTranslatei_y(nY0);
|
|
m_simpleRectVtx[1].y = ViewPortTranslatei_y(nY1);
|
|
}
|
|
|
|
void CRender::SetAddressUAllStages(uint32 dwTile, TextureUVFlag dwFlag)
|
|
{
|
|
}
|
|
|
|
void CRender::SetAddressVAllStages(uint32 dwTile, TextureUVFlag dwFlag)
|
|
{
|
|
}
|
|
|
|
void CRender::SetAllTexelRepeatFlag()
|
|
{
|
|
if( IsTextureEnabled() )
|
|
{
|
|
if( IsTexel0Enable() || gRDP.otherMode.cycle_type == CYCLE_TYPE_COPY )
|
|
SetTexelRepeatFlags(gRSP.curTile);
|
|
if( IsTexel1Enable() )
|
|
SetTexelRepeatFlags((gRSP.curTile+1)&7);
|
|
}
|
|
}
|
|
|
|
|
|
void CRender::SetTexelRepeatFlags(uint32 dwTile)
|
|
{
|
|
Tile &tile = gRDP.tiles[dwTile];
|
|
|
|
if( tile.bForceClampS )
|
|
SetTextureUFlag(TEXTURE_UV_FLAG_CLAMP, dwTile);
|
|
else if( tile.bForceWrapS )
|
|
SetTextureUFlag(TEXTURE_UV_FLAG_WRAP, dwTile);
|
|
else if( tile.dwMaskS == 0 || tile.bClampS )
|
|
{
|
|
if( gRDP.otherMode.cycle_type >= CYCLE_TYPE_COPY )
|
|
SetTextureUFlag(TEXTURE_UV_FLAG_WRAP, dwTile); // Can not clamp in COPY/FILL mode
|
|
else
|
|
SetTextureUFlag(TEXTURE_UV_FLAG_CLAMP, dwTile);
|
|
}
|
|
else if (tile.bMirrorS )
|
|
SetTextureUFlag(TEXTURE_UV_FLAG_MIRROR, dwTile);
|
|
else
|
|
SetTextureUFlag(TEXTURE_UV_FLAG_WRAP, dwTile);
|
|
|
|
if( tile.bForceClampT )
|
|
SetTextureVFlag(TEXTURE_UV_FLAG_CLAMP, dwTile);
|
|
else if( tile.bForceWrapT )
|
|
SetTextureVFlag(TEXTURE_UV_FLAG_WRAP, dwTile);
|
|
else if( tile.dwMaskT == 0 || tile.bClampT)
|
|
{
|
|
if( gRDP.otherMode.cycle_type >= CYCLE_TYPE_COPY )
|
|
SetTextureVFlag(TEXTURE_UV_FLAG_WRAP, dwTile); // Can not clamp in COPY/FILL mode
|
|
else
|
|
SetTextureVFlag(TEXTURE_UV_FLAG_CLAMP, dwTile);
|
|
}
|
|
else if (tile.bMirrorT )
|
|
SetTextureVFlag(TEXTURE_UV_FLAG_MIRROR, dwTile);
|
|
else
|
|
SetTextureVFlag(TEXTURE_UV_FLAG_WRAP, dwTile);
|
|
}
|
|
|
|
void CRender::Initialize(void)
|
|
{
|
|
ClearDeviceObjects();
|
|
InitDeviceObjects();
|
|
}
|
|
|
|
void CRender::CleanUp(void)
|
|
{
|
|
m_pColorCombiner->CleanUp();
|
|
ClearDeviceObjects();
|
|
}
|
|
|
|
void myVec3Transform(float *vecout, float *vecin, float* m)
|
|
{
|
|
float w = m[3]*vecin[0]+m[7]*vecin[1]+m[11]*vecin[2]+m[15];
|
|
vecout[0] = (m[0]*vecin[0]+m[4]*vecin[1]+m[8]*vecin[2]+m[12])/w;
|
|
vecout[1] = (m[1]*vecin[0]+m[5]*vecin[1]+m[9]*vecin[2]+m[13])/w;
|
|
vecout[2] = (m[2]*vecin[0]+m[6]*vecin[1]+m[10]*vecin[2]+m[14])/w;
|
|
}
|
|
|
|
void CRender::SetTextureEnableAndScale(int dwTile, bool bEnable, float fScaleX, float fScaleY)
|
|
{
|
|
gRSP.bTextureEnabled = bEnable;
|
|
|
|
if( bEnable )
|
|
{
|
|
if( gRSP.curTile != (unsigned int)dwTile )
|
|
gRDP.textureIsChanged = true;
|
|
|
|
gRSP.curTile = dwTile;
|
|
|
|
gRSP.fTexScaleX = fScaleX;
|
|
gRSP.fTexScaleY = fScaleY;
|
|
|
|
if( fScaleX == 0 || fScaleY == 0 )
|
|
{
|
|
gRSP.fTexScaleX = 1/32.0f;
|
|
gRSP.fTexScaleY = 1/32.0f;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CRender::SetFogFlagForNegativeW()
|
|
{
|
|
if( !gRSP.bFogEnabled ) return;
|
|
|
|
m_bFogStateSave = gRSP.bFogEnabled;
|
|
|
|
bool flag=gRSP.bFogEnabled;
|
|
|
|
for (uint32 i = 0; i < gRSP.numVertices; i++)
|
|
{
|
|
if( g_vtxBuffer[i].rhw < 0 )
|
|
flag = FALSE;
|
|
}
|
|
|
|
TurnFogOnOff(flag);
|
|
}
|
|
|
|
void CRender::RestoreFogFlag()
|
|
{
|
|
if( !gRSP.bFogEnabled ) return;
|
|
TurnFogOnOff(m_bFogStateSave);
|
|
}
|
|
|
|
void CRender::SetViewport(int nLeft, int nTop, int nRight, int nBottom, int maxZ)
|
|
{
|
|
if( status.bHandleN64RenderTexture )
|
|
return;
|
|
|
|
static float MultX=0, MultY=0;
|
|
|
|
if( gRSP.nVPLeftN == nLeft && gRSP.nVPTopN == nTop &&
|
|
gRSP.nVPRightN == nRight && gRSP.nVPBottomN == nBottom &&
|
|
MultX==windowSetting.fMultX && MultY==windowSetting.fMultY)
|
|
{
|
|
// no changes
|
|
return;
|
|
}
|
|
|
|
MultX=windowSetting.fMultX;
|
|
MultY=windowSetting.fMultY;
|
|
|
|
gRSP.maxZ = maxZ;
|
|
gRSP.nVPLeftN = nLeft;
|
|
gRSP.nVPTopN = nTop;
|
|
gRSP.nVPRightN = nRight;
|
|
gRSP.nVPBottomN = nBottom;
|
|
gRSP.nVPWidthN = nRight - nLeft + 1;
|
|
gRSP.nVPHeightN = nBottom - nTop + 1;
|
|
|
|
UpdateClipRectangle();
|
|
SetViewportRender();
|
|
|
|
LOG_UCODE("SetViewport (%d,%d - %d,%d)",gRSP.nVPLeftN, gRSP.nVPTopN, gRSP.nVPRightN, gRSP.nVPBottomN);
|
|
}
|
|
|
|
extern bool bHalfTxtScale;
|
|
|
|
bool CRender::DrawTriangles()
|
|
{
|
|
if( !status.bCIBufferIsRendered ) g_pFrameBufferManager->ActiveTextureBuffer();
|
|
|
|
DEBUGGER_ONLY_IF( (!debuggerEnableZBuffer), {ZBufferEnable( FALSE );} );
|
|
|
|
if( status.bVIOriginIsUpdated == true && currentRomOptions.screenUpdateSetting==SCREEN_UPDATE_AT_1ST_PRIMITIVE )
|
|
{
|
|
status.bVIOriginIsUpdated=false;
|
|
CGraphicsContext::Get()->UpdateFrame();
|
|
DEBUGGER_PAUSE_AND_DUMP_NO_UPDATE(NEXT_SET_CIMG,{DebuggerAppendMsg("Screen Update at 1st triangle");});
|
|
}
|
|
|
|
// Hack for Pilotwings 64 (U) [!].v64
|
|
static bool skipNext=false;
|
|
if( options.enableHackForGames == HACK_FOR_PILOT_WINGS )
|
|
{
|
|
if( IsUsedAsDI(g_CI.dwAddr) && gRDP.otherMode.z_cmp+gRDP.otherMode.z_upd > 0 )
|
|
{
|
|
TRACE0("Warning: using Flushtris to write Zbuffer" );
|
|
gRSP.numVertices = 0;
|
|
gRSP.maxVertexID = 0;
|
|
skipNext = true;
|
|
return true;
|
|
}
|
|
else if( skipNext )
|
|
{
|
|
skipNext = false;
|
|
gRSP.numVertices = 0;
|
|
gRSP.maxVertexID = 0;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if( status.bN64IsDrawingTextureBuffer && frameBufferOptions.bIgnore )
|
|
{
|
|
gRSP.numVertices = 0;
|
|
gRSP.maxVertexID = 0;
|
|
return true;
|
|
}
|
|
|
|
extern bool bConkerHideShadow;
|
|
if( options.enableHackForGames == HACK_FOR_CONKER && bConkerHideShadow )
|
|
{
|
|
gRSP.numVertices = 0;
|
|
gRSP.maxVertexID = 0;
|
|
return true;
|
|
}
|
|
|
|
if( IsUsedAsDI(g_CI.dwAddr) && !status.bHandleN64RenderTexture )
|
|
{
|
|
status.bFrameBufferIsDrawn = true;
|
|
}
|
|
|
|
/*
|
|
if( status.bHandleN64RenderTexture && g_pRenderTextureInfo->CI_Info.dwSize == TXT_SIZE_8b )
|
|
{
|
|
gRSP.numVertices = 0;
|
|
gRSP.maxVertexID = 0;
|
|
return true;
|
|
}
|
|
*/
|
|
|
|
if (gRSP.numVertices == 0) return true;
|
|
if( status.bHandleN64RenderTexture )
|
|
{
|
|
g_pRenderTextureInfo->maxUsedHeight = g_pRenderTextureInfo->N64Height;
|
|
if( !status.bDirectWriteIntoRDRAM )
|
|
{
|
|
status.bFrameBufferIsDrawn = true;
|
|
status.bFrameBufferDrawnByTriangles = true;
|
|
}
|
|
}
|
|
|
|
if( !gRDP.bFogEnableInBlender && gRSP.bFogEnabled )
|
|
{
|
|
TurnFogOnOff(false);
|
|
}
|
|
|
|
for( int t=0; t<2; t++ )
|
|
{
|
|
float halfscaleS = 1;
|
|
float halfscaleT = 1;
|
|
|
|
// This will get rid of the thin black lines
|
|
if( t==0 && !(m_pColorCombiner->m_bTex0Enabled) )
|
|
continue;
|
|
else
|
|
{
|
|
if( ( gRDP.tiles[gRSP.curTile].dwSize == TXT_SIZE_32b && options.enableHackForGames == HACK_FOR_RUMBLE ) ||
|
|
(bHalfTxtScale && g_curRomInfo.bTextureScaleHack ) ||
|
|
(options.enableHackForGames == HACK_FOR_POLARISSNOCROSS && gRDP.tiles[7].dwFormat == TXT_FMT_CI && gRDP.tiles[7].dwSize == TXT_SIZE_8b
|
|
&& gRDP.tiles[0].dwFormat == TXT_FMT_CI && gRDP.tiles[0].dwSize == TXT_SIZE_8b && gRSP.curTile == 0 ))
|
|
{
|
|
halfscaleS = 0.5;
|
|
halfscaleT = 0.5;
|
|
}
|
|
}
|
|
|
|
if( t==1 && !(m_pColorCombiner->m_bTex1Enabled) ) break;
|
|
|
|
uint32 i;
|
|
if( halfscaleS < 1 )
|
|
{
|
|
for( i=0; i<gRSP.numVertices; i++ )
|
|
{
|
|
if( t == 0 )
|
|
{
|
|
g_vtxBuffer[i].tcord[t].u += gRSP.tex0OffsetX;
|
|
g_vtxBuffer[i].tcord[t].u /= 2;
|
|
g_vtxBuffer[i].tcord[t].u -= gRSP.tex0OffsetX;
|
|
g_vtxBuffer[i].tcord[t].v += gRSP.tex0OffsetY;
|
|
g_vtxBuffer[i].tcord[t].v /= 2;
|
|
g_vtxBuffer[i].tcord[t].v -= gRSP.tex0OffsetY;
|
|
}
|
|
else
|
|
{
|
|
g_vtxBuffer[i].tcord[t].u += gRSP.tex1OffsetX;
|
|
g_vtxBuffer[i].tcord[t].u /= 2;
|
|
g_vtxBuffer[i].tcord[t].u -= gRSP.tex1OffsetX;
|
|
g_vtxBuffer[i].tcord[t].v += gRSP.tex1OffsetY;
|
|
g_vtxBuffer[i].tcord[t].v /= 2;
|
|
g_vtxBuffer[i].tcord[t].v -= gRSP.tex1OffsetY;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
// The code here is disabled because it could cause incorrect texture repeating flag
|
|
// for later DrawTriangles
|
|
bool clampS=true;
|
|
bool clampT=true;
|
|
|
|
for( i=0; i<gRSP.numVertices; i++ )
|
|
{
|
|
float w = CDeviceBuilder::GetGeneralDeviceType() == OGL_DEVICE ? g_vtxProjected5[i][3] : g_vtxBuffer[i].rhw;
|
|
if( w < 0 || g_vtxBuffer[i].tcord[t].u > 1.0 || g_vtxBuffer[i].tcord[t].u < 0.0 )
|
|
{
|
|
clampS = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for( i=0; i<gRSP.numVertices; i++ )
|
|
{
|
|
float w = CDeviceBuilder::GetGeneralDeviceType() == OGL_DEVICE ? g_vtxProjected5[i][3] : g_vtxBuffer[i].rhw;
|
|
if( w < 0 || g_vtxBuffer[i].tcord[t].v > 1.0 || g_vtxBuffer[i].tcord[t].v < 0.0 )
|
|
{
|
|
clampT = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( clampS )
|
|
{
|
|
SetTextureUFlag(TEXTURE_UV_FLAG_CLAMP, gRSP.curTile+t);
|
|
}
|
|
if( clampT )
|
|
{
|
|
SetTextureVFlag(TEXTURE_UV_FLAG_CLAMP, gRSP.curTile+t);
|
|
}
|
|
*/
|
|
}
|
|
|
|
if( status.bHandleN64RenderTexture && g_pRenderTextureInfo->CI_Info.dwSize == TXT_SIZE_8b )
|
|
{
|
|
ZBufferEnable(FALSE);
|
|
}
|
|
|
|
ApplyScissorWithClipRatio();
|
|
|
|
if( g_curRomInfo.bZHack )
|
|
{
|
|
extern void HackZAll();
|
|
HackZAll();
|
|
}
|
|
|
|
bool res = RenderFlushTris();
|
|
g_clippedVtxCount = 0;
|
|
|
|
LOG_UCODE("DrawTriangles: Draw %d Triangles", gRSP.numVertices/3);
|
|
|
|
gRSP.numVertices = 0; // Reset index
|
|
gRSP.maxVertexID = 0;
|
|
|
|
DEBUGGER_PAUSE_AND_DUMP_COUNT_N(NEXT_FLUSH_TRI, {
|
|
TRACE0("Pause after DrawTriangles\n");
|
|
if( logCombiners ) m_pColorCombiner->DisplayMuxString();
|
|
});
|
|
|
|
if( !gRDP.bFogEnableInBlender && gRSP.bFogEnabled )
|
|
{
|
|
TurnFogOnOff(true);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
inline int ReverseCITableLookup(uint32 *pTable, int size, uint32 val)
|
|
{
|
|
for( int i=0; i<size; i++)
|
|
{
|
|
if( pTable[i] == val )
|
|
return i;
|
|
}
|
|
|
|
TRACE0("Cannot find value in CI table");
|
|
return 0;
|
|
}
|
|
|
|
bool SaveCITextureToFile(TxtrCacheEntry &entry, char *filename, bool bShow, bool bWholeTexture )
|
|
{
|
|
if( !( (gRDP.otherMode.text_tlut>=2 || entry.ti.Format == TXT_FMT_CI || entry.ti.Format == TXT_FMT_RGBA) && entry.ti.Size <= TXT_SIZE_8b ) )
|
|
{
|
|
// No a CI texture
|
|
return false;
|
|
}
|
|
if ( entry.ti.TLutFmt != TLUT_FMT_RGBA16 && entry.ti.TLutFmt != TLUT_FMT_IA16 )
|
|
{
|
|
TRACE0("Invalid Tlut format");
|
|
return false;
|
|
}
|
|
|
|
if( !entry.pTexture )
|
|
{
|
|
TRACE0("Null texture");
|
|
return false;
|
|
}
|
|
|
|
uint32 *pTable = NULL;
|
|
int tableSize;
|
|
uint16 * pPal = (uint16 *)entry.ti.PalAddress;
|
|
|
|
// Create the pallette table
|
|
if( entry.ti.Size == TXT_SIZE_4b )
|
|
{
|
|
// 4-bit table
|
|
tableSize = 16;
|
|
pTable = new uint32[16];
|
|
|
|
for( int i=0; i<16; i++ )
|
|
{
|
|
pTable[i] = entry.ti.TLutFmt == TLUT_FMT_RGBA16 ? Convert555ToRGBA(pPal[i^1]) : ConvertIA16ToRGBA(pPal[i^1]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 8-bit table
|
|
tableSize = 256;
|
|
pTable = new uint32[256];
|
|
|
|
for( int i=0; i<256; i++ )
|
|
{
|
|
pTable[i] = entry.ti.TLutFmt == TLUT_FMT_RGBA16 ? Convert555ToRGBA(pPal[i^1]) : ConvertIA16ToRGBA(pPal[i^1]);
|
|
}
|
|
}
|
|
|
|
// Reversely convert current texture to indexed textures
|
|
CTexture &texture = *entry.pTexture;
|
|
//int width = bWholeTexture ? texture.m_dwCreatedTextureWidth : texture.m_dwWidth;
|
|
//int height = bWholeTexture ? texture.m_dwCreatedTextureHeight : texture.m_dwHeight;
|
|
int width = bWholeTexture ? texture.m_dwCreatedTextureWidth : entry.ti.WidthToLoad;
|
|
int height = bWholeTexture ? texture.m_dwCreatedTextureHeight : entry.ti.HeightToLoad;
|
|
int bufSizePerLine = (((((width << entry.ti.Size) + 1 ) >> 1)+3) >> 2)*4; // pad to 32bit boundary
|
|
int bufSize = bufSizePerLine*height;
|
|
BYTE *pbuf = new BYTE[bufSize];
|
|
|
|
DrawInfo srcInfo;
|
|
if( texture.StartUpdate(&srcInfo) )
|
|
{
|
|
int idx = 0;
|
|
for( int i=height-1; i>=0; i--)
|
|
{
|
|
uint32 *pSrc = (uint32*)((BYTE*)srcInfo.lpSurface+srcInfo.lPitch * i);
|
|
for( int j=0; j<width; j++)
|
|
{
|
|
int val = ReverseCITableLookup(pTable, tableSize, *pSrc);
|
|
pSrc++;
|
|
|
|
if( entry.ti.Size == TXT_SIZE_4b )
|
|
{
|
|
// 4 bits
|
|
if( idx%2 )
|
|
{
|
|
// 1
|
|
pbuf[idx>>1] = (pbuf[idx>>1]<<4) | val;
|
|
idx++;
|
|
}
|
|
else
|
|
{
|
|
// 0
|
|
pbuf[idx>>1] = (BYTE)val;
|
|
idx++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 8 bits
|
|
pbuf[idx++] = (BYTE)val;
|
|
}
|
|
}
|
|
if( entry.ti.Size == TXT_SIZE_4b )
|
|
{
|
|
if( idx%8 ) idx = (idx/8+1)*8;
|
|
}
|
|
else
|
|
{
|
|
if( idx%4 ) idx = (idx/4+1)*4;
|
|
}
|
|
}
|
|
|
|
|
|
texture.EndUpdate(&srcInfo);
|
|
}
|
|
|
|
// Create BMP color indexed file
|
|
if( strcasecmp(right(filename,4),".bmp") != 0 ) strcat(filename,".bmp");
|
|
|
|
BITMAPFILEHEADER fileHeader;
|
|
BITMAPINFOHEADER infoHeader;
|
|
|
|
infoHeader.biSize = sizeof( BITMAPINFOHEADER );
|
|
infoHeader.biWidth = width;
|
|
infoHeader.biHeight = height;
|
|
infoHeader.biPlanes = 1;
|
|
infoHeader.biBitCount = entry.ti.Size == TXT_SIZE_4b ? 4 : 8;
|
|
infoHeader.biCompression = BI_RGB;
|
|
infoHeader.biSizeImage = bufSize;
|
|
infoHeader.biXPelsPerMeter = 0;
|
|
infoHeader.biYPelsPerMeter = 0;
|
|
infoHeader.biClrUsed = 0;
|
|
infoHeader.biClrImportant = 0;
|
|
|
|
fileHeader.bfType = 19778;
|
|
fileHeader.bfSize = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) + infoHeader.biSizeImage + tableSize*4;
|
|
fileHeader.bfReserved1 = fileHeader.bfReserved2 = 0;
|
|
fileHeader.bfOffBits = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) + tableSize*4;
|
|
|
|
|
|
FILE *f;
|
|
f = fopen(filename, "wb");
|
|
if(f != NULL)
|
|
{
|
|
fwrite(&fileHeader, sizeof(BITMAPFILEHEADER), 1, f);
|
|
fwrite(&infoHeader, sizeof(BITMAPINFOHEADER), 1, f);
|
|
fwrite(pTable, tableSize*4, 1, f);
|
|
fwrite(pbuf, infoHeader.biSizeImage, 1, f);
|
|
|
|
fclose(f);
|
|
}
|
|
else
|
|
{
|
|
// Do something
|
|
TRACE1("Fail to create file %s", filename);
|
|
}
|
|
|
|
// Clean up
|
|
delete [] pTable;
|
|
delete [] pbuf;
|
|
|
|
return true;
|
|
}
|
|
|
|
void CRender::SaveTextureToFile(CTexture &texture, char *filename, TextureChannel channel, bool bShow, bool bWholeTexture, int width, int height)
|
|
{
|
|
if( width < 0 || height < 0 )
|
|
{
|
|
width = bWholeTexture ? texture.m_dwCreatedTextureWidth : texture.m_dwWidth;
|
|
height = bWholeTexture ? texture.m_dwCreatedTextureHeight : texture.m_dwHeight;
|
|
}
|
|
|
|
BYTE *pbuf = new BYTE[width*height* (channel == TXT_RGBA ? 4 : 3)];
|
|
if( pbuf )
|
|
{
|
|
DrawInfo srcInfo;
|
|
if( texture.StartUpdate(&srcInfo) )
|
|
{
|
|
if( channel == TXT_RGBA )
|
|
{
|
|
uint32 *pbuf2 = (uint32*)pbuf;
|
|
for( int i=height-1; i>=0; i--)
|
|
{
|
|
uint32 *pSrc = (uint32*)((BYTE*)srcInfo.lpSurface+srcInfo.lPitch * i);
|
|
for( int j=0; j<width; j++)
|
|
{
|
|
*pbuf2++ = *pSrc++;
|
|
}
|
|
}
|
|
|
|
if( SaveRGBABufferToPNGFile(filename, (BYTE*)pbuf, width, height ) )
|
|
//if( SaveRGBABufferToPNGFile(filename, (BYTE*)srcInfo.lpSurface, width, height, srcInfo.lPitch ) )
|
|
{
|
|
}
|
|
}
|
|
else
|
|
{
|
|
BYTE *pbuf2 = pbuf;
|
|
for( int i=height-1; i>=0; i--)
|
|
{
|
|
BYTE *pSrc = (BYTE*)srcInfo.lpSurface+srcInfo.lPitch * i;
|
|
for( int j=0; j<width; j++)
|
|
{
|
|
if( channel == TXT_ALPHA )
|
|
{
|
|
pbuf2[0] = pbuf2[1] = pbuf2[2] = pSrc[3];
|
|
}
|
|
else
|
|
{
|
|
pbuf2[0] = pSrc[0];
|
|
pbuf2[1] = pSrc[1];
|
|
pbuf2[2] = pSrc[2];
|
|
}
|
|
|
|
pbuf2 += 3;
|
|
pSrc += 4;
|
|
}
|
|
}
|
|
|
|
if( SaveRGBBufferToFile(filename, pbuf, width, height ) )
|
|
{
|
|
}
|
|
}
|
|
texture.EndUpdate(&srcInfo);
|
|
}
|
|
else
|
|
{
|
|
TRACE0("Cannot lock texture");
|
|
}
|
|
delete [] pbuf;
|
|
}
|
|
else
|
|
{
|
|
TRACE0("Out of memory");
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef _DEBUG
|
|
bool CRender::DrawTexture(int tex, TextureChannel channel)
|
|
{
|
|
if( g_textures[tex].m_pCTexture == NULL )
|
|
{
|
|
TRACE0("Can't draw null texture");
|
|
return false;
|
|
}
|
|
|
|
SaveTextureToFile(tex, channel, true); // Save to file instead of draw to screen
|
|
DebuggerAppendMsg("Texture %d (CurTile:%d): W=%f, H=%f, Real W=%d, H=%d", tex, gRSP.curTile,
|
|
g_textures[tex].m_fTexWidth, g_textures[tex].m_fTexHeight, g_textures[tex].m_dwTileWidth, g_textures[tex].m_dwTileHeight);
|
|
DebuggerAppendMsg("X scale: %f, Y scale: %f, %s", gRSP.fTexScaleX, gRSP.fTexScaleY, gRSP.bTextureEnabled?"Enabled":"Disabled");
|
|
|
|
return true;
|
|
}
|
|
|
|
void CRender::SaveTextureToFile(int tex, TextureChannel channel, bool bShow)
|
|
{
|
|
TxtrCacheEntry &entry = *(g_textures[tex].pTextureEntry);
|
|
|
|
CTexture *pBaseTexture = entry.pTexture;
|
|
if( pBaseTexture == NULL )
|
|
{
|
|
TRACE0("Can't dump null texture");
|
|
return;
|
|
}
|
|
CTexture *pEnhancedTexture = entry.pEnhancedTexture ? entry.pEnhancedTexture : entry.pTexture;
|
|
|
|
bool bInWhole = false;
|
|
if( entry.ti.HeightToCreate == entry.ti.HeightToLoad && entry.ti.WidthToCreate == entry.ti.WidthToLoad
|
|
&& pEnhancedTexture == pBaseTexture )
|
|
bInWhole = true;
|
|
|
|
char filename[256];
|
|
if( (gRDP.otherMode.text_tlut>=2 || g_textures[tex].pTextureEntry->ti.Format == TXT_FMT_CI || g_textures[tex].pTextureEntry->ti.Format == TXT_FMT_RGBA) && g_textures[tex].pTextureEntry->ti.Size <= TXT_SIZE_8b )
|
|
{
|
|
sprintf(filename, "\\%s#%08X#%d#%d_ci", g_curRomInfo.szGameName, g_textures[tex].pTextureEntry->dwCRC,
|
|
g_textures[tex].pTextureEntry->ti.Format,
|
|
g_textures[tex].pTextureEntry->ti.Size);
|
|
SaveCITextureToFile(*(g_textures[tex].pTextureEntry), filename, bShow && bInWhole, false);
|
|
|
|
sprintf(filename, "\\%s#%08X#%d#%d#%08X_ci", g_curRomInfo.szGameName, g_textures[tex].pTextureEntry->dwCRC,
|
|
g_textures[tex].pTextureEntry->ti.Format,
|
|
g_textures[tex].pTextureEntry->ti.Size, g_textures[tex].pTextureEntry->dwPalCRC);
|
|
SaveCITextureToFile(*(g_textures[tex].pTextureEntry), filename, false, false);
|
|
|
|
sprintf(filename, "\\%s#%08X#%d#%d#%08X_ciByRGBA", g_curRomInfo.szGameName, g_textures[tex].pTextureEntry->dwCRC,
|
|
g_textures[tex].pTextureEntry->ti.Format,
|
|
g_textures[tex].pTextureEntry->ti.Size, g_textures[tex].pTextureEntry->dwPalCRC);
|
|
SaveTextureToFile(*pBaseTexture, filename, TXT_RGBA, false, false, g_textures[tex].pTextureEntry->ti.WidthToLoad, g_textures[tex].pTextureEntry->ti.HeightToLoad);
|
|
|
|
DebuggerAppendMsg("Base texture is stored at: %s", filename);
|
|
|
|
if( !bInWhole && bShow )
|
|
{
|
|
sprintf(filename, "\\%s#%08X#%d#%d_ci_%s_debugger", g_curRomInfo.szGameName, g_textures[tex].pTextureEntry->dwCRC,
|
|
g_textures[tex].pTextureEntry->ti.Format,
|
|
g_textures[tex].pTextureEntry->ti.Size, channel == TXT_ALPHA ? "a" : channel == TXT_RGBA ? "all" : "rgb");
|
|
SaveTextureToFile(*pEnhancedTexture, filename, channel, true, true);
|
|
DebuggerAppendMsg("Whole texture is stored at: %s", filename);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sprintf(filename, "\\%s#%08X#%d#%d_%s", g_curRomInfo.szGameName, g_textures[tex].pTextureEntry->dwCRC,
|
|
g_textures[tex].pTextureEntry->ti.Format,
|
|
g_textures[tex].pTextureEntry->ti.Size, channel == TXT_ALPHA ? "a" : channel == TXT_RGBA ? "all" : "rgb");
|
|
SaveTextureToFile(*pBaseTexture, filename, channel, bShow && bInWhole, false,g_textures[tex].pTextureEntry->ti.WidthToLoad, g_textures[tex].pTextureEntry->ti.HeightToLoad);
|
|
DebuggerAppendMsg("Base texture is stored at: %s", filename);
|
|
|
|
if( !bInWhole && bShow )
|
|
{
|
|
sprintf(filename, "\\%s#%08X#%d#%d_%s_debugger", g_curRomInfo.szGameName, g_textures[tex].pTextureEntry->dwCRC,
|
|
g_textures[tex].pTextureEntry->ti.Format,
|
|
g_textures[tex].pTextureEntry->ti.Size, channel == TXT_ALPHA ? "a" : channel == TXT_RGBA ? "all" : "rgb");
|
|
SaveTextureToFile(*pEnhancedTexture, filename, channel, true, true);
|
|
DebuggerAppendMsg("Whole texture is stored at: %s", filename);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
extern RenderTextureInfo gRenderTextureInfos[];
|
|
void SetVertexTextureUVCoord(TexCord &dst, float s, float t, int tile, TxtrCacheEntry *pEntry)
|
|
{
|
|
RenderTexture &txtr = g_textures[tile];
|
|
RenderTextureInfo &info = gRenderTextureInfos[pEntry->txtrBufIdx-1];
|
|
|
|
uint32 addrOffset = g_TI.dwAddr-info.CI_Info.dwAddr;
|
|
uint32 extraTop = (addrOffset>>(info.CI_Info.dwSize-1)) /info.CI_Info.dwWidth;
|
|
uint32 extraLeft = (addrOffset>>(info.CI_Info.dwSize-1))%info.CI_Info.dwWidth;
|
|
|
|
if( pEntry->txtrBufIdx > 0 )
|
|
{
|
|
// Loading from render_texture or back buffer
|
|
s += (extraLeft+pEntry->ti.LeftToLoad)/txtr.m_fTexWidth;
|
|
t += (extraTop+pEntry->ti.TopToLoad)/txtr.m_fTexHeight;
|
|
|
|
s *= info.scaleX;
|
|
t *= info.scaleY;
|
|
}
|
|
|
|
dst.u = s;
|
|
dst.v = t;
|
|
}
|
|
|
|
void CRender::SetVertexTextureUVCoord(TLITVERTEX &v, float fTex0S, float fTex0T)
|
|
{
|
|
RenderTexture &txtr = g_textures[0];
|
|
if( txtr.pTextureEntry && txtr.pTextureEntry->txtrBufIdx > 0 )
|
|
{
|
|
::SetVertexTextureUVCoord(v.tcord[0], fTex0S, fTex0T, 0, txtr.pTextureEntry);
|
|
}
|
|
else
|
|
{
|
|
v.tcord[0].u = fTex0S;
|
|
v.tcord[0].v = fTex0T;
|
|
}
|
|
}
|
|
void CRender::SetVertexTextureUVCoord(TLITVERTEX &v, float fTex0S, float fTex0T, float fTex1S, float fTex1T)
|
|
{
|
|
if( (options.enableHackForGames == HACK_FOR_ZELDA||options.enableHackForGames == HACK_FOR_ZELDA_MM) && m_Mux == 0x00262a60150c937fLL && gRSP.curTile == 0 )
|
|
{
|
|
// Hack for Zelda Sun
|
|
Tile &t0 = gRDP.tiles[0];
|
|
Tile &t1 = gRDP.tiles[1];
|
|
if( t0.dwFormat == TXT_FMT_I && t0.dwSize == TXT_SIZE_8b && t0.dwWidth == 64 &&
|
|
t1.dwFormat == TXT_FMT_I && t1.dwSize == TXT_SIZE_8b && t1.dwWidth == 64 &&
|
|
t0.dwHeight == t1.dwHeight )
|
|
{
|
|
fTex0S /= 2;
|
|
fTex0T /= 2;
|
|
fTex1S /= 2;
|
|
fTex1T /= 2;
|
|
}
|
|
}
|
|
|
|
RenderTexture &txtr0 = g_textures[0];
|
|
if( txtr0.pTextureEntry && txtr0.pTextureEntry->txtrBufIdx > 0 )
|
|
{
|
|
::SetVertexTextureUVCoord(v.tcord[0], fTex0S, fTex0T, 0, txtr0.pTextureEntry);
|
|
}
|
|
else
|
|
{
|
|
v.tcord[0].u = fTex0S;
|
|
v.tcord[0].v = fTex0T;
|
|
}
|
|
|
|
RenderTexture &txtr1 = g_textures[1];
|
|
if( txtr1.pTextureEntry && txtr1.pTextureEntry->txtrBufIdx > 0 )
|
|
{
|
|
::SetVertexTextureUVCoord(v.tcord[1], fTex1S, fTex1T, 1, txtr1.pTextureEntry);
|
|
}
|
|
else
|
|
{
|
|
v.tcord[1].u = fTex1S;
|
|
v.tcord[1].v = fTex1T;
|
|
}
|
|
}
|
|
|
|
void CRender::SetClipRatio(uint32 type, uint32 w1)
|
|
{
|
|
bool modified = false;
|
|
switch(type)
|
|
{
|
|
case RSP_MV_WORD_OFFSET_CLIP_RNX:
|
|
LOG_UCODE(" RSP_MOVE_WORD_CLIP NegX: %d", (LONG)(short)w1);
|
|
if( gRSP.clip_ratio_negx != (short)w1 )
|
|
{
|
|
gRSP.clip_ratio_negx = (short)w1;
|
|
modified = true;
|
|
}
|
|
break;
|
|
case RSP_MV_WORD_OFFSET_CLIP_RNY:
|
|
LOG_UCODE(" RSP_MOVE_WORD_CLIP NegY: %d", (LONG)(short)w1);
|
|
if( gRSP.clip_ratio_negy != (short)w1 )
|
|
{
|
|
gRSP.clip_ratio_negy = (short)w1;
|
|
modified = true;
|
|
}
|
|
break;
|
|
case RSP_MV_WORD_OFFSET_CLIP_RPX:
|
|
LOG_UCODE(" RSP_MOVE_WORD_CLIP PosX: %d", (LONG)(short)w1);
|
|
if( gRSP.clip_ratio_posx != -(short)w1 )
|
|
{
|
|
gRSP.clip_ratio_posx = -(short)w1;
|
|
modified = true;
|
|
}
|
|
break;
|
|
case RSP_MV_WORD_OFFSET_CLIP_RPY:
|
|
LOG_UCODE(" RSP_MOVE_WORD_CLIP PosY: %d", (LONG)(short)w1);
|
|
if( gRSP.clip_ratio_posy != -(short)w1 )
|
|
{
|
|
gRSP.clip_ratio_posy = -(short)w1;
|
|
modified = true;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if( modified )
|
|
{
|
|
UpdateClipRectangle();
|
|
}
|
|
|
|
}
|
|
void CRender::UpdateClipRectangle()
|
|
{
|
|
if( status.bHandleN64RenderTexture )
|
|
{
|
|
//windowSetting.fMultX = windowSetting.fMultY = 1;
|
|
windowSetting.vpLeftW = 0;
|
|
windowSetting.vpTopW = 0;
|
|
windowSetting.vpRightW = newRenderTextureInfo.bufferWidth;
|
|
windowSetting.vpBottomW = newRenderTextureInfo.bufferHeight;
|
|
windowSetting.vpWidthW = newRenderTextureInfo.bufferWidth;
|
|
windowSetting.vpHeightW = newRenderTextureInfo.bufferHeight;
|
|
|
|
gRSP.vtxXMul = windowSetting.vpWidthW/2.0f;
|
|
gRSP.vtxXAdd = gRSP.vtxXMul + windowSetting.vpLeftW;
|
|
gRSP.vtxYMul = -windowSetting.vpHeightW/2.0f;
|
|
gRSP.vtxYAdd = windowSetting.vpHeightW/2.0f + windowSetting.vpTopW+windowSetting.toolbarHeightToUse;
|
|
|
|
// Update clip rectangle by setting scissor
|
|
|
|
int halfx = newRenderTextureInfo.bufferWidth/2;
|
|
int halfy = newRenderTextureInfo.bufferHeight/2;
|
|
int centerx = halfx;
|
|
int centery = halfy;
|
|
|
|
gRSP.clip_ratio_left = centerx - halfx * gRSP.clip_ratio_negx;
|
|
gRSP.clip_ratio_top = centery - halfy * gRSP.clip_ratio_negy;
|
|
gRSP.clip_ratio_right = centerx + halfx * gRSP.clip_ratio_posx;
|
|
gRSP.clip_ratio_bottom = centery + halfy * gRSP.clip_ratio_posy;
|
|
}
|
|
else
|
|
{
|
|
windowSetting.vpLeftW = int(gRSP.nVPLeftN * windowSetting.fMultX);
|
|
windowSetting.vpTopW = int(gRSP.nVPTopN * windowSetting.fMultY);
|
|
windowSetting.vpRightW = int(gRSP.nVPRightN* windowSetting.fMultX);
|
|
windowSetting.vpBottomW = int(gRSP.nVPBottomN* windowSetting.fMultY);
|
|
windowSetting.vpWidthW = int((gRSP.nVPRightN - gRSP.nVPLeftN + 1) * windowSetting.fMultX);
|
|
windowSetting.vpHeightW = int((gRSP.nVPBottomN - gRSP.nVPTopN + 1) * windowSetting.fMultY);
|
|
|
|
gRSP.vtxXMul = windowSetting.vpWidthW/2.0f;
|
|
gRSP.vtxXAdd = gRSP.vtxXMul + windowSetting.vpLeftW;
|
|
gRSP.vtxYMul = -windowSetting.vpHeightW/2.0f;
|
|
gRSP.vtxYAdd = windowSetting.vpHeightW/2.0f + windowSetting.vpTopW+windowSetting.toolbarHeightToUse;
|
|
|
|
// Update clip rectangle by setting scissor
|
|
|
|
int halfx = gRSP.nVPWidthN/2;
|
|
int halfy = gRSP.nVPHeightN/2;
|
|
int centerx = gRSP.nVPLeftN+halfx;
|
|
int centery = gRSP.nVPTopN+halfy;
|
|
|
|
gRSP.clip_ratio_left = centerx - halfx * gRSP.clip_ratio_negx;
|
|
gRSP.clip_ratio_top = centery - halfy * gRSP.clip_ratio_negy;
|
|
gRSP.clip_ratio_right = centerx + halfx * gRSP.clip_ratio_posx;
|
|
gRSP.clip_ratio_bottom = centery + halfy * gRSP.clip_ratio_posy;
|
|
}
|
|
|
|
|
|
UpdateScissorWithClipRatio();
|
|
}
|
|
|
|
void CRender::UpdateScissorWithClipRatio()
|
|
{
|
|
gRSP.real_clip_scissor_left = max(gRDP.scissor.left, gRSP.clip_ratio_left);
|
|
gRSP.real_clip_scissor_top = max(gRDP.scissor.top, gRSP.clip_ratio_top);
|
|
gRSP.real_clip_scissor_right = min(gRDP.scissor.right,gRSP.clip_ratio_right);
|
|
gRSP.real_clip_scissor_bottom = min(gRDP.scissor.bottom, gRSP.clip_ratio_bottom);
|
|
|
|
gRSP.real_clip_scissor_left = max(gRSP.real_clip_scissor_left, 0);
|
|
gRSP.real_clip_scissor_top = max(gRSP.real_clip_scissor_top, 0);
|
|
gRSP.real_clip_scissor_right = min(gRSP.real_clip_scissor_right,windowSetting.uViWidth-1);
|
|
gRSP.real_clip_scissor_bottom = min(gRSP.real_clip_scissor_bottom, windowSetting.uViHeight-1);
|
|
|
|
WindowSettingStruct &w = windowSetting;
|
|
w.clipping.left = (uint32)(gRSP.real_clip_scissor_left*windowSetting.fMultX);
|
|
w.clipping.top = (uint32)(gRSP.real_clip_scissor_top*windowSetting.fMultY);
|
|
w.clipping.bottom = (uint32)(gRSP.real_clip_scissor_bottom*windowSetting.fMultY);
|
|
w.clipping.right = (uint32)(gRSP.real_clip_scissor_right*windowSetting.fMultX);
|
|
if( w.clipping.left > 0 || w.clipping.top > 0 || w.clipping.right < (uint32)windowSetting.uWindowDisplayWidth-1 ||
|
|
w.clipping.bottom < (uint32)windowSetting.uWindowDisplayHeight-1 )
|
|
{
|
|
w.clipping.needToClip = true;
|
|
}
|
|
else
|
|
{
|
|
w.clipping.needToClip = false;
|
|
}
|
|
w.clipping.width = (uint32)((gRSP.real_clip_scissor_right-gRSP.real_clip_scissor_left+1)*windowSetting.fMultX);
|
|
w.clipping.height = (uint32)((gRSP.real_clip_scissor_bottom-gRSP.real_clip_scissor_top+1)*windowSetting.fMultY);
|
|
|
|
float halfx = gRSP.nVPWidthN/2.0f;
|
|
float halfy = gRSP.nVPHeightN/2.0f;
|
|
float centerx = gRSP.nVPLeftN+halfx;
|
|
float centery = gRSP.nVPTopN+halfy;
|
|
|
|
gRSP.real_clip_ratio_negx = (gRSP.real_clip_scissor_left - centerx)/halfx;
|
|
gRSP.real_clip_ratio_negy = (gRSP.real_clip_scissor_top - centery)/halfy;
|
|
gRSP.real_clip_ratio_posx = (gRSP.real_clip_scissor_right - centerx)/halfx;
|
|
gRSP.real_clip_ratio_posy = (gRSP.real_clip_scissor_bottom - centery)/halfy;
|
|
|
|
ApplyScissorWithClipRatio(true);
|
|
}
|
|
|
|
|
|
void CRender::InitOtherModes(void) // Set other modes not covered by color combiner or alpha blender
|
|
{
|
|
ApplyTextureFilter();
|
|
|
|
//
|
|
// I can't think why the hand in mario's menu screen is rendered with an opaque rendermode,
|
|
// and no alpha threshold. We set the alpha reference to 1 to ensure that the transparent pixels
|
|
// don't get rendered. I hope this doesn't fuck anything else up.
|
|
//
|
|
if ( gRDP.otherMode.alpha_compare == 0 )
|
|
{
|
|
if ( gRDP.otherMode.cvg_x_alpha && (gRDP.otherMode.alpha_cvg_sel || gRDP.otherMode.aa_en ) )
|
|
{
|
|
ForceAlphaRef(128); // Strange, I have to use value=2 for pixel shader combiner for Nvidia FX5200
|
|
// for other video cards, value=1 is good enough.
|
|
SetAlphaTestEnable(TRUE);
|
|
}
|
|
else
|
|
{
|
|
SetAlphaTestEnable(FALSE);
|
|
}
|
|
}
|
|
else if ( gRDP.otherMode.alpha_compare == 3 )
|
|
{
|
|
//RDP_ALPHA_COMPARE_DITHER
|
|
SetAlphaTestEnable(FALSE);
|
|
}
|
|
else
|
|
{
|
|
if( (gRDP.otherMode.alpha_cvg_sel ) && !gRDP.otherMode.cvg_x_alpha )
|
|
{
|
|
// Use CVG for pixel alpha
|
|
SetAlphaTestEnable(FALSE);
|
|
}
|
|
else
|
|
{
|
|
// RDP_ALPHA_COMPARE_THRESHOLD || RDP_ALPHA_COMPARE_DITHER
|
|
if( m_dwAlpha==0 )
|
|
ForceAlphaRef(1);
|
|
else
|
|
ForceAlphaRef(m_dwAlpha);
|
|
SetAlphaTestEnable(TRUE);
|
|
}
|
|
}
|
|
|
|
if( options.enableHackForGames == HACK_FOR_SOUTH_PARK_RALLY && m_Mux == 0x00121824ff33ffffLL &&
|
|
gRSP.bCullFront && gRDP.otherMode.aa_en && gRDP.otherMode.z_cmp && gRDP.otherMode.z_upd )
|
|
{
|
|
SetZCompare(FALSE);
|
|
}
|
|
|
|
|
|
if( gRDP.otherMode.cycle_type >= CYCLE_TYPE_COPY )
|
|
{
|
|
// Disable zbuffer for COPY and FILL mode
|
|
SetZCompare(FALSE);
|
|
}
|
|
else
|
|
{
|
|
SetZCompare(gRDP.otherMode.z_cmp);
|
|
SetZUpdate(gRDP.otherMode.z_upd);
|
|
}
|
|
|
|
/*
|
|
if( options.enableHackForGames == HACK_FOR_SOUTH_PARK_RALLY && m_Mux == 0x00121824ff33ffff &&
|
|
gRSP.bCullFront && gRDP.otherMode.z_cmp && gRDP.otherMode.z_upd )//&& gRDP.otherMode.aa_en )
|
|
{
|
|
SetZCompare(FALSE);
|
|
SetZUpdate(FALSE);
|
|
}
|
|
*/
|
|
}
|
|
|
|
|
|
void CRender::SetTextureFilter(uint32 dwFilter)
|
|
{
|
|
if( options.forceTextureFilter == FORCE_DEFAULT_FILTER )
|
|
{
|
|
switch(dwFilter)
|
|
{
|
|
case RDP_TFILTER_AVERAGE: //?
|
|
case RDP_TFILTER_BILERP:
|
|
m_dwMinFilter = m_dwMagFilter = FILTER_LINEAR;
|
|
break;
|
|
default:
|
|
m_dwMinFilter = m_dwMagFilter = FILTER_POINT;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch( options.forceTextureFilter )
|
|
{
|
|
case FORCE_POINT_FILTER:
|
|
m_dwMinFilter = m_dwMagFilter = FILTER_POINT;
|
|
break;
|
|
case FORCE_LINEAR_FILTER:
|
|
case FORCE_BILINEAR_FILTER:
|
|
m_dwMinFilter = m_dwMagFilter = FILTER_LINEAR;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ApplyTextureFilter();
|
|
}
|
|
|
|
bool SaveRGBBufferToFile(char *filename, unsigned char *buf, int width, int height, int pitch)
|
|
{
|
|
if( pitch == -1 )
|
|
pitch = width*3;
|
|
|
|
if( strcasecmp(right(filename,3),"bmp") == 0 )
|
|
{
|
|
BITMAPFILEHEADER fileHeader;
|
|
BITMAPINFOHEADER infoHeader;
|
|
|
|
infoHeader.biSize = sizeof( BITMAPINFOHEADER );
|
|
infoHeader.biWidth = width;
|
|
infoHeader.biHeight = height;
|
|
infoHeader.biPlanes = 1;
|
|
infoHeader.biBitCount = 24;
|
|
infoHeader.biCompression = BI_RGB;
|
|
infoHeader.biSizeImage = width * height * 3;
|
|
infoHeader.biXPelsPerMeter = 0;
|
|
infoHeader.biYPelsPerMeter = 0;
|
|
infoHeader.biClrUsed = 0;
|
|
infoHeader.biClrImportant = 0;
|
|
|
|
fileHeader.bfType = 19778;
|
|
fileHeader.bfSize = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) + infoHeader.biSizeImage;
|
|
fileHeader.bfReserved1 = fileHeader.bfReserved2 = 0;
|
|
fileHeader.bfOffBits = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER );
|
|
|
|
|
|
FILE *f;
|
|
f = fopen(filename, "wb");
|
|
if(f != NULL)
|
|
{
|
|
fwrite(&fileHeader, sizeof(BITMAPFILEHEADER), 1, f);
|
|
fwrite(&infoHeader, sizeof(BITMAPINFOHEADER), 1, f);
|
|
fwrite(buf, infoHeader.biSizeImage, 1, f);
|
|
|
|
fclose(f);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// Do something
|
|
TRACE1("Fail to create file %s", filename);
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( strcasecmp(right(filename,4),".png") != 0 ) strcat(filename,".png");
|
|
|
|
struct BMGImageStruct img;
|
|
memset(&img, 0, sizeof(BMGImageStruct));
|
|
InitBMGImage(&img);
|
|
img.bits = buf;
|
|
img.bits_per_pixel = 24;
|
|
img.height = height;
|
|
img.width = width;
|
|
img.scan_width = pitch;
|
|
BMG_Error code = WritePNG(filename, img);
|
|
|
|
if( code == BMG_OK )
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool SaveRGBABufferToPNGFile(char *filename, unsigned char *buf, int width, int height, int pitch)
|
|
{
|
|
if( pitch == -1 )
|
|
pitch = width*4;
|
|
|
|
if( strcasecmp(right(filename,4),".png") != 0 ) strcat(filename,".png");
|
|
|
|
struct BMGImageStruct img;
|
|
memset(&img, 0, sizeof(BMGImageStruct));
|
|
InitBMGImage(&img);
|
|
img.bits = buf;
|
|
img.bits_per_pixel = 32;
|
|
img.height = height;
|
|
img.width = width;
|
|
img.scan_width = pitch;
|
|
BMG_Error code = WritePNG(filename, img);
|
|
|
|
if( code == BMG_OK )
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|