Emulation/mupen64plus-oldsvn
1
0
Fork 0
mirror of https://github.com/mupen64plus/mupen64plus-oldsvn.git synced 2025-04-02 10:52:35 -04:00
Code Issues Projects Releases Packages Wiki Activity
mupen64plus-oldsvn/tr64_ogl/hle_uc04.h
Louai Al-Khanji 02f735046e Convert from windows to unix line endings
2009-05-28 12:47:17 +00:00

1617 lines
50 KiB
C
Raw Permalink Blame History

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright (C) 2009 icepir8 *
* *
* 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 <gl/gl.h>
//#include <glext.h>
#include "3dmath.h"
void rsp_uc04_vertex();
void rsp_uc04_modifyvertex();
void rsp_uc04_culldl();
void rsp_uc04_branchz();
void rsp_uc04_tri1();
void rsp_uc04_tri2();
void rsp_uc04_quad();
void rsp_uc04_fastcombine();
void rsp_uc04_rdphalf_cont();
void rsp_uc04_rdphalf_2();
void rsp_uc04_line3d();
void rsp_uc04_texture();
void rsp_uc04_popmatrix();
void rsp_uc04_setgeometrymode();
void rsp_uc04_matrix();
void rsp_uc04_moveword();
void rsp_uc04_movemem();
void rsp_uc04_displaylist();
void rsp_uc04_enddl();
void rsp_uc04_rdphalf_1();
void rsp_uc04_setothermode_l();
void rsp_uc04_setothermode_h();
void rsp_uc04_special_1()
{
DebugBox("special_1");
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_SPECIAL_1\n",
ADDR, CMD0, CMD1);
#endif
}
void rsp_uc04_special_2()
{
DebugBox("special_2");
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_SPECIAL_2\n",
ADDR, CMD0, CMD1);
#endif
}
void rsp_uc04_special_3()
{
DebugBox("special_3");
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_SPECIAL_3\n",
ADDR, CMD0, CMD1);
#endif
}
void rsp_uc04_dma_io()
{
DebugBox("dma_io");
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_DMA_IO\n",
ADDR, CMD0, CMD1);
#endif
}
void rsp_uc04_load_ucode()
{
DebugBox("load_ucode");
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_LOAD_UCODE\n",
ADDR, CMD0, CMD1);
#endif
}
void rsp_uc04_noop()
{
DebugBox("noop");
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_NOOP\n",
ADDR, CMD0, CMD1);
#endif
}
extern float fScalex;
extern float fScaley;
//////////////////////////////////////////////////////////////////////////////
// structure is tricky for changing the endians //
//////////////////////////////////////////////////////////////////////////////
typedef struct
{
_s16 y;
_s16 x;
_u16 flags;
_s16 z;
_s16 t;
_s16 s;
_u8 a;
_u8 b;
_u8 g;
_u8 r;
} t_vtx_uc4;
_u32 bzaddr;
//////////////////////////////////////////////////////////////////////////////
// LoadVertex //
//////////////////////////////////////////////////////////////////////////////
void rsp_uc04_vertex()
{
_u32 a = segoffset2addr(rdp_reg.cmd1);
int v0, i, n;
n = (rdp_reg.cmd0 >> 12) & 0xff;
v0 = ((rdp_reg.cmd0 >> 1) & 0x7f) - n;
if (refresh_matrix) update_cmbmatrix();
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_LOADVTX vertex %i..%i\n",
ADDR, CMD0, CMD1, v0, v0+n-1);
#endif
for(i = 0; i < n; i++)
{
// t_vtx_uc4 *vtx = (t_vtx_uc4 *)&pRDRAM[a+(i*sizeof(t_vtx_uc4))];
_u32 ad = a + (i * sizeof(t_vtx_uc4));
rdp_reg.vtx[v0].x = (float)(_s16)doReadMemHalfWord(ad+0);
rdp_reg.vtx[v0].y = (float)(_s16)doReadMemHalfWord(ad+2);
rdp_reg.vtx[v0].z = (float)(_s16)doReadMemHalfWord(ad+4);
rdp_reg.vtx[v0].flags = (_u16)doReadMemHalfWord(ad+6);
rdp_reg.vtx[v0].s = (float)(_s16)doReadMemHalfWord(ad+8);
rdp_reg.vtx[v0].t = (float)(_s16)doReadMemHalfWord(ad+10);
rdp_reg.vtx[v0].r = (_u8)doReadMemByte(ad+12);
rdp_reg.vtx[v0].g = (_u8)doReadMemByte(ad+13);
rdp_reg.vtx[v0].b = (_u8)doReadMemByte(ad+14);
rdp_reg.vtx[v0].a = (_u8)doReadMemByte(ad+15);
if( (USE_MM_HACK) && rdp_reg.combine_h == 0x00262a60 && rdp_reg.combine_l == 0x150c937f && rdp_reg.tile == 0 )
{
// Hack for Zelda Sun
t_tile *t0 = &rdp_reg.td[0];
t_tile *t1 = &rdp_reg.td[1];
if( t0->format == 4 && t0->size == 1 && t0->Width == 64 &&
t1->format == 4 && t1->size == 1 && t1->Width == 64 &&
t0->Height == t1->Height )
{
rdp_reg.vtx[v0].s /= 2;
rdp_reg.vtx[v0].t /= 2;
}
}
{
t_vtx *vertex = &rdp_reg.vtx[v0];
float tmpvtx[4];
tmpvtx[0] = vertex->x;
tmpvtx[1] = vertex->y;
tmpvtx[2] = vertex->z;
tmpvtx[3] = 1.0f;
// transform_vector(&tmpvtx[0],vertex->x,vertex->y,vertex->z);
// project_vector2(&tmpvtx[0]);
cmbtrans_vector(&tmpvtx[0]);
// if (
// (tmpvtx[2] < 0.001f)
// && (tmpvtx[2] >= -0.001f)
// )
// tmpvtx[2] = tmpvtx[3];
vertex->x = tmpvtx[0];
vertex->y = tmpvtx[1];
vertex->z = tmpvtx[2];
vertex->w = tmpvtx[3];
tmpvtx[0] = (float)(_s8)vertex->r;
tmpvtx[1] = (float)(_s8)vertex->g;
tmpvtx[2] = (float)(_s8)vertex->b;
//transform_normal(&tmpvtx[0]);
NormalizeVector(&tmpvtx[0]);
vertex->n1 = tmpvtx[0];
vertex->n2 = tmpvtx[1];
vertex->n3 = tmpvtx[2];
if (0x00020000 & rdp_reg.geometrymode)
{
if (USE_MM_HACK)
math_lightingMM((t_vtx*)(char*)vertex, vertex->lcolor);
else
math_lightingN((t_vtx*)(char*)vertex, vertex->lcolor);
}
else
{
vertex->lcolor[0] = (float)vertex->r / 255.0f;
vertex->lcolor[1] = (float)vertex->g / 255.0f;
vertex->lcolor[2] = (float)vertex->b / 255.0f;
vertex->lcolor[3] = (float)vertex->a / 255.0f;
}
if (0x00040000 & rdp_reg.geometrymode)
{
// G_TEXTURE_GEN enable the automatic generation of the texture
// coordinates s and t. A spherical mapping is used, based on the normal.
float fLenght;
tmpvtx[0] = (float)(_s8)vertex->r;
tmpvtx[1] = (float)(_s8)vertex->g;
tmpvtx[2] = (float)(_s8)vertex->b;
cmbtrans_normal(&tmpvtx[0]);
vertex->n1 = tmpvtx[0];
vertex->n2 = tmpvtx[1];
vertex->n3 = tmpvtx[2];
fLenght = VectorLength(tmpvtx);
vertex->s = (0.5f + (0.5f * vertex->n1 / fLenght));
vertex->t = (0.5f - (0.5f * vertex->n2 / fLenght));
// vertex->s = (0.5f + (0.5f * vertex->n1));
// vertex->t = (0.5f - (0.5f * vertex->n2));
}
#ifdef LOG_ON
LOG_TO_FILE("\tvtx[%02i]: xyzw -> %12.5f, %12.5f, %12.5f, %12.5f\n"
"\ts=%9.4f, t=%9.4f\n\tcolor [%02X,%02X,%02X]\n"
"\tnormals [%12.5f,%12.f,%12.5f]\n",
v0,
rdp_reg.vtx[v0].x, rdp_reg.vtx[v0].y, rdp_reg.vtx[v0].z, rdp_reg.vtx[v0].w,
rdp_reg.vtx[v0].s, rdp_reg.vtx[v0].t,
rdp_reg.vtx[v0].r, rdp_reg.vtx[v0].g, rdp_reg.vtx[v0].b,
rdp_reg.vtx[v0].n1, rdp_reg.vtx[v0].n2, rdp_reg.vtx[v0].n3);
#endif
}
v0++;
}
}
static _u32 tfbuffer[512*256];
extern byte bmpHdr[];
extern int bmpcnt;
extern _u32 *Color16_32;
void DumpBmp(_u8 *bffr,_u32 width, _u32 height)
{
int x,y;
_u32 *tbffr = (_u32*)bffr;
char bmpFileName[128] = "";
FILE *bmpFile;
byte tline[1024 * 4];
char EmuPath[128] = "";
GetEmuDir(EmuPath);
*(_u32*)&bmpHdr[2] = (_u32) ((width * height * 3) + 0x036);
*(_u32*)&bmpHdr[0x12] = width;
*(_u32*)&bmpHdr[0x16] = height;
*(_u32*)&bmpHdr[0x22] = (_u32) ((width * height * 3));
sprintf(bmpFileName,"%sTiles\\Dump%04i.bmp",EmuPath,bmpcnt++);
bmpFile = fopen(bmpFileName,"wb");
fwrite(bmpHdr, 0x36, 1, bmpFile);
for ( y = height - 1;y >= 0; y--)
{
tbffr = (_u32*)bffr;
tbffr += (y * width);
for (x = 0; x < (int)width; x++)
{
{
tline[x*3+0] = ((_u8*)tbffr)[2];
tline[x*3+1] = ((_u8*)tbffr)[1];
tline[x*3+2] = ((_u8*)tbffr)[0];
tbffr++;
}
}
fwrite(tline, width * 3, 1, bmpFile);
}
fclose(bmpFile);
}
typedef struct DRAWIMAGE_t {
float frameX;
float frameY;
float frameW;
float frameH;
WORD imageX;
WORD imageY;
WORD imageW;
WORD imageH;
DWORD imagePtr;
BYTE imageFmt;
BYTE imageSiz;
WORD imagePal;
} DRAWIMAGE;
void rsp_uc04_fullscreen()
{
unsigned long i, j;
unsigned int width = 256;
unsigned int height =256;
unsigned int mode = 2;
_u32 *add = (_u32*)(&pRDRAM[segoffset2addr(rdp_reg.cmd1)]);
t_Fullscreen *fsadd = (t_Fullscreen*)(&pRDRAM[segoffset2addr(rdp_reg.cmd1)]);
_u32 Scrwidth = fsadd->imageW >> 2;
_u32 Scrheight = fsadd->imageH >> 2;
_u32 Dstwidth = fsadd->frameW >> 2;
_u32 Dstheight = fsadd->frameH >> 2;
_u32 fladd = segoffset2addr(fsadd->imagePtr);
_u16 src;
_u16 *base_src_ptr;
// _u32 *lsrc;
_u32 *lbase_src_ptr;
_u32 *dest;
_u32 tmpTex = 0x0800001;
float txl = 0.0f;
float tyl = 0.0f;
float txh = 319.0f * fScalex;
float tyh = 239.0f * fScaley;
float color[4]={1.0f,1.0f,1.0f,1.0f};
GLint hadDepthTest, hadBlending, hadAlphaTest;
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_FULLSCREEN",ADDR, CMD0, CMD1);
LOG_TO_FILE("\tAddress = %08x",segoffset2addr(rdp_reg.cmd1));
LOG_TO_FILE("\tImageAddress = %08x",fladd);
LOG_TO_FILE("\tSrcWidth = %i\tSrcHeight = %i",Scrwidth,Scrheight);
LOG_TO_FILE("\tDstWidth = %i\tDstHeight = %i\n",Dstwidth,Dstheight);
#endif
/**/
glGetIntegerv(GL_DEPTH_TEST, &hadDepthTest); //** Should be glGetBooleanv, but
glGetIntegerv(GL_BLEND, &hadBlending); //** Should be glGetBooleanv, but
glGetIntegerv(GL_ALPHA_TEST, &hadAlphaTest); //** Should be glGetBooleanv, but
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_ALPHA_TEST);
Src_Alpha = GL_SRC_ALPHA;
Dst_Alpha = GL_ONE_MINUS_SRC_ALPHA;
glBlendFunc(Src_Alpha, Dst_Alpha);
glAlphaFunc(GL_GEQUAL,AlphaLevel);
glEnable(GL_BLEND);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
SetOrtho();
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
//glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
glEnable(GL_TEXTURE_2D);
/**/
base_src_ptr = (_u16*)(&pRDRAM[fladd]);
lbase_src_ptr = (_u32*)(&pRDRAM[fladd]);
for (i = 0; i<256*512; i++) tfbuffer[i] = 0;
for(i=0; i<Scrheight; i++)
{
_u16 *tsrc = &(base_src_ptr[i * Scrwidth]);
dest = (_u32*)&tfbuffer[i * 512];
for(j=0; j<Scrwidth; j++)
{
src = tsrc[(j ^ 0x01)];
*dest = Color16_32[src];
dest++;
}
}
#ifdef DUMP_TILE
DumpBmp((_u8*)tfbuffer,512,256);
#endif
/**/
glDeleteTextures(1, &tmpTex);
glBindTexture(GL_TEXTURE_2D, tmpTex);
glEnable(GL_TEXTURE_2D);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 512, 256, 0, GL_RGBA,
GL_UNSIGNED_BYTE, (_u8*)tfbuffer);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glColor4fv(color);
glBegin(GL_QUADS);
glTexCoord2f(0.0f,0.0f);
glVertex2f(txl, tyl);
glTexCoord2f(319.0f/512.0f,0.0f);
glVertex2f(txh, tyl);
glTexCoord2f(319.0f/512.0f,239.0f/256.0f);
glVertex2f(txh, tyh);
glTexCoord2f(0,239.0f/256.0f);
glVertex2f(txl, tyh);
glEnd();
//} // end for ulx uly
glDisable(GL_TEXTURE_2D);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
if (hadBlending) glEnable(GL_BLEND);
if (hadDepthTest) glEnable(GL_DEPTH_TEST);
if (hadAlphaTest) glEnable(GL_ALPHA_TEST);
/**/
}
// Modify vertex offsets
#define F3DEX2_POINT_RGBA 0x10
#define F3DEX2_POINT_ST 0x14
#define F3DEX2_POINT_XYSCREEN 0x18
#define F3DEX2_POINT_ZSCREEN 0x1c
void rsp_uc04_modifyvertex()
{
WORD vtx = (WORD)((CMD0 & 0xFFFF) >> 1);
BYTE where = (BYTE)((CMD0 >> 16) & 0xFF);
switch (where)
{
case F3DEX2_POINT_RGBA:
rdp_reg.vtx[vtx].r = (_u8)((CMD1 >> 24) & 0xFF);
rdp_reg.vtx[vtx].g = (_u8)((CMD1 >> 16) & 0xFF);
rdp_reg.vtx[vtx].b = (_u8)((CMD1 >> 8) & 0xFF);
rdp_reg.vtx[vtx].a = (_u8)((CMD1 ) & 0xFF);
break;
case F3DEX2_POINT_ST:
rdp_reg.vtx[vtx].s = (SHORT)((CMD1 >> 16) & 0xFFFF);// * 0.03125f;
rdp_reg.vtx[vtx].t = (SHORT)(CMD1 & 0xFFFF);// * 0.03125f;
break;
case F3DEX2_POINT_XYSCREEN:
break;
case F3DEX2_POINT_ZSCREEN:
break;
}
//rdp_reg.vtx[vtx].changed = TRUE;
//DebugBox("ModifyVertex\n");
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_MODIFYVTX \n", ADDR, CMD0, CMD1);
#endif
}
void rsp_uc04_culldl()
{
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_CULLDL\n", ADDR, CMD0, CMD1);
#endif
}
void rsp_uc04_branchz()
{
rdp_reg.pc_i++;
if(rdp_reg.pc_i > RDP_STACK_SIZE - 1)
{
return;
}
rdp_reg.pc[rdp_reg.pc_i] = bzaddr;
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_BRANCHZ\n", ADDR, CMD0, CMD1);
#endif
}
void rsp_uc04_tri1()
{
int vn[3];
vn[0] = ((CMD0 >> 16) & 0xff) / 2;
vn[1] = ((CMD0 >> 8) & 0xff) / 2;
vn[2] = ( CMD0 & 0xff) / 2;
DrawVisualTriangle(vn);
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_TRI1 (%i,%i,%i)\n",
ADDR, CMD0, CMD1, vn[0], vn[1], vn[2]);
#endif
} // void rsp_uc04_tri1()
void rsp_uc04_tri2()
{
int vn[6];
vn[0] = ((CMD0 >> 16) & 0xff) / 2;
vn[1] = ((CMD0 >> 8) & 0xff) / 2;
vn[2] = ( CMD0 & 0xff) / 2;
vn[3] = ((CMD1 >> 16) & 0xff) / 2;
vn[4] = ((CMD1 >> 8) & 0xff) / 2;
vn[5] = ( CMD1 & 0xff) / 2;
DrawVisualTriangle(vn);
DrawVisualTriangle(vn+3);
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_TRI2 (%i,%i,%i) (%i,%i,%i)\n",
ADDR, CMD0, CMD1, vn[0], vn[1], vn[2], vn[3], vn[4], vn[5]);
#endif
} // void rsp_uc04_tri2()
void rsp_uc04_quad()
{
int vn[6];
DebugBox("12");
vn[0] = ((rdp_reg.cmd0 >> 16) & 0xff) / 2;
vn[1] = ((rdp_reg.cmd0 >> 8) & 0xff) / 2;
vn[2] = ( rdp_reg.cmd0 & 0xff) / 2;
vn[3] = ((rdp_reg.cmd1 >> 16) & 0xff) / 2;
vn[4] = ((rdp_reg.cmd1 >> 8) & 0xff) / 2;
vn[5] = ( rdp_reg.cmd1 & 0xff) / 2;
DrawVisualTriangle(vn);
DrawVisualTriangle(vn+3);
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_QUAD (%i,%i,%i) (%i,%i,%i)\n",
ADDR, CMD0, CMD1, vn[0], vn[1], vn[2], vn[3], vn[4], vn[5]);
#endif
} // static void rsp_uc04_quad()
void rsp_uc04_fastcombine()
{
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_FAST_COMBINE",ADDR, CMD0, CMD1);
#endif
}
void rsp_uc04_rdphalf_cont()
{
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_RDP_HALF_1\n",ADDR, CMD0, CMD1);
#endif
}
void rsp_uc04_rdphalf_2()
{
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_RDP_HALF_2\n",ADDR, CMD0, CMD1);
#endif
}
void rsp_uc04_line3d()
{
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_LINE_3D\n",ADDR, CMD0, CMD1);
#endif
}
void rsp_uc04_texture()
{
int idx;
int tile = (rdp_reg.cmd0 >> 8) & 0x07; //** tile t0
int tile1 = (tile + 1) & 0x07; //** tile t1
_u32 mipmap_level = (rdp_reg.cmd0 >> 11) & 0x07; //** mipmap_level - not used yet
_u32 on = (rdp_reg.cmd0 & 0xff); //** 1: on - 0:off
float s = (float)((rdp_reg.cmd1 >> 16) & 0xffff);
float t = (float)((rdp_reg.cmd1 ) & 0xffff);
float SScale;
float TScale;
t_tile *tmp_tile = &rdp_reg.td[tile];
t_tile *tmp_tile1 = &rdp_reg.td[tile1];
tmp_tile->Texture_on = (_u8)on;
rdp_reg.tile = tile;
//if (s<=1)
// SScale=1.0f;
//else
SScale=(float)s/65535.f;
//if (t<=1)
// TScale=1.0f;
//else
TScale=(float)t/65535.f;
TScale/=32.f;
SScale/=32.f;
if( (((rdp_reg.cmd1)>>16)&0xFFFF) == 0xFFFF )
{
SScale = 1/32.0f;
}
else if( (((rdp_reg.cmd1)>>16)&0xFFFF) == 0x8000 )
{
SScale = 1/64.0f;
}
if( (((rdp_reg.cmd1) )&0xFFFF) == 0xFFFF )
{
TScale = 1/32.0f;
}
else if( (((rdp_reg.cmd1) )&0xFFFF) == 0x8000 )
{
TScale = 1/64.0f;
}
for (idx=0;idx<7;idx++)
{
rdp_reg.tile = idx;
tmp_tile1 = &rdp_reg.td[idx];
tmp_tile1->SScale=SScale;
tmp_tile1->TScale=TScale;
rdp_reg.m_CurTile = tmp_tile1;
MathTextureScales();
}
rdp_reg.tile = tile;
rdp_reg.m_CurTile = tmp_tile;
// MathTextureScales();
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_TEXTURE",ADDR, CMD0, CMD1);
LOG_TO_FILE("\tTile = %i, Mipmap = %i, enambled = %s\n",tile, mipmap_level, (on)?"on":"off");
#endif
}
void rsp_uc04_popmatrix()
{
// _u32 param = (CMD1 / 64);
_u32 param = (((((CMD0 >> 19) & 0x1f) + 1) * 8)/ 64);
switch(CMD1)
{
case 0x40:
pop_matrix();
break;
}
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_POPMATRIX\n",ADDR, CMD0, CMD1);
#endif
}
void rsp_uc04_setgeometrymode()
{
BOOL mode = FALSE;
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_SETGEOMETRYMODE",ADDR, CMD0, CMD1);
LOG_TO_FILE(
"\tClear:"
"%s"
"%s"
"%s"
"%s"
"%s"
"%s"
"%s"
"%s"
"%s"
"%s"
"%s",
(!(rdp_reg.cmd0 & 0x00000001)) ? "\tzbuffer\n" : "",
(!(rdp_reg.cmd0 & 0x00000002)) ? "\ttexture\n" : "",
(!(rdp_reg.cmd0 & 0x00000004)) ? "\tshade\n" : "",
(!(rdp_reg.cmd0 & 0x00000200)) ? "\tshade smooth\n" : "",
(!(rdp_reg.cmd0 & 0x00001000)) ? "\tcull front\n" : "",
(!(rdp_reg.cmd0 & 0x00002000)) ? "\tcull back\n" : "",
(!(rdp_reg.cmd0 & 0x00010000)) ? "\tfog\n" : "",
(!(rdp_reg.cmd0 & 0x00020000)) ? "\tlightning\n" : "",
(!(rdp_reg.cmd0 & 0x00040000)) ? "\ttexture gen\n" : "",
(!(rdp_reg.cmd0 & 0x00080000)) ? "\ttexture gen lin\n" : "",
(!(rdp_reg.cmd0 & 0x00100000)) ? "\tlod\n" : ""
);
LOG_TO_FILE(
"\tSet:\n"
"%s"
"%s"
"%s"
"%s"
"%s"
"%s"
"%s"
"%s"
"%s"
"%s"
"%s",
(rdp_reg.cmd1 & 0x00000001) ? "\t zbuffer\n" : "",
(rdp_reg.cmd1 & 0x00000002) ? "\t texture\n" : "",
(rdp_reg.cmd1 & 0x00000004) ? "\t shade\n" : "",
(rdp_reg.cmd1 & 0x00000200) ? "\t shade smooth\n" : "",
(rdp_reg.cmd1 & 0x00001000) ? "\t cull front\n" : "",
(rdp_reg.cmd1 & 0x00002000) ? "\t cull back\n" : "",
(rdp_reg.cmd1 & 0x00010000) ? "\t fog\n" : "",
(rdp_reg.cmd1 & 0x00020000) ? "\t lightning\n" : "",
(rdp_reg.cmd1 & 0x00040000) ? "\t texture gen\n" : "",
(rdp_reg.cmd1 & 0x00080000) ? "\t texture gen lin\n" : "",
(rdp_reg.cmd1 & 0x00100000) ? "\t lod\n" : ""
);
#endif
rdp_reg.geometrymode &= (rdp_reg.cmd0 & 0x0ffffff);
rdp_reg.geometrymode |= (rdp_reg.cmd1 & 0x0ffffff);
if(rdp_reg.cmd1 & 0x00000002)
rdp_reg.geometrymode_textures = 1;
switch(rdp_reg.geometrymode & 0x00000600)
{
case 0x0200:
Render_geometry_cullfront(1);
break;
case 0x0400:
Render_geometry_cullback(1);
break;
case 0x0600:
Render_geometry_cullfrontback(1);
break;
default:
Render_geometry_cullfrontback(0);
break;
} //** switch(rdp_reg.geometrymode & 0x00003000)
mode = (rdp_reg.geometrymode & 0x00080000) ? FALSE : TRUE;
if(mode) //
glShadeModel(GL_SMOOTH);
else
glShadeModel(GL_FLAT);
mode = (rdp_reg.geometrymode & 0x00010000) ? FALSE : TRUE;
//Render_Fog(mode);
// if((rdp_reg.geometrymode & 0x00020000) != 0)
// rdp_reg.useLights = 1;
}
void rsp_uc04_matrix()
{
static char *mtxop[] = {
"modelview mul push",
"modelview mul nopush",
"modelview load push",
"modelview load nopush",
"projection mul push",
"projection mul nopush",
"projection load push",
"projection load nopush"};
_u32 a = segoffset2addr(rdp_reg.cmd1);
_u8 command =(_u8)(CMD0 & 0xff);
float m[4][4];
// int i, j;
refresh_lights = TRUE;
hleGetMatrix((float*)&m[0,0], &pRDRAM[a]);
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_LOADMTX at %08X\n", ADDR, CMD0, CMD1, a);
LOG_TO_FILE(
"\t%s\n"
"\t\t{ %#+12.5f %#+12.5f %#+12.5f %#+12.5f }\n"
"\t\t{ %#+12.5f %#+12.5f %#+12.5f %#+12.5f }\n"
"\t\t{ %#+12.5f %#+12.5f %#+12.5f %#+12.5f }\n"
"\t\t{ %#+12.5f %#+12.5f %#+12.5f %#+12.5f }\n",
mtxop[command],
m[0][0], m[0][1], m[0][2], m[0][3],
m[1][0], m[1][1], m[1][2], m[1][3],
m[2][0], m[2][1], m[2][2], m[2][3],
m[3][0], m[3][1], m[3][2], m[3][3]
);
#endif
switch(command)
{
case 0: // modelview mul push
push_mult_matrix((GLfloat *)m);
break;
case 1: // modelview mul nopush
mult_matrix((GLfloat *)m);
break;
case 2: // modelview load push
push_load_matrix((GLfloat *)m);
break;
case 3: // modelview load nopush
load_matrix((GLfloat *)m);
break;
case 4: // projection mul push
DebugBox("strange Matrix-CMD");
//glMultMatrixf((GLfloat *)m);
mult_prj_matrix((GLfloat *)m);
break;
case 5: // projection mul nopush
//glMultMatrixf((GLfloat *)m);
mult_prj_matrix((GLfloat *)m);
break;
case 6: // projection load push
DebugBox("strange Matrix-CMD");
//glLoadMatrixf((GLfloat *)m);
load_prj_matrix((GLfloat *)m);
break;
case 7: // projection load nopush
//glLoadMatrixf((GLfloat *)m);
load_prj_matrix((GLfloat *)m);
break;
default:
break;
} /* switch(command) */
}
void rsp_uc04_moveword()
{
int i;
_u16 offset= (_u16)(CMD0 & 0xffff);
_u8 index= (_u8)(CMD0>>16)&0xff;
_u64 data=rdp_reg.cmd1;
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_MOVEWORD", ADDR, CMD0, CMD1);
#endif
switch(index)
{
case G_MW_MATRIX:
{
// do matrix pre-mult so it's re-updated next time
if (refresh_matrix)
update_cmbmatrix();
if (CMD0 & 0x20) // fractional part
{
float fpart;
int index_x = (CMD0 & 0x1F) >> 1;
int index_y = index_x >> 2;
index_x &= 3;
fpart = (CMD1>>16)/65536.0f;
cmb_mtrx[index_y][index_x] = (float)(int)cmb_mtrx[index_y][index_x];
cmb_mtrx[index_y][index_x] += fpart;
fpart = (CMD1&0xFFFF)/65536.0f;
cmb_mtrx[index_y][index_x+1] = (float)(int)cmb_mtrx[index_y][index_x+1];
cmb_mtrx[index_y][index_x+1] += fpart;
}
else
{
float fpart;
int index_x = (CMD0 & 0x1F) >> 1;
int index_y = index_x >> 2;
index_x &= 3;
fpart = (float)fabs(cmb_mtrx[index_y][index_x] - (int)cmb_mtrx[index_y][index_x]);
cmb_mtrx[index_y][index_x] = (short)(CMD1>>16);
fpart = (float)fabs(cmb_mtrx[index_y][index_x+1] - (int)cmb_mtrx[index_y][index_x+1]);
cmb_mtrx[index_y][index_x+1] = (short)(CMD1&0xFFFF);
}
}
break;
case G_MW_NUMLIGHT:
//rdp_reg.lights = (_u32)((data & 0xff) / 16 - 1);
rdp_reg.lights = (_u32)((data & 0xff) / 24);
if ((rdp_reg.lights < 0)||(rdp_reg.lights > 15)) rdp_reg.lights = 0;
rdp_reg.ambient_light = rdp_reg.lights;
break;
case G_MW_CLIP:
switch((rdp_reg.cmd0 >> 8) & 0xffff)
{
case 0x0004:
rdp_reg.clip.nx = rdp_reg.cmd1;
#ifdef LOG_ON
LOG_TO_FILE("\tClip nx=%08i", CMD1);
#endif
break;
case 0x000c:
rdp_reg.clip.ny = rdp_reg.cmd1;
#ifdef LOG_ON
LOG_TO_FILE("\tClip ny=%08i", CMD1);
#endif
break;
case 0x0014:
rdp_reg.clip.px = rdp_reg.cmd1;
#ifdef LOG_ON
LOG_TO_FILE("\tClip px=%08i", CMD1);
#endif
break;
case 0x001c:
rdp_reg.clip.py = rdp_reg.cmd1;
#ifdef LOG_ON
LOG_TO_FILE("\tClip py=%08i", CMD1);
#endif
break;
default:
break;
} /* switch((rdp_reg.cmd0 >> 8) & 0xffff) */
break;
case G_MW_SEGMENT:
#ifdef LOG_ON
LOG_TO_FILE("\tMOVEWORD SEGMENT: $%08lx -> seg#%d\n", CMD1, offset / 4);
#endif
rdp_reg.segment[offset >> 2] = CMD1 & 0xffffff;
break;
case G_MW_FOG:
{
float fo,fm,min,max,rng;
fm = (float)(_s16)((CMD1 & 0xffff0000)>> 16);
fo = (float)(_s16)((CMD1 & 0xffff));
rng = 128000.0f / fm;
min = 500.0f - ((fo * rng) / 256.0f);
max = rng + min;
rdp_reg.fog_fo = fo;
rdp_reg.fog_fm = fm;
#ifdef LOG_ON
LOG_TO_FILE("\tFog min = %f, max = %f",min,max);
#endif
}
break;
case G_MW_LIGHTCOL:
i = (rdp_reg.cmd0 & 0x0000e000) >> 13;
#ifdef LOG_ON
LOG_TO_FILE("\tLight = %i, Color = %08X", i, CMD1);
#endif
if(rdp_reg.cmd0 & 0x00000400)
{
rdp_reg.light[i].r = ((float)((rdp_reg.cmd1 >> 24) & 0xff))/255.0f;
rdp_reg.light[i].g = ((float)((rdp_reg.cmd1 >> 16) & 0xff))/255.0f;
rdp_reg.light[i].b = ((float)((rdp_reg.cmd1 >> 8) & 0xff))/255.0f;
rdp_reg.light[i].a = 1.0f;
}
else
{
rdp_reg.light[i].r_copy = ((float)((rdp_reg.cmd1 >> 24) & 0xff))/255.0f;
rdp_reg.light[i].g_copy = ((float)((rdp_reg.cmd1 >> 16) & 0xff))/255.0f;
rdp_reg.light[i].b_copy = ((float)((rdp_reg.cmd1 >> 8) & 0xff))/255.0f;
rdp_reg.light[i].a_copy = 1.0f;
}
break;
case G_MW_FORCEMTX:
#ifdef LOG_ON
LOG_TO_FILE("\tG_MW_FORCEMTX\n");
#endif
break;
case G_MW_PERSPNORM:
rdp_reg.perspnorm = (float)(rdp_reg.cmd1 & 0xFFFF) / 65535.0f;
#ifdef LOG_ON
LOG_TO_FILE("\tG_MW_PERSPNORM = %3.5f\n",rdp_reg.perspnorm);
#endif
break;
default:
;
} /* switch(rdp_reg.cmd0 & 0xff) */
}
void rsp_uc04_movemem()
{
_u32 param;
// int i;
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_MOVEMEM",ADDR, CMD0, CMD1);
#endif
param = (CMD0 & 0xff);
switch(param)
{
case G_MV_MMTX:
#ifdef LOG_ON
LOG_TO_FILE("\tMV_MMTX\n");
#endif
break;
case G_MV_PMTX:
#ifdef LOG_ON
LOG_TO_FILE("\tMV_PMTX\n");
#endif
break;
case G_MV_VIEWPORT:
{
int a = segoffset2addr(rdp_reg.cmd1) & 0x007fffff;
a >>= 1;
rdp_reg.vp[0] = ((float)((_s16 *)pRDRAM)[(a+0)^1]) / 4.0f;
rdp_reg.vp[1] = ((float)((_s16 *)pRDRAM)[(a+1)^1]) / 4.0f;
rdp_reg.vp[2] = ((float)((_s16 *)pRDRAM)[(a+2)^1]) / 4.0f;
rdp_reg.vp[3] = ((float)((_s16 *)pRDRAM)[(a+3)^1]) / 4.0f;
rdp_reg.vp[4] = ((float)((_s16 *)pRDRAM)[(a+4)^1]) / 4.0f;
rdp_reg.vp[5] = ((float)((_s16 *)pRDRAM)[(a+5)^1]) / 4.0f;
rdp_reg.vp[6] = ((float)((_s16 *)pRDRAM)[(a+6)^1]) / 4.0f;
rdp_reg.vp[7] = ((float)((_s16 *)pRDRAM)[(a+7)^1]) / 4.0f;
Render_viewport();
#ifdef LOG_ON
LOG_TO_FILE("\tViewPort");
LOG_TO_FILE("\t{%f,%f,%f,%f",rdp_reg.vp[0],rdp_reg.vp[1],rdp_reg.vp[2],rdp_reg.vp[3]);
LOG_TO_FILE("\t %f,%f,%f,%f}\n",rdp_reg.vp[4],rdp_reg.vp[5],rdp_reg.vp[6],rdp_reg.vp[7]);
#endif
}
break;
case G_MV_LIGHT:
{
int a = segoffset2addr(rdp_reg.cmd1) & 0x007fffff;
int i = ((CMD0 >> 5) & 0x3ff);
if (i < G_MVO_L0) break;
i = (i - G_MVO_L0) / 24;
if (1 > 15) break;
rdp_reg.light[i].r = ((float)((_u8 *)pRDRAM)[(a+ 0)^3])/255.0f;
rdp_reg.light[i].g = ((float)((_u8 *)pRDRAM)[(a+ 1)^3])/255.0f;
rdp_reg.light[i].b = ((float)((_u8 *)pRDRAM)[(a+ 2)^3])/255.0f;
rdp_reg.light[i].a = 1.0f;
rdp_reg.light[i].r_copy = ((float)((_u8 *)pRDRAM)[(a+ 4)^3])/255.0f;
rdp_reg.light[i].g_copy = ((float)((_u8 *)pRDRAM)[(a+ 5)^3])/255.0f;
rdp_reg.light[i].b_copy = ((float)((_u8 *)pRDRAM)[(a+ 6)^3])/255.0f;
rdp_reg.light[i].a_copy = 1.0f;
if (((((_u8 *)pRDRAM)[(a+ 0)]) == 0x08) && ((((_u8 *)pRDRAM)[(a+ 4)]) == 0xff) && USE_MM_HACK)
{
rdp_reg.light[i].x = (float)(int)doReadMemHalfWord(a + 8);//((float)((_s8 *)pRDRAM)[(a+ 8)^3])/127.0f;doReadMemHalfWord();
rdp_reg.light[i].y = (float)(int)doReadMemHalfWord(a + 10);//((float)((_s8 *)pRDRAM)[(a+ 9)^3])/127.0f;
rdp_reg.light[i].z = (float)(int)doReadMemHalfWord(a + 12);//((float)((_s8 *)pRDRAM)[(a+10)^3])/127.0f;
rdp_reg.light[i].w = (float)(int)doReadMemHalfWord(a + 14);//1.0f;
}
else
{
rdp_reg.light[i].x = ((float)((_s8 *)pRDRAM)[(a+ 8)^3])/127.0f;
rdp_reg.light[i].y = ((float)((_s8 *)pRDRAM)[(a+ 9)^3])/127.0f;
rdp_reg.light[i].z = ((float)((_s8 *)pRDRAM)[(a+10)^3])/127.0f;
rdp_reg.light[i].w = 1.0f;
}
refresh_lights = TRUE;
#ifdef LOG_ON
LOG_TO_FILE("\tLight[%i]",i);
LOG_TO_FILE("\tRed = %f, Green = %f, Blue = %f, Alpha = %f",
rdp_reg.light[i].r,
rdp_reg.light[i].g,
rdp_reg.light[i].b,
rdp_reg.light[i].a);
LOG_TO_FILE("\tx = %f, y = %f, z = %f\n",
rdp_reg.light[i].x,
rdp_reg.light[i].y,
rdp_reg.light[i].z);
#endif
}
break;
case G_MV_POINT:
#ifdef LOG_ON
LOG_TO_FILE("\tG_MV_POINT\n");
#endif
break;
case G_MV_MATRIX:
#ifdef LOG_ON
LOG_TO_FILE("\tMV_MATRIX\n");
#endif
{
_u32 a = segoffset2addr(CMD1);
refresh_matrix = FALSE;
hleGetMatrix((float*)&cmb_mtrx[0,0], &pRDRAM[a]);
}
break;
case G_MVO_LOOKATX:
break;
case G_MVO_LOOKATY:
break;
case G_MVO_L0:
case G_MVO_L1:
case G_MVO_L2:
case G_MVO_L3:
case G_MVO_L4:
case G_MVO_L5:
case G_MVO_L6:
case G_MVO_L7:
break;
default:
//DebugBox("unknow MoveMem %04x", param);
break;
} /* switch((rdp_reg.cmd0 >> 8) & 0xffff) */
}
void rsp_uc04_displaylist()
{
_u32 addr = segoffset2addr(CMD1);
_u8 push = (_u8)(CMD0 >> 16) & 0xff;
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_DISPLAYLIST",ADDR, CMD0, CMD1);
LOG_TO_FILE("\tAddress = %08x %s\n",addr, (push)?", Branch":", Push");
#endif
switch(push)
{
case 0: // push: we do a call of the dl
rdp_reg.pc_i++;
if(rdp_reg.pc_i > RDP_STACK_SIZE-1)
{
DebugBox("DList Stack overflow");
return;
}
rdp_reg.pc[rdp_reg.pc_i] = addr;
break;
case 1: // branch
rdp_reg.pc[rdp_reg.pc_i] = addr;
break;
default:
DebugBox("Unknow DList command");
break;
} // switch(push)
}
void rsp_uc04_enddl()
{
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_END_DISPLAYLIST\n",ADDR, CMD0, CMD1);
#endif
if(rdp_reg.pc_i < 0)
{
DebugBox("EndDL - Display Stack underrun");
rdp_reg.halt = 1;
return;
}
if(rdp_reg.pc_i == 0)
{
rdp_reg.halt = 1;
}
rdp_reg.pc_i--;
}
void rsp_uc04_enddisplaylist()
{
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_END_DISPLAYLIST?\n",ADDR, CMD0, CMD1);
#endif
rdp_reg.halt = 1;
return;
}
void rsp_uc04_rdphalf_1()
{
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_END_RDP_HALF_1\n",ADDR, CMD0, CMD1);
#endif
bzaddr = segoffset2addr(rdp_reg.cmd1);
}
void rsp_uc04_setothermode_l()
{
static char *ac[] = { "none", "threshold", "?", "diter" };
static char *zs[] = { "pixel", "prim" };
static char *a1[] =
{
" bl_1ma (1)",
" bl_a_mem (1)",
" bl_1 (1)",
" bl_0 (1)"
};
static char *b1[] =
{
" bl_clr_in (1)",
" bl_clr_mem (1)",
" bl_clr_bl (1)",
" bl_clr_fog (1)"
};
static char *c1[] =
{
" bl_a_in (1)",
" bl_a_fog (1)",
" bl_a_shade (1)",
" bl_0 (1)"
};
static char *d1[] =
{
" bl_1ma (1)",
" bl_a_mem (1)",
" bl_1 (1)",
" bl_0 (1)"
};
static char *a2[] =
{
" bl_1ma (2)",
" bl_a_mem (2)",
" bl_1 (2)",
" bl_0 (2)"
};
static char *b2[] =
{
" bl_clr_in (2)",
" bl_clr_mem (2)",
" bl_clr_bl (2)",
" bl_clr_fog (2)"
};
static char *c2[] =
{
" bl_a_in (2)",
" bl_a_fog (2)",
" bl_a_shade (2)",
" bl_0 (2)"
};
static char *d2[] =
{
" bl_1ma (2)",
" bl_a_mem (2)",
" bl_1 (2)",
" bl_0 (2)"
};
int len = ((rdp_reg.cmd0) & 0xff) + 1;
int sft = 32 - ((rdp_reg.cmd0 >> 8) & 0xff) - len;
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_SETOTHERMODE_L ", ADDR, CMD0, CMD1);
#endif
switch (sft) //((rdp_reg.cmd0 >> 8) & 0xff)
{
case 0x00:
#ifdef LOG_ON
LOG_TO_FILE("\tALPHACOMPARE: %s\n", ac[(rdp_reg.cmd1>>0x00) & 0x3]);
#endif
rdp_reg.mode_l &= ~0x00000003;
rdp_reg.cmd1 &= 0x00000003;
rdp_reg.mode_l |= rdp_reg.cmd1;
break;
case 0x02:
#ifdef LOG_ON
LOG_TO_FILE("\tZSRCSEL: %s\n", zs[(rdp_reg.cmd1>>0x02) & 0x1]);
#endif
rdp_reg.mode_l &= ~0x00000004;
rdp_reg.cmd1 &= 0x00000004;
rdp_reg.mode_l |= rdp_reg.cmd1;
break;
case 0x03:
#ifdef LOG_ON
LOG_TO_FILE("\tRENDERMODE: ");
LOG_TO_FILE(""
"%s"
"%s"
"%s"
"%s"
"%s"
"%s"
"%s"
"%s"
"%s"
"%s"
"%s"
"%s"
"%s"
"%s\n"
"%s\n"
"%s\n"
"%s\n"
"%s\n"
"%s\n"
"%s\n"
"%s\n",
(rdp_reg.cmd1 & 0x00000008) ? "\tanti alias on\n" : "\tanti alias off\n",
(rdp_reg.cmd1 & 0x00000010) ? "\tz_cmp on\n" : "\tz_cmp off\n",
(rdp_reg.cmd1 & 0x00000020) ? "\tz_upd on\n" : "\tz_upd off\n",
(rdp_reg.cmd1 & 0x00000040) ? "\tim_rd on\n" : "\tim_rd off\n",
(rdp_reg.cmd1 & 0x00000080) ? "\tclr_on_cvg on\n" : "\tclr_on_cvg off\n",
(rdp_reg.cmd1 & 0x00000100) ? "\tcvg_dst_warp on\n" : "\tcvg_dst_warp off\n",
(rdp_reg.cmd1 & 0x00000200) ? "\tcvg_dst_full on\n" : "\tcvg_dst_full off\n",
(rdp_reg.cmd1 & 0x00000400) ? "\tz_inter on\n" : "\tz_inter off\n",
(rdp_reg.cmd1 & 0x00000800) ? "\tz_xlu on\n" : "\tz_xlu off\n",
(rdp_reg.cmd1 & 0x00001000) ? "\tcvg_x_alpha on\n" : "\tcvg_x_alpha off\n",
(rdp_reg.cmd1 & 0x00002000) ? "\talpha_cvg_sel on\n" : "\talpha_cvg_sel off\n",
(rdp_reg.cmd1 & 0x00004000) ? "\tforce_bl on\n" : "\tforce_bl off\n",
(rdp_reg.cmd1 & 0x00008000) ? "\ttex_edge? on\n" : "\ttex_edge? off\n",
a2[(rdp_reg.cmd1>>16) & 0x3],
a1[(rdp_reg.cmd1>>18) & 0x3],
b2[(rdp_reg.cmd1>>20) & 0x3],
b1[(rdp_reg.cmd1>>22) & 0x3],
c2[(rdp_reg.cmd1>>24) & 0x3],
c1[(rdp_reg.cmd1>>26) & 0x3],
d2[(rdp_reg.cmd1>>28) & 0x3],
d1[(rdp_reg.cmd1>>30) & 0x3]
);
#endif
rdp_reg.mode_l &= ~0xfffffff8;
rdp_reg.cmd1 &= 0xfffffff8;
rdp_reg.mode_l |= rdp_reg.cmd1;
break;
case 0x10:
rdp_reg.mode_l &= ~0xffff0000;
rdp_reg.cmd1 &= 0xffff0000;
rdp_reg.mode_l |= rdp_reg.cmd1;
#ifdef LOG_ON
LOG_TO_FILE("\tBLENDER: ");
LOG_TO_FILE(""
"%s\n"
"%s\n"
"%s\n"
"%s\n"
"%s\n"
"%s\n"
"%s\n"
"%s\n",
a2[(rdp_reg.cmd1>>16) & 0x3],
a1[(rdp_reg.cmd1>>18) & 0x3],
b2[(rdp_reg.cmd1>>20) & 0x3],
b1[(rdp_reg.cmd1>>22) & 0x3],
c2[(rdp_reg.cmd1>>24) & 0x3],
c1[(rdp_reg.cmd1>>26) & 0x3],
d2[(rdp_reg.cmd1>>28) & 0x3],
d1[(rdp_reg.cmd1>>30) & 0x3]
);
#endif
break;
default:
//PRINT_RDP("SETOTHERMODE_L ?\n");
;
} /* switch((rdp_reg.cmd0 >> 8) & 0xff) */
if(rdp_reg.mode_l & 0x00000010)
Render_geometry_zbuffer(1);
else
Render_geometry_zbuffer(0);
if ((rdp_reg.mode_l & 0x0c00) != 0xc00) glDepthRange(-1,1.);
else glDepthRange(-1,0.9995);
if (rdp_reg.mode_l & 0x00000020)
Render_geometry_zwrite(1);
else
Render_geometry_zwrite(0);
/*
switch (rdp_reg.mode_l & 0x00000003)
{
case 0:
Src_Alpha = GL_ONE;
Dst_Alpha = GL_ZERO;
break;
case 1:
case 2:
case 3:
Src_Alpha = GL_SRC_ALPHA;
Dst_Alpha = GL_ONE_MINUS_SRC_ALPHA;
break;
}
*/
/*
// if ((rdp_reg.mode_l & 0x0f0f0000) != 0x50000)
if ((rdp_reg.mode_l & 0x0f000000) != 0x0)
{
Src_Alpha = GL_SRC_ALPHA;
Dst_Alpha = GL_ONE_MINUS_SRC_ALPHA;
}
else
{
// Src_Alpha = GL_ONE;
// Dst_Alpha = GL_ZERO;
}
*/
}
void rsp_uc04_setothermode_h()
{
static char *ad[] = { "pattern", "notpattern", "noise", "disable" };
static char *rd[] = { "magicsq", "bayer", "noise", "?" };
static char *ck[] = { "none", "key" };
static char *tc[] = { "conv", "?", "?", "?", "?", "filtconv", "filt", "?" };
static char *tf[] = { "point", "?", "bilerp", "average" };
static char *tt[] = { "none", "?", "rgba16", "ia16" };
static char *tl[] = { "tile", "lod" };
static char *td[] = { "clamp", "sharpen", "detail", "?" };
static char *tp[] = { "none", "persp" };
static char *ct[] = { "1cycle", "2cycle", "copy", "fill" };
static char *cd[] = { "disable(hw>1)", "enable(hw>1)", "disable(hw1)", "enable(hw1)" };
static char *pm[] = { "nprimitive", "1primitive" };
int len = (rdp_reg.cmd0 & 0xff) +1;
int sft = 32 - ((rdp_reg.cmd0 >> 8) & 0xff) - len;
// switch((rdp_reg.cmd0 >> 8) & 0xff)
#ifdef LOG_ON
LOG_TO_FILE("%08X: %08X %08X CMD UC4_SETOTHERMODE_H\n",ADDR, CMD0, CMD1);
#endif
switch(sft)
{
case 0x00:
#ifdef LOG_ON
LOG_TO_FILE("\tBLENDMASK - ignored\n");
#endif
break;
case 0x04:
rdp_reg.mode_h &= ~0x00000030;
rdp_reg.cmd1 &= 0x00000030;
rdp_reg.mode_h |= rdp_reg.cmd1;
#ifdef LOG_ON
LOG_TO_FILE("\tALPHADITHER: %s\n", ad[(rdp_reg.cmd1>>0x04) & 0x3]);
#endif
break;
case 0x06:
rdp_reg.mode_h &= ~0x000000c0;
rdp_reg.cmd1 &= 0x000000c0;
rdp_reg.mode_h |= rdp_reg.cmd1;
#ifdef LOG_ON
LOG_TO_FILE("\tRGBDITHER: %s\n", rd[(rdp_reg.cmd1>>0x06) & 0x3]);
#endif
break;
case 0x08:
rdp_reg.mode_h &= ~0x00000100;
rdp_reg.cmd1 &= 0x00000100;
rdp_reg.mode_h |= rdp_reg.cmd1;
#ifdef LOG_ON
LOG_TO_FILE("\tCOMBINEKEY: %s\n", ck[(rdp_reg.cmd1>>0x08) & 0x1]);
#endif
break;
case 0x09:
#ifdef LOG_ON
LOG_TO_FILE("\tTEXTURECONVERT: %s\n", tc[(rdp_reg.cmd1>>0x09) & 0x7]);
#endif
rdp_reg.mode_h &= ~0x00000e00;
rdp_reg.cmd1 &= 0x00000e00;
rdp_reg.mode_h |= rdp_reg.cmd1;
break;
case 0x0c:
rdp_reg.mode_h &= ~0x00003000;
rdp_reg.cmd1 &= 0x00003000;
rdp_reg.mode_h |= rdp_reg.cmd1;
#ifdef LOG_ON
LOG_TO_FILE("\tTEXTUREFILTER: %s\n", tf[(rdp_reg.cmd1>>0x0c) & 0x3]);
#endif
break;
case 0x0e:
rdp_reg.mode_h &= ~0x0000c000;
rdp_reg.cmd1 &= 0x0000c000;
rdp_reg.mode_h |= rdp_reg.cmd1;
#ifdef LOG_ON
LOG_TO_FILE("\tTEXTURELUT: %s\n", tt[(rdp_reg.cmd1>>0x0e) & 0x3]);
#endif
break;
case 0x10:
rdp_reg.mode_h &= ~0x00010000;
rdp_reg.cmd1 &= 0x00010000;
rdp_reg.mode_h |= rdp_reg.cmd1;
#ifdef LOG_ON
LOG_TO_FILE("\tTEXTURELOD: %s\n", tl[(rdp_reg.cmd1>>0x10) & 0x1]);
#endif
break;
case 0x11:
rdp_reg.mode_h &= ~0x00060000;
rdp_reg.cmd1 &= 0x00060000;
rdp_reg.mode_h |= rdp_reg.cmd1;
#ifdef LOG_ON
LOG_TO_FILE("\tTEXTUREDETAIL: %s\n", td[(rdp_reg.cmd1>>0x11) & 0x3]);
#endif
break;
case 0x13:
rdp_reg.mode_h &= ~0x00080000;
rdp_reg.cmd1 &= 0x00080000;
rdp_reg.mode_h |= rdp_reg.cmd1;
#ifdef LOG_ON
LOG_TO_FILE("\tTEXTUREPERSP: %s\n", tp[(rdp_reg.cmd1>>0x13) & 0x1]);
#endif
break;
case 0x14:
cycle_mode = (_u8)((rdp_reg.cmd1>>0x14) & 0x3);
rdp_reg.mode_h &= ~0x00300000;
rdp_reg.cmd1 &= 0x00300000;
rdp_reg.mode_h |= rdp_reg.cmd1;
#ifdef LOG_ON
LOG_TO_FILE("\tCYCLETYPE: %s\n", ct[(rdp_reg.cmd1>>0x14) & 0x3]);
#endif
break;
case 0x16:
rdp_reg.mode_h &= ~0x00400000;
rdp_reg.cmd1 &= 0x00400000;
rdp_reg.mode_h |= rdp_reg.cmd1;
#ifdef LOG_ON
LOG_TO_FILE("\tCOLORDITHER: %s\n", cd[(rdp_reg.cmd1>>0x16) & 0x1]);
#endif
break;
case 0x17:
rdp_reg.mode_h &= ~0x00800000;
rdp_reg.cmd1 &= 0x00800000;
rdp_reg.mode_h |= rdp_reg.cmd1;
#ifdef LOG_ON
LOG_TO_FILE("\tPIPELINEMODE: %s\n", pm[(rdp_reg.cmd1>>0x17) & 0x1]);
#endif
break;
default:
#ifdef LOG_ON
LOG_TO_FILE("\tUNDEFINED\n");
#endif
break;
} /* switch((rdp_reg.cmd0 >> 8) & 0xff) */
}
Reference in a new issue View git blame Copy permalink