X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=source%2Frice_gles%2Fsrc%2FDebugger.cpp;fp=source%2Frice_gles%2Fsrc%2FDebugger.cpp;h=438931e052ee50283581d879c18c8a4d95721165;hb=d07c171fa694cae985ad7045f9ce2b2f1a5699b4;hp=0000000000000000000000000000000000000000;hpb=ca22e7b76883b946060a6b40bb8709c1981e1cf6;p=mupen64plus-pandora.git diff --git a/source/rice_gles/src/Debugger.cpp b/source/rice_gles/src/Debugger.cpp new file mode 100644 index 0000000..438931e --- /dev/null +++ b/source/rice_gles/src/Debugger.cpp @@ -0,0 +1,710 @@ +/* +Copyright (C) 2002 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. + +*/ + +#define M64P_PLUGIN_PROTOTYPES 1 +#include "m64p_plugin.h" +#include "typedefs.h" + +#ifndef DEBUGGER +void __cdecl DebuggerAppendMsg(const char * Message, ...) {} + +#else + +void DumpMatrix2(const Matrix &mtx, const char* prompt); + +bool debuggerWinOpened = false; +bool debuggerDrawRenderTexture = false; +int debuggerDrawRenderTextureNo = 0; + +bool logCombiners = false; +bool logWarning = true; +bool logTriangles = false; +bool logMatrix = false; +bool logVertex = false; +bool logTextures = false; +bool logTextureBuffer = false; +bool logToScreen = true; +bool logToFile = false; +bool logUcodes = false; +bool logMicrocode = false; +bool logFog = false; +bool logDetails = false; + +FILE *logFp = NULL; + +bool debuggerEnableTexture=true; +bool debuggerEnableZBuffer=true; +bool debuggerEnableCullFace=true; +bool debuggerEnableTestTris=true; +bool debuggerEnableAlphaTest=true; +bool debuggerContinueWithUnknown=false; + +bool debuggerPause = false; +bool pauseAtNext = true; +int eventToPause = NEXT_FRAME; +int debuggerPauseCount = 340; +int countToPause = 1; + +bool debuggerDropCombiners=false; +bool debuggerDropGeneralCombiners=false; +bool debuggerDropDecodedMux=false; +bool debuggerDropCombinerInfos=false; + +char msgBuf[0x20000+2]; +bool msgBufUpdated = false; +extern FiddledVtx * g_pVtxBase; + +uint32 CachedTexIndex = 0; + +const char* otherNexts[] = { + "Frame", + "Flush Tri", + "TextRect", + "Triangle", + "Set CImg", + "ObjTxt Cmd", + "Obj BG", + "Sprite2D", + "FillRect", + "DList", + "Ucode", + "Texture Buffer", + "Matrix Cmd", + "Vertex Cmd", + "New Texture", + "Set Texture", + "Mux", + "Set Light", + "Set Mode Cmd", + "Set Prim Color", + "Texture Cmd", + "Unknown Ops", + "Scale Image", + "LoadTlut", + "Ucode Switching", +}; +int numberOfNextOthers = sizeof(otherNexts)/sizeof(char*); + +const char* thingsToDump[] = { + "Cur Texture RGBA", + "Cur+1 Texture RGBA", + "Colors", + "Memory At", + "Mux", + "Simple Mux", + "Other Modes", + "Texture #", + "Tile #", + "VI Regs", + "Cur Txt to file", + "Cur+1 Txt to file", + "Cur Texture RGB", + "Cur Texture Alpha", + "Cur+1 Texture RGB", + "Cur+1 Texture Alpha", + "Light Info", + "Tlut", + "Obj Tlut", + "Vertexes", + "Cached Texture", + "Next Texture", + "Prev Texture", + "Dlist At", + "Matrix At", + "Combined Matrix", + "World Top Matrix", + "Projection Matrix", + "World Matrix #", + "Frame Buffer in RDRAM", + "BackBuffer", + "TexBuffer #", +}; +int numberOfThingsToDump = sizeof(thingsToDump)/sizeof(char*); + +enum { + DUMP_CUR_TEXTURE_RGBA, + DUMP_CUR_1_TEXTURE_RGBA, + DUMP_COLORS, + DUMP_CONTENT_AT, + DUMP_CUR_MUX, + DUMP_SIMPLE_MUX, + DUMP_OTHER_MODE, + DUMP_TEXTURE_AT, + DUMP_TILE_AT, + DUMP_VI_REGS, + DUMP_CUR_TEXTURE_TO_FILE, + DUMP_CUR_1_TEXTURE_TO_FILE, + DUMP_CUR_TEXTURE_RGB, + DUMP_CUR_TEXTURE_ALPHA, + DUMP_CUR_1_TEXTURE_RGB, + DUMP_CUR_1_TEXTURE_ALPHA, + DUMP_LIGHT, + DUMP_TLUT, + DUMP_OBJ_TLUT, + DUMP_VERTEXES, + DUMP_CACHED_TEX, + DUMP_NEXT_TEX, + DUMP_PREV_TEX, + DUMP_DLIST_AT, + DUMP_MATRIX_AT, + DUMP_COMBINED_MATRIX, + DUMP_WORLD_TOP_MATRIX, + DUMP_PROJECTION_MATRIX, + DUMP_WORLD_MATRIX_AT, + DUMP_FRAME_BUFFER, + DUMP_BACKBUFFER, + DUMP_TEXBUFFER_AT, +}; + +//--------------------------------------------------------------------- +void DumpVIRegisters(void) +{ + DebuggerAppendMsg("----VI Registers----\nSTATUS:\t%08X\nORIGIN:\t%08X\nWIDTH:\t%08X\n\ +V_SYNC:\t%08X\nH_SYNC:\t%08X\nX_SCALE:\t%08X\nY_SCALE:\t%08X\n\ +H_START:\t%08X\nV_START:\t%08X\nVI Width=%f(x %f), VI Height=%f(x %f)\n\n", + *g_GraphicsInfo.VI_STATUS_REG, *g_GraphicsInfo.VI_ORIGIN_REG, *g_GraphicsInfo.VI_WIDTH_REG, *g_GraphicsInfo.VI_V_SYNC_REG, + *g_GraphicsInfo.VI_H_SYNC_REG, *g_GraphicsInfo.VI_X_SCALE_REG, *g_GraphicsInfo.VI_Y_SCALE_REG, + *g_GraphicsInfo.VI_H_START_REG, *g_GraphicsInfo.VI_V_START_REG, windowSetting.fViWidth,windowSetting.fMultX, + windowSetting.fViHeight,windowSetting.fMultY); + DebuggerAppendMsg("Scissor: x0=%d y0=%d x1=%d y1=%d mode=%d", + gRDP.scissor.left, gRDP.scissor.top, + gRDP.scissor.right, gRDP.scissor.bottom, + gRDP.scissor.mode); + DebuggerAppendMsg("Effective scissor: x0=%d y0=%d x1=%d y1=%d", + gRSP.real_clip_scissor_left, gRSP.real_clip_scissor_top, + gRSP.real_clip_scissor_right, gRSP.real_clip_scissor_bottom); + DebuggerAppendMsg("Clipping: (%d) left=%f top=%f right=%f bottom=%f", + gRSP.clip_ratio_posx, gRSP.real_clip_ratio_negx , gRSP.real_clip_ratio_negy, + gRSP.real_clip_ratio_posx, gRSP.real_clip_ratio_posy); + DebuggerAppendMsg("Viewport: left=%d top=%d right=%d bottom=%d", + gRSP.nVPLeftN, gRSP.nVPTopN , gRSP.nVPRightN, + gRSP.nVPBottomN); + DebuggerAppendMsg("Current CImg: Addr=0x%08X, Fmt:%s-%sb, Width=%d\n", + g_CI.dwAddr, pszImgFormat[g_CI.dwFormat], pszImgSize[g_CI.dwSize], g_CI.dwWidth); + DebuggerAppendMsg("Current ZImg: Addr=0x%08X, Fmt:%s-%sb, Width=%d\n", + g_ZI.dwAddr, pszImgFormat[g_ZI.dwFormat], pszImgSize[g_ZI.dwSize], g_ZI.dwWidth); +} + +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 DumpHex(uint32 rdramAddr, int count); +uint32 StrToHex(char *HexStr); + +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); +} + +void DumpTexture(int tex, TextureChannel channel = TXT_RGB ) +{ + CRender::GetRender()->DrawTexture(tex, channel); +} + +void DumpRenderTexture(int tex=-1) +{ + if( CDeviceBuilder::GetBuilder()->GetGeneralDeviceType() == DIRECTX_DEVICE ) + { + g_pFrameBufferManager->DisplayRenderTexture(tex); + } + else + { + debuggerDrawRenderTextureNo = tex; + debuggerDrawRenderTexture = true; + } +} + +void DumpTextureToFile(int tex, TextureChannel channel = TXT_RGB) +{ + CRender::GetRender()->SaveTextureToFile(tex, channel,false); +} + +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]); + } +} + +extern char ucodeNames_GBI1[256]; +extern char ucodeNames_GBI2[256]; + +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 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]); +} + +// High +static const char *alphadithertypes[4] = {"Pattern", "NotPattern", "Noise", "Disable"}; +static const char *rgbdithertype[4] = {"MagicSQ", "Bayer", "Noise", "Disable"}; +static const char *convtype[8] = {"Conv", "?", "?", "?", "?", "FiltConv", "Filt", "?"}; +static const char *filtertype[4] = {"Point", "?", "Bilinear", "Average"}; +static const char *cycletype[4] = {"1Cycle", "2Cycle", "Copy", "Fill"}; +static const char *alphacomptype[4] = {"None", "Threshold", "?", "Dither"}; +static const char * szCvgDstMode[4] = { "Clamp", "Wrap", "Full", "Save" }; +static const char * szZMode[4] = { "Opa", "Inter", "XLU", "Decal" }; +static const char * szZSrcSel[2] = { "Pixel", "Primitive" }; +static const char * sc_szBlClr[4] = { "In", "Mem", "Bl", "Fog" }; +static const char * sc_szBlA1[4] = { "AIn", "AFog", "AShade", "0" }; +static const char * sc_szBlA2[4] = { "1-A", "AMem", "1", "0" }; + +void DumpOtherMode() +{ + uint16 blender = gRDP.otherMode.blender; + RDP_BlenderSetting &bl = *(RDP_BlenderSetting*)(&(blender)); + DebuggerAppendMsg( "Other Modes"); + DebuggerAppendMsg( "\talpha_compare:\t%s", alphacomptype[ gRDP.otherMode.alpha_compare ]); + DebuggerAppendMsg( "\tdepth_source:\t%s", szZSrcSel[ gRDP.otherMode.depth_source ]); + DebuggerAppendMsg( "\taa_en:\t\t%d", gRDP.otherMode.aa_en ); + DebuggerAppendMsg( "\tz_cmp:\t\t%d", gRDP.otherMode.z_cmp ); + DebuggerAppendMsg( "\tz_upd:\t\t%d", gRDP.otherMode.z_upd ); + DebuggerAppendMsg( "\tim_rd:\t\t%d", gRDP.otherMode.im_rd ); + DebuggerAppendMsg( "\tclr_on_cvg:\t%d", gRDP.otherMode.clr_on_cvg ); + DebuggerAppendMsg( "\tcvg_dst:\t\t%s", szCvgDstMode[ gRDP.otherMode.cvg_dst ] ); + DebuggerAppendMsg( "\tzmode:\t\t%s", szZMode[ gRDP.otherMode.zmode ] ); + DebuggerAppendMsg( "\tcvg_x_alpha:\t%d", gRDP.otherMode.cvg_x_alpha ); + DebuggerAppendMsg( "\talpha_cvg_sel:\t%d", gRDP.otherMode.alpha_cvg_sel ); + DebuggerAppendMsg( "\tforce_bl:\t\t%d", gRDP.otherMode.force_bl ); + DebuggerAppendMsg( "\ttex_edge:\t\t%d", gRDP.otherMode.tex_edge ); + DebuggerAppendMsg( "\tblender:\t\t%04x - Cycle1:\t%s * %s + %s * %s\n\t\t\tCycle2:\t%s * %s + %s * %s", gRDP.otherMode.blender, + sc_szBlClr[bl.c1_m1a], sc_szBlA1[bl.c1_m1b], sc_szBlClr[bl.c1_m2a], sc_szBlA2[bl.c1_m2b], + sc_szBlClr[bl.c2_m1a], sc_szBlA1[bl.c2_m1b], sc_szBlClr[bl.c2_m2a], sc_szBlA2[bl.c2_m2b]); + DebuggerAppendMsg( "\tblend_mask:\t%d", gRDP.otherMode.blend_mask ); + DebuggerAppendMsg( "\talpha_dither:\t%s", alphadithertypes[ gRDP.otherMode.alpha_dither ] ); + DebuggerAppendMsg( "\trgb_dither:\t\t%s", rgbdithertype[ gRDP.otherMode.rgb_dither ] ); + DebuggerAppendMsg( "\tcomb_key:\t%s", gRDP.otherMode.key_en ? "Key" : "None" ); + DebuggerAppendMsg( "\ttext_conv:\t\t%s", convtype[ gRDP.otherMode.text_conv ] ); + DebuggerAppendMsg( "\ttext_filt:\t\t%s", filtertype[ gRDP.otherMode.text_filt ] ); + DebuggerAppendMsg( "\ttext_tlut:\t\t%s", textluttype[ gRDP.otherMode.text_tlut ] ); + DebuggerAppendMsg( "\ttext_lod:\t\t%s", gRDP.otherMode.text_lod ? "Yes": "No" ); + DebuggerAppendMsg( "\ttext_detail:\t\t%s", gRDP.otherMode.text_detail ? "Yes": "No" ); + DebuggerAppendMsg( "\ttext_sharpen:\t\t%s", gRDP.otherMode.text_sharpen ? "Yes": "No" ); + DebuggerAppendMsg( "\ttext_persp:\t%s", gRDP.otherMode.text_persp ? "On" : "Off" ); + DebuggerAppendMsg( "\tcycle_type:\t%s", cycletype[ gRDP.otherMode.cycle_type ] ); + DebuggerAppendMsg( "\tpipeline:\t\t%s", gRDP.otherMode.atomic_prim ? "1Primitive" : "NPrimitive" ); + + DebuggerAppendMsg("\n\nSP render flags:"); + DebuggerAppendMsg("\tCull mode: %s%s", gRSP.bCullFront?"Cull Front":"", gRSP.bCullBack?" Cull Back":""); + DebuggerAppendMsg("\tShade mode: %d", gRSP.shadeMode); + DebuggerAppendMsg("\tFog: %s", gRSP.bFogEnabled?"enabled":"disabled"); + DebuggerAppendMsg("\tZbuffer in SP: %s", gRSP.bZBufferEnabled?"enabled":"disabled"); + DebuggerAppendMsg("\tLighting: %s", gRSP.bLightingEnable?"enabled":"disabled"); + DebuggerAppendMsg("\\Number of lights: %d", gRSPnumLights); + DebuggerAppendMsg("\tTexture Gen: %s", gRSP.bTextureGen?"enabled":"disabled"); + DebuggerAppendMsg("\tTexture Gen Linear: %s", (gRDP.geometryMode & G_TEXTURE_GEN_LINEAR)?"enabled":"disabled"); +} + +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); + DebuggerAppendMsg("ScaledS:%s, ScaledT:%s", p->pTexture->m_bScaledS?"T":"F", p->pTexture->m_bScaledT?"T":"F"); + } + else + { + DebuggerAppendMsg("No cached texture at index = %d\n", index); + } +} + +extern uint32 gObjTlutAddr; +void DumpInfo(int thingToDump) +{ + switch(thingToDump) + { + case DUMP_COLORS: + DebuggerAppendMsg("----Colors----\nPrim Color:\t%08X\nEnv Color:\t%08X\n" + "Fill Color:\t%08X\nFog Color:\t%08X\n" + "Prim Depth:\t%f\nPrim LOD Frac:\t%08X\n", + GetPrimitiveColor(), GetEnvColor(), gRDP.fillColor, + CRender::GetRender()->GetFogColor(), GetPrimitiveDepth(), GetLODFrac()); + break; + case DUMP_CUR_MUX: + CRender::GetRender()->m_pColorCombiner->DisplayMuxString(); + break; + case DUMP_LIGHT: + DebuggerAppendMsg("----Light Colors----\nNumber of Lights: %d\n",GetNumLights()); + for( uint32 i=0; im_pColorCombiner->DisplaySimpleMuxString(); + break; + case DUMP_OTHER_MODE: + DumpOtherMode(); + break; + case DUMP_FRAME_BUFFER: + CRender::GetRender()->DrawFrameBuffer(true); + break; + case DUMP_CONTENT_AT: + { + } + break; + case DUMP_DLIST_AT: + { + } + break; + case DUMP_MATRIX_AT: + { + } + break; + case DUMP_NEXT_TEX: + CachedTexIndex++; + if( CachedTexIndex >= gTextureManager.GetNumOfCachedTexture() ) + { + CachedTexIndex = 0; + } + DumpCachedTexture(CachedTexIndex); + break; + case DUMP_PREV_TEX: + CachedTexIndex--; + if( CachedTexIndex < 0 || CachedTexIndex >= gTextureManager.GetNumOfCachedTexture() ) + CachedTexIndex = 0; + DumpCachedTexture(CachedTexIndex); + break; + case DUMP_CACHED_TEX: + DumpCachedTexture(CachedTexIndex); + break; + case DUMP_TEXBUFFER_AT: + { + } + break; + case DUMP_COMBINED_MATRIX: + DumpMatrix2(gRSPworldProject,"Combined Matrix"); + break; + case DUMP_WORLD_TOP_MATRIX: + DumpMatrix2(gRSP.modelviewMtxs[gRSP.modelViewMtxTop],"World Top Matrix"); + break; + case DUMP_WORLD_MATRIX_AT: + { + } + break; + case DUMP_PROJECTION_MATRIX: + DumpMatrix2(gRSP.projectionMtxs[gRSP.projectionMtxTop],"Projection Top Matrix"); + break; + } +} + + +void SetLogToFile(bool log) +{ + if( log ) + { + if( logFp == NULL ) + { + logFp = fopen("\\RiceVideo.log", "at"); + } + } + else + { + if( logFp != NULL ) + { + fclose(logFp); + logFp = NULL; + } + } +} + + +void __cdecl DebuggerAppendMsg(const char * Message, ...) +{ + if( !logToScreen && !logToFile ) + return; + + char Msg[5000]; + va_list ap; + + va_start( ap, Message ); + vsprintf( Msg, Message, ap ); + va_end( ap ); + + if( Msg[strlen(Msg)-1]!='\n' ) strcat(Msg,"\n"); + + if( logToScreen ) + { + DebugMessage(M64MSG_INFO, "Rice Debug: %s", Msg); + } + + if( logToFile ) + { + fprintf(logFp, "%s\n", Msg); + } +} + + +void DebuggerPause() +{ + while( debuggerPause ) + { + if( debuggerDrawRenderTexture ) + { + g_pFrameBufferManager->DisplayRenderTexture(debuggerDrawRenderTextureNo); + debuggerDrawRenderTexture = false; + } + usleep(100 * 1000); + debuggerPause = false; + } +} + +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); + } +} + +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"); +} + +uint32 StrToHex(char *HexStr) +{ + uint32 temp = 0; + + for(uint32 k = 0; k < strlen(HexStr); k++) + { + if(HexStr[k] <= '9' && HexStr[k] >= '0') + { + temp = temp << 4; + temp += HexStr[k] - '0'; + } + else if(HexStr[k] <= 'F' && HexStr[k] >= 'A') + { + temp = temp << 4; + temp += HexStr[k] - 'A' + 10; + } + else if(HexStr[k] <= 'f' && HexStr[k] >= 'a') + { + temp = temp << 4; + temp += HexStr[k] - 'a' + 10; + } + else + { + return(temp); + } + } + + return(temp); +} + +void DEBUGGER_PAUSE_COUNT_N(uint32 val) +{ + if (eventToPause == (int)val) + { + if(debuggerPauseCount>0) + debuggerPauseCount--; + if(debuggerPauseCount==0) + { + CGraphicsContext::Get()->UpdateFrame(); + debuggerPause = true; + } + } +} + +void DEBUGGER_PAUSE_COUNT_N_WITHOUT_UPDATE(uint32 val) +{ + if(eventToPause == (int)val) + { + if(debuggerPauseCount>0) + debuggerPauseCount--; + if(debuggerPauseCount==0) + { + debuggerPauseCount = countToPause; + debuggerPause = true; + } + } +} + +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 DumpMatrix(const Matrix &mat, const char* prompt) +{ + if( pauseAtNext && logMatrix ) + { + DumpMatrix2(mat, prompt); + } +} + +#endif +