ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
BizHawk/libmupen64plus/mupen64plus-video-z64/src/rgl_debugger.cpp

862 lines
27 KiB
C++
Raw Normal View History

Added mupen64plus-video-z64
2014-07-09 23:40:12 +00:00
/*
* z64
*
* Copyright (C) 2007 ziggy
*
* 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.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
**/
#include "rdp.h"
#include "rgl.h"
static const char *saRGBText[] =
{
"PREV", "TEXEL0", "TEXEL1", "PRIM",
"SHADE", "ENV", "NOISE", "1",
"0", "0", "0", "0",
"0", "0", "0", "0"
};
static const char *mRGBText[] =
{
"PREV", "TEXEL0", "TEXEL1", "PRIM",
"SHADE", "ENV", "SCALE", "PREV_ALPHA",
"TEXEL0_ALPHA", "TEXEL1_ALPHA", "PRIM_ALPHA", "SHADE_ALPHA",
"ENV_ALPHA", "LOD_FRACTION", "PRIM_LOD_FRAC", "K5",
"0", "0", "0", "0",
"0", "0", "0", "0",
"0", "0", "0", "0",
"0", "0", "0", "0"
};
static const char *aRGBText[] =
{
"PREV", "TEXEL0", "TEXEL1", "PRIM",
"SHADE", "ENV", "1", "0",
};
static const char *saAText[] =
{
"PREV", "TEXEL0", "TEXEL1", "PRIM",
"SHADE", "ENV", "1", "0",
};
static const char *sbAText[] =
{
"PREV", "TEXEL0", "TEXEL1", "PRIM",
"SHADE", "ENV", "1", "0",
};
static const char *mAText[] =
{
"LOD_FRACTION", "TEXEL0", "TEXEL1", "PRIM",
"SHADE", "ENV", "PRIM_LOD_FRAC", "0",
};
static const char *aAText[] =
{
"PREV", "TEXEL0", "TEXEL1", "PRIM",
"SHADE", "ENV", "1", "0",
};
const static char * bRGBText[] = { "PREV", "FRAG", "BLEND", "FOG" };
const static char * bAText[2][4] = { {"PREVA", "FOGA", "SHADEA", "0"},
{"(1.0-ALPHA)", "FRAGA", "1", "0"}};
char * rglCombiner2String(rdpState_t & state)
{
rdpOtherModes_t om = state.otherModes;
int cycle = RDP_GETOM_CYCLE_TYPE(om);
static char res[256];
char * p = res;
if (cycle < 2) {
p += sprintf(
p,
"c = [ (%s - %s) * %s + %s | (%s - %s) * %s + %s ]\n",
saRGBText[RDP_GETCM_SUB_A_RGB0(state.combineModes)],
saRGBText[RDP_GETCM_SUB_B_RGB0(state.combineModes)],
mRGBText[RDP_GETCM_MUL_RGB0(state.combineModes)],
aRGBText[RDP_GETCM_ADD_RGB0(state.combineModes)],
saAText[RDP_GETCM_SUB_A_A0(state.combineModes)],
sbAText[RDP_GETCM_SUB_B_A0(state.combineModes)],
mAText[RDP_GETCM_MUL_A0(state.combineModes)],
aAText[RDP_GETCM_ADD_A0(state.combineModes)]);
}
if (cycle == 1) {
p += sprintf(
p,
"c = [ (%s - %s) * %s + %s | (%s - %s) * %s + %s ]\n",
saRGBText[RDP_GETCM_SUB_A_RGB1(state.combineModes)],
saRGBText[RDP_GETCM_SUB_B_RGB1(state.combineModes)],
mRGBText[RDP_GETCM_MUL_RGB1(state.combineModes)],
aRGBText[RDP_GETCM_ADD_RGB1(state.combineModes)],
saAText[RDP_GETCM_SUB_A_A1(state.combineModes)],
sbAText[RDP_GETCM_SUB_B_A1(state.combineModes)],
mAText[RDP_GETCM_MUL_A1(state.combineModes)],
aAText[RDP_GETCM_ADD_A1(state.combineModes)]);
}
if (cycle < 2) {
p += sprintf(
p,
"%s*%s + %s*%s\n"
,bAText[0][RDP_GETOM_BLEND_M1B_0(state.otherModes)],
bRGBText[RDP_GETOM_BLEND_M1A_0(state.otherModes)],
bAText[1][RDP_GETOM_BLEND_M2B_0(state.otherModes)],
bRGBText[RDP_GETOM_BLEND_M2A_0(state.otherModes)]
);
}
if (cycle == 1) {
p += sprintf(
p,
"%s*%s + %s*%s\n"
,bAText[0][RDP_GETOM_BLEND_M1B_1(state.otherModes)],
bRGBText[RDP_GETOM_BLEND_M1A_1(state.otherModes)],
bAText[1][RDP_GETOM_BLEND_M2B_1(state.otherModes)],
bRGBText[RDP_GETOM_BLEND_M2A_1(state.otherModes)]
);
}
return res;
}
#ifdef RDP_DEBUG
#include <SDL.h>
//#include <IL/il.h>
#include <assert.h>
#include <FTGLTextureFont.h>
#define FONT "LucidaTypewriterRegular.ttf"
#define SMALLFONT "LucidaTypewriterRegular.ttf"
//#define SMALLFONT "/usr/share/fonts/corefonts/arial.ttf"
#define FS 12
#define SMALLFS 12
static FTFont * font;
static FTFont * smallfont;
static FTFont * curfont;
static int fbindex;
static int chunkindex, stripindex;
static int mx, my;
static float scalex, scaley;
static rglShader_t * alphaShader;
static int lines[0x10000], nblines;
static char dasm[512];
void gglPrint(int x, int y, const char * text)
{
glPushAttrib(GL_ALL_ATTRIB_BITS);
glPushMatrix();
glTranslatef(x, y, 0);
glEnable( GL_TEXTURE_2D);
glDisable( GL_DEPTH_TEST);
//glRasterPos2i( x , y);
curfont->Render(text);
glPopMatrix();
glPopAttrib();
//printf("%s\n", text);
}
void gglPrintf(int x, int y, const char * s, ...)
{
char buf[1024];
va_list ap;
va_start(ap, s);
vsprintf(buf, s, ap);
va_end(ap);
gglPrint(x, y, buf);
}
void rglDisplayTrace(int x, int y, int start, int lines)
{
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
rglUseShader(0);
curfont = smallfont;
start = ::lines[start];
while (lines-->0 && start <= rdpTracePos) {
glColor4f(0,0,0, 0.5);
glEnable(GL_BLEND);
glDisable(GL_TEXTURE_2D);
glBegin(GL_TRIANGLE_STRIP);
glVertex2f(x, y);
glVertex2f(x+2*screen_width*3/4, y);
glVertex2f(x, y-(SMALLFS+2));
glVertex2f(x+2*screen_width*3/4, y-(SMALLFS+2));
glEnd();
glColor4f(1,1,0.5,1);
glDisable(GL_BLEND);
start += rdp_dasm(rdpTraceBuf, start, start+256, dasm)/4;
gglPrintf(x, y-(SMALLFS), "%4x %s", start, dasm);
y -= (SMALLFS+2);
}
curfont = font;
// glDisable(GL_BLEND);
}
void rglDisplayColor(uint32_t color, int x , int y, const char * name, int sixteen = 0)
{
float r, g, b, a;
if (sixteen) {
r = RDP_GETC16_R(color)/ 31.0f;
g = RDP_GETC16_G(color)/ 31.0f;
b = RDP_GETC16_B(color)/ 31.0f;
a = RDP_GETC16_A(color)/ 1.0f;
} else {
r = RDP_GETC32_R(color)/255.0f;
g = RDP_GETC32_G(color)/255.0f;
b = RDP_GETC32_B(color)/255.0f;
a = RDP_GETC32_A(color)/255.0f;
}
y -= FS+2;
glColor4f(r, g, b, 1);
glDisable(GL_TEXTURE_2D);
glBegin(GL_TRIANGLE_STRIP);
glVertex2f(x, y);
glVertex2f(x+128, y);
glVertex2f(x, y-16);
glVertex2f(x+128, y-16);
glEnd();
glEnable(GL_TEXTURE_2D);
glColor4f(1,1,1,1);
gglPrintf(x, y+2, "%5s %08x", name, color);
}
void rglDisplayChunkInfo(rglRenderChunk_t & chunk)
{
int x = 0, y = screen_height;
int i;
rdpState_t & state = chunk.rdpState;
rdpOtherModes_t om = state.otherModes;
rdpCombineModes_t cm = state.combineModes;
int cycle = RDP_GETOM_CYCLE_TYPE(om);
rglDisplayColor(chunk.rdpState.primColor, x, y, "prim");
y -= 16+FS+10;
rglDisplayColor(chunk.rdpState.blendColor, x, y, "blend");
y -= 16+FS+10;
rglDisplayColor(chunk.rdpState.envColor, x, y, "env");
y -= 16+FS+10;
rglDisplayColor(chunk.rdpState.fogColor, x, y, "fog");
y -= 16+FS+10;
rglDisplayColor(chunk.rdpState.fillColor, x, y, "fill", 1);
y -= 16+FS+10;
y += 5*(16+FS+10);
x += 128+20;
glColor4f(1,1,1,1);
int oldy = y;
for (i=0; i<8; i++) {
int j;
int oldx = x;
if (!(chunk.flags & (1<<i))) continue;
rglTile_t & tile = chunk.tiles[i];
int w = tile.w, h = tile.h;
if (w > 64) w = 64;
if (h > 64) h = 64;
gglPrintf(x, y-h-FS, "#%d %dx%d %x", i, tile.w, tile.h, tile.hiresBuffer? 0 : tile.tex->crc);
gglPrintf(x, y-h-2*FS, "fmt %s-%d %d %d", rdpImageFormats[tile.format], tile.size, tile.line, tile.hiresBuffer? tile.hiresBuffer-rBuffers : -1);
gglPrintf(x, y-h-3*FS, "clip %dx%d %dx%d", tile.sl, tile.tl, tile.sh, tile.th);
gglPrintf(x, y-h-4*FS, "mask %dx%d shift %dx%d", tile.mask_s, tile.mask_t, tile.shift_s, tile.shift_t);
gglPrintf(x, y-h-5*FS, "%d %d %d %d pal %d", tile.cs, tile.ms, tile.ct, tile.ms, tile.palette);
glEnable(GL_TEXTURE_2D);
if (tile.hiresBuffer)
glBindTexture(GL_TEXTURE_2D, tile.hiresBuffer->texid);
else
glBindTexture(GL_TEXTURE_2D, tile.tex->id);
for (j=0; j<2; j++) {
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(0, 0); glVertex2f(x, y);
glTexCoord2f(0, 1); glVertex2f(x, y-h);
glTexCoord2f(1, 0); glVertex2f(x+w, y);
glTexCoord2f(1, 1); glVertex2f(x+w, y-h);
glEnd();
rglUseShader(alphaShader);
x += w+2;
}
rglUseShader(0);
// if ((tile.w+2)*2 < 256)
// x += 256 - (tile.w+2)*2;
x = oldx;
y -= h + 5*FS + 5;
}
y = oldy;
x = 128+210;
y -= FS;
gglPrintf(x, y, "cycle %d persp %d detail %d sharpen %d tex_lod %d en_tlut %d tlut_type %d clipm %d",
RDP_GETOM_CYCLE_TYPE(om),
RDP_GETOM_PERSP_TEX_EN(om),
RDP_GETOM_DETAIL_TEX_EN(om),
RDP_GETOM_SHARPEN_TEX_EN(om),
RDP_GETOM_TEX_LOD_EN(om),
RDP_GETOM_EN_TLUT(om),
RDP_GETOM_TLUT_TYPE(om),
chunk.rdpState.clipMode);
y -= FS;
gglPrintf(x, y, "sample_type %d mid %d lerp0 %d lerp1 %d convert1 %d key_en %d rgb_dith_sel %d",
RDP_GETOM_SAMPLE_TYPE(om),
RDP_GETOM_MID_TEXEL(om),
RDP_GETOM_BI_LERP0(om),
RDP_GETOM_BI_LERP1(om),
RDP_GETOM_CONVERT_ONE(om),
RDP_GETOM_KEY_EN(om),
RDP_GETOM_RGB_DITHER_SEL(om));
y -= FS;
gglPrintf(x, y, "A_dith_sel %d force_blend %d A_cvg_sel %d cvgXA %d Zmode %d cvg_dest %d col_on %d",
RDP_GETOM_ALPHA_DITHER_SEL(om),
RDP_GETOM_FORCE_BLEND(om),
RDP_GETOM_ALPHA_CVG_SELECT(om),
RDP_GETOM_CVG_TIMES_ALPHA(om),
RDP_GETOM_Z_MODE(om),
RDP_GETOM_CVG_DEST(om),
RDP_GETOM_COLOR_ON_CVG(om));
y -= FS;
gglPrintf(x, y, "img_read %d Zupdate %d Zcmp_sel %d antialias %d Zsource %d dith_A_en %d A_cmp %d",
RDP_GETOM_IMAGE_READ_EN(om),
RDP_GETOM_Z_UPDATE_EN(om),
RDP_GETOM_Z_COMPARE_EN(om),
RDP_GETOM_ANTIALIAS_EN(om),
RDP_GETOM_Z_SOURCE_SEL(om),
RDP_GETOM_DITHER_ALPHA_EN(om),
RDP_GETOM_ALPHA_COMPARE_EN(om));
y -= 2*FS;
if (cycle < 2) {
gglPrintf(x, y,
"c = [ (%s - %s) * %s + %s | (%s - %s) * %s + %s ];",
saRGBText[RDP_GETCM_SUB_A_RGB0(state.combineModes)],
saRGBText[RDP_GETCM_SUB_B_RGB0(state.combineModes)],
mRGBText[RDP_GETCM_MUL_RGB0(state.combineModes)],
aRGBText[RDP_GETCM_ADD_RGB0(state.combineModes)],
saAText[RDP_GETCM_SUB_A_A0(state.combineModes)],
sbAText[RDP_GETCM_SUB_B_A0(state.combineModes)],
mAText[RDP_GETCM_MUL_A0(state.combineModes)],
aAText[RDP_GETCM_ADD_A0(state.combineModes)]);
y -= FS;
}
if (cycle == 1) {
//if (cycle < 2) {
gglPrintf(x, y,
"c = [ (%s - %s) * %s + %s | (%s - %s) * %s + %s ];",
saRGBText[RDP_GETCM_SUB_A_RGB1(state.combineModes)],
saRGBText[RDP_GETCM_SUB_B_RGB1(state.combineModes)],
mRGBText[RDP_GETCM_MUL_RGB1(state.combineModes)],
aRGBText[RDP_GETCM_ADD_RGB1(state.combineModes)],
saAText[RDP_GETCM_SUB_A_A1(state.combineModes)],
sbAText[RDP_GETCM_SUB_B_A1(state.combineModes)],
mAText[RDP_GETCM_MUL_A1(state.combineModes)],
aAText[RDP_GETCM_ADD_A1(state.combineModes)]);
y -= FS;
}
if (cycle < 2) {
gglPrintf(x, y,
"%s*%s + %s*%s"
,bAText[0][RDP_GETOM_BLEND_M1B_0(state.otherModes)],
bRGBText[RDP_GETOM_BLEND_M1A_0(state.otherModes)],
bAText[1][RDP_GETOM_BLEND_M2B_0(state.otherModes)],
bRGBText[RDP_GETOM_BLEND_M2A_0(state.otherModes)]
);
y -= FS;
}
if (cycle == 1) {
//if (cycle < 2) {
gglPrintf(x, y,
"%s*%s + %s*%s"
,bAText[0][RDP_GETOM_BLEND_M1B_1(state.otherModes)],
bRGBText[RDP_GETOM_BLEND_M1A_1(state.otherModes)],
bAText[1][RDP_GETOM_BLEND_M2B_1(state.otherModes)],
bRGBText[RDP_GETOM_BLEND_M2A_1(state.otherModes)]
);
y -= FS;
}
if (chunk.nbStrips) {
y -= FS;
rglStrip_t & strip = chunk.strips[chunkindex >= 0? stripindex:0];
int i;
for (i=0; i<strip.nbVtxs; i++) {
rglVertex_t vtx = strip.vtxs[i];
int oldx;
gglPrintf(x, y, "%g %g %g %g", vtx.x, vtx.y, vtx.z, vtx.w);
x += 256;
if (strip.flags & RGL_STRIP_SHADE) {
gglPrintf(x, y, "%d %d %d %d", vtx.r, vtx.g, vtx.b, vtx.a);
x += 200;
}
if (strip.flags & (RGL_STRIP_TEX1|RGL_STRIP_TEX2)) {
gglPrintf(x, y, "%g %g", vtx.s, vtx.t);
x += 192;
}
y -= FS;
x = oldx;
}
}
// LOG("missing om %x %x (%x %x)\n",
// chunk.rdpState.otherModes.w1&RDP_OM_MISSING1,
// chunk.rdpState.otherModes.w2&RDP_OM_MISSING2,
// RDP_OM_MISSING1,
// RDP_OM_MISSING2);
// LOG("missing cm %x %x\n",
// chunk.rdpState.combineModes.w1&~(RDP_COMBINE_MASK11|RDP_COMBINE_MASK21),
// chunk.rdpState.combineModes.w2&~(RDP_COMBINE_MASK12|RDP_COMBINE_MASK22));
}
void rglDisplayFramebuffer(rglRenderBuffer_t & buffer, int alpha)
{
int i;
if (alpha)
rglUseShader(alphaShader);
else
rglUseShader(rglCopyShader);
glBindTexture(GL_TEXTURE_2D, buffer.texid);
glEnable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
glColor4ub(255, 255, 255, 255);
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(1, 1); glVertex2f(1, 0);
glTexCoord2f(0, 1); glVertex2f(0, 0);
glTexCoord2f(1, 0); glVertex2f(1, 1);
glTexCoord2f(0, 0); glVertex2f(0, 1);
glEnd();
}
void rglDisplayFlat(rglRenderChunk_t & chunk)
{
int j;
rglRenderBuffer_t & buffer = *chunk.renderBuffer;
glPushAttrib(GL_ALL_ATTRIB_BITS);
//glEnable(GL_SCISSOR_TEST);
rglUseShader(0);
glDisable(GL_TEXTURE_2D);
glDisable(GL_CULL_FACE);
// glScissor((chunk.rdpState.clip.xh >>2)*buffer.realWidth/buffer.width,
// (chunk.rdpState.clip.yh >>2)*buffer.realHeight/buffer.height,
// (chunk.rdpState.clip.xl-chunk.rdpState.clip.xh >>2)*buffer.realWidth/buffer.width,
// (chunk.rdpState.clip.yl-chunk.rdpState.clip.yh >>2)*buffer.realHeight/buffer.height);
for (j=0; j<chunk.nbStrips; j++) {
rglStrip_t & strip = chunk.strips[j];
int k;
if (chunkindex >= 0 && j == stripindex) {
glPushAttrib(GL_ALL_ATTRIB_BITS);
glColor4ub(255, 255, 128, 255);
}
glBegin(GL_TRIANGLE_STRIP);
for (k=0; k<strip.nbVtxs; k++) {
glVertex2f((strip.vtxs[k].x/(buffer.width)),
1-(strip.vtxs[k].y/(buffer.height)));
}
glEnd();
if (chunkindex >= 0 && j == stripindex)
glPopAttrib();
}
glPopAttrib();
}
int rglFindStrip(rglRenderChunk_t & chunk, float mx, float my)
{
int j;
rglRenderBuffer_t & buffer = *chunk.renderBuffer;
for (j=chunk.nbStrips-1; j>=0; j--) {
rglStrip_t & strip = chunk.strips[j];
int k;
struct { float x, y; } s[3];
for (k=0; k<strip.nbVtxs; k++) {
s[0] = s[1];
s[1] = s[2];
s[2].x = strip.vtxs[k].x/(buffer.width);
s[2].y = 1 - strip.vtxs[k].y/(buffer.height);
if (k >= 2) {
float last = 0;
int i;
for (i=0; i<3; i++) {
float dx1 = s[(i+1)%3].x - s[i].x;
float dy1 = s[(i+1)%3].y - s[i].y;
float dx2 = mx - s[i].x;
float dy2 = my - s[i].y;
dx1 = dx1*dy2-dx2*dy1;
if (dx1 == 0) goto next;
if (last*dx1 < 0)
goto next;
last = dx1;
}
stripindex = j;
return j;
next:;
}
}
}
return -1;
}
void rglDisplayFlat(rglRenderBuffer_t & buffer)
{
int i;
for (i=0; i<nbChunks; i++) {
rglRenderChunk_t & chunk = chunks[i];
if (chunk.renderBuffer != &buffer) continue;
rglDisplayFlat(chunk);
}
}
int rglFindChunk(rglRenderBuffer_t & buffer, float mx, float my)
{
int i;
if (chunkindex <= 0)
i = nbChunks-1;
else
i = chunkindex-1;
for (; i>=0; i--) {
rglRenderChunk_t & chunk = chunks[i];
if (chunk.renderBuffer != &buffer) continue;
if (rglFindStrip(chunk, mx, my) >= 0)
return i;
}
return -1;
}
void rglShowCursor(int state)
{
#ifdef WIN32
#else
SDL_ShowCursor(state);
#endif
}
#ifndef WIN32
static int keys[512];
#define MOUSEBUT 511
#else
# define MOUSEBUT VK_LBUTTON
# define SDLK_ESCAPE VK_ESCAPE
# define SDLK_KP_PLUS VK_ADD
# define SDLK_KP_MINUS VK_SUBTRACT
# define SDLK_TAB VK_TAB
# define SDLK_UP VK_UP
# define SDLK_DOWN VK_DOWN
# define SDLK_PAGEUP VK_PRIOR
# define SDLK_PAGEDOWN VK_NEXT
#endif
int rglCheckKey(int key)
{
#ifdef WIN32
return GetAsyncKeyState (key) & 1;
#else
if (key >= 'A' && key <= 'Z') key += 'a' - 'A';
int res = keys[key];
keys[key] = 0;
return res;
#endif
}
void rglDebugger()
{
SDL_Event event;
int paused = 1;
int i, j;
int traceX = 1;
int tracepos = 0;
int tracepage = (screen_height*3/4)/(SMALLFS+2);
int oldchunkindex = -1;
fbindex = 0;
chunkindex = -1;
void rglInitDebugger();
rglInitDebugger();
rglShowCursor(SDL_ENABLE);
glActiveTextureARB(GL_TEXTURE1_ARB);
glDisable(GL_TEXTURE_2D);
glActiveTextureARB(GL_TEXTURE2_ARB);
glDisable(GL_TEXTURE_2D);
glActiveTextureARB(GL_TEXTURE0_ARB);
glDrawBuffer(GL_BACK);
for (i=nblines=0; i<=rdpTracePos; i += rdp_dasm(rdpTraceBuf, i, i+256, dasm)/4, nblines++)
lines[nblines] = i;
if (nbChunks > 1)
// skip chunk 0 as it's usually depth clear
fbindex = chunks[1].renderBuffer - rBuffers;
while (paused) {
#ifndef WIN32
int res = SDL_WaitEvent(&event);
while (res) {
switch (event.type) {
case SDL_MOUSEBUTTONDOWN:
keys[MOUSEBUT] = 1;
break;
case SDL_MOUSEBUTTONUP:
keys[MOUSEBUT] = 0;
break;
case SDL_KEYDOWN:
if (event.key.keysym.sym < MOUSEBUT)
keys[event.key.keysym.sym] = 1;
break;
case SDL_KEYUP:
if (event.key.keysym.sym < MOUSEBUT)
keys[event.key.keysym.sym] = 0;
break;
}
res = SDL_PollEvent(&event);
}
#endif
rglRenderBuffer_t & buffer = rBuffers[fbindex];
scalex = buffer.realWidth; scaley = buffer.realHeight;
if (rBuffers[fbindex].fbid) {
if (buffer.realWidth > scalex*3/4 ||
buffer.realHeight > scaley*3/4) {
scalex = scalex*3/4;
scaley = scaley*3/4;
}
}
if (rglCheckKey(MOUSEBUT)) {
if (buffer.fbid) {
#ifdef WIN32
POINT pt;
GetCursorPos(&pt);
mx = pt.x;
my = pt.y;
#else
SDL_GetMouseState(&mx, &my);
#endif
int old = chunkindex;
if (old >= 0)
chunkindex++;
chunkindex = rglFindChunk(buffer, float(mx)/scalex, float(screen_height - my)/scaley);
if (old >= 0 && chunkindex == old) {
} else {
chunkindex = -1;
}
chunkindex = rglFindChunk(buffer, float(mx)/scalex, float(screen_height - my)/scaley);
if (chunkindex >= 0 && nbChunks)
printf("%s\n", chunks[chunkindex].shader->fsrc);
}
}
if (rglCheckKey('P') || rglCheckKey(SDLK_ESCAPE))
paused = 0;
if (rglCheckKey(SDLK_KP_PLUS)) {
if (fbindex < MAX_RENDER_BUFFERS-1/* &&
rBuffers[fbindex+1].fbid*/)
fbindex++;
chunkindex = -1;
}
if (rglCheckKey(SDLK_KP_MINUS)) {
if (fbindex > 0/* &&
rBuffers[fbindex-1].fbid*/)
fbindex--;
chunkindex = -1;
}
if (rglCheckKey(SDLK_TAB))
traceX = !traceX;
if (rglCheckKey(SDLK_UP))
tracepos--;
if (rglCheckKey(SDLK_DOWN))
tracepos++;
if (rglCheckKey(SDLK_PAGEUP))
tracepos -= tracepage/2;
if (rglCheckKey(SDLK_PAGEDOWN))
tracepos += tracepage/2;
if (tracepos < 0)
tracepos = 0;
if (tracepos > nblines-tracepage/2)
tracepos = nblines-tracepage/2;
//rglRenderChunks();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glDrawBuffer(GL_BACK);
glDisable(GL_SCISSOR_TEST);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glActiveTextureARB(GL_TEXTURE1_ARB);
glDisable(GL_TEXTURE_2D);
glActiveTextureARB(GL_TEXTURE0_ARB);
glDisable(GL_ALPHA_TEST);
glClearColor(0, 0, 0, 0);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glClear(GL_COLOR_BUFFER_BIT);
if (buffer.fbid) {
//glViewport(0, 0, scalex*screen_width/buffer.realWidth, scaley*screen_height/buffer.realHeight);
glViewport(0, 0, scalex, scaley);
rglDisplayFramebuffer(buffer, 0);
glViewport(scalex, 0, scalex, scaley);
rglDisplayFramebuffer(buffer, 1);
glViewport(0, 0, scalex, scaley);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glEnable(GL_BLEND);
//glBlendFunc( GL_ONE, GL_ONE );
glBlendFunc(GL_SRC_COLOR, GL_ONE_MINUS_DST_COLOR);
if (chunkindex < 0) {
//glColor4f(0.1, 0, 0.1, 0.5);
glColor4f(0.6, 0, 0.6, 0.5);
rglDisplayFlat(buffer);
} else {
glColor4f(0.6, 0, 0.6, 0.5);
rglDisplayFlat(chunks[chunkindex]);
}
}
{
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glDisable(GL_BLEND);
glMatrixMode( GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, screen_width, 0, screen_height);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glViewport(0, 0, screen_width, screen_height);
rglUseShader(0);
glColor3f(1,0.5,0.5);
gglPrintf(0, 0, "Fb #%d at $%x --> %x (%dx%d fmt %s-%d) upto %d %s", fbindex,
buffer.addressStart, buffer.addressStop,
buffer.width, buffer.height,
(buffer.flags & RGL_RB_DEPTH)? "Z":rdpImageFormats[buffer.format], buffer.size,
buffer.chunkId,
(buffer.flags & RGL_RB_ERASED)? "ERASED":"");
if (chunkindex >= 0) {
gglPrintf(0, FS, "Chunk #%d", chunkindex);
rglDisplayChunkInfo(chunks[chunkindex]);
}
if (oldchunkindex != chunkindex) {
oldchunkindex = chunkindex;
if (chunkindex >= 0)
for (i=0; i<nblines; i++)
if (lines[i] == chunks[chunkindex].tracePos)
tracepos = i;
}
rglDisplayTrace(traceX*scalex, screen_height*3/4, tracepos, tracepage);
glMatrixMode( GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
rglSwapBuffers();
}
rglShowCursor(SDL_DISABLE);
}
void rglCloseDebugger()
{
if (font) {
delete font;
font = 0;
}
if (smallfont) {
delete smallfont;
smallfont = 0;
}
if (alphaShader) {
rglDeleteShader(alphaShader);
alphaShader = 0;
}
}
void rglInitDebugger()
{
if (!font) {
char s[1024];
extern char rgl_cwd[512];
sprintf(s, "%s/"FONT, rgl_cwd);
curfont = font = new FTGLTextureFont(s);
sprintf(s, "%s/"SMALLFONT, rgl_cwd);
smallfont = new FTGLTextureFont(s);
if (!font || !smallfont) {
LOGERROR("Couldn't load font '%s'\n", s);
return;
}
font->FaceSize(FS);
smallfont->FaceSize(SMALLFS);
}
if (!alphaShader) {
alphaShader = rglCreateShader(
"void main() \n"
"{ \n"
" gl_Position = ftransform(); \n"
" gl_FrontColor = gl_Color; \n"
" gl_TexCoord[0] = gl_MultiTexCoord0; \n"
"} \n"
,
"uniform sampler2D texture0; \n"
" \n"
"void main() \n"
"{ \n"
" gl_FragColor = gl_Color * texture2D(texture0, vec2(gl_TexCoord[0])).a; \n"
"} \n"
);
}
}
void rdpBacktrace()
{
int i=0;
while (i <= rdpTracePos) {
i += rdp_dasm(rdpTraceBuf, i, i+256, dasm)/4;
printf("%4x %s\n", i, dasm);
}
}
#endif