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

Make it possible to turn off the tiny vertex format setup JIT, may help macosx compatibility work (pretty useless, a jit for the actual vertex loading would have been much more useful) 

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@993 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
hrydgard 2008-10-28 21:04:14 +00:00
parent 50547cdb58
commit 22e1ecbb51
4 changed files with 246 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
Source/Core/VideoCommon/Src/NativeVertexFormat.h
View File

@ -18,7 +18,6 @@
#ifndef _NATIVEVERTEXFORMAT_H #ifndef _NATIVEVERTEXFORMAT_H
#define _NATIVEVERTEXFORMAT_H #define _NATIVEVERTEXFORMAT_H
#include "CPMemory.h"
#include "PluginSpecs.h" #include "PluginSpecs.h"
// m_components // m_components
@ -58,6 +57,31 @@ enum {
#define LOADERDECL __cdecl #define LOADERDECL __cdecl
typedef void (LOADERDECL *TPipelineFunction)(const void *); typedef void (LOADERDECL *TPipelineFunction)(const void *);
enum VarType {
VAR_BYTE,
VAR_UNSIGNED_BYTE,
VAR_SHORT,
VAR_UNSIGNED_SHORT,
VAR_FLOAT,
};
struct PortableVertexDeclaration
{
int stride;
int num_normals;
int normal_offset[3];
VarType normal_gl_type;
int normal_gl_size;
VarType color_gl_type; // always GL_UNSIGNED_BYTE
int color_offset[2];
VarType texcoord_gl_type[8];
int texcoord_gl_size[8];
int texcoord_offset[8];
int texcoord_size[8];
int posmtx_offset;
};
// The implementation of this class is specific for GL/DX, so NativeVertexFormat.cpp // The implementation of this class is specific for GL/DX, so NativeVertexFormat.cpp
// is in the respective plugin, not here in VideoCommon. // is in the respective plugin, not here in VideoCommon.
@ -66,15 +90,15 @@ typedef void (LOADERDECL *TPipelineFunction)(const void *);
class NativeVertexFormat class NativeVertexFormat
{ {
u8* m_compiledCode; u8* m_compiledCode;
PortableVertexDeclaration vtx_decl;
public: public:
NativeVertexFormat(); NativeVertexFormat();
~NativeVertexFormat(); ~NativeVertexFormat();
void Initialize(const TVtxDesc &vtx_desc, const TVtxAttr &vtx_attr); void Initialize(const PortableVertexDeclaration &vtx_decl);
void SetupVertexPointers() const; void SetupVertexPointers() const;
// TODO: move these in under private: // TODO: move these in under private:
int m_VBVertexStride; // PC-side vertex stride
u32 m_components; // VB_HAS_X. Bitmask telling what vertex components are present. u32 m_components; // VB_HAS_X. Bitmask telling what vertex components are present.
}; };

151
Source/Plugins/Plugin_VideoOGL/Src/NativeVertexFormat.cpp
View File

@ -27,6 +27,10 @@
#define COMPILED_CODE_SIZE 4096 #define COMPILED_CODE_SIZE 4096
#ifdef _WIN32
#define USE_JIT
#endif
// Note the use of CallCdeclFunction3I etc. // Note the use of CallCdeclFunction3I etc.
// This is a horrible hack that is necessary because in 64-bit mode, Opengl32.dll is based way, way above the 32-bit // This is a horrible hack that is necessary because in 64-bit mode, Opengl32.dll is based way, way above the 32-bit
// address space that is within reach of a CALL, and just doing &fn gives us these high uncallable addresses. So we // address space that is within reach of a CALL, and just doing &fn gives us these high uncallable addresses. So we
@ -56,86 +60,52 @@ NativeVertexFormat::~NativeVertexFormat()
m_compiledCode = 0; m_compiledCode = 0;
} }
void NativeVertexFormat::SetupVertexPointers() const { inline GLuint VarToGL(VarType t)
// Cast a pointer to compiled code to a pointer to a function taking no parameters, through a (void *) cast first to {
// get around type checking errors, and call it. switch (t) {
((void (*)())(void*)m_compiledCode)(); case VAR_BYTE: return GL_BYTE;
case VAR_UNSIGNED_BYTE: return GL_UNSIGNED_BYTE;
case VAR_SHORT: return GL_SHORT;
case VAR_UNSIGNED_SHORT: return GL_UNSIGNED_SHORT;
case VAR_FLOAT: return GL_FLOAT;
}
} }
void NativeVertexFormat::Initialize(const TVtxDesc &vtx_desc, const TVtxAttr &vtx_attr) void NativeVertexFormat::Initialize(const PortableVertexDeclaration &vtx_decl)
{ {
using namespace Gen; using namespace Gen;
const int col[2] = {vtx_desc.Color0, vtx_desc.Color1};
// TextureCoord
const int tc[8] = {
vtx_desc.Tex0Coord, vtx_desc.Tex1Coord, vtx_desc.Tex2Coord, vtx_desc.Tex3Coord,
vtx_desc.Tex4Coord, vtx_desc.Tex5Coord, vtx_desc.Tex6Coord, vtx_desc.Tex7Coord,
};
DVSTARTPROFILE(); if (vtx_decl.stride & 3) {
if (m_VBVertexStride & 3) {
// We will not allow vertex components causing uneven strides. // We will not allow vertex components causing uneven strides.
PanicAlert("Uneven vertex stride: %i", m_VBVertexStride); PanicAlert("Uneven vertex stride: %i", vtx_decl.stride);
} }
// compile the pointer set function - why? // Alright, we have our vertex declaration. Compile some crazy code to set it quickly using GL.
u8 *old_code_ptr = GetWritableCodePtr(); u8 *old_code_ptr = GetWritableCodePtr();
SetCodePtr(m_compiledCode); SetCodePtr(m_compiledCode);
Util::EmitPrologue(6); Util::EmitPrologue(6);
int offset = 0;
// Position, part 1 CallCdeclFunction4_I(glVertexPointer, 3, GL_FLOAT, vtx_decl.stride, 0);
if (vtx_desc.Position != NOT_PRESENT) { // TODO: Why the check? Always present, AFAIK!
CallCdeclFunction4_I(glVertexPointer, 3, GL_FLOAT, m_VBVertexStride, 0);
offset += 12;
}
// Normals if (vtx_decl.num_normals >= 1) {
if (vtx_desc.Normal != NOT_PRESENT) { CallCdeclFunction3_I(glNormalPointer, VarToGL(vtx_decl.normal_gl_type), vtx_decl.stride, vtx_decl.normal_offset[0]);
switch (vtx_attr.NormalFormat) { if (vtx_decl.num_normals == 3) {
case FORMAT_UBYTE: CallCdeclFunction6((void *)glVertexAttribPointer, SHADER_NORM1_ATTRIB, vtx_decl.normal_gl_size, VarToGL(vtx_decl.normal_gl_type), GL_TRUE, vtx_decl.stride, vtx_decl.normal_offset[1]);
case FORMAT_BYTE: CallCdeclFunction6((void *)glVertexAttribPointer, SHADER_NORM2_ATTRIB, vtx_decl.normal_gl_size, VarToGL(vtx_decl.normal_gl_type), GL_TRUE, vtx_decl.stride, vtx_decl.normal_offset[2]);
CallCdeclFunction3_I(glNormalPointer, GL_BYTE, m_VBVertexStride, offset); offset += 4;
if (vtx_attr.NormalElements) {
CallCdeclFunction6((void *)glVertexAttribPointer, SHADER_NORM1_ATTRIB, 4, GL_BYTE, GL_TRUE, m_VBVertexStride, offset); offset += 4;
CallCdeclFunction6((void *)glVertexAttribPointer, SHADER_NORM2_ATTRIB, 4, GL_BYTE, GL_TRUE, m_VBVertexStride, offset); offset += 4;
}
break;
case FORMAT_USHORT:
case FORMAT_SHORT:
CallCdeclFunction3_I(glNormalPointer, GL_SHORT, m_VBVertexStride, offset); offset += 8;
if (vtx_attr.NormalElements) {
CallCdeclFunction6((void *)glVertexAttribPointer, SHADER_NORM1_ATTRIB, 4, GL_SHORT, GL_TRUE, m_VBVertexStride, offset); offset += 8;
CallCdeclFunction6((void *)glVertexAttribPointer, SHADER_NORM2_ATTRIB, 4, GL_SHORT, GL_TRUE, m_VBVertexStride, offset); offset += 8;
}
break;
case FORMAT_FLOAT:
CallCdeclFunction3_I(glNormalPointer, GL_FLOAT, m_VBVertexStride, offset); offset += 12;
if (vtx_attr.NormalElements) {
CallCdeclFunction6((void *)glVertexAttribPointer, SHADER_NORM1_ATTRIB, 3, GL_FLOAT, GL_TRUE, m_VBVertexStride, offset); offset += 12;
CallCdeclFunction6((void *)glVertexAttribPointer, SHADER_NORM2_ATTRIB, 3, GL_FLOAT, GL_TRUE, m_VBVertexStride, offset); offset += 12;
}
break;
default: _assert_(0); break;
} }
} }
// TODO : With byte or short normals above, offset will be misaligned (not 4byte aligned)! Ugh!
for (int i = 0; i < 2; i++) { for (int i = 0; i < 2; i++) {
if (col[i] != NOT_PRESENT) { if (vtx_decl.color_offset[i] != -1) {
if (i) if (i == 0)
CallCdeclFunction4((void *)glSecondaryColorPointer, 4, GL_UNSIGNED_BYTE, m_VBVertexStride, offset); CallCdeclFunction4_I(glColorPointer, 4, GL_UNSIGNED_BYTE, vtx_decl.stride, vtx_decl.color_offset[i]);
else else
CallCdeclFunction4_I(glColorPointer, 4, GL_UNSIGNED_BYTE, m_VBVertexStride, offset); CallCdeclFunction4((void *)glSecondaryColorPointer, 4, GL_UNSIGNED_BYTE, vtx_decl.stride, vtx_decl.color_offset[i]);
offset += 4;
} }
} }
// TextureCoord
for (int i = 0; i < 8; i++) { for (int i = 0; i < 8; i++) {
if (tc[i] != NOT_PRESENT || (m_components & (VB_HAS_TEXMTXIDX0 << i))) { if (vtx_decl.texcoord_offset[i] != -1) {
int id = GL_TEXTURE0 + i; int id = GL_TEXTURE0 + i;
#ifdef _M_X64 #ifdef _M_X64
#ifdef _MSC_VER #ifdef _MSC_VER
@ -155,31 +125,16 @@ void NativeVertexFormat::Initialize(const TVtxDesc &vtx_desc, const TVtxAttr &vt
ABI_RestoreStack(1 * 4); ABI_RestoreStack(1 * 4);
#endif #endif
#endif #endif
// TODO : More potential disalignment! CallCdeclFunction4_I(
if (m_components & (VB_HAS_TEXMTXIDX0 << i)) { glTexCoordPointer, vtx_decl.texcoord_size[i], VarToGL(vtx_decl.texcoord_gl_type[i]),
if (tc[i] != NOT_PRESENT) { vtx_decl.stride, vtx_decl.texcoord_offset[i]);
CallCdeclFunction4_I(glTexCoordPointer, 3, GL_FLOAT, m_VBVertexStride, offset);
offset += 12;
}
else {
CallCdeclFunction4_I(glTexCoordPointer, 3, GL_SHORT, m_VBVertexStride, offset);
offset += 8;
}
}
else {
CallCdeclFunction4_I(glTexCoordPointer, vtx_attr.texCoord[i].Elements ? 2 : 1, GL_FLOAT, m_VBVertexStride, offset);
offset += 4 * (vtx_attr.texCoord[i].Elements ? 2 : 1);
}
} }
} }
if (vtx_desc.PosMatIdx) { if (vtx_decl.posmtx_offset != -1) {
CallCdeclFunction6((void *)glVertexAttribPointer, SHADER_POSMTX_ATTRIB, 4, GL_UNSIGNED_BYTE, GL_FALSE, m_VBVertexStride, offset); CallCdeclFunction6((void *)glVertexAttribPointer, SHADER_POSMTX_ATTRIB, 4, GL_UNSIGNED_BYTE, GL_FALSE, vtx_decl.stride, vtx_decl.posmtx_offset);
offset += 4;
} }
_assert_(offset + m_VBStridePad == m_VBVertexStride);
Util::EmitEpilogue(6); Util::EmitEpilogue(6);
if (Gen::GetCodePtr() - (u8*)m_compiledCode > COMPILED_CODE_SIZE) if (Gen::GetCodePtr() - (u8*)m_compiledCode > COMPILED_CODE_SIZE)
{ {
@ -187,4 +142,44 @@ void NativeVertexFormat::Initialize(const TVtxDesc &vtx_desc, const TVtxAttr &vt
} }
SetCodePtr(old_code_ptr); SetCodePtr(old_code_ptr);
this->vtx_decl = vtx_decl;
}
void NativeVertexFormat::SetupVertexPointers() const {
// Cast a pointer to compiled code to a pointer to a function taking no parameters, through a (void *) cast first to
// get around type checking errors, and call it.
#ifdef USE_JIT
((void (*)())(void*)m_compiledCode)();
#else
glVertexPointer(3, GL_FLOAT, vtx_decl.stride, 0);
if (vtx_decl.num_normals >= 1) {
glNormalPointer(VarToGL(vtx_decl.normal_gl_type), vtx_decl.stride, (void *)vtx_decl.normal_offset[0]);
if (vtx_decl.num_normals == 3) {
glVertexAttribPointer(SHADER_NORM1_ATTRIB, vtx_decl.normal_gl_size, VarToGL(vtx_decl.normal_gl_type), GL_TRUE, vtx_decl.stride, (void *)vtx_decl.normal_offset[1]);
glVertexAttribPointer(SHADER_NORM2_ATTRIB, vtx_decl.normal_gl_size, VarToGL(vtx_decl.normal_gl_type), GL_TRUE, vtx_decl.stride, (void *)vtx_decl.normal_offset[2]);
}
}
for (int i = 0; i < 2; i++) {
if (vtx_decl.color_offset[i] != -1) {
if (i == 0)
glColorPointer(4, GL_UNSIGNED_BYTE, vtx_decl.stride, (void *)vtx_decl.color_offset[i]);
else
glSecondaryColorPointer(4, GL_UNSIGNED_BYTE, vtx_decl.stride, (void *)vtx_decl.color_offset[i]);
}
}
for (int i = 0; i < 8; i++) {
if (vtx_decl.texcoord_offset[i] != -1) {
int id = GL_TEXTURE0 + i;
glClientActiveTexture(id);
glTexCoordPointer(vtx_decl.texcoord_size[i], VarToGL(vtx_decl.texcoord_gl_type[i]),
vtx_decl.stride, (void *)vtx_decl.texcoord_offset[i]);
}
}
if (vtx_decl.posmtx_offset != -1) {
glVertexAttribPointer(SHADER_POSMTX_ATTRIB, 4, GL_UNSIGNED_BYTE, GL_FALSE, vtx_decl.stride, (void *)vtx_decl.posmtx_offset);
}
#endif
} }

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

@ -225,13 +225,24 @@ int VertexLoader::ComputeVertexSize()
void VertexLoader::CompileVertexTranslator() void VertexLoader::CompileVertexTranslator()
{ {
// Colors
const int col[2] = {m_VtxDesc.Color0, m_VtxDesc.Color1};
// TextureCoord
const int tc[8] = {
m_VtxDesc.Tex0Coord, m_VtxDesc.Tex1Coord, m_VtxDesc.Tex2Coord, m_VtxDesc.Tex3Coord,
m_VtxDesc.Tex4Coord, m_VtxDesc.Tex5Coord, m_VtxDesc.Tex6Coord, m_VtxDesc.Tex7Coord,
};
// Reset pipeline // Reset pipeline
m_numPipelineStages = 0; m_numPipelineStages = 0;
// It's a bit ugly that we poke inside m_NativeFmt in this function. Planning to fix this. // It's a bit ugly that we poke inside m_NativeFmt in this function. Planning to fix this.
m_NativeFmt->m_VBVertexStride = 0; native_stride = 0;
m_NativeFmt->m_components = 0; m_NativeFmt->m_components = 0;
// Position
int offset = 0;
// m_VBVertexStride for texmtx and posmtx is computed later when writing. // m_VBVertexStride for texmtx and posmtx is computed later when writing.
// Position Matrix Index // Position Matrix Index
@ -250,8 +261,10 @@ void VertexLoader::CompileVertexTranslator()
if (m_VtxDesc.Tex7MatIdx) {m_NativeFmt->m_components |= VB_HAS_TEXMTXIDX7; WriteCall(TexMtx_ReadDirect_UByte); } if (m_VtxDesc.Tex7MatIdx) {m_NativeFmt->m_components |= VB_HAS_TEXMTXIDX7; WriteCall(TexMtx_ReadDirect_UByte); }
// Position // Position
if (m_VtxDesc.Position != NOT_PRESENT) if (m_VtxDesc.Position != NOT_PRESENT) {
m_NativeFmt->m_VBVertexStride += 12; offset += 12;
native_stride += 12;
}
switch (m_VtxDesc.Position) { switch (m_VtxDesc.Position) {
case NOT_PRESENT: {_assert_msg_(0, "Vertex descriptor without position!", "WTF?");} break; case NOT_PRESENT: {_assert_msg_(0, "Vertex descriptor without position!", "WTF?");} break;
@ -311,29 +324,22 @@ void VertexLoader::CompileVertexTranslator()
case FORMAT_FLOAT: sizePro = 4*3; break; case FORMAT_FLOAT: sizePro = 4*3; break;
default: _assert_(0); break; default: _assert_(0); break;
} }
m_NativeFmt->m_VBVertexStride += sizePro * (m_VtxAttr.NormalElements?3:1); native_stride += sizePro * (m_VtxAttr.NormalElements?3:1);
int numNormals = (m_VtxAttr.NormalElements == 1) ? NRM_THREE : NRM_ONE; int numNormals = (m_VtxAttr.NormalElements == 1) ? NRM_THREE : NRM_ONE;
m_NativeFmt->m_components |= VB_HAS_NRM0; m_NativeFmt->m_components |= VB_HAS_NRM0;
if (numNormals == NRM_THREE) if (numNormals == NRM_THREE)
m_NativeFmt->m_components |= VB_HAS_NRM1 | VB_HAS_NRM2; m_NativeFmt->m_components |= VB_HAS_NRM1 | VB_HAS_NRM2;
} }
// Colors
int col[2] = {m_VtxDesc.Color0, m_VtxDesc.Color1};
for (int i = 0; i < 2; i++) { for (int i = 0; i < 2; i++) {
SetupColor(i, col[i], m_VtxAttr.color[i].Comp, m_VtxAttr.color[i].Elements); SetupColor(i, col[i], m_VtxAttr.color[i].Comp, m_VtxAttr.color[i].Elements);
if (col[i] != NOT_PRESENT) if (col[i] != NOT_PRESENT)
m_NativeFmt->m_VBVertexStride += 4; native_stride += 4;
} }
// TextureCoord
int tc[8] = {
m_VtxDesc.Tex0Coord, m_VtxDesc.Tex1Coord, m_VtxDesc.Tex2Coord, m_VtxDesc.Tex3Coord,
m_VtxDesc.Tex4Coord, m_VtxDesc.Tex5Coord, m_VtxDesc.Tex6Coord, m_VtxDesc.Tex7Coord,
};
// Texture matrix indices (remove if corresponding texture coordinate isn't enabled) // Texture matrix indices (remove if corresponding texture coordinate isn't enabled)
for (int i = 0; i < 8; i++) { for (int i = 0; i < 8; i++) {
SetupTexCoord(i, tc[i], m_VtxAttr.texCoord[i].Format, m_VtxAttr.texCoord[i].Elements, m_VtxAttr.texCoord[i].Frac); SetupTexCoord(i, tc[i], m_VtxAttr.texCoord[i].Format, m_VtxAttr.texCoord[i].Elements, m_VtxAttr.texCoord[i].Frac);
@ -341,17 +347,17 @@ void VertexLoader::CompileVertexTranslator()
if (tc[i] != NOT_PRESENT) { if (tc[i] != NOT_PRESENT) {
// if texmtx is included, texcoord will always be 3 floats, z will be the texmtx index // if texmtx is included, texcoord will always be 3 floats, z will be the texmtx index
WriteCall(m_VtxAttr.texCoord[i].Elements ? TexMtx_Write_Float : TexMtx_Write_Float2); WriteCall(m_VtxAttr.texCoord[i].Elements ? TexMtx_Write_Float : TexMtx_Write_Float2);
m_NativeFmt->m_VBVertexStride += 12; native_stride += 12;
} }
else { else {
WriteCall(TexMtx_Write_Short3); WriteCall(TexMtx_Write_Short3);
m_NativeFmt->m_VBVertexStride += 8; // still include the texture coordinate, but this time as 6 bytes native_stride += 8; // still include the texture coordinate, but this time as 6 + 2 bytes
m_NativeFmt->m_components |= VB_HAS_UV0 << i; // have to include since using now m_NativeFmt->m_components |= VB_HAS_UV0 << i; // have to include since using now
} }
} }
else { else {
if (tc[i] != NOT_PRESENT) if (tc[i] != NOT_PRESENT)
m_NativeFmt->m_VBVertexStride += 4 * (m_VtxAttr.texCoord[i].Elements ? 2 : 1); native_stride += 4 * (m_VtxAttr.texCoord[i].Elements ? 2 : 1);
} }
if (tc[i] == NOT_PRESENT) { if (tc[i] == NOT_PRESENT) {
@ -370,17 +376,122 @@ void VertexLoader::CompileVertexTranslator()
if (m_VtxDesc.PosMatIdx) { if (m_VtxDesc.PosMatIdx) {
WriteCall(PosMtx_Write); WriteCall(PosMtx_Write);
m_NativeFmt->m_VBVertexStride += 4; native_stride += 4;
} }
m_NativeFmt->Initialize(m_VtxDesc, m_VtxAttr); PortableVertexDeclaration vtx_decl;
int m_components = m_NativeFmt->m_components;
const TVtxAttr &vtx_attr = m_VtxAttr;
const TVtxDesc &vtx_desc = m_VtxDesc;
// Normals
vtx_decl.num_normals = 0;
if (vtx_desc.Normal != NOT_PRESENT) {
vtx_decl.num_normals = vtx_attr.NormalElements ? 3 : 1;
switch (vtx_attr.NormalFormat) {
case FORMAT_UBYTE:
case FORMAT_BYTE:
vtx_decl.normal_gl_type = VAR_BYTE;
vtx_decl.normal_gl_size = 4;
vtx_decl.normal_offset[0] = offset;
offset += 4;
if (vtx_attr.NormalElements) {
vtx_decl.normal_offset[1] = offset;
offset += 4;
vtx_decl.normal_offset[2] = offset;
offset += 4;
}
break;
case FORMAT_USHORT:
case FORMAT_SHORT:
vtx_decl.normal_gl_type = VAR_SHORT;
vtx_decl.normal_gl_size = 4;
vtx_decl.normal_offset[0] = offset;
offset += 8;
if (vtx_attr.NormalElements) {
vtx_decl.normal_offset[1] = offset;
offset += 8;
vtx_decl.normal_offset[2] = offset;
offset += 8;
}
break;
case FORMAT_FLOAT:
vtx_decl.normal_gl_type = VAR_FLOAT;
vtx_decl.normal_gl_size = 3;
vtx_decl.normal_offset[0] = offset;
offset += 12;
if (vtx_attr.NormalElements) {
vtx_decl.normal_offset[1] = offset;
offset += 12;
vtx_decl.normal_offset[2] = offset;
offset += 12;
}
break;
default: _assert_(0); break;
}
}
// TODO : With byte or short normals above, offset will be misaligned (not 4byte aligned)! Ugh!
vtx_decl.color_gl_type = VAR_UNSIGNED_BYTE;
for (int i = 0; i < 2; i++) {
if (col[i] != NOT_PRESENT) {
vtx_decl.color_offset[i] = offset;
offset += 4;
} else {
vtx_decl.color_offset[i] = -1;
}
}
// TextureCoord
for (int i = 0; i < 8; i++) {
if (tc[i] != NOT_PRESENT || (m_components & (VB_HAS_TEXMTXIDX0 << i))) {
// TODO : More potential disalignment!
if (m_components & (VB_HAS_TEXMTXIDX0 << i)) {
if (tc[i] != NOT_PRESENT) {
vtx_decl.texcoord_offset[i] = offset;
vtx_decl.texcoord_gl_type[i] = VAR_FLOAT;
vtx_decl.texcoord_size[i] = 3;
offset += 12;
}
else {
vtx_decl.texcoord_offset[i] = offset;
vtx_decl.texcoord_gl_type[i] = VAR_SHORT;
vtx_decl.texcoord_size[i] = 4;
offset += 8;
}
}
else {
vtx_decl.texcoord_offset[i] = offset;
vtx_decl.texcoord_gl_type[i] = VAR_FLOAT;
vtx_decl.texcoord_size[i] = vtx_attr.texCoord[i].Elements ? 2 : 1;
offset += 4 * (vtx_attr.texCoord[i].Elements ? 2 : 1);
}
} else {
vtx_decl.texcoord_offset[i] = -1;
}
}
if (vtx_desc.PosMatIdx) {
vtx_decl.posmtx_offset = offset;
offset += 4;
} else {
vtx_decl.posmtx_offset = -1;
}
vtx_decl.stride = native_stride;
if (vtx_decl.stride != offset)
PanicAlert("offset/stride mismatch, %i %i", vtx_decl.stride, offset);
m_NativeFmt->Initialize(vtx_decl);
} }
void VertexLoader::SetupColor(int num, int mode, int format, int elements) void VertexLoader::SetupColor(int num, int mode, int format, int elements)
{ {
// if COL0 not present, then embed COL1 into COL0 // if COL0 not present, then embed COL1 into COL0
if (num == 1 && !(m_NativeFmt->m_components & VB_HAS_COL0)) // if (num == 1 && !(m_NativeFmt->m_components & VB_HAS_COL0))
num = 0; // num = 0;
m_NativeFmt->m_components |= VB_HAS_COL0 << num; m_NativeFmt->m_components |= VB_HAS_COL0 << num;
switch (mode) switch (mode)
@ -526,11 +637,11 @@ void VertexLoader::RunVertices(int vtx_attr_group, int primitive, int count)
switch (primitive) { switch (primitive) {
case 3: // strip case 3: // strip
case 4: // fan case 4: // fan
if (VertexManager::GetRemainingSize() < 3 * m_NativeFmt->m_VBVertexStride) if (VertexManager::GetRemainingSize() < 3 * native_stride)
VertexManager::Flush(); VertexManager::Flush();
break; break;
case 6: // line strip case 6: // line strip
if (VertexManager::GetRemainingSize() < 2 * m_NativeFmt->m_VBVertexStride) if (VertexManager::GetRemainingSize() < 2 * native_stride)
VertexManager::Flush(); VertexManager::Flush();
break; break;
case 0: // quads case 0: // quads
@ -550,7 +661,7 @@ void VertexLoader::RunVertices(int vtx_attr_group, int primitive, int count)
{ {
if ((v % granularity) == 0) if ((v % granularity) == 0)
{ {
if (VertexManager::GetRemainingSize() < granularity*m_NativeFmt->m_VBVertexStride) { if (VertexManager::GetRemainingSize() < granularity*native_stride) {
// This buffer full - break current primitive and flush, to switch to the next buffer. // This buffer full - break current primitive and flush, to switch to the next buffer.
u8* plastptr = VertexManager::s_pCurBufferPointer; u8* plastptr = VertexManager::s_pCurBufferPointer;
if (v - startv > 0) if (v - startv > 0)
@ -561,27 +672,27 @@ void VertexLoader::RunVertices(int vtx_attr_group, int primitive, int count)
case 3: // triangle strip, copy last two vertices case 3: // triangle strip, copy last two vertices
// a little trick since we have to keep track of signs // a little trick since we have to keep track of signs
if (v & 1) { if (v & 1) {
memcpy_gc(VertexManager::s_pCurBufferPointer, plastptr-2*m_NativeFmt->m_VBVertexStride, m_NativeFmt->m_VBVertexStride); memcpy_gc(VertexManager::s_pCurBufferPointer, plastptr-2*native_stride, native_stride);
memcpy_gc(VertexManager::s_pCurBufferPointer+m_NativeFmt->m_VBVertexStride, plastptr-m_NativeFmt->m_VBVertexStride*2, 2*m_NativeFmt->m_VBVertexStride); memcpy_gc(VertexManager::s_pCurBufferPointer+native_stride, plastptr-native_stride*2, 2*native_stride);
VertexManager::s_pCurBufferPointer += m_NativeFmt->m_VBVertexStride*3; VertexManager::s_pCurBufferPointer += native_stride*3;
extraverts = 3; extraverts = 3;
} }
else { else {
memcpy_gc(VertexManager::s_pCurBufferPointer, plastptr-m_NativeFmt->m_VBVertexStride*2, m_NativeFmt->m_VBVertexStride*2); memcpy_gc(VertexManager::s_pCurBufferPointer, plastptr-native_stride*2, native_stride*2);
VertexManager::s_pCurBufferPointer += m_NativeFmt->m_VBVertexStride*2; VertexManager::s_pCurBufferPointer += native_stride*2;
extraverts = 2; extraverts = 2;
} }
break; break;
case 4: // tri fan, copy first and last vert case 4: // tri fan, copy first and last vert
memcpy_gc(VertexManager::s_pCurBufferPointer, plastptr-m_NativeFmt->m_VBVertexStride*(v-startv+extraverts), m_NativeFmt->m_VBVertexStride); memcpy_gc(VertexManager::s_pCurBufferPointer, plastptr-native_stride*(v-startv+extraverts), native_stride);
VertexManager::s_pCurBufferPointer += m_NativeFmt->m_VBVertexStride; VertexManager::s_pCurBufferPointer += native_stride;
memcpy_gc(VertexManager::s_pCurBufferPointer, plastptr-m_NativeFmt->m_VBVertexStride, m_NativeFmt->m_VBVertexStride); memcpy_gc(VertexManager::s_pCurBufferPointer, plastptr-native_stride, native_stride);
VertexManager::s_pCurBufferPointer += m_NativeFmt->m_VBVertexStride; VertexManager::s_pCurBufferPointer += native_stride;
extraverts = 2; extraverts = 2;
break; break;
case 6: // line strip case 6: // line strip
memcpy_gc(VertexManager::s_pCurBufferPointer, plastptr-m_NativeFmt->m_VBVertexStride, m_NativeFmt->m_VBVertexStride); memcpy_gc(VertexManager::s_pCurBufferPointer, plastptr-native_stride, native_stride);
VertexManager::s_pCurBufferPointer += m_NativeFmt->m_VBVertexStride; VertexManager::s_pCurBufferPointer += native_stride;
extraverts = 1; extraverts = 1;
break; break;
default: default:

1
Source/Plugins/Plugin_VideoOGL/Src/VertexLoader.h
View File

@ -75,6 +75,7 @@ private:
// PC vertex format // PC vertex format
NativeVertexFormat *m_NativeFmt; NativeVertexFormat *m_NativeFmt;
int native_stride;
// Pipeline. To be JIT compiled in the future. // Pipeline. To be JIT compiled in the future.
TPipelineFunction m_PipelineStages[32]; // TODO - figure out real max. it's lower. TPipelineFunction m_PipelineStages[32]; // TODO - figure out real max. it's lower.