From 342c5597190d1276586bd7d03badda783e68e86e Mon Sep 17 00:00:00 2001 From: donkopunchstania Date: Sun, 2 Nov 2008 05:07:14 +0000 Subject: [PATCH] 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 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 --- Source/Core/VideoCommon/Src/PixelShader.cpp | 2 +- .../Plugins/Plugin_VideoOGL/Src/BPStructs.cpp | 6 +- .../Plugin_VideoOGL/Src/VertexLoader.cpp | 8 +- .../Src/VertexLoader_Normal.cpp | 480 ++++++++++-------- .../Plugin_VideoOGL/Src/VertexLoader_Normal.h | 35 +- .../Src/VertexShaderManager.cpp | 4 +- 6 files changed, 308 insertions(+), 227 deletions(-) diff --git a/Source/Core/VideoCommon/Src/PixelShader.cpp b/Source/Core/VideoCommon/Src/PixelShader.cpp index 0e9691ff75..799335735d 100644 --- a/Source/Core/VideoCommon/Src/PixelShader.cpp +++ b/Source/Core/VideoCommon/Src/PixelShader.cpp @@ -499,7 +499,7 @@ static void WriteStage(char *&p, int n, u32 texture_mask) // bias 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 ) WRITE(p, "indtevcrd%d.%s += %s;\n", n, tevIndBiasField[bpmem.tevind[n].bias], tevIndBiasAdd[bpmem.tevind[n].fmt]); diff --git a/Source/Plugins/Plugin_VideoOGL/Src/BPStructs.cpp b/Source/Plugins/Plugin_VideoOGL/Src/BPStructs.cpp index dba58bc0d8..7e3c937b75 100644 --- a/Source/Plugins/Plugin_VideoOGL/Src/BPStructs.cpp +++ b/Source/Plugins/Plugin_VideoOGL/Src/BPStructs.cpp @@ -426,13 +426,15 @@ void BPWritten(int addr, int changes, int newval) VertexManager::Flush(); ((u32*)&bpmem)[addr] = newval; + //The bottom right is within the rectangle. TRectangle rc = { (int)(bpmem.copyTexSrcXY.x), (int)(bpmem.copyTexSrcXY.y), - (int)((bpmem.copyTexSrcXY.x + bpmem.copyTexSrcWH.x + 1)), - (int)((bpmem.copyTexSrcXY.y + bpmem.copyTexSrcWH.y + 1)) + (int)((bpmem.copyTexSrcXY.x + bpmem.copyTexSrcWH.x)), + (int)((bpmem.copyTexSrcXY.y + bpmem.copyTexSrcWH.y)) }; //Need another rc here to get it to scale. + //Here the bottom right is the out of the rectangle. TRectangle multirc = { (int)(bpmem.copyTexSrcXY.x * MValueX), (int)(bpmem.copyTexSrcXY.y * MValueY), diff --git a/Source/Plugins/Plugin_VideoOGL/Src/VertexLoader.cpp b/Source/Plugins/Plugin_VideoOGL/Src/VertexLoader.cpp index ee45ed9787..4c658a8aaa 100644 --- a/Source/Plugins/Plugin_VideoOGL/Src/VertexLoader.cpp +++ b/Source/Plugins/Plugin_VideoOGL/Src/VertexLoader.cpp @@ -155,9 +155,8 @@ int VertexLoader::ComputeVertexSize() break; } - VertexLoader_Normal::index3 = m_VtxAttr.NormalIndex3 ? true : false; 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 int col[2] = {m_VtxDesc.Color0, m_VtxDesc.Color1}; @@ -304,12 +303,11 @@ void VertexLoader::CompileVertexTranslator() // Normals 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); + TPipelineFunction pFunc = VertexLoader_Normal::GetFunction(m_VtxDesc.Normal, m_VtxAttr.NormalFormat, m_VtxAttr.NormalElements, m_VtxAttr.NormalIndex3); if (pFunc == 0) { 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!"); } WriteCall(pFunc); diff --git a/Source/Plugins/Plugin_VideoOGL/Src/VertexLoader_Normal.cpp b/Source/Plugins/Plugin_VideoOGL/Src/VertexLoader_Normal.cpp index 779b75d159..2b429cee2a 100644 --- a/Source/Plugins/Plugin_VideoOGL/Src/VertexLoader_Normal.cpp +++ b/Source/Plugins/Plugin_VideoOGL/Src/VertexLoader_Normal.cpp @@ -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_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]; -TPipelineFunction VertexLoader_Normal::m_funcTable[NUM_NRM_TYPE][NUM_NRM_FORMAT][NUM_NRM_ELEMENTS]; - -bool VertexLoader_Normal::index3; +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][NUM_NRM_INDICES]; void VertexLoader_Normal::Init(void) { // size table - m_sizeTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT] = 3; - m_sizeTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT] = 3; - m_sizeTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT] = 6; - m_sizeTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT] = 6; - m_sizeTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT] = 12; - m_sizeTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT3] = 9; - m_sizeTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT3] = 9; - m_sizeTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT3] = 18; - m_sizeTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT3] = 18; - m_sizeTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT3] = 36; + m_sizeTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT] [NRM_INDICES1] = 3; + m_sizeTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT] [NRM_INDICES1] = 3; + m_sizeTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT] [NRM_INDICES1] = 6; + m_sizeTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT] [NRM_INDICES1] = 6; + m_sizeTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT] [NRM_INDICES1] = 12; + m_sizeTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT3] [NRM_INDICES1] = 9; + m_sizeTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT3] [NRM_INDICES1] = 9; + m_sizeTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT3] [NRM_INDICES1] = 18; + m_sizeTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT3] [NRM_INDICES1] = 18; + m_sizeTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT3] [NRM_INDICES1] = 36; - m_sizeTable[NRM_INDEX8][FORMAT_UBYTE] [NRM_NBT] = 1; - m_sizeTable[NRM_INDEX8][FORMAT_BYTE] [NRM_NBT] = 1; - m_sizeTable[NRM_INDEX8][FORMAT_USHORT][NRM_NBT] = 1; - m_sizeTable[NRM_INDEX8][FORMAT_SHORT] [NRM_NBT] = 1; - m_sizeTable[NRM_INDEX8][FORMAT_FLOAT] [NRM_NBT] = 1; - m_sizeTable[NRM_INDEX8][FORMAT_UBYTE] [NRM_NBT3] = 3; - m_sizeTable[NRM_INDEX8][FORMAT_BYTE] [NRM_NBT3] = 3; - m_sizeTable[NRM_INDEX8][FORMAT_USHORT][NRM_NBT3] = 3; - m_sizeTable[NRM_INDEX8][FORMAT_SHORT] [NRM_NBT3] = 3; - m_sizeTable[NRM_INDEX8][FORMAT_FLOAT] [NRM_NBT3] = 3; + m_sizeTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT] [NRM_INDICES3] = 3; + m_sizeTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT] [NRM_INDICES3] = 3; + m_sizeTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT] [NRM_INDICES3] = 6; + m_sizeTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT] [NRM_INDICES3] = 6; + m_sizeTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT] [NRM_INDICES3] = 12; + m_sizeTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT3] [NRM_INDICES3] = 9; + m_sizeTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT3] [NRM_INDICES3] = 9; + m_sizeTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT3] [NRM_INDICES3] = 18; + m_sizeTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT3] [NRM_INDICES3] = 18; + m_sizeTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT3] [NRM_INDICES3] = 36; - m_sizeTable[NRM_INDEX16][FORMAT_UBYTE] [NRM_NBT] = 2; - m_sizeTable[NRM_INDEX16][FORMAT_BYTE] [NRM_NBT] = 2; - m_sizeTable[NRM_INDEX16][FORMAT_USHORT][NRM_NBT] = 2; - m_sizeTable[NRM_INDEX16][FORMAT_SHORT] [NRM_NBT] = 2; - m_sizeTable[NRM_INDEX16][FORMAT_FLOAT] [NRM_NBT] = 2; - m_sizeTable[NRM_INDEX16][FORMAT_UBYTE] [NRM_NBT3] = 6; - m_sizeTable[NRM_INDEX16][FORMAT_BYTE] [NRM_NBT3] = 6; - m_sizeTable[NRM_INDEX16][FORMAT_USHORT][NRM_NBT3] = 6; - m_sizeTable[NRM_INDEX16][FORMAT_SHORT] [NRM_NBT3] = 6; - m_sizeTable[NRM_INDEX16][FORMAT_FLOAT] [NRM_NBT3] = 6; + m_sizeTable[NRM_INDEX8][FORMAT_UBYTE] [NRM_NBT] [NRM_INDICES1] = 1; + m_sizeTable[NRM_INDEX8][FORMAT_BYTE] [NRM_NBT] [NRM_INDICES1] = 1; + m_sizeTable[NRM_INDEX8][FORMAT_USHORT][NRM_NBT] [NRM_INDICES1] = 1; + m_sizeTable[NRM_INDEX8][FORMAT_SHORT] [NRM_NBT] [NRM_INDICES1] = 1; + m_sizeTable[NRM_INDEX8][FORMAT_FLOAT] [NRM_NBT] [NRM_INDICES1] = 1; + m_sizeTable[NRM_INDEX8][FORMAT_UBYTE] [NRM_NBT3] [NRM_INDICES1] = 1; + m_sizeTable[NRM_INDEX8][FORMAT_BYTE] [NRM_NBT3] [NRM_INDICES1] = 1; + m_sizeTable[NRM_INDEX8][FORMAT_USHORT][NRM_NBT3] [NRM_INDICES1] = 1; + m_sizeTable[NRM_INDEX8][FORMAT_SHORT] [NRM_NBT3] [NRM_INDICES1] = 1; + 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 - m_funcTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT] = Normal_DirectByte; //HACK - m_funcTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT] = Normal_DirectByte; - m_funcTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT] = Normal_DirectShort; //HACK - m_funcTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT] = Normal_DirectShort; - m_funcTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT] = Normal_DirectFloat; - m_funcTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT3] = Normal_DirectByte3; //HACK - m_funcTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT3] = Normal_DirectByte3; - m_funcTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT3] = Normal_DirectShort3; //HACK - m_funcTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT3] = Normal_DirectShort3; - m_funcTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT3] = Normal_DirectFloat3; + m_funcTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT] [NRM_INDICES1] = Normal_DirectByte; //HACK + m_funcTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT] [NRM_INDICES1] = Normal_DirectByte; + m_funcTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT] [NRM_INDICES1] = Normal_DirectShort; //HACK + m_funcTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT] [NRM_INDICES1] = Normal_DirectShort; + m_funcTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT] [NRM_INDICES1] = Normal_DirectFloat; + m_funcTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT3] [NRM_INDICES1] = Normal_DirectByte3; //HACK + m_funcTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT3] [NRM_INDICES1] = Normal_DirectByte3; + m_funcTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT3] [NRM_INDICES1] = Normal_DirectShort3; //HACK + m_funcTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT3] [NRM_INDICES1] = Normal_DirectShort3; + 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_INDEX8][FORMAT_BYTE] [NRM_NBT] = Normal_Index8_Byte; - m_funcTable[NRM_INDEX8][FORMAT_USHORT][NRM_NBT] = Normal_Index8_Short; //HACK - m_funcTable[NRM_INDEX8][FORMAT_SHORT] [NRM_NBT] = Normal_Index8_Short; - m_funcTable[NRM_INDEX8][FORMAT_FLOAT] [NRM_NBT] = Normal_Index8_Float; - m_funcTable[NRM_INDEX8][FORMAT_UBYTE] [NRM_NBT3] = Normal_Index8_Byte3; //HACK - m_funcTable[NRM_INDEX8][FORMAT_BYTE] [NRM_NBT3] = Normal_Index8_Byte3; - m_funcTable[NRM_INDEX8][FORMAT_USHORT][NRM_NBT3] = Normal_Index8_Short3; //HACK - m_funcTable[NRM_INDEX8][FORMAT_SHORT] [NRM_NBT3] = Normal_Index8_Short3; - m_funcTable[NRM_INDEX8][FORMAT_FLOAT] [NRM_NBT3] = Normal_Index8_Float3; + m_funcTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT] [NRM_INDICES3] = Normal_DirectByte; //HACK + m_funcTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT] [NRM_INDICES3] = Normal_DirectByte; + m_funcTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT] [NRM_INDICES3] = Normal_DirectShort; //HACK + m_funcTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT] [NRM_INDICES3] = Normal_DirectShort; + m_funcTable[NRM_DIRECT][FORMAT_FLOAT] [NRM_NBT] [NRM_INDICES3] = Normal_DirectFloat; + m_funcTable[NRM_DIRECT][FORMAT_UBYTE] [NRM_NBT3] [NRM_INDICES3] = Normal_DirectByte3; //HACK + m_funcTable[NRM_DIRECT][FORMAT_BYTE] [NRM_NBT3] [NRM_INDICES3] = Normal_DirectByte3; + m_funcTable[NRM_DIRECT][FORMAT_USHORT][NRM_NBT3] [NRM_INDICES3] = Normal_DirectShort3; //HACK + m_funcTable[NRM_DIRECT][FORMAT_SHORT] [NRM_NBT3] [NRM_INDICES3] = Normal_DirectShort3; + 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_INDEX16][FORMAT_BYTE] [NRM_NBT] = Normal_Index16_Byte; - m_funcTable[NRM_INDEX16][FORMAT_USHORT][NRM_NBT] = Normal_Index16_Short; //HACK - m_funcTable[NRM_INDEX16][FORMAT_SHORT] [NRM_NBT] = Normal_Index16_Short; - m_funcTable[NRM_INDEX16][FORMAT_FLOAT] [NRM_NBT] = Normal_Index16_Float; - m_funcTable[NRM_INDEX16][FORMAT_UBYTE] [NRM_NBT3] = Normal_Index16_Byte3; //HACK - m_funcTable[NRM_INDEX16][FORMAT_BYTE] [NRM_NBT3] = Normal_Index16_Byte3; - m_funcTable[NRM_INDEX16][FORMAT_USHORT][NRM_NBT3] = Normal_Index16_Short3; //HACK - m_funcTable[NRM_INDEX16][FORMAT_SHORT] [NRM_NBT3] = Normal_Index16_Short3; - m_funcTable[NRM_INDEX16][FORMAT_FLOAT] [NRM_NBT3] = Normal_Index16_Float3; + m_funcTable[NRM_INDEX8][FORMAT_UBYTE] [NRM_NBT] [NRM_INDICES1] = Normal_Index8_Byte; //HACK + m_funcTable[NRM_INDEX8][FORMAT_BYTE] [NRM_NBT] [NRM_INDICES1] = Normal_Index8_Byte; + m_funcTable[NRM_INDEX8][FORMAT_USHORT][NRM_NBT] [NRM_INDICES1] = Normal_Index8_Short; //HACK + m_funcTable[NRM_INDEX8][FORMAT_SHORT] [NRM_NBT] [NRM_INDICES1] = Normal_Index8_Short; + m_funcTable[NRM_INDEX8][FORMAT_FLOAT] [NRM_NBT] [NRM_INDICES1] = Normal_Index8_Float; + m_funcTable[NRM_INDEX8][FORMAT_UBYTE] [NRM_NBT3] [NRM_INDICES1] = Normal_Index8_Byte3_Indices1; //HACK + m_funcTable[NRM_INDEX8][FORMAT_BYTE] [NRM_NBT3] [NRM_INDICES1] = Normal_Index8_Byte3_Indices1; + m_funcTable[NRM_INDEX8][FORMAT_USHORT][NRM_NBT3] [NRM_INDICES1] = Normal_Index8_Short3_Indices1; //HACK + m_funcTable[NRM_INDEX8][FORMAT_SHORT] [NRM_NBT3] [NRM_INDICES1] = Normal_Index8_Short3_Indices1; + 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] / 3; - else - return m_sizeTable[_type][_format][_elements]; + return m_sizeTable[_type][_format][_elements][_index3]; } -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; } @@ -225,84 +286,90 @@ void LOADERDECL VertexLoader_Normal::Normal_Index8_Float(const void *_p) LOG_NORMF(); } -void LOADERDECL VertexLoader_Normal::Normal_Index8_Byte3(const void *_p) +void LOADERDECL VertexLoader_Normal::Normal_Index8_Byte3_Indices1(const void *_p) { - if (index3) { - for (int i = 0; i < 3; i++) { - u8 Index = DataReadU8(); - 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(); - } - } - 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(); - } + 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_Indices1(const void *_p) { - if (index3) { - for (int i = 0; i < 3; i++) { - u8 Index = DataReadU8(); - 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 { + 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++) + { 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(); - } + 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_Float3(const void *_p) +void LOADERDECL VertexLoader_Normal::Normal_Index8_Short3_Indices3(const void *_p) { - if (index3) { - for (int i = 0; i < 3; i++) { - u8 Index = DataReadU8(); - 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(); - } - } - else { + for (int i = 0; i < 3; i++) + { 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(); - } + 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_Indices3(const void *_p) +{ + for (int i = 0; i < 3; i++) + { + u8 Index = DataReadU8(); + 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 --- ///////////////////////////////////////////////////////////////////////////////////////////////////// @@ -340,88 +407,87 @@ void LOADERDECL VertexLoader_Normal::Normal_Index16_Float(const void *_p) 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(); - 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(); - } - } - 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(); - } + 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) + u16 Index = DataReadU16(); + for (int i = 0; i < 3; i++) { - 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(); - 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(); - } + 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(const void *_p) +void LOADERDECL VertexLoader_Normal::Normal_Index16_Float3_Indices1(const void *_p) { - if (index3) + u16 Index = DataReadU16(); + for (int i = 0; i < 3; i++) { - for (int i = 0; i < 3; i++) - { - u16 Index = DataReadU16(); - 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(); - } - } - 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(); - } + 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_Byte3_Indices3(const void *_p) +{ + 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++) + { + u16 Index = DataReadU16(); + 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(); + } +} diff --git a/Source/Plugins/Plugin_VideoOGL/Src/VertexLoader_Normal.h b/Source/Plugins/Plugin_VideoOGL/Src/VertexLoader_Normal.h index 98066c7e53..e3fcdab9c7 100644 --- a/Source/Plugins/Plugin_VideoOGL/Src/VertexLoader_Normal.h +++ b/Source/Plugins/Plugin_VideoOGL/Src/VertexLoader_Normal.h @@ -24,15 +24,14 @@ class VertexLoader_Normal { public: - static bool index3; // Init static void Init(void); // 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 - 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: enum ENormalType @@ -61,9 +60,17 @@ private: NUM_NRM_ELEMENTS }; + enum ENormalIndices + { + NRM_INDICES1 = 0, + NRM_INDICES3 = 1, + NUM_NRM_INDICES + }; + + // tables - static u8 m_sizeTable[NUM_NRM_TYPE][NUM_NRM_FORMAT][NUM_NRM_ELEMENTS]; - static TPipelineFunction m_funcTable[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][NUM_NRM_INDICES]; // direct 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_Short(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_Short3(const void *_p); - static void LOADERDECL Normal_Index8_Float3(const void *_p); + static void LOADERDECL Normal_Index8_Byte3_Indices1(const void *_p); + static void LOADERDECL Normal_Index8_Short3_Indices1(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 static void LOADERDECL Normal_Index16_Byte(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_Byte3(const void *_p); - static void LOADERDECL Normal_Index16_Short3(const void *_p); - static void LOADERDECL Normal_Index16_Float3(const void *_p); + static void LOADERDECL Normal_Index16_Byte3_Indices1(const void *_p); + static void LOADERDECL Normal_Index16_Short3_Indices1(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 diff --git a/Source/Plugins/Plugin_VideoOGL/Src/VertexShaderManager.cpp b/Source/Plugins/Plugin_VideoOGL/Src/VertexShaderManager.cpp index 4964c7a9d3..a483f4b1d7 100644 --- a/Source/Plugins/Plugin_VideoOGL/Src/VertexShaderManager.cpp +++ b/Source/Plugins/Plugin_VideoOGL/Src/VertexShaderManager.cpp @@ -466,7 +466,9 @@ void VertexShaderMngr::SetConstants() g_fProjectionMatrix[12] = 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; } else {