自学教程：C++ DebuggerAppendMsg函数代码示例

void DumpDlistAt(uint32 dwPC){    uint32 word0, word1, opcode;    char *name;    switch( gRSP.ucode )    {    case 2:    case 10:    //case 8:        name=ucodeNames_GBI2;        break;    default:        name=ucodeNames_GBI1;    }    DebuggerAppendMsg("/n/n");    //if( dwPC>100 ) dwPC -= 40;    for( uint32 i=0; i<20; i++)    {        word0 = g_pRDRAMu32[(dwPC>>2)+0];        word1 = g_pRDRAMu32[(dwPC>>2)+1];        opcode = word0>>24;        DebuggerAppendMsg("%08X: %08X, %08X - %s", dwPC, word0, word1, name[opcode] );        dwPC+=8;    }    DebuggerAppendMsg("/n/n");}

void DumpHex(uint32 rdramAddr, int count){    rdramAddr &= 0xFFFFFFF0;    uint32 *ptr = (uint32 *)((rdramAddr&(g_dwRamSize-1))+g_pRDRAMu8);    for( int i=0; i<(count+3)/4; i++)    {        DebuggerAppendMsg("%08X: %08X, %08X, %08X, %08X/n",             rdramAddr+i*16, ptr[i*4], ptr[i*4+1], ptr[i*4+2], ptr[i*4+3]);    }    DebuggerAppendMsg("/n");}

void DumpMatrix2(const Matrix &mat, const char* prompt){    DebuggerAppendMsg(prompt);    DebuggerAppendMsg(        " %#+12.5f %#+12.5f %#+12.5f %#+12.5f/n"        " %#+12.5f %#+12.5f %#+12.5f %#+12.5f/n"        " %#+12.5f %#+12.5f %#+12.5f %#+12.5f/n"        " %#+12.5f %#+12.5f %#+12.5f %#+12.5f/n",        mat.m[0][0], mat.m[0][1], mat.m[0][2], mat.m[0][3],        mat.m[1][0], mat.m[1][1], mat.m[1][2], mat.m[1][3],        mat.m[2][0], mat.m[2][1], mat.m[2][2], mat.m[2][3],        mat.m[3][0], mat.m[3][1], mat.m[3][2], mat.m[3][3]);}

void DecodedMux::DisplaySimpliedMuxString(const char *prompt){    DebuggerAppendMsg("//Simplied Mux=0x%08x%08x/t%s in %s/n", m_dwMux0, m_dwMux1, prompt, g_curRomInfo.szGameName);    DebuggerAppendMsg("Simplied DWORDs=%08X, %08X, %08X, %08X", m_dWords[0],m_dWords[1],m_dWords[2],m_dWords[3]);    Display(true);    DebuggerAppendMsg("Simplfied type: %s", muxTypeStrs[mType]);    if( m_dwShadeColorChannelFlag != 0 )    {        if( m_dwShadeColorChannelFlag == MUX_ENV )            TRACE0("Shade = ENV in color channel")        else if( m_dwShadeColorChannelFlag == MUX_PRIM )            TRACE0("Shade = PRIM in color channel")        else if( m_dwShadeColorChannelFlag == MUX_LODFRAC )            TRACE0("Shade = MUX_LODFRAC in color channel")        else if( m_dwShadeColorChannelFlag == MUX_PRIMLODFRAC )            TRACE0("Shade = MUX_PRIMLODFRAC in color channel")        else            DisplayConstantsWithShade(m_dwShadeColorChannelFlag,COLOR_CHANNEL);    }    if( m_dwShadeAlphaChannelFlag != 0 )    {        if( m_dwShadeAlphaChannelFlag == MUX_ENV )            TRACE0("Shade = ENV in alpha channel")        else if( m_dwShadeAlphaChannelFlag == MUX_PRIM )            TRACE0("Shade = PRIM in alpha channel")        else if( m_dwShadeAlphaChannelFlag == MUX_LODFRAC )            TRACE0("Shade = MUX_LODFRAC in alpha channel")        else if( m_dwShadeAlphaChannelFlag == MUX_PRIMLODFRAC )            TRACE0("Shade = MUX_PRIMLODFRAC in alpha channel")        else            DisplayConstantsWithShade(m_dwShadeAlphaChannelFlag,ALPHA_CHANNEL);    }    for( int i=0; i<2; i++ )    {        if( m_ColorTextureFlag[i] != 0 )        {            if( m_ColorTextureFlag[i] == MUX_ENV )                TRACE1("Tex %d = ENV", i)            else if( m_ColorTextureFlag[i] == MUX_PRIM )                TRACE1("Tex %d = PRIM", i)            else if( m_ColorTextureFlag[i] == MUX_LODFRAC )                TRACE1("Tex %d = MUX_LODFRAC", i)            else if( m_ColorTextureFlag[i] == MUX_PRIMLODFRAC )                TRACE1("Tex %d = MUX_PRIMLODFRAC", i)        }    }    TRACE0("/n");}

void COGLColorCombiner4::DisplaySimpleMuxString(void){    char buf0[30], buf1[30], buf2[30];    OGLExtCombinerSaveType &result = m_vCompiledSettings[m_lastIndex];    COGLColorCombiner::DisplaySimpleMuxString();    DebuggerAppendMsg("OpenGL 1.2: %d Stages", result.numOfUnits);    for( int i=0; i<result.numOfUnits; i++ )    {        DebuggerAppendMsg("//aRGB%d:/t%s: %s, %s, %s/n", i,GetOpStr(result.units[i].rgbOp), DecodedMux::FormatStr(result.units[i].rgbArg0,buf0), DecodedMux::FormatStr(result.units[i].rgbArg1,buf1), DecodedMux::FormatStr(result.units[i].rgbArg2,buf2));        DebuggerAppendMsg("//aAlpha%d:/t%s: %s, %s, %s/n", i,GetOpStr(result.units[i].alphaOp), DecodedMux::FormatStr(result.units[i].alphaArg0,buf0), DecodedMux::FormatStr(result.units[i].alphaArg1,buf1), DecodedMux::FormatStr(result.units[i].alphaArg2,buf2));    }    TRACE0("/n/n");}

void OGLRender::DrawSimple2DTexture(float x0, float y0, float x1, float y1, float u0, float v0, float u1, float v1, COLOR dif, COLOR spe, float z, float rhw){    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 Simple2DTexture");});

void DumpVertexArray(void){	DebuggerAppendMsg("----Vertexes----/n");	try{		for( int i=0; i<32; i++ )		{			FiddledVtx &v = g_pVtxBase[i];			DebuggerAppendMsg("[%d] x=%d,y=%d,z=%d -- r=%d,g=%d,b=%d,a=%d/n", i, v.x, v.y, v.z, 				v.rgba.r, v.rgba.g, v.rgba.b, v.rgba.a);			DebuggerAppendMsg("/tx=%f,y=%f,z=%f,rhw=%f/n", g_vecProjected[i].x, g_vecProjected[i].y, g_vecProjected[i].z, g_vecProjected[i].w);		}	}catch(...)	{		DebuggerAppendMsg("Invalid memory pointer of vertex array/n");	}}

void COGLColorCombiner::DisableCombiner(void){    m_pOGLRender->DisableMultiTexture();    glEnable(GL_BLEND);    OPENGL_CHECK_ERRORS;    glBlendFunc(GL_ONE, GL_ZERO);    OPENGL_CHECK_ERRORS;        if( m_bTexelsEnable )    {        COGLTexture* pTexture = g_textures[gRSP.curTile].m_pCOGLTexture;        if( pTexture )         {            m_pOGLRender->EnableTexUnit(0,TRUE);            m_pOGLRender->BindTexture(pTexture->m_dwTextureName, 0);            glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);            OPENGL_CHECK_ERRORS;            m_pOGLRender->SetAllTexelRepeatFlag();        }#ifdef DEBUGGER        else        {            DebuggerAppendMsg("Check me, texture is NULL but it is enabled");        }#endif    }    else    {        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);        OPENGL_CHECK_ERRORS;        m_pOGLRender->EnableTexUnit(0,FALSE);    }}

void DumpMatrixAt(uint32 dwPC){    Matrix mat;    const float fRecip = 1.0f / 65536.0f;    for (uint32 dwI = 0; dwI < 4; dwI++)    {        for (uint32 dwJ = 0; dwJ < 4; dwJ++)        {            int nDataHi = *(short  *)(g_pRDRAMu8 + ((dwPC+(dwI<<3)+(dwJ<<1)     )^0x2));            int nDataLo = *(uint16 *)(g_pRDRAMu8 + ((dwPC+(dwI<<3)+(dwJ<<1) + 32)^0x2));            mat.m[dwI][dwJ] = (float)((nDataHi << 16) | nDataLo) * fRecip;        }    }    TRACE0("Dump Matrix in Memory");    DebuggerAppendMsg(        " %#+12.5f %#+12.5f %#+12.5f %#+12.5f/n"        " %#+12.5f %#+12.5f %#+12.5f %#+12.5f/n"        " %#+12.5f %#+12.5f %#+12.5f %#+12.5f/n"        " %#+12.5f %#+12.5f %#+12.5f %#+12.5f/n",        mat.m[0][0], mat.m[0][1], mat.m[0][2], mat.m[0][3],        mat.m[1][0], mat.m[1][1], mat.m[1][2], mat.m[1][3],        mat.m[2][0], mat.m[2][1], mat.m[2][2], mat.m[2][3],        mat.m[3][0], mat.m[3][1], mat.m[3][2], mat.m[3][3]);}

void DumpCachedTexture(uint32 index){    TxtrCacheEntry *p = gTextureManager.GetCachedTexture(index);    if( p != NULL )    {        char filename[80];        sprintf(filename,"//Texture%d_rgb", index);        CRender::GetRender()->SaveTextureToFile(*(p->pTexture), filename, TXT_RGB);        DebuggerAppendMsg("Display cached texture #%d of %d/n", index, gTextureManager.GetNumOfCachedTexture());        DebuggerAppendMsg("W:%d, H:%d, RealW:%d, RealH:%d, D3DW:%d, D3DH: %d", p->ti.WidthToCreate, p->ti.HeightToCreate,            p->ti.WidthToLoad, p->ti.HeightToLoad, p->pTexture->m_dwCreatedTextureWidth, p->pTexture->m_dwCreatedTextureHeight);    }    else    {        DebuggerAppendMsg("No cached texture at index = %d/n", index);    }}

void DumpTileInfo(uint32 dwTile){    const char *pszOnOff[2] = {"Off", "On"};    DebuggerAppendMsg("Tile: %d/nFmt: %s/%s Line:%d (Pitch %d) TMem:0x%04x Palette:%d/n",        dwTile, pszImgFormat[gRDP.tiles[dwTile].dwFormat], pszImgSize[gRDP.tiles[dwTile].dwSize],        gRDP.tiles[dwTile].dwLine, gRDP.tiles[dwTile].dwPitch, gRDP.tiles[dwTile].dwTMem, gRDP.tiles[dwTile].dwPalette);    DebuggerAppendMsg("S: Clamp: %s Mirror:%s Mask:0x%x Shift:0x%x/n",        pszOnOff[gRDP.tiles[dwTile].bClampS],pszOnOff[gRDP.tiles[dwTile].bMirrorS],        gRDP.tiles[dwTile].dwMaskS, gRDP.tiles[dwTile].dwShiftS);    DebuggerAppendMsg("T: Clamp: %s Mirror:%s Mask:0x%x Shift:0x%x/n",        pszOnOff[gRDP.tiles[dwTile].bClampT],pszOnOff[gRDP.tiles[dwTile].bMirrorT],        gRDP.tiles[dwTile].dwMaskT, gRDP.tiles[dwTile].dwShiftT);    DebuggerAppendMsg("(%d,%d) -> (%d,%d), hilite [%d, %d]/n",        gRDP.tiles[dwTile].sl, gRDP.tiles[dwTile].tl, gRDP.tiles[dwTile].sh, gRDP.tiles[dwTile].th,        gRDP.tiles[dwTile].hilite_sl,gRDP.tiles[dwTile].hilite_tl);}

//Copies Direct3D graphics surface to the RDRAM memory structure//Doesnt use render-targets (no HWFBE)void DXFrameBufferManager::CopyD3DSurfaceToRDRAM(uint32 addr, uint32 fmt, uint32 siz, uint32 width, uint32 height, uint32 bufWidth, uint32 bufHeight, uint32 startaddr, uint32 memsize, uint32 pitch, IDirect3DSurface9 *surf){	if( addr == 0 || addr>=g_dwRamSize )	return;	if( pitch == 0 ) pitch = width;	IDirect3DSurface9 *surf2 = NULL;	TXTRBUF_DUMP(DebuggerAppendMsg("Copy Back to N64 RDRAM"););

void DumpTlut(uint16* palAddr){    for( uint32 i=0; i<0x100; i+=8 )    {        DebuggerAppendMsg("0x%4X 0x%4X 0x%4X 0x%4X 0x%4X 0x%4X 0x%4X 0x%4X ",             g_wRDPTlut[i], g_wRDPTlut[i+1], g_wRDPTlut[i+2], g_wRDPTlut[i+2],             g_wRDPTlut[i+4], g_wRDPTlut[i+5], g_wRDPTlut[i+6], g_wRDPTlut[i+7]);    }}

void OGLRender::EnableTexUnit(int unitno, bool flag){#ifdef DEBUGGER    if( unitno != 0 )        DebuggerAppendMsg("Check me, in the base OpenGL render, unitno!=0");#endif    if( m_texUnitEnabled[0] != flag )        m_texUnitEnabled[0] = flag;}

void OGLRender::SetZBias(int bias){#if defined(DEBUGGER)    if( pauseAtNext == true )      DebuggerAppendMsg("Set zbias = %d", bias);#endif    // set member variable and apply the setting in opengl    m_dwZBias = bias;    ApplyZBias(bias);}

// Yoshi's Story uses this - 0xb0void RSP_S2DEX_SELECT_DL(Gfx *gfx){    //static BOOL bWarned = FALSE;    //if (!bWarned)    {        RSP_RDP_NOIMPL("RDP: RSP_S2DEX_SELECT_DL (0x%08x 0x%08x)", (gfx->words.w0), (gfx->words.w1));        //bWarned = TRUE;    }    DEBUGGER_PAUSE_AND_DUMP_COUNT_N(NEXT_OBJ_TXT_CMD, {DebuggerAppendMsg("Paused at RSP_S2DEX_SELECT_DL");});

void __cdecl LOG_UCODE(const char* szFormat, ...){    if( logUcodes)    {        char Msg[400];        va_list va;        va_start(va, szFormat);        vsprintf( Msg, szFormat, va );        va_end(va);        DebuggerAppendMsg("%s/n", Msg);    }}

BOOL CALLBACK MyEnumChildProc(HWND hwnd, LPARAM lParam){#ifndef _XBOX	int id = GetDlgCtrlID(hwnd);	if( id != 0 )	{		if( CGraphicsContext::m_hWndStatus != hwnd && IsWindow( hwnd ) )		{			RECT rect;			GetClientRect(hwnd, &rect);			if( rect.left == 0 && rect.top == 0 && rect.bottom < 40 && rect.right > 320 )			{				DEBUGGER_IF_DUMP((CGraphicsContext::m_hWndToolbar!=NULL), {DebuggerAppendMsg("Check me, found two toolbar");});

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.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");});

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 COGLColorCombiner::InitCombinerCycleCopy(void){    m_pOGLRender->DisableMultiTexture();    m_pOGLRender->EnableTexUnit(0,TRUE);    COGLTexture* pTexture = g_textures[gRSP.curTile].m_pCOGLTexture;    if( pTexture )    {        m_pOGLRender->BindTexture(pTexture->m_dwTextureName, 0);        m_pOGLRender->SetTexelRepeatFlags(gRSP.curTile);    }#ifdef _DEBUG    else    {        DebuggerAppendMsg("Check me, texture is NULL");    }#endif    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);}

void COGLColorCombinerNvidia::DisplayNVCombinerString(NVRegisterCombinerSettingType &record){    NVRegisterCombinerParserType &result = record.parseResult;    char buf[2000];    char buf0[30];    char buf1[30];    char buf2[30];    char buf3[30];    char buf4[30];    char buf5[30];    char buf6[30];    buf[0]='/0';    TRACE0("/n/n");    TRACE0("/nNvidia combiner stages:/n");    DebuggerAppendMsg("//aRGB0:/t%s * %s + %s * %s/n", DecodedMux::FormatStr(result.s1rgb.a, buf0),         DecodedMux::FormatStr(result.s1rgb.b, buf1), DecodedMux::FormatStr(result.s1rgb.c, buf2),DecodedMux::FormatStr(result.s1rgb.d, buf3));          DebuggerAppendMsg("//aA0:/t%s * %s + %s * %s/n", DecodedMux::FormatStr(result.s1alpha.a, buf0),         DecodedMux::FormatStr(result.s1alpha.b, buf1), DecodedMux::FormatStr(result.s1alpha.c, buf2),DecodedMux::FormatStr(result.s1alpha.d, buf3));            if( record.numOfStages == 2 )    {        DebuggerAppendMsg("//aRGB1:/t%s * %s + %s * %s/n", DecodedMux::FormatStr(result.s2rgb.a, buf0),             DecodedMux::FormatStr(result.s2rgb.b, buf1), DecodedMux::FormatStr(result.s2rgb.c, buf2),DecodedMux::FormatStr(result.s2rgb.d, buf3));              DebuggerAppendMsg("//aA1:/t%s * %s + %s * %s/n", DecodedMux::FormatStr(result.s2alpha.a, buf0),             DecodedMux::FormatStr(result.s2alpha.b, buf1), DecodedMux::FormatStr(result.s2alpha.c, buf2),DecodedMux::FormatStr(result.s2alpha.d, buf3));            }    DebuggerAppendMsg("//Final:/t%s * %s + (1 - %s) * %s + %s/n/tE=%s, F=%s/n", FormatStrForFinalStage(result.finalrgb.a, buf0),         FormatStrForFinalStage(result.finalrgb.b, buf1), FormatStrForFinalStage(result.finalrgb.a, buf2),        FormatStrForFinalStage(result.finalrgb.c, buf3), FormatStrForFinalStage(result.finalrgb.d, buf4),        FormatStrForFinalStage(result.finalrgb.e, buf5), FormatStrForFinalStage(result.finalrgb.f, buf6));    if( result.constant0 != MUX_0 )    {        DebuggerAppendMsg("//Constant 0:/t%s/n", DecodedMux::FormatStr(result.constant0, buf0));    }    if( result.constant1 != MUX_0 )    {        DebuggerAppendMsg("//Constant 1:/t%s/n", DecodedMux::FormatStr(result.constant1, buf0));    }    TRACE0("/n/n");}

void CGXRenderTexture::LoadTexture(TxtrCacheEntry* pEntry){#if 0	//This function copies the current color buffer (m_pTexture for this RenderTexture) to pEntry->pTexture	bool IsBeingRendered = m_beingRendered;	if( IsBeingRendered )	{		TXTRBUF_DUMP(TRACE0("Warning, loading from render_texture while it is being rendered"));		SetAsRenderTarget(false);		//return;	}	CTexture *pSurf = pEntry->pTexture;	TxtrInfo &ti = pEntry->ti;	// Need to load texture from the saved back buffer	MYLPDIRECT3DTEXTURE pNewTexture = MYLPDIRECT3DTEXTURE(pSurf->GetTexture());	MYLPDIRECT3DSURFACE pNewSurface = NULL;	HRESULT res = pNewTexture->GetSurfaceLevel(0,&pNewSurface);	MYLPDIRECT3DSURFACE pSourceSurface = NULL;	(MYLPDIRECT3DTEXTURE(m_pTexture->GetTexture()))->GetSurfaceLevel(0,&pSourceSurface);	int left = (pEntry->ti.Address- m_pInfo->CI_Info.dwAddr )%m_pInfo->CI_Info.bpl + pEntry->ti.LeftToLoad;	int top = (pEntry->ti.Address- m_pInfo->CI_Info.dwAddr)/m_pInfo->CI_Info.bpl + pEntry->ti.TopToLoad;	RECT srcrect = {uint32(left*m_pInfo->scaleX) ,uint32(top*m_pInfo->scaleY), 		uint32(min(m_width, left+(int)ti.WidthToLoad)*m_pInfo->scaleX), 		uint32(min(m_height,top+(int)ti.HeightToLoad)*m_pInfo->scaleY) };	if( pNewSurface != NULL && pSourceSurface != NULL )	{		if( left < m_width && top<m_height )		{			RECT dstrect = {0,0,ti.WidthToLoad,ti.HeightToLoad};			HRESULT res = D3DXLoadSurfaceFromSurface(pNewSurface,NULL,&dstrect,pSourceSurface,NULL,&srcrect,D3DX_FILTER_POINT ,0xFF000000);			DEBUGGER_IF_DUMP(( res != S_OK), {DebuggerAppendMsg("Error to reload texture from render_texture, res=%x", res);} );

void DLParser_Process(){	dlistMtxCount = 0;	bHalfTxtScale = false;	if ( CRender::g_pRender == NULL)	{		TriggerDPInterrupt();		return;	}	status.bScreenIsDrawn = true;	DebuggerPauseCountN( NEXT_DLIST );	status.gRDPTime = timeGetTime();	status.gDlistCount++;	OSTask * pTask = (OSTask *)(g_GraphicsInfo.DMEM + 0x0FC0);	u32 code_base = (u32)pTask->t.ucode & 0x1fffffff;	u32 code_size = pTask->t.ucode_size;	u32 data_base = (u32)pTask->t.ucode_data & 0x1fffffff;	u32 data_size = pTask->t.ucode_data_size;	u32 stack_size = pTask->t.dram_stack_size >> 6;	if (gLastUcodeBase != code_base)	{		DLParser_InitMicrocode(code_base, code_size, data_base, data_size);	}	// Initialize stack	status.bN64FrameBufferIsUsed = false;	gDlistStackPointer=0;	gDlistStack[gDlistStackPointer].pc = (uint32)pTask->t.data_ptr;	gDlistStack[gDlistStackPointer].countdown = MAX_DL_COUNT;		DEBUGGER_PAUSE_AT_COND_AND_DUMP_COUNT_N((gDlistStack[gDlistStackPointer].pc == 0 && pauseAtNext && eventToPause==NEXT_UNKNOWN_OP),			{DebuggerAppendMsg("Start Task without DLIST: ucode=%08X, data=%08X", (uint32)pTask->t.ucode, (uint32)pTask->t.ucode_data);});

void DecodedMux::Display(bool simplified,FILE *fp){    DecodedMux decodedMux;    DecodedMux *mux;    if( simplified )    {        mux = this;    }    else    {        decodedMux.Decode(m_dwMux0, m_dwMux1);        mux = &decodedMux;    }    char buf0[30];    char buf1[30];    char buf2[30];    char buf3[30];    for( int i=0; i<2; i++ )    {        for(int j=0;j<2;j++)        {            N64CombinerType &m = mux->m_n64Combiners[i+2*j];            if( fp )            {                fprintf(fp,"%s: (%s - %s) * %s + %s/n", MuxGroupStr[i+2*j], FormatStr(m.a,buf0),                     FormatStr(m.b,buf1), FormatStr(m.c,buf2), FormatStr(m.d,buf3));            }            else            {                DebuggerAppendMsg("%s: (%s - %s) * %s + %s/n", MuxGroupStr[i+2*j], FormatStr(m.a,buf0),                     FormatStr(m.b,buf1), FormatStr(m.c,buf2), FormatStr(m.d,buf3));            }        }    }}

void CNvTNTCombiner::DisplaySimpleMuxString(){    char buf0[30];    char buf1[30];    char buf2[30];    char buf3[30];    TNT2CombinerSaveType &result = m_vCompiledTNTSettings[m_lastIndexTNT];    TRACE0("/nNVidia TNT2+ Combiner/n");            DebuggerAppendMsg("//aRGB0:/t(%s * %s) %s (%s * %s)/n", DecodedMux::FormatStr(result.unit1.rgbArg0,buf0), DecodedMux::FormatStr(result.unit1.rgbArg1,buf1), result.unit1.rgbOp==0x0104?"+":"-", DecodedMux::FormatStr(result.unit1.rgbArg2,buf2), DecodedMux::FormatStr(result.unit1.rgbArg3,buf3));            DebuggerAppendMsg("//aRGB1:/t(%s * %s) %s (%s * %s)/n", DecodedMux::FormatStr(result.unit2.rgbArg0,buf0), DecodedMux::FormatStr(result.unit2.rgbArg1,buf1), result.unit2.rgbOp==0x0104?"+":"-", DecodedMux::FormatStr(result.unit2.rgbArg2,buf2), DecodedMux::FormatStr(result.unit2.rgbArg3,buf3));            DebuggerAppendMsg("//aAlpha0:/t(%s * %s) %s (%s * %s)/n", DecodedMux::FormatStr(result.unit1.alphaArg0,buf0), DecodedMux::FormatStr(result.unit1.alphaArg1,buf1), result.unit1.alphaOp==0x0104?"+":"-", DecodedMux::FormatStr(result.unit1.alphaArg2,buf2), DecodedMux::FormatStr(result.unit1.alphaArg3,buf3));            DebuggerAppendMsg("//aAlpha1:/t(%s * %s) %s (%s * %s)/n", DecodedMux::FormatStr(result.unit2.alphaArg0,buf0), DecodedMux::FormatStr(result.unit2.alphaArg1,buf1), result.unit2.alphaOp==0x0104?"+":"-", DecodedMux::FormatStr(result.unit2.alphaArg2,buf2), DecodedMux::FormatStr(result.unit2.alphaArg3,buf3));    if( result.unit1.constant != MUX_0 )        DebuggerAppendMsg("//Constant for unit 1:/t%s/n", DecodedMux::FormatStr(result.unit1.constant,buf0));    if( result.unit2.constant != MUX_0 )        DebuggerAppendMsg("//Constant for unit 2:/t%s/n", DecodedMux::FormatStr(result.unit2.constant,buf0));    TRACE0("/n/n");}

//.........这里部分代码省略.........    }    if( frameBufferOptions.bCheckBackBufs && g_pFrameBufferManager->CheckAddrInBackBuffers(pgti->Address, pgti->HeightToLoad*pgti->Pitch) >= 0 )    {        if( !frameBufferOptions.bWriteBackBufToRDRAM )        {            // Load the texture from recent back buffer            txtBufIdxToLoadFrom = g_pFrameBufferManager->CheckAddrInRenderTextures(pgti->Address);            if( txtBufIdxToLoadFrom >= 0 )            {                loadFromTextureBuffer = true;                // Check if it is the same size,                RenderTextureInfo &info = gRenderTextureInfos[txtBufIdxToLoadFrom];                //if( info.pRenderTexture && info.CI_Info.dwAddr == pgti->Address && info.CI_Info.dwFormat == pgti->Format                 if( info.pRenderTexture && info.CI_Info.dwFormat == pgti->Format                     && info.CI_Info.dwSize == pgti->Size )                {                    info.txtEntry.ti = *pgti;                    return &info.txtEntry;                }            }        }    }    if (pEntry && pEntry->dwTimeLastUsed == status.gRDPTime && status.gDlistCount != 0 && !status.bN64FrameBufferIsUsed )       // This is not good, Palatte may changes    {        // We've already calculated a CRC this frame!        dwAsmCRC = pEntry->dwCRC;    }    else    {        if ( doCRCCheck )        {            if( loadFromTextureBuffer )                dwAsmCRC = gRenderTextureInfos[txtBufIdxToLoadFrom].crcInRDRAM;            else                CalculateRDRAMCRC(pgti->pPhysicalAddress, pgti->LeftToLoad, pgti->TopToLoad, pgti->WidthToLoad, pgti->HeightToLoad, pgti->Size, pgti->Pitch);        }    }    int maxCI = 0;    if ( doCRCCheck && (pgti->Format == TXT_FMT_CI || (pgti->Format == TXT_FMT_RGBA && pgti->Size <= TXT_SIZE_8b )))    {        //maxCI = pgti->Size == TXT_SIZE_8b ? 255 : 15;        extern unsigned char CalculateMaxCI(void *pPhysicalAddress, uint32 left, uint32 top, uint32 width, uint32 height, uint32 size, uint32 pitchInBytes );        if( !pEntry || pEntry->dwCRC != dwAsmCRC || pEntry->maxCI < 0 )        {            maxCI = CalculateMaxCI(pgti->pPhysicalAddress, pgti->LeftToLoad, pgti->TopToLoad, pgti->WidthToLoad, pgti->HeightToLoad, pgti->Size, pgti->Pitch);        }        else        {            maxCI = pEntry->maxCI;        }        //Check PAL CRC        uint8 * pStart;        uint32 dwPalSize = 16;        uint32 dwOffset;        if( pgti->Size == TXT_SIZE_8b )        {            dwPalSize = 256;            dwOffset = 0;        }        else        {            dwOffset = pgti->Palette << 4;        }        pStart = (uint8*)pgti->PalAddress+dwOffset*2;        //uint32 y;        //for (y = 0; y < dwPalSize*2; y+=4)        //{        //  dwPalCRC = (dwPalCRC + *(uint32*)&pStart[y]);        //}        uint32 dwAsmCRCSave = dwAsmCRC;        //dwPalCRC = CalculateRDRAMCRC(pStart, 0, 0, dwPalSize, 1, TXT_SIZE_16b, dwPalSize*2);        dwPalCRC = CalculateRDRAMCRC(pStart, 0, 0, maxCI+1, 1, TXT_SIZE_16b, dwPalSize*2);        dwAsmCRC = dwAsmCRCSave;    }    if (pEntry && doCRCCheck )    {        if(pEntry->dwCRC == dwAsmCRC && pEntry->dwPalCRC == dwPalCRC &&            (!loadFromTextureBuffer || gRenderTextureInfos[txtBufIdxToLoadFrom].updateAtFrame < pEntry->FrameLastUsed ) )        {            // Tile is ok, return            pEntry->dwUses++;            pEntry->dwTimeLastUsed = status.gRDPTime;            pEntry->FrameLastUsed = status.gDlistCount;            LOG_TEXTURE(TRACE0("   Use current texture:/n"));            pEntry->lastEntry = g_lastTextureEntry;            g_lastTextureEntry = pEntry;            lastEntryModified = false;            DEBUGGER_IF_DUMP((pauseAtNext && loadFromTextureBuffer) ,            {DebuggerAppendMsg("Load cached texture from render_texture");}            );