ShuriZma
/
desmume
mirror of https://github.com/TASEmulators/desmume.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

convert heart of geometry engine to fixed point. some things will be broken but it is hopefully only one cause which we'll fix when we find it. but then again, maybe i broke everything.

This commit is contained in:
zeromus 2010-06-13 03:20:14 +00:00
parent 8fd20b6b3b
commit 24bff13260
4 changed files with 252 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

228
desmume/src/gfx3d.cpp
View File

@ -337,8 +337,8 @@ CACHE_ALIGN MatrixStack mtxStack[4] = {
int _hack_getMatrixStackLevel(int which) { return mtxStack[which].position; } int _hack_getMatrixStackLevel(int which) { return mtxStack[which].position; }
static CACHE_ALIGN float mtxCurrent [4][16]; static CACHE_ALIGN s32 mtxCurrent [4][16];
static CACHE_ALIGN float mtxTemporal[16]; static CACHE_ALIGN s32 mtxTemporal[16];
static u32 mode = 0; static u32 mode = 0;
// Indexes for matrix loading/multiplication // Indexes for matrix loading/multiplication
@ -349,21 +349,21 @@ static u8 MM4x3ind = 0;
static u8 MM3x3ind = 0; static u8 MM3x3ind = 0;
// Data for vertex submission // Data for vertex submission
static CACHE_ALIGN u16 u16coord[4] = {0, 0, 0, 0}; static CACHE_ALIGN s16 s16coord[4] = {0, 0, 0, 0};
static char coordind = 0; static char coordind = 0;
static u32 vtxFormat = 0; static u32 vtxFormat = 0;
static BOOL inBegin = FALSE; static BOOL inBegin = FALSE;
// Data for basic transforms // Data for basic transforms
static CACHE_ALIGN float trans[4] = {0.0, 0.0, 0.0, 0.0}; static CACHE_ALIGN s32 trans[4] = {0, 0, 0, 0};
static int transind = 0; static int transind = 0;
static CACHE_ALIGN float scale[4] = {0.0, 0.0, 0.0, 0.0}; static CACHE_ALIGN s32 scale[4] = {0, 0, 0, 0};
static int scaleind = 0; static int scaleind = 0;
static u32 viewport = 0; static u32 viewport = 0;
//various other registers //various other registers
static float _t=0, _s=0; static s32 _t=0, _s=0;
static float last_t, last_s; static s32 last_t, last_s;
static u32 clCmd = 0; static u32 clCmd = 0;
static u32 clInd = 0; static u32 clInd = 0;
@ -527,7 +527,7 @@ void gfx3d_reset()
texturePalette = 0; texturePalette = 0;
polyAttrPending = 0; polyAttrPending = 0;
mode = 0; mode = 0;
u16coord[0] = u16coord[1] = u16coord[2] = u16coord[3] = 0; s16coord[0] = s16coord[1] = s16coord[2] = s16coord[3] = 0;
coordind = 0; coordind = 0;
vtxFormat = 0; vtxFormat = 0;
memset(trans, 0, sizeof(trans)); memset(trans, 0, sizeof(trans));
@ -592,22 +592,25 @@ void gfx3d_reset()
//Submit a vertex to the GE //Submit a vertex to the GE
static void SetVertex() static void SetVertex()
{ {
float coord[3] = { s32 coord[3] = {
float16table[u16coord[0]], s16coord[0],
float16table[u16coord[1]], s16coord[1],
float16table[u16coord[2]] s16coord[2]
}; };
ALIGN(16) float coordTransformed[4] = { coord[0], coord[1], coord[2], 1.f }; ALIGN(16) s32 coordTransformed[4] = { coord[0], coord[1], coord[2], (1<<12) };
if (texCoordinateTransform == 3) if (texCoordinateTransform == 3)
{ {
//UNTESTED since fixed point conversion, and almost certainly wrong.
last_s =((coord[0]*mtxCurrent[3][0] + last_s =((coord[0]*mtxCurrent[3][0] +
coord[1]*mtxCurrent[3][4] + coord[1]*mtxCurrent[3][4] +
coord[2]*mtxCurrent[3][8]) + _s * 16.0f) / 16.0f; coord[2]*mtxCurrent[3][8]) + _s * 16.0f) / 16.0f;
last_t =((coord[0]*mtxCurrent[3][1] + last_t =((coord[0]*mtxCurrent[3][1] +
coord[1]*mtxCurrent[3][5] + coord[1]*mtxCurrent[3][5] +
coord[2]*mtxCurrent[3][9]) + _t * 16.0f) / 16.0f; coord[2]*mtxCurrent[3][9]) + _t * 16.0f) / 16.0f;
last_s /= 4096.0f;
last_t /= 4096.0f;
} }
@ -624,6 +627,10 @@ static void SetVertex()
//when we need to) //when we need to)
MatrixMultVec4x4_M2(mtxCurrent[0], coordTransformed); MatrixMultVec4x4_M2(mtxCurrent[0], coordTransformed);
//printf("%f %f %f\n",s16coord[0]/4096.0f,s16coord[1]/4096.0f,s16coord[2]/4096.0f);
//printf("x %f %f %f %f\n",mtxCurrent[0][0]/4096.0f,mtxCurrent[0][1]/4096.0f,mtxCurrent[0][2]/4096.0f,mtxCurrent[0][3]/4096.0f);
//printf(" = %f %f %f %f\n",coordTransformed[0]/4096.0f,coordTransformed[1]/4096.0f,coordTransformed[2]/4096.0f,coordTransformed[3]/4096.0f);
//TODO - culling should be done here. //TODO - culling should be done here.
//TODO - viewport transform? //TODO - viewport transform?
@ -653,12 +660,12 @@ static void SetVertex()
// //MatrixPrint(mtxCurrent[1]); // //MatrixPrint(mtxCurrent[1]);
//} //}
vert.texcoord[0] = last_s; vert.texcoord[0] = last_s/16.0f;
vert.texcoord[1] = last_t; vert.texcoord[1] = last_t/16.0f;
vert.coord[0] = coordTransformed[0]; vert.coord[0] = coordTransformed[0]/4096.0f;
vert.coord[1] = coordTransformed[1]; vert.coord[1] = coordTransformed[1]/4096.0f;
vert.coord[2] = coordTransformed[2]; vert.coord[2] = coordTransformed[2]/4096.0f;
vert.coord[3] = coordTransformed[3]; vert.coord[3] = coordTransformed[3]/4096.0f;
vert.color[0] = GFX3D_5TO6(colorRGB[0]); vert.color[0] = GFX3D_5TO6(colorRGB[0]);
vert.color[1] = GFX3D_5TO6(colorRGB[1]); vert.color[1] = GFX3D_5TO6(colorRGB[1]);
vert.color[2] = GFX3D_5TO6(colorRGB[2]); vert.color[2] = GFX3D_5TO6(colorRGB[2]);
@ -778,7 +785,8 @@ static void gfx3d_glLightDirection_cache(int index)
cacheLightDirection[index][3] = 0; cacheLightDirection[index][3] = 0;
/* Multiply the vector by the directional matrix */ /* Multiply the vector by the directional matrix */
MatrixMultVec3x3(mtxCurrent[2], cacheLightDirection[index]); CACHE_ALIGN float temp[16] = {mtxCurrent[2][0]/4096.0f,mtxCurrent[2][1]/4096.0f,mtxCurrent[2][2]/4096.0f,mtxCurrent[2][3]/4096.0f,mtxCurrent[2][4]/4096.0f,mtxCurrent[2][5]/4096.0f,mtxCurrent[2][6]/4096.0f,mtxCurrent[2][7]/4096.0f,mtxCurrent[2][8]/4096.0f,mtxCurrent[2][9]/4096.0f,mtxCurrent[2][10]/4096.0f,mtxCurrent[2][11]/4096.0f,mtxCurrent[2][12]/4096.0f,mtxCurrent[2][13]/4096.0f,mtxCurrent[2][14]/4096.0f,mtxCurrent[2][15]/4096.0f};
MatrixMultVec3x3(temp, cacheLightDirection[index]);
/* Calculate the half vector */ /* Calculate the half vector */
float lineOfSight[4] = {0.0f, 0.0f, -1.0f, 0.0f}; float lineOfSight[4] = {0.0f, 0.0f, -1.0f, 0.0f};
@ -824,12 +832,12 @@ static void gfx3d_glPopMatrix(s32 i)
//this was necessary to fix sims apartment pets //this was necessary to fix sims apartment pets
//i = (i<<26)>>26; //i = (i<<26)>>26;
MatrixStackPopMatrix((float*)mtxCurrent[mymode], &mtxStack[mymode], i); MatrixStackPopMatrix(mtxCurrent[mymode], &mtxStack[mymode], i);
GFX_DELAY(36); GFX_DELAY(36);
if (mymode == 2) if (mymode == 2)
MatrixStackPopMatrix((float*)mtxCurrent[1], &mtxStack[1], i); MatrixStackPopMatrix(mtxCurrent[1], &mtxStack[1], i);
MMU_new.gxstat.sb = 1; // set busy MMU_new.gxstat.sb = 1; // set busy
} }
@ -891,7 +899,7 @@ static void gfx3d_glLoadIdentity()
static BOOL gfx3d_glLoadMatrix4x4(s32 v) static BOOL gfx3d_glLoadMatrix4x4(s32 v)
{ {
mtxCurrent[mode][ML4x4ind] = (float)((v<<4)>>4); mtxCurrent[mode][ML4x4ind] = v;
++ML4x4ind; ++ML4x4ind;
if(ML4x4ind<16) return FALSE; if(ML4x4ind<16) return FALSE;
@ -899,7 +907,7 @@ static BOOL gfx3d_glLoadMatrix4x4(s32 v)
GFX_DELAY(19); GFX_DELAY(19);
vector_fix2float<4>(mtxCurrent[mode], 4096.f); //vector_fix2float<4>(mtxCurrent[mode], 4096.f);
if (mode == 2) if (mode == 2)
MatrixCopy (mtxCurrent[1], mtxCurrent[2]); MatrixCopy (mtxCurrent[1], mtxCurrent[2]);
@ -910,18 +918,18 @@ static BOOL gfx3d_glLoadMatrix4x4(s32 v)
static BOOL gfx3d_glLoadMatrix4x3(s32 v) static BOOL gfx3d_glLoadMatrix4x3(s32 v)
{ {
mtxCurrent[mode][ML4x3ind] = (float)((v<<4)>>4); mtxCurrent[mode][ML4x3ind] = v;
ML4x3ind++; ML4x3ind++;
if((ML4x3ind & 0x03) == 3) ML4x3ind++; if((ML4x3ind & 0x03) == 3) ML4x3ind++;
if(ML4x3ind<16) return FALSE; if(ML4x3ind<16) return FALSE;
ML4x3ind = 0; ML4x3ind = 0;
vector_fix2float<4>(mtxCurrent[mode], 4096.f); //vector_fix2float<4>(mtxCurrent[mode], 4096.f);
//fill in the unusued matrix values //fill in the unusued matrix values
mtxCurrent[mode][3] = mtxCurrent[mode][7] = mtxCurrent[mode][11] = 0.f; mtxCurrent[mode][3] = mtxCurrent[mode][7] = mtxCurrent[mode][11] = 0;
mtxCurrent[mode][15] = 1.f; mtxCurrent[mode][15] = (1<<12);
GFX_DELAY(30); GFX_DELAY(30);
@ -933,7 +941,7 @@ static BOOL gfx3d_glLoadMatrix4x3(s32 v)
static BOOL gfx3d_glMultMatrix4x4(s32 v) static BOOL gfx3d_glMultMatrix4x4(s32 v)
{ {
mtxTemporal[MM4x4ind] = (float)((v<<4)>>4); mtxTemporal[MM4x4ind] = v;
MM4x4ind++; MM4x4ind++;
if(MM4x4ind<16) return FALSE; if(MM4x4ind<16) return FALSE;
@ -941,7 +949,7 @@ static BOOL gfx3d_glMultMatrix4x4(s32 v)
GFX_DELAY(35); GFX_DELAY(35);
vector_fix2float<4>(mtxTemporal, 4096.f); //vector_fix2float<4>(mtxTemporal, 4096.f);
MatrixMultiply (mtxCurrent[mode], mtxTemporal); MatrixMultiply (mtxCurrent[mode], mtxTemporal);
@ -959,7 +967,7 @@ static BOOL gfx3d_glMultMatrix4x4(s32 v)
static BOOL gfx3d_glMultMatrix4x3(s32 v) static BOOL gfx3d_glMultMatrix4x3(s32 v)
{ {
mtxTemporal[MM4x3ind] = (float)((v<<4)>>4); mtxTemporal[MM4x3ind] = v;
MM4x3ind++; MM4x3ind++;
if((MM4x3ind & 0x03) == 3) MM4x3ind++; if((MM4x3ind & 0x03) == 3) MM4x3ind++;
@ -968,11 +976,11 @@ static BOOL gfx3d_glMultMatrix4x3(s32 v)
GFX_DELAY(31); GFX_DELAY(31);
vector_fix2float<4>(mtxTemporal, 4096.f); //vector_fix2float<4>(mtxTemporal, 4096.f);
//fill in the unusued matrix values //fill in the unusued matrix values
mtxTemporal[3] = mtxTemporal[7] = mtxTemporal[11] = 0.f; mtxTemporal[3] = mtxTemporal[7] = mtxTemporal[11] = 0;
mtxTemporal[15] = 1.f; mtxTemporal[15] = 1<<12;
MatrixMultiply (mtxCurrent[mode], mtxTemporal); MatrixMultiply (mtxCurrent[mode], mtxTemporal);
@ -991,7 +999,7 @@ static BOOL gfx3d_glMultMatrix4x3(s32 v)
static BOOL gfx3d_glMultMatrix3x3(s32 v) static BOOL gfx3d_glMultMatrix3x3(s32 v)
{ {
mtxTemporal[MM3x3ind] = (float)((v<<4)>>4); mtxTemporal[MM3x3ind] = v;
MM3x3ind++; MM3x3ind++;
@ -1001,11 +1009,11 @@ static BOOL gfx3d_glMultMatrix3x3(s32 v)
GFX_DELAY(28); GFX_DELAY(28);
vector_fix2float<3>(mtxTemporal, 4096.f); //vector_fix2float<3>(mtxTemporal, 4096.f);
//fill in the unusued matrix values //fill in the unusued matrix values
mtxTemporal[3] = mtxTemporal[7] = mtxTemporal[11] = 0; mtxTemporal[3] = mtxTemporal[7] = mtxTemporal[11] = 0;
mtxTemporal[15] = 1; mtxTemporal[15] = 1<<12;
mtxTemporal[12] = mtxTemporal[13] = mtxTemporal[14] = 0; mtxTemporal[12] = mtxTemporal[13] = mtxTemporal[14] = 0;
MatrixMultiply (mtxCurrent[mode], mtxTemporal); MatrixMultiply (mtxCurrent[mode], mtxTemporal);
@ -1026,7 +1034,7 @@ static BOOL gfx3d_glMultMatrix3x3(s32 v)
static BOOL gfx3d_glScale(s32 v) static BOOL gfx3d_glScale(s32 v)
{ {
scale[scaleind] = fix2float(v); scale[scaleind] = v;
++scaleind; ++scaleind;
@ -1048,7 +1056,7 @@ static BOOL gfx3d_glScale(s32 v)
static BOOL gfx3d_glTranslate(s32 v) static BOOL gfx3d_glTranslate(s32 v)
{ {
trans[transind] = fix2float(v); trans[transind] = v;
++transind; ++transind;
@ -1078,24 +1086,25 @@ static void gfx3d_glColor3b(u32 v)
GFX_DELAY(1); GFX_DELAY(1);
} }
static void gfx3d_glNormal(u32 v) static void gfx3d_glNormal(s32 v)
{ {
int i,c; s16 nx = ((v<<22)>>22)<<3;
ALIGN(16) float normal[4] = { normalTable[v&1023], s16 ny = ((v<<12)>>22)<<3;
normalTable[(v>>10)&1023], s16 nz = ((v<<2)>>22)<<3;
normalTable[(v>>20)&1023],
1};
if (texCoordinateTransform == 2) if (texCoordinateTransform == 2)
{ {
last_s =( (normal[0] *mtxCurrent[3][0] + normal[1] *mtxCurrent[3][4] + //SM64 highlight rendered star in main menu tests this
normal[2] *mtxCurrent[3][8]) + (_s*16.0f)) / 16.0f; last_s = (s32)(((s64)nx * mtxCurrent[3][0] + (s64)ny * mtxCurrent[3][4] + (s64)nz * mtxCurrent[3][8] + (_s<<24))>>24);
last_t =( (normal[0] *mtxCurrent[3][1] + normal[1] *mtxCurrent[3][5] + last_t = (s32)(((s64)nx * mtxCurrent[3][1] + (s64)ny * mtxCurrent[3][5] + (s64)nz * mtxCurrent[3][9] + (_t<<24))>>24);
normal[2] *mtxCurrent[3][9]) + (_t*16.0f)) / 16.0f;
} }
CACHE_ALIGN float normal[4] = { nx/4096.0f, ny/4096.0f, nz/4096.0f, 1.0f };
//use the current normal transform matrix //use the current normal transform matrix
MatrixMultVec3x3 (mtxCurrent[2], normal); CACHE_ALIGN float temp[16] = {mtxCurrent[2][0]/4096.0f,mtxCurrent[2][1]/4096.0f,mtxCurrent[2][2]/4096.0f,mtxCurrent[2][3]/4096.0f,mtxCurrent[2][4]/4096.0f,mtxCurrent[2][5]/4096.0f,mtxCurrent[2][6]/4096.0f,mtxCurrent[2][7]/4096.0f,mtxCurrent[2][8]/4096.0f,mtxCurrent[2][9]/4096.0f,mtxCurrent[2][10]/4096.0f,mtxCurrent[2][11]/4096.0f,mtxCurrent[2][12]/4096.0f,mtxCurrent[2][13]/4096.0f,mtxCurrent[2][14]/4096.0f,mtxCurrent[2][15]/4096.0f};
MatrixMultVec3x3 (temp, normal);
//apply lighting model //apply lighting model
{ {
@ -1121,7 +1130,7 @@ static void gfx3d_glNormal(u32 v)
int vertexColor[3] = { emission[0], emission[1], emission[2] }; int vertexColor[3] = { emission[0], emission[1], emission[2] };
for(i=0; i<4; i++) for(int i=0; i<4; i++)
{ {
if(!((lightMask>>i)&1)) continue; if(!((lightMask>>i)&1)) continue;
@ -1154,7 +1163,7 @@ static void gfx3d_glNormal(u32 v)
shininessLevel = gfx3d.state.shininessTable[shininessIndex]; shininessLevel = gfx3d.state.shininessTable[shininessIndex];
} }
for(c = 0; c < 3; c++) for(int c = 0; c < 3; c++)
{ {
vertexColor[c] += (int)(((specular[c] * _lightColor[c] * shininessLevel) vertexColor[c] += (int)(((specular[c] * _lightColor[c] * shininessLevel)
+ (diffuse[c] * _lightColor[c] * diffuseLevel) + (diffuse[c] * _lightColor[c] * diffuseLevel)
@ -1162,7 +1171,7 @@ static void gfx3d_glNormal(u32 v)
} }
} }
for(c=0;c<3;c++) for(int c=0;c<3;c++)
colorRGB[c] = std::min(31,vertexColor[c]); colorRGB[c] = std::min(31,vertexColor[c]);
} }
@ -1173,22 +1182,18 @@ static void gfx3d_glNormal(u32 v)
GFX_DELAY_M2((lightMask>>3) & 0x01); GFX_DELAY_M2((lightMask>>3) & 0x01);
} }
static void gfx3d_glTexCoord(u32 val) static void gfx3d_glTexCoord(s32 val)
{ {
_t = (s16)(val>>16); _s = ((val<<16)>>16);
_s = (s16)(val&0xFFFF); _t = (val>>16);
_s /= 16.0f;
_t /= 16.0f;
if (texCoordinateTransform == 1) if (texCoordinateTransform == 1)
{ {
last_s =_s*mtxCurrent[3][0] + _t*mtxCurrent[3][4] + //dragon quest 4 overworld will test this
0.0625f*mtxCurrent[3][8] + 0.0625f*mtxCurrent[3][12]; last_s = (s32)(((s64)(_s<<12) * mtxCurrent[3][0] + (s64)(_t<<12) * mtxCurrent[3][4] + ((s64)mtxCurrent[3][8]<<12) + ((s64)mtxCurrent[3][12]<<12))>>24);
last_t =_s*mtxCurrent[3][1] + _t*mtxCurrent[3][5] + last_t = (s32)(((s64)(_s<<12) * mtxCurrent[3][1] + (s64)(_t<<12) * mtxCurrent[3][5] + ((s64)mtxCurrent[3][9]<<12) + ((s64)mtxCurrent[3][13]<<12))>>24);
0.0625f*mtxCurrent[3][9] + 0.0625f*mtxCurrent[3][13];
} }
else else if(texCoordinateTransform == 0)
{ {
last_s=_s; last_s=_s;
last_t=_t; last_t=_t;
@ -1196,21 +1201,18 @@ static void gfx3d_glTexCoord(u32 val)
GFX_DELAY(1); GFX_DELAY(1);
} }
static BOOL gfx3d_glVertex16b(unsigned int v) static BOOL gfx3d_glVertex16b(s32 v)
{ {
if(coordind==0) if(coordind==0)
{ {
//coord[0] = float16table[v&0xFFFF]; s16coord[0] = (v<<16)>>16;
//coord[1] = float16table[v>>16]; s16coord[1] = (v>>16)&0xFFFF;
u16coord[0] = v&0xFFFF;
u16coord[1] = (v>>16)&0xFFFF;
++coordind; ++coordind;
return FALSE; return FALSE;
} }
//coord[2] = float16table[v&0xFFFF]; s16coord[2] = (v<<16)>>16;
u16coord[2] = v&0xFFFF;
coordind = 0; coordind = 0;
SetVertex (); SetVertex ();
@ -1219,40 +1221,37 @@ static BOOL gfx3d_glVertex16b(unsigned int v)
return TRUE; return TRUE;
} }
static void gfx3d_glVertex10b(u32 v) static void gfx3d_glVertex10b(s32 v)
{ {
//coord[0] = float10Table[v&1023]; //TODO TODO TODO - contemplate the sign extension - shift in zeroes or ones? zeroes is certainly more normal..
//coord[1] = float10Table[(v>>10)&1023]; s16coord[0] = ((v<<22)>>22)<<6;
//coord[2] = float10Table[(v>>20)&1023]; s16coord[1] = ((v<<12)>>22)<<6;
u16coord[0] = (v&1023)<<6; s16coord[2] = ((v<<2)>>22)<<6;
u16coord[1] = ((v>>10)&1023)<<6;
u16coord[2] = ((v>>20)&1023)<<6;
GFX_DELAY(8); GFX_DELAY(8);
SetVertex (); SetVertex ();
} }
static void gfx3d_glVertex3_cord(unsigned int one, unsigned int two, unsigned int v) template<int ONE, int TWO>
static void gfx3d_glVertex3_cord(s32 v)
{ {
//coord[one] = float16table[v&0xffff]; s16coord[ONE] = (v<<16)>>16;
//coord[two] = float16table[v>>16]; s16coord[TWO] = (v>>16);
u16coord[one] = v&0xffff;
u16coord[two] = (v>>16)&0xFFFF;
SetVertex (); SetVertex ();
GFX_DELAY(8); GFX_DELAY(8);
} }
static void gfx3d_glVertex_rel(u32 v) static void gfx3d_glVertex_rel(s32 v)
{ {
//coord[0] += float10RelTable[v&1023]; s16 x = ((v<<22)>>22);
//coord[1] += float10RelTable[(v>>10)&1023]; s16 y = ((v<<12)>>22);
//coord[2] += float10RelTable[(v>>20)&1023]; s16 z = ((v<<2)>>22);
u16coord[0] += (u16)(((s16)((v&1023)<<6))>>6); s16coord[0] += x;
u16coord[1] += (u16)(((s16)(((v>>10)&1023)<<6))>>6); s16coord[1] += y;
u16coord[2] += (u16)(((s16)(((v>>20)&1023)<<6))>>6); s16coord[2] += z;
SetVertex (); SetVertex ();
@ -1377,6 +1376,7 @@ static void gfx3d_glViewPort(u32 v)
static BOOL gfx3d_glBoxTest(u32 v) static BOOL gfx3d_glBoxTest(u32 v)
{ {
printf("boxtest\n");
MMU_new.gxstat.tr = 0; // clear boxtest bit MMU_new.gxstat.tr = 0; // clear boxtest bit
MMU_new.gxstat.tb = 1; // busy MMU_new.gxstat.tb = 1; // busy
@ -1473,11 +1473,10 @@ static BOOL gfx3d_glBoxTest(u32 v)
for(int i=0;i<8;i++) { for(int i=0;i<8;i++) {
//MatrixMultVec4x4_M2(mtxCurrent[0], verts[i].coord); //MatrixMultVec4x4_M2(mtxCurrent[0], verts[i].coord);
//yuck.. cant use the sse2 accelerated ones because vert.coords is not cache aligned or something CACHE_ALIGN float temp1[16] = {mtxCurrent[1][0]/4096.0f,mtxCurrent[1][1]/4096.0f,mtxCurrent[1][2]/4096.0f,mtxCurrent[1][3]/4096.0f,mtxCurrent[1][4]/4096.0f,mtxCurrent[1][5]/4096.0f,mtxCurrent[1][6]/4096.0f,mtxCurrent[1][7]/4096.0f,mtxCurrent[1][8]/4096.0f,mtxCurrent[1][9]/4096.0f,mtxCurrent[1][10]/4096.0f,mtxCurrent[1][11]/4096.0f,mtxCurrent[1][12]/4096.0f,mtxCurrent[1][13]/4096.0f,mtxCurrent[1][14]/4096.0f,mtxCurrent[1][15]/4096.0f};
//i dunno CACHE_ALIGN float temp0[16] = {mtxCurrent[0][0]/4096.0f,mtxCurrent[0][1]/4096.0f,mtxCurrent[0][2]/4096.0f,mtxCurrent[0][3]/4096.0f,mtxCurrent[0][4]/4096.0f,mtxCurrent[0][5]/4096.0f,mtxCurrent[0][6]/4096.0f,mtxCurrent[0][7]/4096.0f,mtxCurrent[0][8]/4096.0f,mtxCurrent[0][9]/4096.0f,mtxCurrent[0][10]/4096.0f,mtxCurrent[0][11]/4096.0f,mtxCurrent[0][12]/4096.0f,mtxCurrent[0][13]/4096.0f,mtxCurrent[0][14]/4096.0f,mtxCurrent[0][15]/4096.0f};
_NOSSE_MatrixMultVec4x4(temp1,verts[i].coord);
_NOSSE_MatrixMultVec4x4(mtxCurrent[1],verts[i].coord); _NOSSE_MatrixMultVec4x4(temp0,verts[i].coord);
_NOSSE_MatrixMultVec4x4(mtxCurrent[0],verts[i].coord);
} }
//clip each poly //clip each poly
@ -1511,6 +1510,7 @@ static BOOL gfx3d_glBoxTest(u32 v)
static BOOL gfx3d_glPosTest(u32 v) static BOOL gfx3d_glPosTest(u32 v)
{ {
printf("postest\n");
//this is apparently tested by transformers decepticons and ultimate spiderman //this is apparently tested by transformers decepticons and ultimate spiderman
//printf("POSTEST\n"); //printf("POSTEST\n");
@ -1524,8 +1524,11 @@ static BOOL gfx3d_glPosTest(u32 v)
PTcoords[3] = 1.0f; PTcoords[3] = 1.0f;
MatrixMultVec4x4(mtxCurrent[1], PTcoords); CACHE_ALIGN float temp1[16] = {mtxCurrent[1][0]/4096.0f,mtxCurrent[1][1]/4096.0f,mtxCurrent[1][2]/4096.0f,mtxCurrent[1][3]/4096.0f,mtxCurrent[1][4]/4096.0f,mtxCurrent[1][5]/4096.0f,mtxCurrent[1][6]/4096.0f,mtxCurrent[1][7]/4096.0f,mtxCurrent[1][8]/4096.0f,mtxCurrent[1][9]/4096.0f,mtxCurrent[1][10]/4096.0f,mtxCurrent[1][11]/4096.0f,mtxCurrent[1][12]/4096.0f,mtxCurrent[1][13]/4096.0f,mtxCurrent[1][14]/4096.0f,mtxCurrent[1][15]/4096.0f};
MatrixMultVec4x4(mtxCurrent[0], PTcoords); CACHE_ALIGN float temp0[16] = {mtxCurrent[0][0]/4096.0f,mtxCurrent[0][1]/4096.0f,mtxCurrent[0][2]/4096.0f,mtxCurrent[0][3]/4096.0f,mtxCurrent[0][4]/4096.0f,mtxCurrent[0][5]/4096.0f,mtxCurrent[0][6]/4096.0f,mtxCurrent[0][7]/4096.0f,mtxCurrent[0][8]/4096.0f,mtxCurrent[0][9]/4096.0f,mtxCurrent[0][10]/4096.0f,mtxCurrent[0][11]/4096.0f,mtxCurrent[0][12]/4096.0f,mtxCurrent[0][13]/4096.0f,mtxCurrent[0][14]/4096.0f,mtxCurrent[0][15]/4096.0f};
MatrixMultVec4x4(temp1, PTcoords);
MatrixMultVec4x4(temp0, PTcoords);
MMU_new.gxstat.tb = 0; MMU_new.gxstat.tb = 0;
@ -1536,6 +1539,7 @@ static BOOL gfx3d_glPosTest(u32 v)
static void gfx3d_glVecTest(u32 v) static void gfx3d_glVecTest(u32 v)
{ {
printf("vectest\n");
GFX_DELAY(5); GFX_DELAY(5);
//this is tested by phoenix wright in its evidence inspector modelviewer //this is tested by phoenix wright in its evidence inspector modelviewer
@ -1547,7 +1551,8 @@ static void gfx3d_glVecTest(u32 v)
normalTable[(v>>20)&1023], normalTable[(v>>20)&1023],
0}; 0};
MatrixMultVec4x4(mtxCurrent[2], normal); CACHE_ALIGN float temp[16] = {mtxCurrent[2][0]/4096.0f,mtxCurrent[2][1]/4096.0f,mtxCurrent[2][2]/4096.0f,mtxCurrent[2][3]/4096.0f,mtxCurrent[2][4]/4096.0f,mtxCurrent[2][5]/4096.0f,mtxCurrent[2][6]/4096.0f,mtxCurrent[2][7]/4096.0f,mtxCurrent[2][8]/4096.0f,mtxCurrent[2][9]/4096.0f,mtxCurrent[2][10]/4096.0f,mtxCurrent[2][11]/4096.0f,mtxCurrent[2][12]/4096.0f,mtxCurrent[2][13]/4096.0f,mtxCurrent[2][14]/4096.0f,mtxCurrent[2][15]/4096.0f};
MatrixMultVec4x4(temp, normal);
s16 x = (s16)(normal[0]*4096); s16 x = (s16)(normal[0]*4096);
s16 y = (s16)(normal[1]*4096); s16 y = (s16)(normal[1]*4096);
@ -1620,9 +1625,9 @@ void gfx3d_UpdateToonTable(u8 offset, u32 val)
s32 gfx3d_GetClipMatrix (unsigned int index) s32 gfx3d_GetClipMatrix (unsigned int index)
{ {
float val = MatrixGetMultipliedIndex (index, mtxCurrent[0], mtxCurrent[1]); s32 val = MatrixGetMultipliedIndex (index, mtxCurrent[0], mtxCurrent[1]);
val *= (1<<12); //val *= (1<<12);
return (s32)val; return (s32)val;
} }
@ -1631,7 +1636,8 @@ s32 gfx3d_GetDirectionalMatrix (unsigned int index)
{ {
int _index = (((index / 3) * 4) + (index % 3)); int _index = (((index / 3) * 4) + (index % 3));
return (s32)(mtxCurrent[2][_index]*(1<<12)); //return (s32)(mtxCurrent[2][_index]*(1<<12));
return mtxCurrent[2][_index];
} }
void gfx3d_glAlphaFunc(u32 v) void gfx3d_glAlphaFunc(u32 v)
@ -1834,13 +1840,13 @@ static void gfx3d_execute(u8 cmd, u32 param)
gfx3d_glVertex10b(param); gfx3d_glVertex10b(param);
break; break;
case 0x25: // VTX_XY - Set Vertex XY Coordinates (W) case 0x25: // VTX_XY - Set Vertex XY Coordinates (W)
gfx3d_glVertex3_cord(0, 1, param); gfx3d_glVertex3_cord<0,1>(param);
break; break;
case 0x26: // VTX_XZ - Set Vertex XZ Coordinates (W) case 0x26: // VTX_XZ - Set Vertex XZ Coordinates (W)
gfx3d_glVertex3_cord(0, 2, param); gfx3d_glVertex3_cord<0,2>(param);
break; break;
case 0x27: // VTX_YZ - Set Vertex YZ Coordinates (W) case 0x27: // VTX_YZ - Set Vertex YZ Coordinates (W)
gfx3d_glVertex3_cord(1, 2, param); gfx3d_glVertex3_cord<1,2>(param);
break; break;
case 0x28: // VTX_DIFF - Set Relative Vertex Coordinates (W) case 0x28: // VTX_DIFF - Set Relative Vertex Coordinates (W)
gfx3d_glVertex_rel(param); gfx3d_glVertex_rel(param);
@ -2205,13 +2211,13 @@ void gfx3d_Control(u32 v)
//other misc stuff //other misc stuff
void gfx3d_glGetMatrix(unsigned int m_mode, int index, float* dest) void gfx3d_glGetMatrix(unsigned int m_mode, int index, float* dest)
{ {
if(index == -1) //if(index == -1)
{ //{
MatrixCopy(dest, mtxCurrent[m_mode]); // MatrixCopy(dest, mtxCurrent[m_mode]);
return; // return;
} //}
MatrixCopy(dest, MatrixStackGetPos(&mtxStack[m_mode], index)); //MatrixCopy(dest, MatrixStackGetPos(&mtxStack[m_mode], index));
} }
void gfx3d_glGetLightDirection(unsigned int index, unsigned int* dest) void gfx3d_glGetLightDirection(unsigned int index, unsigned int* dest)
@ -2267,7 +2273,7 @@ SFORMAT SF_GFX3D[]={
{ "MM4I", 1, 1, &MM4x4ind}, { "MM4I", 1, 1, &MM4x4ind},
{ "MM3I", 1, 1, &MM4x3ind}, { "MM3I", 1, 1, &MM4x3ind},
{ "MMxI", 1, 1, &MM3x3ind}, { "MMxI", 1, 1, &MM3x3ind},
{ "GSCO", 4, 1, u16coord}, { "GSCO", 4, 1, s16coord},
{ "GCOI", 1, 1, &coordind}, { "GCOI", 1, 1, &coordind},
{ "GVFM", 4, 1, &vtxFormat}, { "GVFM", 4, 1, &vtxFormat},
{ "GTRN", 4, 4, trans}, { "GTRN", 4, 4, trans},

120
desmume/src/matrix.cpp
View File

@ -39,6 +39,19 @@ void _NOSSE_MatrixMultVec4x4 (const float *matrix, float *vecPtr)
vecPtr[3] = x * matrix[3] + y * matrix[7] + z * matrix[11] + w * matrix[15]; vecPtr[3] = x * matrix[3] + y * matrix[7] + z * matrix[11] + w * matrix[15];
} }
void MatrixMultVec4x4 (const s32 *matrix, s32 *vecPtr)
{
s64 x = vecPtr[0];
s64 y = vecPtr[1];
s64 z = vecPtr[2];
s64 w = vecPtr[3];
vecPtr[0] = (s32)((x * matrix[0] + y * matrix[4] + z * matrix[ 8] + w * matrix[12])>>12);
vecPtr[1] = (s32)((x * matrix[1] + y * matrix[5] + z * matrix[ 9] + w * matrix[13])>>12);
vecPtr[2] = (s32)((x * matrix[2] + y * matrix[6] + z * matrix[10] + w * matrix[14])>>12);
vecPtr[3] = (s32)((x * matrix[3] + y * matrix[7] + z * matrix[11] + w * matrix[15])>>12);
}
//------------------------- //-------------------------
//switched SSE functions: implementations for no SSE //switched SSE functions: implementations for no SSE
@ -116,6 +129,12 @@ void MatrixScale (float *matrix, const float *ptr)
#endif //switched c/asm functions #endif //switched c/asm functions
//----------------------------------------- //-----------------------------------------
void MatrixInit (s32 *matrix)
{
memset (matrix, 0, sizeof(float)*16);
matrix[0] = matrix[5] = matrix[10] = matrix[15] = 1<<12;
}
void MatrixInit (float *matrix) void MatrixInit (float *matrix)
{ {
memset (matrix, 0, sizeof(float)*16); memset (matrix, 0, sizeof(float)*16);
@ -135,6 +154,13 @@ void MatrixTranspose(float *matrix)
#undef swap #undef swap
} }
void MatrixIdentity (s32 *matrix)
{
matrix[1] = matrix[2] = matrix[3] = matrix[4] = 0;
matrix[6] = matrix[7] = matrix[8] = matrix[9] = 0;
matrix[11] = matrix[12] = matrix[13] = matrix[14] = 0;
matrix[0] = matrix[5] = matrix[10] = matrix[15] = 1<<12;
}
void MatrixIdentity (float *matrix) void MatrixIdentity (float *matrix)
{ {
matrix[1] = matrix[2] = matrix[3] = matrix[4] = 0.0f; matrix[1] = matrix[2] = matrix[3] = matrix[4] = 0.0f;
@ -151,6 +177,16 @@ float MatrixGetMultipliedIndex (int index, float *matrix, float *rightMatrix)
(matrix[iMod+8]*rightMatrix[iDiv+2])+(matrix[iMod+12]*rightMatrix[iDiv+3]); (matrix[iMod+8]*rightMatrix[iDiv+2])+(matrix[iMod+12]*rightMatrix[iDiv+3]);
} }
s32 MatrixGetMultipliedIndex (int index, s32 *matrix, s32 *rightMatrix)
{
int iMod = index%4, iDiv = (index>>2)<<2;
s64 temp = ((s64)matrix[iMod ]*rightMatrix[iDiv ])+((s64)matrix[iMod+ 4]*rightMatrix[iDiv+1])+
((s64)matrix[iMod+8]*rightMatrix[iDiv+2])+((s64)matrix[iMod+12]*rightMatrix[iDiv+3]);
return (s32)(temp>>12);
}
void MatrixSet (float *matrix, int x, int y, float value) // TODO void MatrixSet (float *matrix, int x, int y, float value) // TODO
{ {
matrix [x+(y<<2)] = value; matrix [x+(y<<2)] = value;
@ -177,6 +213,27 @@ void MatrixCopy (float* matrixDST, const float* matrixSRC)
} }
void MatrixCopy (s32* matrixDST, const s32* matrixSRC)
{
matrixDST[0] = matrixSRC[0];
matrixDST[1] = matrixSRC[1];
matrixDST[2] = matrixSRC[2];
matrixDST[3] = matrixSRC[3];
matrixDST[4] = matrixSRC[4];
matrixDST[5] = matrixSRC[5];
matrixDST[6] = matrixSRC[6];
matrixDST[7] = matrixSRC[7];
matrixDST[8] = matrixSRC[8];
matrixDST[9] = matrixSRC[9];
matrixDST[10] = matrixSRC[10];
matrixDST[11] = matrixSRC[11];
matrixDST[12] = matrixSRC[12];
matrixDST[13] = matrixSRC[13];
matrixDST[14] = matrixSRC[14];
matrixDST[15] = matrixSRC[15];
}
int MatrixCompare (const float* matrixDST, const float* matrixSRC) int MatrixCompare (const float* matrixDST, const float* matrixSRC)
{ {
return memcmp((void*)matrixDST, matrixSRC, sizeof(float)*16); return memcmp((void*)matrixDST, matrixSRC, sizeof(float)*16);
@ -200,7 +257,7 @@ void MatrixStackSetMaxSize (MatrixStack *stack, int size)
if (stack->matrix != NULL) { if (stack->matrix != NULL) {
free (stack->matrix); free (stack->matrix);
} }
stack->matrix = (float*) malloc (stack->size*16*sizeof(float)); stack->matrix = new s32[stack->size*16*sizeof(s32)];
for (i = 0; i < stack->size; i++) for (i = 0; i < stack->size; i++)
{ {
@ -226,7 +283,7 @@ static void MatrixStackSetStackPosition (MatrixStack *stack, int pos)
stack->position &= stack->size; stack->position &= stack->size;
} }
void MatrixStackPushMatrix (MatrixStack *stack, const float *ptr) void MatrixStackPushMatrix (MatrixStack *stack, const s32 *ptr)
{ {
//printf("Push %i pos %i\n", stack->type, stack->position); //printf("Push %i pos %i\n", stack->type, stack->position);
if ((stack->type == 0) || (stack->type == 3)) if ((stack->type == 0) || (stack->type == 3))
@ -236,7 +293,7 @@ void MatrixStackPushMatrix (MatrixStack *stack, const float *ptr)
MatrixStackSetStackPosition (stack, 1); MatrixStackSetStackPosition (stack, 1);
} }
void MatrixStackPopMatrix (float *mtxCurr, MatrixStack *stack, int size) void MatrixStackPopMatrix (s32 *mtxCurr, MatrixStack *stack, int size)
{ {
//printf("Pop %i pos %i (change %d)\n", stack->type, stack->position, -size); //printf("Pop %i pos %i (change %d)\n", stack->type, stack->position, -size);
MatrixStackSetStackPosition(stack, -size); MatrixStackSetStackPosition(stack, -size);
@ -246,18 +303,18 @@ void MatrixStackPopMatrix (float *mtxCurr, MatrixStack *stack, int size)
MatrixCopy (mtxCurr, &stack->matrix[stack->position*16]); MatrixCopy (mtxCurr, &stack->matrix[stack->position*16]);
} }
float * MatrixStackGetPos (MatrixStack *stack, int pos) s32 * MatrixStackGetPos (MatrixStack *stack, int pos)
{ {
assert(pos<31); assert(pos<31);
return &stack->matrix[pos*16]; return &stack->matrix[pos*16];
} }
float * MatrixStackGet (MatrixStack *stack) s32 * MatrixStackGet (MatrixStack *stack)
{ {
return &stack->matrix[stack->position*16]; return &stack->matrix[stack->position*16];
} }
void MatrixStackLoadMatrix (MatrixStack *stack, int pos, const float *ptr) void MatrixStackLoadMatrix (MatrixStack *stack, int pos, const s32 *ptr)
{ {
assert(pos<31); assert(pos<31);
MatrixCopy (&stack->matrix[pos*16], ptr); MatrixCopy (&stack->matrix[pos*16], ptr);
@ -355,3 +412,54 @@ void Vector4Copy(float *dst, const float *src)
} }
void MatrixMultiply (s32 *matrix, const s32 *rightMatrix)
{
s64 tmpMatrix[16];
tmpMatrix[0] = (matrix[0]*(s64)rightMatrix[0])+(matrix[4]*(s64)rightMatrix[1])+(matrix[8]*(s64)rightMatrix[2])+(matrix[12]*(s64)rightMatrix[3]);
tmpMatrix[1] = (matrix[1]*(s64)rightMatrix[0])+(matrix[5]*(s64)rightMatrix[1])+(matrix[9]*(s64)rightMatrix[2])+(matrix[13]*(s64)rightMatrix[3]);
tmpMatrix[2] = (matrix[2]*(s64)rightMatrix[0])+(matrix[6]*(s64)rightMatrix[1])+(matrix[10]*(s64)rightMatrix[2])+(matrix[14]*(s64)rightMatrix[3]);
tmpMatrix[3] = (matrix[3]*(s64)rightMatrix[0])+(matrix[7]*(s64)rightMatrix[1])+(matrix[11]*(s64)rightMatrix[2])+(matrix[15]*(s64)rightMatrix[3]);
tmpMatrix[4] = (matrix[0]*(s64)rightMatrix[4])+(matrix[4]*(s64)rightMatrix[5])+(matrix[8]*(s64)rightMatrix[6])+(matrix[12]*(s64)rightMatrix[7]);
tmpMatrix[5] = (matrix[1]*(s64)rightMatrix[4])+(matrix[5]*(s64)rightMatrix[5])+(matrix[9]*(s64)rightMatrix[6])+(matrix[13]*(s64)rightMatrix[7]);
tmpMatrix[6] = (matrix[2]*(s64)rightMatrix[4])+(matrix[6]*(s64)rightMatrix[5])+(matrix[10]*(s64)rightMatrix[6])+(matrix[14]*(s64)rightMatrix[7]);
tmpMatrix[7] = (matrix[3]*(s64)rightMatrix[4])+(matrix[7]*(s64)rightMatrix[5])+(matrix[11]*(s64)rightMatrix[6])+(matrix[15]*(s64)rightMatrix[7]);
tmpMatrix[8] = (matrix[0]*(s64)rightMatrix[8])+(matrix[4]*(s64)rightMatrix[9])+(matrix[8]*(s64)rightMatrix[10])+(matrix[12]*(s64)rightMatrix[11]);
tmpMatrix[9] = (matrix[1]*(s64)rightMatrix[8])+(matrix[5]*(s64)rightMatrix[9])+(matrix[9]*(s64)rightMatrix[10])+(matrix[13]*(s64)rightMatrix[11]);
tmpMatrix[10] = (matrix[2]*(s64)rightMatrix[8])+(matrix[6]*(s64)rightMatrix[9])+(matrix[10]*(s64)rightMatrix[10])+(matrix[14]*(s64)rightMatrix[11]);
tmpMatrix[11] = (matrix[3]*(s64)rightMatrix[8])+(matrix[7]*(s64)rightMatrix[9])+(matrix[11]*(s64)rightMatrix[10])+(matrix[15]*(s64)rightMatrix[11]);
tmpMatrix[12] = (matrix[0]*(s64)rightMatrix[12])+(matrix[4]*(s64)rightMatrix[13])+(matrix[8]*(s64)rightMatrix[14])+(matrix[12]*(s64)rightMatrix[15]);
tmpMatrix[13] = (matrix[1]*(s64)rightMatrix[12])+(matrix[5]*(s64)rightMatrix[13])+(matrix[9]*(s64)rightMatrix[14])+(matrix[13]*(s64)rightMatrix[15]);
tmpMatrix[14] = (matrix[2]*(s64)rightMatrix[12])+(matrix[6]*(s64)rightMatrix[13])+(matrix[10]*(s64)rightMatrix[14])+(matrix[14]*(s64)rightMatrix[15]);
tmpMatrix[15] = (matrix[3]*(s64)rightMatrix[12])+(matrix[7]*(s64)rightMatrix[13])+(matrix[11]*(s64)rightMatrix[14])+(matrix[15]*(s64)rightMatrix[15]);
for(int i=0;i<16;i++)
matrix[i] = (s32)(tmpMatrix[i]>>12);
}
void MatrixScale(s32 *matrix, const s32 *ptr)
{
for(int i=0;i<12;i++)
matrix[i] = (s32)(((s64)matrix[i]*ptr[i>>2])>>12);
}
void MatrixTranslate(s32 *matrix, const s32 *ptr)
{
for(int i=0;i<4;i++)
{
s64 temp = ((s64)matrix[i+12])<<12;
temp += (s64)matrix[i]*ptr[0];
temp += (s64)matrix[i+4]*ptr[1];
temp += (s64)matrix[i+8]*ptr[2];
matrix[i+12] = (s32)(temp>>12);
}
}
void MatrixMultVec4x4_M2(const s32 *matrix, s32 *vecPtr)
{
MatrixMultVec4x4(matrix+16,vecPtr);
MatrixMultVec4x4(matrix,vecPtr);
}

23
desmume/src/matrix.h
View File

@ -38,32 +38,36 @@
struct MatrixStack struct MatrixStack
{ {
MatrixStack(int size, int type); MatrixStack(int size, int type);
float *matrix; s32 *matrix;
s32 position; s32 position;
s32 size; s32 size;
u8 type; u8 type;
}; };
void MatrixInit (float *matrix); void MatrixInit (float *matrix);
void MatrixInit (s32 *matrix);
//In order to conditionally use these asm optimized functions in visual studio //In order to conditionally use these asm optimized functions in visual studio
//without having to make new build types to exclude the assembly files. //without having to make new build types to exclude the assembly files.
//a bit sloppy, but there aint much to it //a bit sloppy, but there aint much to it
float MatrixGetMultipliedIndex (int index, float *matrix, float *rightMatrix); float MatrixGetMultipliedIndex (int index, float *matrix, float *rightMatrix);
s32 MatrixGetMultipliedIndex (int index, s32 *matrix, s32 *rightMatrix);
void MatrixSet (float *matrix, int x, int y, float value); void MatrixSet (float *matrix, int x, int y, float value);
void MatrixCopy (float * matrixDST, const float * matrixSRC); void MatrixCopy (float * matrixDST, const float * matrixSRC);
void MatrixCopy (s32 * matrixDST, const s32 * matrixSRC);
int MatrixCompare (const float * matrixDST, const float * matrixSRC); int MatrixCompare (const float * matrixDST, const float * matrixSRC);
void MatrixIdentity (float *matrix); void MatrixIdentity (float *matrix);
void MatrixIdentity (s32 *matrix);
void MatrixTranspose (float *matrix); void MatrixTranspose (float *matrix);
void MatrixStackInit (MatrixStack *stack); void MatrixStackInit (MatrixStack *stack);
void MatrixStackSetMaxSize (MatrixStack *stack, int size); void MatrixStackSetMaxSize (MatrixStack *stack, int size);
void MatrixStackPushMatrix (MatrixStack *stack, const float *ptr); void MatrixStackPushMatrix (MatrixStack *stack, const s32 *ptr);
void MatrixStackPopMatrix (float *mtxCurr, MatrixStack *stack, int size); void MatrixStackPopMatrix (s32 *mtxCurr, MatrixStack *stack, int size);
float* MatrixStackGetPos (MatrixStack *stack, int pos); s32* MatrixStackGetPos (MatrixStack *stack, int pos);
float* MatrixStackGet (MatrixStack *stack); s32* MatrixStackGet (MatrixStack *stack);
void MatrixStackLoadMatrix (MatrixStack *stack, int pos, const float *ptr); void MatrixStackLoadMatrix (MatrixStack *stack, int pos, const s32 *ptr);
void Vector2Copy(float *dst, const float *src); void Vector2Copy(float *dst, const float *src);
void Vector2Add(float *dst, const float *src); void Vector2Add(float *dst, const float *src);
@ -330,5 +334,12 @@ static FORCEINLINE void memset_u8(void* dst, u8 val)
#endif //switched SSE functions #endif //switched SSE functions
void MatrixMultVec4x4 (const s32 *matrix, s32 *vecPtr);
void MatrixMultVec4x4_M2(const s32 *matrix, s32 *vecPtr);
void MatrixMultiply(s32* matrix, const s32* rightMatrix);
void MatrixScale(s32 *matrix, const s32 *ptr);
void MatrixTranslate(s32 *matrix, const s32 *ptr);
#endif #endif

8
desmume/src/windows/matrixView.cpp
View File

@ -62,7 +62,7 @@ void MatrixView_OnPaintPositionMatrix(HWND hwnd)
stackIndex = SendMessage(hStackCombo, CB_GETCURSEL, 0, 0) - 1; stackIndex = SendMessage(hStackCombo, CB_GETCURSEL, 0, 0) - 1;
gfx3d_glGetMatrix(1, stackIndex, matrix); //gfx3d_glGetMatrix(1, stackIndex, matrix);
MatrixView_SetMatrix(hwnd, idcGroup, matrix); MatrixView_SetMatrix(hwnd, idcGroup, matrix);
} }
@ -85,7 +85,7 @@ void MatrixView_OnPaintDirectionMatrix(HWND hwnd)
stackIndex = SendMessage(hStackCombo, CB_GETCURSEL, 0, 0) - 1; stackIndex = SendMessage(hStackCombo, CB_GETCURSEL, 0, 0) - 1;
gfx3d_glGetMatrix(2, stackIndex, matrix); //gfx3d_glGetMatrix(2, stackIndex, matrix);
MatrixView_SetMatrix(hwnd, idcGroup, matrix); MatrixView_SetMatrix(hwnd, idcGroup, matrix);
} }
@ -104,7 +104,7 @@ void MatrixView_OnPaintProjectionMatrix(HWND hwnd)
float mat[16]; float mat[16];
gfx3d_glGetMatrix(0, -1, mat); //gfx3d_glGetMatrix(0, -1, mat);
MatrixView_SetMatrix(hwnd, idcGroup, mat); MatrixView_SetMatrix(hwnd, idcGroup, mat);
} }
@ -123,7 +123,7 @@ void MatrixView_OnPaintTextureMatrix(HWND hwnd)
float mat[16]; float mat[16];
gfx3d_glGetMatrix(3, -1, mat); //gfx3d_glGetMatrix(3, -1, mat);
MatrixView_SetMatrix(hwnd, idcGroup, mat); MatrixView_SetMatrix(hwnd, idcGroup, mat);
} }