Debugger.cpp

/*
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, ...) {}

#ifdef WANT_LOG_UCODE
#include <varargs.h>
#include <stdio.h>
void __cdecl LOG_UCODE(const char* szFormat, ...)
{
    {
        char Msg[400];
        va_list va;
        va_start(va, szFormat);
        vsprintf( Msg, szFormat, va );
        va_end(va);
        printf("%s\n", Msg);
    }
}
#endif

#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; i<GetNumLights()+2; i++)
        {
            DebuggerAppendMsg("Light %d:\t%08X, (%d,%d,%d)\n", i, gRSPn64lights[i].dwRGBA,gRSPn64lights[i].x,gRSPn64lights[i].y,gRSPn64lights[i].z );
        }
        break;
    case DUMP_TEXTURE_AT:
        {
        }
        break;
    case DUMP_CUR_TEXTURE_RGBA:
        DumpTexture(gRSP.curTile, TXT_RGBA);
        break;
    case DUMP_CUR_1_TEXTURE_RGBA:
        DumpTexture((1+gRSP.curTile)%7, TXT_RGBA);
        break;
    case DUMP_CUR_TEXTURE_RGB:
        DumpTexture(gRSP.curTile, TXT_RGB);
        break;
    case DUMP_CUR_1_TEXTURE_RGB:
        DumpTexture((1+gRSP.curTile)%7, TXT_RGB);
        break;
    case DUMP_CUR_TEXTURE_TO_FILE:
        DumpTextureToFile(0,TXT_RGB);
        DumpTextureToFile(0,TXT_ALPHA);
        DumpTextureToFile(0,TXT_RGBA);
        break;
    case DUMP_CUR_1_TEXTURE_TO_FILE:
        DumpTextureToFile(1,TXT_RGB);
        DumpTextureToFile(1,TXT_ALPHA);
        DumpTextureToFile(1,TXT_RGBA);
        break;
    case DUMP_CUR_TEXTURE_ALPHA:
        DumpTexture(0, TXT_ALPHA);
        break;
    case DUMP_CUR_1_TEXTURE_ALPHA:
        DumpTexture(1, TXT_ALPHA);
        break;
    case DUMP_TLUT:
        DumpTlut(g_wRDPTlut);
        break;
    case DUMP_OBJ_TLUT:
        DumpTlut((uint16*)(g_pRDRAMu8+gObjTlutAddr));
        break;
    case DUMP_TILE_AT:
        {
        }
        break;
    case DUMP_VERTEXES:
        DumpVertexArray();
        break;
    case DUMP_VI_REGS:
        DumpVIRegisters();
        break;
    case DUMP_SIMPLE_MUX:
        CRender::GetRender()->m_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