The-Homebrew-Cloud/dolphin
2
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-03-12 14:46:49 +01:00
Code Issues Packages Projects Releases Wiki Activity

fixed an off by one error I created in the texture copy function in bpstructs.cpp. SSBM no longer has black on ground. sorry about that ;p

Browse Source 
noticed the real HW doesn't clip some things it should. modified the projection matrix to account for this.
changed normal loader to better handle 1 or 3 index NBT data which fixed an underrun.
added missing z component in biasing section of indirect texturing.

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@1048 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
donkopunchstania 2008-11-02 05:07:14 +00:00
parent b6c0530e15
commit 342c559719
6 changed files with 308 additions and 227 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/Core/VideoCommon/Src/PixelShader.cpp
View File

@ -499,7 +499,7 @@ static void WriteStage(char *&p, int n, u32 texture_mask)
// bias // bias
WRITE(p, "float3 indtevcrd%d = indtex%d;\n", n, bpmem.tevind[n].bt); WRITE(p, "float3 indtevcrd%d = indtex%d;\n", n, bpmem.tevind[n].bt);
WRITE(p, "indtevcrd%d.xy *= %s;\n", n, tevIndFmtScale[bpmem.tevind[n].fmt]); WRITE(p, "indtevcrd%d.xyz *= %s;\n", n, tevIndFmtScale[bpmem.tevind[n].fmt]);
if (bpmem.tevind[n].bias != ITB_NONE ) if (bpmem.tevind[n].bias != ITB_NONE )
WRITE(p, "indtevcrd%d.%s += %s;\n", n, tevIndBiasField[bpmem.tevind[n].bias], tevIndBiasAdd[bpmem.tevind[n].fmt]); WRITE(p, "indtevcrd%d.%s += %s;\n", n, tevIndBiasField[bpmem.tevind[n].bias], tevIndBiasAdd[bpmem.tevind[n].fmt]);

6
Source/Plugins/Plugin_VideoOGL/Src/BPStructs.cpp
View File

@ -426,13 +426,15 @@ void BPWritten(int addr, int changes, int newval)
VertexManager::Flush(); VertexManager::Flush();
((u32*)&bpmem)[addr] = newval; ((u32*)&bpmem)[addr] = newval;
//The bottom right is within the rectangle.
TRectangle rc = { TRectangle rc = {
(int)(bpmem.copyTexSrcXY.x), (int)(bpmem.copyTexSrcXY.x),
(int)(bpmem.copyTexSrcXY.y), (int)(bpmem.copyTexSrcXY.y),
(int)((bpmem.copyTexSrcXY.x + bpmem.copyTexSrcWH.x + 1)), (int)((bpmem.copyTexSrcXY.x + bpmem.copyTexSrcWH.x)),
(int)((bpmem.copyTexSrcXY.y + bpmem.copyTexSrcWH.y + 1)) (int)((bpmem.copyTexSrcXY.y + bpmem.copyTexSrcWH.y))
}; };
//Need another rc here to get it to scale. //Need another rc here to get it to scale.
//Here the bottom right is the out of the rectangle.
TRectangle multirc = { TRectangle multirc = {
(int)(bpmem.copyTexSrcXY.x * MValueX), (int)(bpmem.copyTexSrcXY.x * MValueX),
(int)(bpmem.copyTexSrcXY.y * MValueY), (int)(bpmem.copyTexSrcXY.y * MValueY),

8
Source/Plugins/Plugin_VideoOGL/Src/VertexLoader.cpp
View File

@ -155,9 +155,8 @@ int VertexLoader::ComputeVertexSize()
break; break;
} }
VertexLoader_Normal::index3 = m_VtxAttr.NormalIndex3 ? true : false;
if (m_VtxDesc.Normal != NOT_PRESENT) if (m_VtxDesc.Normal != NOT_PRESENT)
m_VertexSize += VertexLoader_Normal::GetSize(m_VtxDesc.Normal, m_VtxAttr.NormalFormat, m_VtxAttr.NormalElements); m_VertexSize += VertexLoader_Normal::GetSize(m_VtxDesc.Normal, m_VtxAttr.NormalFormat, m_VtxAttr.NormalElements, m_VtxAttr.NormalIndex3);
// Colors // Colors
int col[2] = {m_VtxDesc.Color0, m_VtxDesc.Color1}; int col[2] = {m_VtxDesc.Color0, m_VtxDesc.Color1};
@ -304,12 +303,11 @@ void VertexLoader::CompileVertexTranslator()
// Normals // Normals
if (m_VtxDesc.Normal != NOT_PRESENT) { if (m_VtxDesc.Normal != NOT_PRESENT) {
VertexLoader_Normal::index3 = m_VtxAttr.NormalIndex3 ? true : false; TPipelineFunction pFunc = VertexLoader_Normal::GetFunction(m_VtxDesc.Normal, m_VtxAttr.NormalFormat, m_VtxAttr.NormalElements, m_VtxAttr.NormalIndex3);
TPipelineFunction pFunc = VertexLoader_Normal::GetFunction(m_VtxDesc.Normal, m_VtxAttr.NormalFormat, m_VtxAttr.NormalElements);
if (pFunc == 0) if (pFunc == 0)
{ {
char temp[256]; char temp[256];
sprintf(temp,"%i %i %i", m_VtxDesc.Normal, m_VtxAttr.NormalFormat, m_VtxAttr.NormalElements); sprintf(temp,"%i %i %i %i", m_VtxDesc.Normal, m_VtxAttr.NormalFormat, m_VtxAttr.NormalElements, m_VtxAttr.NormalIndex3);
g_VideoInitialize.pSysMessage("VertexLoader_Normal::GetFunction returned zero!"); g_VideoInitialize.pSysMessage("VertexLoader_Normal::GetFunction returned zero!");
} }
WriteCall(pFunc); WriteCall(pFunc);

392
Source/Plugins/Plugin_VideoOGL/Src/VertexLoader_Normal.cpp
View File

@ -25,93 +25,154 @@
#define LOG_NORM16() PRIM_LOG("norm: %f %f %f, ", ((s16*)VertexManager::s_pCurBufferPointer)[-3]/32767.0f, ((s16*)VertexManager::s_pCurBufferPointer)[-2]/32767.0f, ((s16*)VertexManager::s_pCurBufferPointer)[-1]/32767.0f); #define LOG_NORM16() PRIM_LOG("norm: %f %f %f, ", ((s16*)VertexManager::s_pCurBufferPointer)[-3]/32767.0f, ((s16*)VertexManager::s_pCurBufferPointer)[-2]/32767.0f, ((s16*)VertexManager::s_pCurBufferPointer)[-1]/32767.0f);
#define LOG_NORMF() PRIM_LOG("norm: %f %f %f, ", ((float*)VertexManager::s_pCurBufferPointer)[-3], ((float*)VertexManager::s_pCurBufferPointer)[-2], ((float*)VertexManager::s_pCurBufferPointer)[-1]); #define LOG_NORMF() PRIM_LOG("norm: %f %f %f, ", ((float*)VertexManager::s_pCurBufferPointer)[-3], ((float*)VertexManager::s_pCurBufferPointer)[-2], ((float*)VertexManager::s_pCurBufferPointer)[-1]);
u8 VertexLoader_Normal::m_sizeTable[NUM_NRM_TYPE][NUM_NRM_FORMAT][NUM_NRM_ELEMENTS]; u8 VertexLoader_Normal::m_sizeTable[NUM_NRM_TYPE][NUM_NRM_FORMAT][NUM_NRM_ELEMENTS][NUM_NRM_INDICES];
TPipelineFunction VertexLoader_Normal::m_funcTable[NUM_NRM_TYPE][NUM_NRM_FORMAT][NUM_NRM_ELEMENTS]; TPipelineFunction VertexLoader_Normal::m_funcTable[NUM_NRM_TYPE][NUM_NRM_FORMAT][NUM_NRM_ELEMENTS][NUM_NRM_INDICES];
bool VertexLoader_Normal::index3;
void VertexLoader_Normal::Init(void) void VertexLoader_Normal::Init(void)
{ {
// size table // size table
m_sizeTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT] = 3; m_sizeTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT] [NRM_INDICES1] = 3;
m_sizeTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT] = 3; m_sizeTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT] [NRM_INDICES1] = 3;
m_sizeTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT] = 6; m_sizeTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT] [NRM_INDICES1] = 6;
m_sizeTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT] = 6; m_sizeTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT] [NRM_INDICES1] = 6;
m_sizeTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT] = 12; m_sizeTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT] [NRM_INDICES1] = 12;
m_sizeTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT3] = 9; m_sizeTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT3] [NRM_INDICES1] = 9;
m_sizeTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT3] = 9; m_sizeTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT3] [NRM_INDICES1] = 9;
m_sizeTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT3] = 18; m_sizeTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT3] [NRM_INDICES1] = 18;
m_sizeTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT3] = 18; m_sizeTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT3] [NRM_INDICES1] = 18;
m_sizeTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT3] = 36; m_sizeTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT3] [NRM_INDICES1] = 36;
m_sizeTable[NRM_INDEX8][FORMAT_UBYTE] [NRM_NBT] = 1; m_sizeTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT] [NRM_INDICES3] = 3;
m_sizeTable[NRM_INDEX8][FORMAT_BYTE] [NRM_NBT] = 1; m_sizeTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT] [NRM_INDICES3] = 3;
m_sizeTable[NRM_INDEX8][FORMAT_USHORT][NRM_NBT] = 1; m_sizeTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT] [NRM_INDICES3] = 6;
m_sizeTable[NRM_INDEX8][FORMAT_SHORT] [NRM_NBT] = 1; m_sizeTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT] [NRM_INDICES3] = 6;
m_sizeTable[NRM_INDEX8][FORMAT_FLOAT] [NRM_NBT] = 1; m_sizeTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT] [NRM_INDICES3] = 12;
m_sizeTable[NRM_INDEX8][FORMAT_UBYTE] [NRM_NBT3] = 3; m_sizeTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT3] [NRM_INDICES3] = 9;
m_sizeTable[NRM_INDEX8][FORMAT_BYTE] [NRM_NBT3] = 3; m_sizeTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT3] [NRM_INDICES3] = 9;
m_sizeTable[NRM_INDEX8][FORMAT_USHORT][NRM_NBT3] = 3; m_sizeTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT3] [NRM_INDICES3] = 18;
m_sizeTable[NRM_INDEX8][FORMAT_SHORT] [NRM_NBT3] = 3; m_sizeTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT3] [NRM_INDICES3] = 18;
m_sizeTable[NRM_INDEX8][FORMAT_FLOAT] [NRM_NBT3] = 3; m_sizeTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT3] [NRM_INDICES3] = 36;
m_sizeTable[NRM_INDEX16][FORMAT_UBYTE] [NRM_NBT] = 2; m_sizeTable[NRM_INDEX8][FORMAT_UBYTE] [NRM_NBT] [NRM_INDICES1] = 1;
m_sizeTable[NRM_INDEX16][FORMAT_BYTE] [NRM_NBT] = 2; m_sizeTable[NRM_INDEX8][FORMAT_BYTE] [NRM_NBT] [NRM_INDICES1] = 1;
m_sizeTable[NRM_INDEX16][FORMAT_USHORT][NRM_NBT] = 2; m_sizeTable[NRM_INDEX8][FORMAT_USHORT][NRM_NBT] [NRM_INDICES1] = 1;
m_sizeTable[NRM_INDEX16][FORMAT_SHORT] [NRM_NBT] = 2; m_sizeTable[NRM_INDEX8][FORMAT_SHORT] [NRM_NBT] [NRM_INDICES1] = 1;
m_sizeTable[NRM_INDEX16][FORMAT_FLOAT] [NRM_NBT] = 2; m_sizeTable[NRM_INDEX8][FORMAT_FLOAT] [NRM_NBT] [NRM_INDICES1] = 1;
m_sizeTable[NRM_INDEX16][FORMAT_UBYTE] [NRM_NBT3] = 6; m_sizeTable[NRM_INDEX8][FORMAT_UBYTE] [NRM_NBT3] [NRM_INDICES1] = 1;
m_sizeTable[NRM_INDEX16][FORMAT_BYTE] [NRM_NBT3] = 6; m_sizeTable[NRM_INDEX8][FORMAT_BYTE] [NRM_NBT3] [NRM_INDICES1] = 1;
m_sizeTable[NRM_INDEX16][FORMAT_USHORT][NRM_NBT3] = 6; m_sizeTable[NRM_INDEX8][FORMAT_USHORT][NRM_NBT3] [NRM_INDICES1] = 1;
m_sizeTable[NRM_INDEX16][FORMAT_SHORT] [NRM_NBT3] = 6; m_sizeTable[NRM_INDEX8][FORMAT_SHORT] [NRM_NBT3] [NRM_INDICES1] = 1;
m_sizeTable[NRM_INDEX16][FORMAT_FLOAT] [NRM_NBT3] = 6; m_sizeTable[NRM_INDEX8][FORMAT_FLOAT] [NRM_NBT3] [NRM_INDICES1] = 1;
m_sizeTable[NRM_INDEX8][FORMAT_UBYTE] [NRM_NBT] [NRM_INDICES3] = 1;
m_sizeTable[NRM_INDEX8][FORMAT_BYTE] [NRM_NBT] [NRM_INDICES3] = 1;
m_sizeTable[NRM_INDEX8][FORMAT_USHORT][NRM_NBT] [NRM_INDICES3] = 1;
m_sizeTable[NRM_INDEX8][FORMAT_SHORT] [NRM_NBT] [NRM_INDICES3] = 1;
m_sizeTable[NRM_INDEX8][FORMAT_FLOAT] [NRM_NBT] [NRM_INDICES3] = 1;
m_sizeTable[NRM_INDEX8][FORMAT_UBYTE] [NRM_NBT3] [NRM_INDICES3] = 3;
m_sizeTable[NRM_INDEX8][FORMAT_BYTE] [NRM_NBT3] [NRM_INDICES3] = 3;
m_sizeTable[NRM_INDEX8][FORMAT_USHORT][NRM_NBT3] [NRM_INDICES3] = 3;
m_sizeTable[NRM_INDEX8][FORMAT_SHORT] [NRM_NBT3] [NRM_INDICES3] = 3;
m_sizeTable[NRM_INDEX8][FORMAT_FLOAT] [NRM_NBT3] [NRM_INDICES3] = 3;
m_sizeTable[NRM_INDEX16][FORMAT_UBYTE] [NRM_NBT] [NRM_INDICES1] = 2;
m_sizeTable[NRM_INDEX16][FORMAT_BYTE] [NRM_NBT] [NRM_INDICES1] = 2;
m_sizeTable[NRM_INDEX16][FORMAT_USHORT][NRM_NBT] [NRM_INDICES1] = 2;
m_sizeTable[NRM_INDEX16][FORMAT_SHORT] [NRM_NBT] [NRM_INDICES1] = 2;
m_sizeTable[NRM_INDEX16][FORMAT_FLOAT] [NRM_NBT] [NRM_INDICES1] = 2;
m_sizeTable[NRM_INDEX16][FORMAT_UBYTE] [NRM_NBT3] [NRM_INDICES1] = 2;
m_sizeTable[NRM_INDEX16][FORMAT_BYTE] [NRM_NBT3] [NRM_INDICES1] = 2;
m_sizeTable[NRM_INDEX16][FORMAT_USHORT][NRM_NBT3] [NRM_INDICES1] = 2;
m_sizeTable[NRM_INDEX16][FORMAT_SHORT] [NRM_NBT3] [NRM_INDICES1] = 2;
m_sizeTable[NRM_INDEX16][FORMAT_FLOAT] [NRM_NBT3] [NRM_INDICES1] = 2;
m_sizeTable[NRM_INDEX16][FORMAT_UBYTE] [NRM_NBT] [NRM_INDICES3] = 2;
m_sizeTable[NRM_INDEX16][FORMAT_BYTE] [NRM_NBT] [NRM_INDICES3] = 2;
m_sizeTable[NRM_INDEX16][FORMAT_USHORT][NRM_NBT] [NRM_INDICES3] = 2;
m_sizeTable[NRM_INDEX16][FORMAT_SHORT] [NRM_NBT] [NRM_INDICES3] = 2;
m_sizeTable[NRM_INDEX16][FORMAT_FLOAT] [NRM_NBT] [NRM_INDICES3] = 2;
m_sizeTable[NRM_INDEX16][FORMAT_UBYTE] [NRM_NBT3] [NRM_INDICES3] = 6;
m_sizeTable[NRM_INDEX16][FORMAT_BYTE] [NRM_NBT3] [NRM_INDICES3] = 6;
m_sizeTable[NRM_INDEX16][FORMAT_USHORT][NRM_NBT3] [NRM_INDICES3] = 6;
m_sizeTable[NRM_INDEX16][FORMAT_SHORT] [NRM_NBT3] [NRM_INDICES3] = 6;
m_sizeTable[NRM_INDEX16][FORMAT_FLOAT] [NRM_NBT3] [NRM_INDICES3] = 6;
// function table // function table
m_funcTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT] = Normal_DirectByte; //HACK m_funcTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT] [NRM_INDICES1] = Normal_DirectByte; //HACK
m_funcTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT] = Normal_DirectByte; m_funcTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT] [NRM_INDICES1] = Normal_DirectByte;
m_funcTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT] = Normal_DirectShort; //HACK m_funcTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT] [NRM_INDICES1] = Normal_DirectShort; //HACK
m_funcTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT] = Normal_DirectShort; m_funcTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT] [NRM_INDICES1] = Normal_DirectShort;
m_funcTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT] = Normal_DirectFloat; m_funcTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT] [NRM_INDICES1] = Normal_DirectFloat;
m_funcTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT3] = Normal_DirectByte3; //HACK m_funcTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT3] [NRM_INDICES1] = Normal_DirectByte3; //HACK
m_funcTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT3] = Normal_DirectByte3; m_funcTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT3] [NRM_INDICES1] = Normal_DirectByte3;
m_funcTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT3] = Normal_DirectShort3; //HACK m_funcTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT3] [NRM_INDICES1] = Normal_DirectShort3; //HACK
m_funcTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT3] = Normal_DirectShort3; m_funcTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT3] [NRM_INDICES1] = Normal_DirectShort3;
m_funcTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT3] = Normal_DirectFloat3; m_funcTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT3] [NRM_INDICES1] = Normal_DirectFloat3;
m_funcTable[NRM_INDEX8][FORMAT_UBYTE] [NRM_NBT] = Normal_Index8_Byte; //HACK m_funcTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT] [NRM_INDICES3] = Normal_DirectByte; //HACK
m_funcTable[NRM_INDEX8][FORMAT_BYTE] [NRM_NBT] = Normal_Index8_Byte; m_funcTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT] [NRM_INDICES3] = Normal_DirectByte;
m_funcTable[NRM_INDEX8][FORMAT_USHORT][NRM_NBT] = Normal_Index8_Short; //HACK m_funcTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT] [NRM_INDICES3] = Normal_DirectShort; //HACK
m_funcTable[NRM_INDEX8][FORMAT_SHORT] [NRM_NBT] = Normal_Index8_Short; m_funcTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT] [NRM_INDICES3] = Normal_DirectShort;
m_funcTable[NRM_INDEX8][FORMAT_FLOAT] [NRM_NBT] = Normal_Index8_Float; m_funcTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT] [NRM_INDICES3] = Normal_DirectFloat;
m_funcTable[NRM_INDEX8][FORMAT_UBYTE] [NRM_NBT3] = Normal_Index8_Byte3; //HACK m_funcTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT3] [NRM_INDICES3] = Normal_DirectByte3; //HACK
m_funcTable[NRM_INDEX8][FORMAT_BYTE] [NRM_NBT3] = Normal_Index8_Byte3; m_funcTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT3] [NRM_INDICES3] = Normal_DirectByte3;
m_funcTable[NRM_INDEX8][FORMAT_USHORT][NRM_NBT3] = Normal_Index8_Short3; //HACK m_funcTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT3] [NRM_INDICES3] = Normal_DirectShort3; //HACK
m_funcTable[NRM_INDEX8][FORMAT_SHORT] [NRM_NBT3] = Normal_Index8_Short3; m_funcTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT3] [NRM_INDICES3] = Normal_DirectShort3;
m_funcTable[NRM_INDEX8][FORMAT_FLOAT] [NRM_NBT3] = Normal_Index8_Float3; m_funcTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT3] [NRM_INDICES3] = Normal_DirectFloat3;
m_funcTable[NRM_INDEX16][FORMAT_UBYTE] [NRM_NBT] = Normal_Index16_Byte; //HACK m_funcTable[NRM_INDEX8][FORMAT_UBYTE] [NRM_NBT] [NRM_INDICES1] = Normal_Index8_Byte; //HACK
m_funcTable[NRM_INDEX16][FORMAT_BYTE] [NRM_NBT] = Normal_Index16_Byte; m_funcTable[NRM_INDEX8][FORMAT_BYTE] [NRM_NBT] [NRM_INDICES1] = Normal_Index8_Byte;
m_funcTable[NRM_INDEX16][FORMAT_USHORT][NRM_NBT] = Normal_Index16_Short; //HACK m_funcTable[NRM_INDEX8][FORMAT_USHORT][NRM_NBT] [NRM_INDICES1] = Normal_Index8_Short; //HACK
m_funcTable[NRM_INDEX16][FORMAT_SHORT] [NRM_NBT] = Normal_Index16_Short; m_funcTable[NRM_INDEX8][FORMAT_SHORT] [NRM_NBT] [NRM_INDICES1] = Normal_Index8_Short;
m_funcTable[NRM_INDEX16][FORMAT_FLOAT] [NRM_NBT] = Normal_Index16_Float; m_funcTable[NRM_INDEX8][FORMAT_FLOAT] [NRM_NBT] [NRM_INDICES1] = Normal_Index8_Float;
m_funcTable[NRM_INDEX16][FORMAT_UBYTE] [NRM_NBT3] = Normal_Index16_Byte3; //HACK m_funcTable[NRM_INDEX8][FORMAT_UBYTE] [NRM_NBT3] [NRM_INDICES1] = Normal_Index8_Byte3_Indices1; //HACK
m_funcTable[NRM_INDEX16][FORMAT_BYTE] [NRM_NBT3] = Normal_Index16_Byte3; m_funcTable[NRM_INDEX8][FORMAT_BYTE] [NRM_NBT3] [NRM_INDICES1] = Normal_Index8_Byte3_Indices1;
m_funcTable[NRM_INDEX16][FORMAT_USHORT][NRM_NBT3] = Normal_Index16_Short3; //HACK m_funcTable[NRM_INDEX8][FORMAT_USHORT][NRM_NBT3] [NRM_INDICES1] = Normal_Index8_Short3_Indices1; //HACK
m_funcTable[NRM_INDEX16][FORMAT_SHORT] [NRM_NBT3] = Normal_Index16_Short3; m_funcTable[NRM_INDEX8][FORMAT_SHORT] [NRM_NBT3] [NRM_INDICES1] = Normal_Index8_Short3_Indices1;
m_funcTable[NRM_INDEX16][FORMAT_FLOAT] [NRM_NBT3] = Normal_Index16_Float3; m_funcTable[NRM_INDEX8][FORMAT_FLOAT] [NRM_NBT3] [NRM_INDICES1] = Normal_Index8_Float3_Indices1;
m_funcTable[NRM_INDEX8][FORMAT_UBYTE] [NRM_NBT] [NRM_INDICES3] = Normal_Index8_Byte; //HACK
m_funcTable[NRM_INDEX8][FORMAT_BYTE] [NRM_NBT] [NRM_INDICES3] = Normal_Index8_Byte;
m_funcTable[NRM_INDEX8][FORMAT_USHORT][NRM_NBT] [NRM_INDICES3] = Normal_Index8_Short; //HACK
m_funcTable[NRM_INDEX8][FORMAT_SHORT] [NRM_NBT] [NRM_INDICES3] = Normal_Index8_Short;
m_funcTable[NRM_INDEX8][FORMAT_FLOAT] [NRM_NBT] [NRM_INDICES3] = Normal_Index8_Float;
m_funcTable[NRM_INDEX8][FORMAT_UBYTE] [NRM_NBT3] [NRM_INDICES3] = Normal_Index8_Byte3_Indices3; //HACK
m_funcTable[NRM_INDEX8][FORMAT_BYTE] [NRM_NBT3] [NRM_INDICES3] = Normal_Index8_Byte3_Indices3;
m_funcTable[NRM_INDEX8][FORMAT_USHORT][NRM_NBT3] [NRM_INDICES3] = Normal_Index8_Short3_Indices3; //HACK
m_funcTable[NRM_INDEX8][FORMAT_SHORT] [NRM_NBT3] [NRM_INDICES3] = Normal_Index8_Short3_Indices3;
m_funcTable[NRM_INDEX8][FORMAT_FLOAT] [NRM_NBT3] [NRM_INDICES3] = Normal_Index8_Float3_Indices3;
m_funcTable[NRM_INDEX16][FORMAT_UBYTE] [NRM_NBT] [NRM_INDICES1] = Normal_Index16_Byte; //HACK
m_funcTable[NRM_INDEX16][FORMAT_BYTE] [NRM_NBT] [NRM_INDICES1] = Normal_Index16_Byte;
m_funcTable[NRM_INDEX16][FORMAT_USHORT][NRM_NBT] [NRM_INDICES1] = Normal_Index16_Short; //HACK
m_funcTable[NRM_INDEX16][FORMAT_SHORT] [NRM_NBT] [NRM_INDICES1] = Normal_Index16_Short;
m_funcTable[NRM_INDEX16][FORMAT_FLOAT] [NRM_NBT] [NRM_INDICES1] = Normal_Index16_Float;
m_funcTable[NRM_INDEX16][FORMAT_UBYTE] [NRM_NBT3] [NRM_INDICES1] = Normal_Index16_Byte3_Indices1; //HACK
m_funcTable[NRM_INDEX16][FORMAT_BYTE] [NRM_NBT3] [NRM_INDICES1] = Normal_Index16_Byte3_Indices1;
m_funcTable[NRM_INDEX16][FORMAT_USHORT][NRM_NBT3] [NRM_INDICES1] = Normal_Index16_Short3_Indices1; //HACK
m_funcTable[NRM_INDEX16][FORMAT_SHORT] [NRM_NBT3] [NRM_INDICES1] = Normal_Index16_Short3_Indices1;
m_funcTable[NRM_INDEX16][FORMAT_FLOAT] [NRM_NBT3] [NRM_INDICES1] = Normal_Index16_Float3_Indices1;
m_funcTable[NRM_INDEX16][FORMAT_UBYTE] [NRM_NBT] [NRM_INDICES3] = Normal_Index16_Byte; //HACK
m_funcTable[NRM_INDEX16][FORMAT_BYTE] [NRM_NBT] [NRM_INDICES3] = Normal_Index16_Byte;
m_funcTable[NRM_INDEX16][FORMAT_USHORT][NRM_NBT] [NRM_INDICES3] = Normal_Index16_Short; //HACK
m_funcTable[NRM_INDEX16][FORMAT_SHORT] [NRM_NBT] [NRM_INDICES3] = Normal_Index16_Short;
m_funcTable[NRM_INDEX16][FORMAT_FLOAT] [NRM_NBT] [NRM_INDICES3] = Normal_Index16_Float;
m_funcTable[NRM_INDEX16][FORMAT_UBYTE] [NRM_NBT3] [NRM_INDICES3] = Normal_Index16_Byte3_Indices3; //HACK
m_funcTable[NRM_INDEX16][FORMAT_BYTE] [NRM_NBT3] [NRM_INDICES3] = Normal_Index16_Byte3_Indices3;
m_funcTable[NRM_INDEX16][FORMAT_USHORT][NRM_NBT3] [NRM_INDICES3] = Normal_Index16_Short3_Indices3; //HACK
m_funcTable[NRM_INDEX16][FORMAT_SHORT] [NRM_NBT3] [NRM_INDICES3] = Normal_Index16_Short3_Indices3;
m_funcTable[NRM_INDEX16][FORMAT_FLOAT] [NRM_NBT3] [NRM_INDICES3] = Normal_Index16_Float3_Indices3;
} }
unsigned int VertexLoader_Normal::GetSize(unsigned int _type, unsigned int _format, unsigned int _elements) unsigned int VertexLoader_Normal::GetSize(unsigned int _type, unsigned int _format, unsigned int _elements, unsigned int _index3)
{ {
if (!index3 && _elements == NRM_NBT3) return m_sizeTable[_type][_format][_elements][_index3];
return m_sizeTable[_type][_format][_elements] / 3;
else
return m_sizeTable[_type][_format][_elements];
} }
TPipelineFunction VertexLoader_Normal::GetFunction(unsigned int _type, unsigned int _format, unsigned int _elements) TPipelineFunction VertexLoader_Normal::GetFunction(unsigned int _type, unsigned int _format, unsigned int _elements, unsigned int _index3)
{ {
TPipelineFunction pFunc = m_funcTable[_type][_format][_elements]; TPipelineFunction pFunc = m_funcTable[_type][_format][_elements][_index3];
return pFunc; return pFunc;
} }
@ -225,10 +286,52 @@ void LOADERDECL VertexLoader_Normal::Normal_Index8_Float(const void *_p)
LOG_NORMF(); LOG_NORMF();
} }
void LOADERDECL VertexLoader_Normal::Normal_Index8_Byte3(const void *_p) void LOADERDECL VertexLoader_Normal::Normal_Index8_Byte3_Indices1(const void *_p)
{
u8 Index = DataReadU8();
for (int i = 0; i < 3; i++)
{
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 1*3*i;
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress);
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+1);
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+2);
VertexManager::s_pCurBufferPointer++;
LOG_NORM8();
}
}
void LOADERDECL VertexLoader_Normal::Normal_Index8_Short3_Indices1(const void *_p)
{
u8 Index = DataReadU8();
for (int i = 0; i < 3; i++)
{
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 2*3*i;
((u16*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_U16(iAddress);
((u16*)VertexManager::s_pCurBufferPointer)[1] = Memory_Read_U16(iAddress+2);
((u16*)VertexManager::s_pCurBufferPointer)[2] = Memory_Read_U16(iAddress+4);
VertexManager::s_pCurBufferPointer += 8;
LOG_NORM16();
}
}
void LOADERDECL VertexLoader_Normal::Normal_Index8_Float3_Indices1(const void *_p)
{
u8 Index = DataReadU8();
for (int i = 0; i < 3; i++)
{
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 4*3*i;
((float*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_Float(iAddress);
((float*)VertexManager::s_pCurBufferPointer)[1] = Memory_Read_Float(iAddress+4);
((float*)VertexManager::s_pCurBufferPointer)[2] = Memory_Read_Float(iAddress+8);
VertexManager::s_pCurBufferPointer += 12;
LOG_NORMF();
}
}
void LOADERDECL VertexLoader_Normal::Normal_Index8_Byte3_Indices3(const void *_p)
{
for (int i = 0; i < 3; i++)
{ {
if (index3) {
for (int i = 0; i < 3; i++) {
u8 Index = DataReadU8(); u8 Index = DataReadU8();
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 1*3*i; u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 1*3*i;
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress); *VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress);
@ -238,23 +341,11 @@ void LOADERDECL VertexLoader_Normal::Normal_Index8_Byte3(const void *_p)
LOG_NORM8(); LOG_NORM8();
} }
} }
else {
u8 Index = DataReadU8();
for (int i = 0; i < 3; i++) {
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 1*3*i;
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress);
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+1);
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+2);
VertexManager::s_pCurBufferPointer++;
LOG_NORM8();
}
}
}
void LOADERDECL VertexLoader_Normal::Normal_Index8_Short3(const void *_p) void LOADERDECL VertexLoader_Normal::Normal_Index8_Short3_Indices3(const void *_p)
{
for (int i = 0; i < 3; i++)
{ {
if (index3) {
for (int i = 0; i < 3; i++) {
u8 Index = DataReadU8(); u8 Index = DataReadU8();
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 2*3*i; u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 2*3*i;
((u16*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_U16(iAddress); ((u16*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_U16(iAddress);
@ -264,23 +355,11 @@ void LOADERDECL VertexLoader_Normal::Normal_Index8_Short3(const void *_p)
LOG_NORM16(); LOG_NORM16();
} }
} }
else {
u8 Index = DataReadU8();
for (int i = 0; i < 3; i++) {
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 2*3*i;
((u16*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_U16(iAddress);
((u16*)VertexManager::s_pCurBufferPointer)[1] = Memory_Read_U16(iAddress+2);
((u16*)VertexManager::s_pCurBufferPointer)[2] = Memory_Read_U16(iAddress+4);
VertexManager::s_pCurBufferPointer += 8;
LOG_NORM16();
}
}
}
void LOADERDECL VertexLoader_Normal::Normal_Index8_Float3(const void *_p) void LOADERDECL VertexLoader_Normal::Normal_Index8_Float3_Indices3(const void *_p)
{
for (int i = 0; i < 3; i++)
{ {
if (index3) {
for (int i = 0; i < 3; i++) {
u8 Index = DataReadU8(); u8 Index = DataReadU8();
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 4*3*i; u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 4*3*i;
((float*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_Float(iAddress); ((float*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_Float(iAddress);
@ -290,18 +369,6 @@ void LOADERDECL VertexLoader_Normal::Normal_Index8_Float3(const void *_p)
LOG_NORMF(); LOG_NORMF();
} }
} }
else {
u8 Index = DataReadU8();
for (int i = 0; i < 3; i++) {
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 4*3*i;
((float*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_Float(iAddress);
((float*)VertexManager::s_pCurBufferPointer)[1] = Memory_Read_Float(iAddress+4);
((float*)VertexManager::s_pCurBufferPointer)[2] = Memory_Read_Float(iAddress+8);
VertexManager::s_pCurBufferPointer += 12;
LOG_NORMF();
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////
// --- Index16 --- // --- Index16 ---
@ -340,11 +407,11 @@ void LOADERDECL VertexLoader_Normal::Normal_Index16_Float(const void *_p)
LOG_NORMF(); LOG_NORMF();
} }
void LOADERDECL VertexLoader_Normal::Normal_Index16_Byte3(const void *_p) void LOADERDECL VertexLoader_Normal::Normal_Index16_Byte3_Indices1(const void *_p)
{ {
if (index3) {
for (int i = 0; i < 3; i++) {
u16 Index = DataReadU16(); u16 Index = DataReadU16();
for (int i = 0; i < 3; i++)
{
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 1*3*i; u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 1*3*i;
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress); *VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress);
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+1); *VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+1);
@ -353,35 +420,8 @@ void LOADERDECL VertexLoader_Normal::Normal_Index16_Byte3(const void *_p)
LOG_NORM8(); LOG_NORM8();
} }
} }
else {
u16 Index = DataReadU16();
for (int i = 0; i < 3; i++) {
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 1*3*i;
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress);
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+1);
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+2);
VertexManager::s_pCurBufferPointer++;
LOG_NORM8();
}
}
}
void LOADERDECL VertexLoader_Normal::Normal_Index16_Short3(const void *_p) void LOADERDECL VertexLoader_Normal::Normal_Index16_Short3_Indices1(const void *_p)
{
if (index3)
{
for (int i = 0; i < 3; i++)
{
u16 Index = DataReadU16();
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 2*3*i;
((u16*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_U16(iAddress);
((u16*)VertexManager::s_pCurBufferPointer)[1] = Memory_Read_U16(iAddress+2);
((u16*)VertexManager::s_pCurBufferPointer)[2] = Memory_Read_U16(iAddress+4);
VertexManager::s_pCurBufferPointer += 8;
LOG_NORM16();
}
}
else
{ {
u16 Index = DataReadU16(); u16 Index = DataReadU16();
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
@ -394,11 +434,51 @@ void LOADERDECL VertexLoader_Normal::Normal_Index16_Short3(const void *_p)
LOG_NORM16(); LOG_NORM16();
} }
} }
void LOADERDECL VertexLoader_Normal::Normal_Index16_Float3_Indices1(const void *_p)
{
u16 Index = DataReadU16();
for (int i = 0; i < 3; i++)
{
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 4*3*i;
((float*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_Float(iAddress);
((float*)VertexManager::s_pCurBufferPointer)[1] = Memory_Read_Float(iAddress+4);
((float*)VertexManager::s_pCurBufferPointer)[2] = Memory_Read_Float(iAddress+8);
VertexManager::s_pCurBufferPointer += 12;
LOG_NORMF();
}
} }
void LOADERDECL VertexLoader_Normal::Normal_Index16_Float3(const void *_p) void LOADERDECL VertexLoader_Normal::Normal_Index16_Byte3_Indices3(const void *_p)
{ {
if (index3) for (int i = 0; i < 3; i++)
{
u16 Index = DataReadU16();
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 1*3*i;
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress);
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+1);
*VertexManager::s_pCurBufferPointer++ = Memory_Read_U8(iAddress+2);
VertexManager::s_pCurBufferPointer++;
LOG_NORM8();
}
}
void LOADERDECL VertexLoader_Normal::Normal_Index16_Short3_Indices3(const void *_p)
{
for (int i = 0; i < 3; i++)
{
u16 Index = DataReadU16();
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 2*3*i;
((u16*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_U16(iAddress);
((u16*)VertexManager::s_pCurBufferPointer)[1] = Memory_Read_U16(iAddress+2);
((u16*)VertexManager::s_pCurBufferPointer)[2] = Memory_Read_U16(iAddress+4);
VertexManager::s_pCurBufferPointer += 8;
LOG_NORM16();
}
}
void LOADERDECL VertexLoader_Normal::Normal_Index16_Float3_Indices3(const void *_p)
{ {
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
{ {
@ -411,17 +491,3 @@ void LOADERDECL VertexLoader_Normal::Normal_Index16_Float3(const void *_p)
LOG_NORMF(); LOG_NORMF();
} }
} }
else
{
u16 Index = DataReadU16();
for (int i = 0; i < 3; i++)
{
u32 iAddress = arraybases[ARRAY_NORMAL] + (Index * arraystrides[ARRAY_NORMAL]) + 4*3*i;
((float*)VertexManager::s_pCurBufferPointer)[0] = Memory_Read_Float(iAddress);
((float*)VertexManager::s_pCurBufferPointer)[1] = Memory_Read_Float(iAddress+4);
((float*)VertexManager::s_pCurBufferPointer)[2] = Memory_Read_Float(iAddress+8);
VertexManager::s_pCurBufferPointer += 12;
LOG_NORMF();
}
}
}

35
Source/Plugins/Plugin_VideoOGL/Src/VertexLoader_Normal.h
View File

@ -24,15 +24,14 @@ class VertexLoader_Normal
{ {
public: public:
static bool index3;
// Init // Init
static void Init(void); static void Init(void);
// GetSize // GetSize
static unsigned int GetSize(unsigned int _type, unsigned int _format, unsigned int _elements); static unsigned int GetSize(unsigned int _type, unsigned int _format, unsigned int _elements, unsigned int _index3);
// GetFunction // GetFunction
static TPipelineFunction GetFunction(unsigned int _type, unsigned int _format, unsigned int _elements); static TPipelineFunction GetFunction(unsigned int _type, unsigned int _format, unsigned int _elements, unsigned int _index3);
private: private:
enum ENormalType enum ENormalType
@ -61,9 +60,17 @@ private:
NUM_NRM_ELEMENTS NUM_NRM_ELEMENTS
}; };
enum ENormalIndices
{
NRM_INDICES1 = 0,
NRM_INDICES3 = 1,
NUM_NRM_INDICES
};
// tables // tables
static u8 m_sizeTable[NUM_NRM_TYPE][NUM_NRM_FORMAT][NUM_NRM_ELEMENTS]; static u8 m_sizeTable[NUM_NRM_TYPE][NUM_NRM_FORMAT][NUM_NRM_ELEMENTS][NUM_NRM_INDICES];
static TPipelineFunction m_funcTable[NUM_NRM_TYPE][NUM_NRM_FORMAT][NUM_NRM_ELEMENTS]; static TPipelineFunction m_funcTable[NUM_NRM_TYPE][NUM_NRM_FORMAT][NUM_NRM_ELEMENTS][NUM_NRM_INDICES];
// direct // direct
static void LOADERDECL Normal_DirectByte(const void *_p); static void LOADERDECL Normal_DirectByte(const void *_p);
@ -77,17 +84,23 @@ private:
static void LOADERDECL Normal_Index8_Byte(const void *_p); static void LOADERDECL Normal_Index8_Byte(const void *_p);
static void LOADERDECL Normal_Index8_Short(const void *_p); static void LOADERDECL Normal_Index8_Short(const void *_p);
static void LOADERDECL Normal_Index8_Float(const void *_p); static void LOADERDECL Normal_Index8_Float(const void *_p);
static void LOADERDECL Normal_Index8_Byte3(const void *_p); static void LOADERDECL Normal_Index8_Byte3_Indices1(const void *_p);
static void LOADERDECL Normal_Index8_Short3(const void *_p); static void LOADERDECL Normal_Index8_Short3_Indices1(const void *_p);
static void LOADERDECL Normal_Index8_Float3(const void *_p); static void LOADERDECL Normal_Index8_Float3_Indices1(const void *_p);
static void LOADERDECL Normal_Index8_Byte3_Indices3(const void *_p);
static void LOADERDECL Normal_Index8_Short3_Indices3(const void *_p);
static void LOADERDECL Normal_Index8_Float3_Indices3(const void *_p);
// index16 // index16
static void LOADERDECL Normal_Index16_Byte(const void *_p); static void LOADERDECL Normal_Index16_Byte(const void *_p);
static void LOADERDECL Normal_Index16_Short(const void *_p); static void LOADERDECL Normal_Index16_Short(const void *_p);
static void LOADERDECL Normal_Index16_Float(const void *_p); static void LOADERDECL Normal_Index16_Float(const void *_p);
static void LOADERDECL Normal_Index16_Byte3(const void *_p); static void LOADERDECL Normal_Index16_Byte3_Indices1(const void *_p);
static void LOADERDECL Normal_Index16_Short3(const void *_p); static void LOADERDECL Normal_Index16_Short3_Indices1(const void *_p);
static void LOADERDECL Normal_Index16_Float3(const void *_p); static void LOADERDECL Normal_Index16_Float3_Indices1(const void *_p);
static void LOADERDECL Normal_Index16_Byte3_Indices3(const void *_p);
static void LOADERDECL Normal_Index16_Short3_Indices3(const void *_p);
static void LOADERDECL Normal_Index16_Float3_Indices3(const void *_p);
}; };
#endif #endif

4
Source/Plugins/Plugin_VideoOGL/Src/VertexShaderManager.cpp
View File

@ -466,7 +466,9 @@ void VertexShaderMngr::SetConstants()
g_fProjectionMatrix[12] = 0.0f; g_fProjectionMatrix[12] = 0.0f;
g_fProjectionMatrix[13] = 0.0f; g_fProjectionMatrix[13] = 0.0f;
g_fProjectionMatrix[14] = -1.0f; // donkopunchstania: GC GPU rounds differently?
// -(1 + epsilon) so objects are clipped as they are on the real HW
g_fProjectionMatrix[14] = -1.00000011921f;
g_fProjectionMatrix[15] = 0.0f; g_fProjectionMatrix[15] = 0.0f;
} }
else { else {