mirror of
https://github.com/baldurk/renderdoc.git
synced 2026-05-28 04:41:07 +00:00
Implement remaining glVertexAttrib functions
This commit is contained in:
baldurk
@@ -191,7 +191,7 @@ enum GLChunkType
|
||||
SCISSOR_ARRAY,
|
||||
BINDVERTEXARRAY,
|
||||
BINDVERTEXBUFFER,
|
||||
VERTEXDIVISOR,
|
||||
VERTEXBINDINGDIVISOR,
|
||||
DISPATCH_COMPUTE,
|
||||
MEMORY_BARRIER,
|
||||
DRAWARRAYS,
|
||||
@@ -235,12 +235,16 @@ enum GLChunkType
|
||||
UNMAP,
|
||||
GEN_VERTEXARRAY,
|
||||
BIND_VERTEXARRAY,
|
||||
VERTEXATTRIB_GENERIC,
|
||||
VERTEXATTRIBPOINTER,
|
||||
VERTEXATTRIBIPOINTER,
|
||||
VERTEXATTRIBLPOINTER,
|
||||
ENABLEVERTEXATTRIBARRAY,
|
||||
DISABLEVERTEXATTRIBARRAY,
|
||||
VERTEXATTRIBFORMAT,
|
||||
VERTEXATTRIBIFORMAT,
|
||||
VERTEXATTRIBLFORMAT,
|
||||
VERTEXATTRIBDIVISOR,
|
||||
VERTEXATTRIBBINDING,
|
||||
|
||||
OBJECT_LABEL,
|
||||
|
||||
@@ -188,12 +188,16 @@ const char *GLChunkNames[] =
|
||||
"glUnmapBuffer",
|
||||
"glGenVertexArrays",
|
||||
"glBindVertexArray",
|
||||
"glVertexAttrib*",
|
||||
"glVertexAttribPointer",
|
||||
"glVertexAttribIPointer",
|
||||
"glVertexAttribLPointer",
|
||||
"glEnableVertexAttribArray",
|
||||
"glDisableVertexAttribArray",
|
||||
"glVertexAttribFormat",
|
||||
"glVertexAttribIFormat",
|
||||
"glVertexAttribLFormat",
|
||||
"glVertexAttribDivisor",
|
||||
"glVertexAttribBinding",
|
||||
|
||||
|
||||
@@ -1702,7 +1706,7 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
|
||||
case BINDVERTEXBUFFER:
|
||||
Serialise_glBindVertexBuffer(0, 0, 0, 0);
|
||||
break;
|
||||
case VERTEXDIVISOR:
|
||||
case VERTEXBINDINGDIVISOR:
|
||||
Serialise_glVertexBindingDivisor(0, 0);
|
||||
break;
|
||||
case DISPATCH_COMPUTE:
|
||||
@@ -1834,18 +1838,30 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
|
||||
case VERTEXATTRIBIPOINTER:
|
||||
Serialise_glVertexAttribIPointer(0, 0, eGL_NONE, 0, NULL);
|
||||
break;
|
||||
case VERTEXATTRIBLPOINTER:
|
||||
Serialise_glVertexAttribLPointer(0, 0, eGL_NONE, 0, NULL);
|
||||
break;
|
||||
case ENABLEVERTEXATTRIBARRAY:
|
||||
Serialise_glEnableVertexAttribArray(0);
|
||||
break;
|
||||
case DISABLEVERTEXATTRIBARRAY:
|
||||
Serialise_glDisableVertexAttribArray(0);
|
||||
break;
|
||||
case VERTEXATTRIB_GENERIC:
|
||||
Serialise_glVertexAttrib(0, 0, eGL_NONE, GL_FALSE, NULL, Attrib_packed);
|
||||
break;
|
||||
case VERTEXATTRIBFORMAT:
|
||||
Serialise_glVertexAttribFormat(0, 0, eGL_NONE, 0, 0);
|
||||
break;
|
||||
case VERTEXATTRIBIFORMAT:
|
||||
Serialise_glVertexAttribIFormat(0, 0, eGL_NONE, 0);
|
||||
break;
|
||||
case VERTEXATTRIBLFORMAT:
|
||||
Serialise_glVertexAttribLFormat(0, 0, eGL_NONE, 0);
|
||||
break;
|
||||
case VERTEXATTRIBDIVISOR:
|
||||
Serialise_glVertexAttribDivisor(0, 0);
|
||||
break;
|
||||
case VERTEXATTRIBBINDING:
|
||||
Serialise_glVertexAttribBinding(0, 0);
|
||||
break;
|
||||
|
||||
@@ -496,11 +496,108 @@ class WrappedOpenGL
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data));
|
||||
|
||||
enum AttribType
|
||||
{
|
||||
Attrib_GLdouble = 0x01,
|
||||
Attrib_GLfloat = 0x02,
|
||||
Attrib_GLshort = 0x03,
|
||||
Attrib_GLushort = 0x04,
|
||||
Attrib_GLbyte = 0x05,
|
||||
Attrib_GLubyte = 0x06,
|
||||
Attrib_GLint = 0x07,
|
||||
Attrib_GLuint = 0x08,
|
||||
Attrib_packed = 0x09,
|
||||
Attrib_typemask = 0x0f,
|
||||
|
||||
Attrib_L = 0x10,
|
||||
Attrib_I = 0x20,
|
||||
Attrib_N = 0x40,
|
||||
};
|
||||
|
||||
bool Serialise_glVertexAttrib(GLuint index, int count, GLenum type, GLboolean normalized, const void *value, int attribtype);
|
||||
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib1d(GLuint index, GLdouble x));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib1dv(GLuint index, const GLdouble *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib1f(GLuint index, GLfloat x));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib1fv(GLuint index, const GLfloat *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib1s(GLuint index, GLshort x));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib1sv(GLuint index, const GLshort *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib2dv(GLuint index, const GLdouble *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib2fv(GLuint index, const GLfloat *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib2s(GLuint index, GLshort x, GLshort y));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib2sv(GLuint index, const GLshort *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib3dv(GLuint index, const GLdouble *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib3fv(GLuint index, const GLfloat *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib3sv(GLuint index, const GLshort *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib4Nbv(GLuint index, const GLbyte *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib4Niv(GLuint index, const GLint *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib4Nsv(GLuint index, const GLshort *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib4Nubv(GLuint index, const GLubyte *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib4Nuiv(GLuint index, const GLuint *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib4Nusv(GLuint index, const GLushort *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib4bv(GLuint index, const GLbyte *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib4dv(GLuint index, const GLdouble *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib4fv(GLuint index, const GLfloat *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib4iv(GLuint index, const GLint *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib4sv(GLuint index, const GLshort *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib4ubv(GLuint index, const GLubyte *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib4uiv(GLuint index, const GLuint *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib4usv(GLuint index, const GLushort *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribI1i(GLuint index, GLint x));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribI1iv(GLuint index, const GLint *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribI1ui(GLuint index, GLuint x));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribI1uiv(GLuint index, const GLuint *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribI2i(GLuint index, GLint x, GLint y));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribI2iv(GLuint index, const GLint *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribI2ui(GLuint index, GLuint x, GLuint y));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribI2uiv(GLuint index, const GLuint *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribI3iv(GLuint index, const GLint *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribI3uiv(GLuint index, const GLuint *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribI4bv(GLuint index, const GLbyte *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribI4iv(GLuint index, const GLint *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribI4sv(GLuint index, const GLshort *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribI4ubv(GLuint index, const GLubyte *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribI4uiv(GLuint index, const GLuint *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribI4usv(GLuint index, const GLushort *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribL1d(GLuint index, GLdouble x));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribL1dv(GLuint index, const GLdouble *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribL2dv(GLuint index, const GLdouble *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribL3dv(GLuint index, const GLdouble *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribL4dv(GLuint index, const GLdouble *v));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value));
|
||||
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribBinding(GLuint attribindex, GLuint bindingindex));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribDivisor(GLuint index, GLuint divisor));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glEnableVertexAttribArray(GLuint index));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glDisableVertexAttribArray(GLuint index));
|
||||
IMPLEMENT_FUNCTION_SERIALISED(void, glGenVertexArrays(GLsizei n, GLuint *arrays));
|
||||
|
||||
@@ -299,11 +299,86 @@ struct GLHookSet
|
||||
PFNGLGENVERTEXARRAYSPROC glGenVertexArrays;
|
||||
PFNGLBINDVERTEXARRAYPROC glBindVertexArray;
|
||||
PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays;
|
||||
PFNGLVERTEXATTRIB1DPROC glVertexAttrib1d;
|
||||
PFNGLVERTEXATTRIB1DVPROC glVertexAttrib1dv;
|
||||
PFNGLVERTEXATTRIB1FPROC glVertexAttrib1f;
|
||||
PFNGLVERTEXATTRIB1FVPROC glVertexAttrib1fv;
|
||||
PFNGLVERTEXATTRIB1SPROC glVertexAttrib1s;
|
||||
PFNGLVERTEXATTRIB1SVPROC glVertexAttrib1sv;
|
||||
PFNGLVERTEXATTRIB2DPROC glVertexAttrib2d;
|
||||
PFNGLVERTEXATTRIB2DVPROC glVertexAttrib2dv;
|
||||
PFNGLVERTEXATTRIB2FPROC glVertexAttrib2f;
|
||||
PFNGLVERTEXATTRIB2FVPROC glVertexAttrib2fv;
|
||||
PFNGLVERTEXATTRIB2SPROC glVertexAttrib2s;
|
||||
PFNGLVERTEXATTRIB2SVPROC glVertexAttrib2sv;
|
||||
PFNGLVERTEXATTRIB3DPROC glVertexAttrib3d;
|
||||
PFNGLVERTEXATTRIB3DVPROC glVertexAttrib3dv;
|
||||
PFNGLVERTEXATTRIB3FPROC glVertexAttrib3f;
|
||||
PFNGLVERTEXATTRIB3FVPROC glVertexAttrib3fv;
|
||||
PFNGLVERTEXATTRIB3SPROC glVertexAttrib3s;
|
||||
PFNGLVERTEXATTRIB3SVPROC glVertexAttrib3sv;
|
||||
PFNGLVERTEXATTRIB4NBVPROC glVertexAttrib4Nbv;
|
||||
PFNGLVERTEXATTRIB4NIVPROC glVertexAttrib4Niv;
|
||||
PFNGLVERTEXATTRIB4NSVPROC glVertexAttrib4Nsv;
|
||||
PFNGLVERTEXATTRIB4NUBPROC glVertexAttrib4Nub;
|
||||
PFNGLVERTEXATTRIB4NUBVPROC glVertexAttrib4Nubv;
|
||||
PFNGLVERTEXATTRIB4NUIVPROC glVertexAttrib4Nuiv;
|
||||
PFNGLVERTEXATTRIB4NUSVPROC glVertexAttrib4Nusv;
|
||||
PFNGLVERTEXATTRIB4BVPROC glVertexAttrib4bv;
|
||||
PFNGLVERTEXATTRIB4DPROC glVertexAttrib4d;
|
||||
PFNGLVERTEXATTRIB4DVPROC glVertexAttrib4dv;
|
||||
PFNGLVERTEXATTRIB4FPROC glVertexAttrib4f;
|
||||
PFNGLVERTEXATTRIB4FVPROC glVertexAttrib4fv;
|
||||
PFNGLVERTEXATTRIB4IVPROC glVertexAttrib4iv;
|
||||
PFNGLVERTEXATTRIB4SPROC glVertexAttrib4s;
|
||||
PFNGLVERTEXATTRIB4SVPROC glVertexAttrib4sv;
|
||||
PFNGLVERTEXATTRIB4UBVPROC glVertexAttrib4ubv;
|
||||
PFNGLVERTEXATTRIB4UIVPROC glVertexAttrib4uiv;
|
||||
PFNGLVERTEXATTRIB4USVPROC glVertexAttrib4usv;
|
||||
PFNGLVERTEXATTRIBI1IPROC glVertexAttribI1i;
|
||||
PFNGLVERTEXATTRIBI1IVPROC glVertexAttribI1iv;
|
||||
PFNGLVERTEXATTRIBI1UIPROC glVertexAttribI1ui;
|
||||
PFNGLVERTEXATTRIBI1UIVPROC glVertexAttribI1uiv;
|
||||
PFNGLVERTEXATTRIBI2IPROC glVertexAttribI2i;
|
||||
PFNGLVERTEXATTRIBI2IVPROC glVertexAttribI2iv;
|
||||
PFNGLVERTEXATTRIBI2UIPROC glVertexAttribI2ui;
|
||||
PFNGLVERTEXATTRIBI2UIVPROC glVertexAttribI2uiv;
|
||||
PFNGLVERTEXATTRIBI3IPROC glVertexAttribI3i;
|
||||
PFNGLVERTEXATTRIBI3IVPROC glVertexAttribI3iv;
|
||||
PFNGLVERTEXATTRIBI3UIPROC glVertexAttribI3ui;
|
||||
PFNGLVERTEXATTRIBI3UIVPROC glVertexAttribI3uiv;
|
||||
PFNGLVERTEXATTRIBI4BVPROC glVertexAttribI4bv;
|
||||
PFNGLVERTEXATTRIBI4IPROC glVertexAttribI4i;
|
||||
PFNGLVERTEXATTRIBI4IVPROC glVertexAttribI4iv;
|
||||
PFNGLVERTEXATTRIBI4SVPROC glVertexAttribI4sv;
|
||||
PFNGLVERTEXATTRIBI4UBVPROC glVertexAttribI4ubv;
|
||||
PFNGLVERTEXATTRIBI4UIPROC glVertexAttribI4ui;
|
||||
PFNGLVERTEXATTRIBI4UIVPROC glVertexAttribI4uiv;
|
||||
PFNGLVERTEXATTRIBI4USVPROC glVertexAttribI4usv;
|
||||
PFNGLVERTEXATTRIBL1DPROC glVertexAttribL1d;
|
||||
PFNGLVERTEXATTRIBL1DVPROC glVertexAttribL1dv;
|
||||
PFNGLVERTEXATTRIBL2DPROC glVertexAttribL2d;
|
||||
PFNGLVERTEXATTRIBL2DVPROC glVertexAttribL2dv;
|
||||
PFNGLVERTEXATTRIBL3DPROC glVertexAttribL3d;
|
||||
PFNGLVERTEXATTRIBL3DVPROC glVertexAttribL3dv;
|
||||
PFNGLVERTEXATTRIBL4DPROC glVertexAttribL4d;
|
||||
PFNGLVERTEXATTRIBL4DVPROC glVertexAttribL4dv;
|
||||
PFNGLVERTEXATTRIBP1UIPROC glVertexAttribP1ui;
|
||||
PFNGLVERTEXATTRIBP1UIVPROC glVertexAttribP1uiv;
|
||||
PFNGLVERTEXATTRIBP2UIPROC glVertexAttribP2ui;
|
||||
PFNGLVERTEXATTRIBP2UIVPROC glVertexAttribP2uiv;
|
||||
PFNGLVERTEXATTRIBP3UIPROC glVertexAttribP3ui;
|
||||
PFNGLVERTEXATTRIBP3UIVPROC glVertexAttribP3uiv;
|
||||
PFNGLVERTEXATTRIBP4UIPROC glVertexAttribP4ui;
|
||||
PFNGLVERTEXATTRIBP4UIVPROC glVertexAttribP4uiv;
|
||||
PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer;
|
||||
PFNGLVERTEXATTRIBIPOINTERPROC glVertexAttribIPointer;
|
||||
PFNGLVERTEXATTRIBLPOINTERPROC glVertexAttribLPointer;
|
||||
PFNGLVERTEXATTRIBBINDINGPROC glVertexAttribBinding;
|
||||
PFNGLVERTEXATTRIBFORMATPROC glVertexAttribFormat;
|
||||
PFNGLVERTEXATTRIBIFORMATPROC glVertexAttribIFormat;
|
||||
PFNGLVERTEXATTRIBLFORMATPROC glVertexAttribLFormat;
|
||||
PFNGLVERTEXATTRIBDIVISORPROC glVertexAttribDivisor;
|
||||
PFNGLBINDATTRIBLOCATIONPROC glBindAttribLocation;
|
||||
PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray;
|
||||
PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray;
|
||||
|
||||
@@ -322,11 +322,86 @@
|
||||
HookExtension(PFNGLGENVERTEXARRAYSPROC, glGenVertexArrays); \
|
||||
HookExtension(PFNGLBINDVERTEXARRAYPROC, glBindVertexArray); \
|
||||
HookExtension(PFNGLDELETEVERTEXARRAYSPROC, glDeleteVertexArrays); \
|
||||
HookExtension(PFNGLVERTEXATTRIB1DPROC, glVertexAttrib1d); \
|
||||
HookExtension(PFNGLVERTEXATTRIB1DVPROC, glVertexAttrib1dv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB1FPROC, glVertexAttrib1f); \
|
||||
HookExtension(PFNGLVERTEXATTRIB1FVPROC, glVertexAttrib1fv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB1SPROC, glVertexAttrib1s); \
|
||||
HookExtension(PFNGLVERTEXATTRIB1SVPROC, glVertexAttrib1sv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB2DPROC, glVertexAttrib2d); \
|
||||
HookExtension(PFNGLVERTEXATTRIB2DVPROC, glVertexAttrib2dv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB2FPROC, glVertexAttrib2f); \
|
||||
HookExtension(PFNGLVERTEXATTRIB2FVPROC, glVertexAttrib2fv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB2SPROC, glVertexAttrib2s); \
|
||||
HookExtension(PFNGLVERTEXATTRIB2SVPROC, glVertexAttrib2sv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB3DPROC, glVertexAttrib3d); \
|
||||
HookExtension(PFNGLVERTEXATTRIB3DVPROC, glVertexAttrib3dv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB3FPROC, glVertexAttrib3f); \
|
||||
HookExtension(PFNGLVERTEXATTRIB3FVPROC, glVertexAttrib3fv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB3SPROC, glVertexAttrib3s); \
|
||||
HookExtension(PFNGLVERTEXATTRIB3SVPROC, glVertexAttrib3sv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB4NBVPROC, glVertexAttrib4Nbv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB4NIVPROC, glVertexAttrib4Niv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB4NSVPROC, glVertexAttrib4Nsv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB4NUBPROC, glVertexAttrib4Nub); \
|
||||
HookExtension(PFNGLVERTEXATTRIB4NUBVPROC, glVertexAttrib4Nubv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB4NUIVPROC, glVertexAttrib4Nuiv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB4NUSVPROC, glVertexAttrib4Nusv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB4BVPROC, glVertexAttrib4bv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB4DPROC, glVertexAttrib4d); \
|
||||
HookExtension(PFNGLVERTEXATTRIB4DVPROC, glVertexAttrib4dv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB4FPROC, glVertexAttrib4f); \
|
||||
HookExtension(PFNGLVERTEXATTRIB4FVPROC, glVertexAttrib4fv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB4IVPROC, glVertexAttrib4iv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB4SPROC, glVertexAttrib4s); \
|
||||
HookExtension(PFNGLVERTEXATTRIB4SVPROC, glVertexAttrib4sv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB4UBVPROC, glVertexAttrib4ubv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB4UIVPROC, glVertexAttrib4uiv); \
|
||||
HookExtension(PFNGLVERTEXATTRIB4USVPROC, glVertexAttrib4usv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBI1IPROC, glVertexAttribI1i); \
|
||||
HookExtension(PFNGLVERTEXATTRIBI1IVPROC, glVertexAttribI1iv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBI1UIPROC, glVertexAttribI1ui); \
|
||||
HookExtension(PFNGLVERTEXATTRIBI1UIVPROC, glVertexAttribI1uiv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBI2IPROC, glVertexAttribI2i); \
|
||||
HookExtension(PFNGLVERTEXATTRIBI2IVPROC, glVertexAttribI2iv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBI2UIPROC, glVertexAttribI2ui); \
|
||||
HookExtension(PFNGLVERTEXATTRIBI2UIVPROC, glVertexAttribI2uiv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBI3IPROC, glVertexAttribI3i); \
|
||||
HookExtension(PFNGLVERTEXATTRIBI3IVPROC, glVertexAttribI3iv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBI3UIPROC, glVertexAttribI3ui); \
|
||||
HookExtension(PFNGLVERTEXATTRIBI3UIVPROC, glVertexAttribI3uiv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBI4BVPROC, glVertexAttribI4bv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBI4IPROC, glVertexAttribI4i); \
|
||||
HookExtension(PFNGLVERTEXATTRIBI4IVPROC, glVertexAttribI4iv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBI4SVPROC, glVertexAttribI4sv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBI4UBVPROC, glVertexAttribI4ubv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBI4UIPROC, glVertexAttribI4ui); \
|
||||
HookExtension(PFNGLVERTEXATTRIBI4UIVPROC, glVertexAttribI4uiv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBI4USVPROC, glVertexAttribI4usv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBL1DPROC, glVertexAttribL1d); \
|
||||
HookExtension(PFNGLVERTEXATTRIBL1DVPROC, glVertexAttribL1dv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBL2DPROC, glVertexAttribL2d); \
|
||||
HookExtension(PFNGLVERTEXATTRIBL2DVPROC, glVertexAttribL2dv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBL3DPROC, glVertexAttribL3d); \
|
||||
HookExtension(PFNGLVERTEXATTRIBL3DVPROC, glVertexAttribL3dv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBL4DPROC, glVertexAttribL4d); \
|
||||
HookExtension(PFNGLVERTEXATTRIBL4DVPROC, glVertexAttribL4dv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBP1UIPROC, glVertexAttribP1ui); \
|
||||
HookExtension(PFNGLVERTEXATTRIBP1UIVPROC, glVertexAttribP1uiv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBP2UIPROC, glVertexAttribP2ui); \
|
||||
HookExtension(PFNGLVERTEXATTRIBP2UIVPROC, glVertexAttribP2uiv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBP3UIPROC, glVertexAttribP3ui); \
|
||||
HookExtension(PFNGLVERTEXATTRIBP3UIVPROC, glVertexAttribP3uiv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBP4UIPROC, glVertexAttribP4ui); \
|
||||
HookExtension(PFNGLVERTEXATTRIBP4UIVPROC, glVertexAttribP4uiv); \
|
||||
HookExtension(PFNGLVERTEXATTRIBPOINTERPROC, glVertexAttribPointer); \
|
||||
HookExtension(PFNGLVERTEXATTRIBIPOINTERPROC, glVertexAttribIPointer); \
|
||||
HookExtension(PFNGLVERTEXATTRIBLPOINTERPROC, glVertexAttribLPointer); \
|
||||
HookExtension(PFNGLVERTEXATTRIBBINDINGPROC, glVertexAttribBinding); \
|
||||
HookExtension(PFNGLVERTEXATTRIBFORMATPROC, glVertexAttribFormat); \
|
||||
HookExtension(PFNGLVERTEXATTRIBIFORMATPROC, glVertexAttribIFormat); \
|
||||
HookExtension(PFNGLVERTEXATTRIBLFORMATPROC, glVertexAttribLFormat); \
|
||||
HookExtension(PFNGLVERTEXATTRIBDIVISORPROC, glVertexAttribDivisor); \
|
||||
HookExtension(PFNGLBINDATTRIBLOCATIONPROC, glBindAttribLocation); \
|
||||
HookExtension(PFNGLENABLEVERTEXATTRIBARRAYPROC, glEnableVertexAttribArray); \
|
||||
HookExtension(PFNGLDISABLEVERTEXATTRIBARRAYPROC, glDisableVertexAttribArray); \
|
||||
@@ -850,11 +925,86 @@
|
||||
HookWrapper2(void, glGenVertexArrays, GLsizei, n, GLuint *, arrays); \
|
||||
HookWrapper1(void, glBindVertexArray, GLuint, array); \
|
||||
HookWrapper2(void, glDeleteVertexArrays, GLsizei, n, const GLuint *, arrays); \
|
||||
HookWrapper2(void, glVertexAttrib1d, GLuint, index, GLdouble, x); \
|
||||
HookWrapper2(void, glVertexAttrib1dv, GLuint, index, const GLdouble *, v); \
|
||||
HookWrapper2(void, glVertexAttrib1f, GLuint, index, GLfloat, x); \
|
||||
HookWrapper2(void, glVertexAttrib1fv, GLuint, index, const GLfloat *, v); \
|
||||
HookWrapper2(void, glVertexAttrib1s, GLuint, index, GLshort, x); \
|
||||
HookWrapper2(void, glVertexAttrib1sv, GLuint, index, const GLshort *, v); \
|
||||
HookWrapper3(void, glVertexAttrib2d, GLuint, index, GLdouble, x, GLdouble, y); \
|
||||
HookWrapper2(void, glVertexAttrib2dv, GLuint, index, const GLdouble *, v); \
|
||||
HookWrapper3(void, glVertexAttrib2f, GLuint, index, GLfloat, x, GLfloat, y); \
|
||||
HookWrapper2(void, glVertexAttrib2fv, GLuint, index, const GLfloat *, v); \
|
||||
HookWrapper3(void, glVertexAttrib2s, GLuint, index, GLshort, x, GLshort, y); \
|
||||
HookWrapper2(void, glVertexAttrib2sv, GLuint, index, const GLshort *, v); \
|
||||
HookWrapper4(void, glVertexAttrib3d, GLuint, index, GLdouble, x, GLdouble, y, GLdouble, z); \
|
||||
HookWrapper2(void, glVertexAttrib3dv, GLuint, index, const GLdouble *, v); \
|
||||
HookWrapper4(void, glVertexAttrib3f, GLuint, index, GLfloat, x, GLfloat, y, GLfloat, z); \
|
||||
HookWrapper2(void, glVertexAttrib3fv, GLuint, index, const GLfloat *, v); \
|
||||
HookWrapper4(void, glVertexAttrib3s, GLuint, index, GLshort, x, GLshort, y, GLshort, z); \
|
||||
HookWrapper2(void, glVertexAttrib3sv, GLuint, index, const GLshort *, v); \
|
||||
HookWrapper2(void, glVertexAttrib4Nbv, GLuint, index, const GLbyte *, v); \
|
||||
HookWrapper2(void, glVertexAttrib4Niv, GLuint, index, const GLint *, v); \
|
||||
HookWrapper2(void, glVertexAttrib4Nsv, GLuint, index, const GLshort *, v); \
|
||||
HookWrapper5(void, glVertexAttrib4Nub, GLuint, index, GLubyte, x, GLubyte, y, GLubyte, z, GLubyte, w); \
|
||||
HookWrapper2(void, glVertexAttrib4Nubv, GLuint, index, const GLubyte *, v); \
|
||||
HookWrapper2(void, glVertexAttrib4Nuiv, GLuint, index, const GLuint *, v); \
|
||||
HookWrapper2(void, glVertexAttrib4Nusv, GLuint, index, const GLushort *, v); \
|
||||
HookWrapper2(void, glVertexAttrib4bv, GLuint, index, const GLbyte *, v); \
|
||||
HookWrapper5(void, glVertexAttrib4d, GLuint, index, GLdouble, x, GLdouble, y, GLdouble, z, GLdouble, w); \
|
||||
HookWrapper2(void, glVertexAttrib4dv, GLuint, index, const GLdouble *, v); \
|
||||
HookWrapper5(void, glVertexAttrib4f, GLuint, index, GLfloat, x, GLfloat, y, GLfloat, z, GLfloat, w); \
|
||||
HookWrapper2(void, glVertexAttrib4fv, GLuint, index, const GLfloat *, v); \
|
||||
HookWrapper2(void, glVertexAttrib4iv, GLuint, index, const GLint *, v); \
|
||||
HookWrapper5(void, glVertexAttrib4s, GLuint, index, GLshort, x, GLshort, y, GLshort, z, GLshort, w); \
|
||||
HookWrapper2(void, glVertexAttrib4sv, GLuint, index, const GLshort *, v); \
|
||||
HookWrapper2(void, glVertexAttrib4ubv, GLuint, index, const GLubyte *, v); \
|
||||
HookWrapper2(void, glVertexAttrib4uiv, GLuint, index, const GLuint *, v); \
|
||||
HookWrapper2(void, glVertexAttrib4usv, GLuint, index, const GLushort *, v); \
|
||||
HookWrapper2(void, glVertexAttribI1i, GLuint, index, GLint, x); \
|
||||
HookWrapper2(void, glVertexAttribI1iv, GLuint, index, const GLint *, v); \
|
||||
HookWrapper2(void, glVertexAttribI1ui, GLuint, index, GLuint, x); \
|
||||
HookWrapper2(void, glVertexAttribI1uiv, GLuint, index, const GLuint *, v); \
|
||||
HookWrapper3(void, glVertexAttribI2i, GLuint, index, GLint, x, GLint, y); \
|
||||
HookWrapper2(void, glVertexAttribI2iv, GLuint, index, const GLint *, v); \
|
||||
HookWrapper3(void, glVertexAttribI2ui, GLuint, index, GLuint, x, GLuint, y); \
|
||||
HookWrapper2(void, glVertexAttribI2uiv, GLuint, index, const GLuint *, v); \
|
||||
HookWrapper4(void, glVertexAttribI3i, GLuint, index, GLint, x, GLint, y, GLint, z); \
|
||||
HookWrapper2(void, glVertexAttribI3iv, GLuint, index, const GLint *, v); \
|
||||
HookWrapper4(void, glVertexAttribI3ui, GLuint, index, GLuint, x, GLuint, y, GLuint, z); \
|
||||
HookWrapper2(void, glVertexAttribI3uiv, GLuint, index, const GLuint *, v); \
|
||||
HookWrapper2(void, glVertexAttribI4bv, GLuint, index, const GLbyte *, v); \
|
||||
HookWrapper5(void, glVertexAttribI4i, GLuint, index, GLint, x, GLint, y, GLint, z, GLint, w); \
|
||||
HookWrapper2(void, glVertexAttribI4iv, GLuint, index, const GLint *, v); \
|
||||
HookWrapper2(void, glVertexAttribI4sv, GLuint, index, const GLshort *, v); \
|
||||
HookWrapper2(void, glVertexAttribI4ubv, GLuint, index, const GLubyte *, v); \
|
||||
HookWrapper5(void, glVertexAttribI4ui, GLuint, index, GLuint, x, GLuint, y, GLuint, z, GLuint, w); \
|
||||
HookWrapper2(void, glVertexAttribI4uiv, GLuint, index, const GLuint *, v); \
|
||||
HookWrapper2(void, glVertexAttribI4usv, GLuint, index, const GLushort *, v); \
|
||||
HookWrapper2(void, glVertexAttribL1d, GLuint, index, GLdouble, x); \
|
||||
HookWrapper2(void, glVertexAttribL1dv, GLuint, index, const GLdouble *, v); \
|
||||
HookWrapper3(void, glVertexAttribL2d, GLuint, index, GLdouble, x, GLdouble, y); \
|
||||
HookWrapper2(void, glVertexAttribL2dv, GLuint, index, const GLdouble *, v); \
|
||||
HookWrapper4(void, glVertexAttribL3d, GLuint, index, GLdouble, x, GLdouble, y, GLdouble, z); \
|
||||
HookWrapper2(void, glVertexAttribL3dv, GLuint, index, const GLdouble *, v); \
|
||||
HookWrapper5(void, glVertexAttribL4d, GLuint, index, GLdouble, x, GLdouble, y, GLdouble, z, GLdouble, w); \
|
||||
HookWrapper2(void, glVertexAttribL4dv, GLuint, index, const GLdouble *, v); \
|
||||
HookWrapper4(void, glVertexAttribP1ui, GLuint, index, GLenum, type, GLboolean, normalized, GLuint, value); \
|
||||
HookWrapper4(void, glVertexAttribP1uiv, GLuint, index, GLenum, type, GLboolean, normalized, const GLuint *, value); \
|
||||
HookWrapper4(void, glVertexAttribP2ui, GLuint, index, GLenum, type, GLboolean, normalized, GLuint, value); \
|
||||
HookWrapper4(void, glVertexAttribP2uiv, GLuint, index, GLenum, type, GLboolean, normalized, const GLuint *, value); \
|
||||
HookWrapper4(void, glVertexAttribP3ui, GLuint, index, GLenum, type, GLboolean, normalized, GLuint, value); \
|
||||
HookWrapper4(void, glVertexAttribP3uiv, GLuint, index, GLenum, type, GLboolean, normalized, const GLuint *, value); \
|
||||
HookWrapper4(void, glVertexAttribP4ui, GLuint, index, GLenum, type, GLboolean, normalized, GLuint, value); \
|
||||
HookWrapper4(void, glVertexAttribP4uiv, GLuint, index, GLenum, type, GLboolean, normalized, const GLuint *, value); \
|
||||
HookWrapper6(void, glVertexAttribPointer, GLuint, index, GLint, size, GLenum, type, GLboolean, normalized, GLsizei, stride, const void *, pointer); \
|
||||
HookWrapper5(void, glVertexAttribIPointer, GLuint, index, GLint, size, GLenum, type, GLsizei, stride, const void *, pointer); \
|
||||
HookWrapper5(void, glVertexAttribLPointer, GLuint, index, GLint, size, GLenum, type, GLsizei, stride, const void *, pointer); \
|
||||
HookWrapper2(void, glVertexAttribBinding, GLuint, attribindex, GLuint, bindingindex); \
|
||||
HookWrapper5(void, glVertexAttribFormat, GLuint, attribindex, GLint, size, GLenum, type, GLboolean, normalized, GLuint, relativeoffset); \
|
||||
HookWrapper4(void, glVertexAttribIFormat, GLuint, attribindex, GLint, size, GLenum, type, GLuint, relativeoffset); \
|
||||
HookWrapper4(void, glVertexAttribLFormat, GLuint, attribindex, GLint, size, GLenum, type, GLuint, relativeoffset); \
|
||||
HookWrapper2(void, glVertexAttribDivisor, GLuint, index, GLuint, divisor); \
|
||||
HookWrapper3(void, glBindAttribLocation, GLuint, program, GLuint, index, const GLchar *, name); \
|
||||
HookWrapper1(void, glEnableVertexAttribArray, GLuint, index); \
|
||||
HookWrapper1(void, glDisableVertexAttribArray, GLuint, index); \
|
||||
|
||||
@@ -101,6 +101,13 @@ void GLRenderState::FetchState()
|
||||
m_Real->glGetIntegeri_v(eGL_VERTEX_BINDING_DIVISOR, i, (GLint *)&VertexBuffers[i].Divisor);
|
||||
}
|
||||
|
||||
// the spec says that you can only query for the format that was previously set, or you get
|
||||
// undefined results. Ie. if someone set ints, this might return anything. However there's also
|
||||
// no way to query for the type so we just have to hope for the best and hope most people are
|
||||
// sane and don't use these except for a default "all 0s" attrib.
|
||||
for(GLuint i=0; i < (GLuint)ARRAY_COUNT(GenericVertexAttribs); i++)
|
||||
m_Real->glGetVertexAttribfv(i, eGL_CURRENT_VERTEX_ATTRIB, &GenericVertexAttribs[i].x);
|
||||
|
||||
m_Real->glGetFloatv(eGL_POINT_FADE_THRESHOLD_SIZE, &PointFadeThresholdSize);
|
||||
m_Real->glGetIntegerv(eGL_POINT_SPRITE_COORD_ORIGIN, (GLint*)&PointSpriteOrigin);
|
||||
|
||||
@@ -286,6 +293,11 @@ void GLRenderState::ApplyState()
|
||||
m_Real->glVertexBindingDivisor(i, VertexBuffers[i].Divisor);
|
||||
}
|
||||
|
||||
// See FetchState(). The spec says that you have to SET the right format for the shader too,
|
||||
// but we couldn't query for the format so we can't set it here.
|
||||
for(GLuint i=0; i < (GLuint)ARRAY_COUNT(GenericVertexAttribs); i++)
|
||||
m_Real->glVertexAttrib4fv(i, &GenericVertexAttribs[i].x);
|
||||
|
||||
m_Real->glPointParameterf(eGL_POINT_FADE_THRESHOLD_SIZE, PointFadeThresholdSize);
|
||||
m_Real->glPointParameteri(eGL_POINT_SPRITE_COORD_ORIGIN, (GLint)PointSpriteOrigin);
|
||||
|
||||
@@ -520,6 +532,11 @@ void GLRenderState::Serialise(LogState state, void *ctx, WrappedOpenGL *gl)
|
||||
if(state < WRITING && ID != ResourceId()) VertexBuffers[i].Buffer = rm->GetLiveResource(ID).name;
|
||||
}
|
||||
|
||||
for(size_t i=0; i < ARRAY_COUNT(GenericVertexAttribs); i++)
|
||||
{
|
||||
m_pSerialiser->Serialise<4>("GL_CURRENT_VERTEX_ATTRIB", &GenericVertexAttribs[i].x);
|
||||
}
|
||||
|
||||
m_pSerialiser->Serialise("GL_POINT_FADE_THRESHOLD_SIZE", PointFadeThresholdSize);
|
||||
m_pSerialiser->Serialise("GL_POINT_SPRITE_COORD_ORIGIN", PointSpriteOrigin);
|
||||
|
||||
|
||||
@@ -29,6 +29,8 @@
|
||||
#include "gl_hookset.h"
|
||||
#include "gl_manager.h"
|
||||
|
||||
#include "maths/vec.h"
|
||||
|
||||
struct GLRenderState
|
||||
{
|
||||
GLRenderState(const GLHookSet *funcs, Serialiser *ser, LogState state);
|
||||
@@ -106,6 +108,8 @@ struct GLRenderState
|
||||
} VertexBuffers[16];
|
||||
GLuint VAO;
|
||||
|
||||
Vec4f GenericVertexAttribs[32];
|
||||
|
||||
float PointFadeThresholdSize;
|
||||
GLenum PointSpriteOrigin;
|
||||
|
||||
|
||||
@@ -1191,6 +1191,58 @@ void WrappedOpenGL::glVertexAttribIPointer(GLuint index, GLint size, GLenum type
|
||||
}
|
||||
}
|
||||
|
||||
bool WrappedOpenGL::Serialise_glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
|
||||
{
|
||||
SERIALISE_ELEMENT(uint32_t, Index, index);
|
||||
SERIALISE_ELEMENT(int32_t, Size, size);
|
||||
SERIALISE_ELEMENT(GLenum, Type, type);
|
||||
SERIALISE_ELEMENT(uint32_t, Stride, stride);
|
||||
SERIALISE_ELEMENT(uint64_t, Offset, (uint64_t)pointer);
|
||||
SERIALISE_ELEMENT(ResourceId, id, m_VertexArrayRecord ? m_VertexArrayRecord->GetResourceID() : ResourceId());
|
||||
|
||||
if(m_State < WRITING)
|
||||
{
|
||||
if(id != ResourceId())
|
||||
{
|
||||
GLResource res = GetResourceManager()->GetLiveResource(id);
|
||||
m_Real.glBindVertexArray(res.name);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_Real.glBindVertexArray(0);
|
||||
}
|
||||
|
||||
m_Real.glVertexAttribLPointer(Index, Size, Type, Stride, (const void *)Offset);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void WrappedOpenGL::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
|
||||
{
|
||||
m_Real.glVertexAttribLPointer(index, size, type, stride, pointer);
|
||||
|
||||
if(m_State >= WRITING)
|
||||
{
|
||||
GLResourceRecord *r = m_State == WRITING_CAPFRAME ? m_ContextRecord : m_VertexArrayRecord;
|
||||
|
||||
if(r)
|
||||
{
|
||||
if(m_State == WRITING_IDLE && !VertexArrayUpdateCheck())
|
||||
return;
|
||||
if(m_State == WRITING_CAPFRAME && m_VertexArrayRecord)
|
||||
GetResourceManager()->MarkResourceFrameReferenced(m_VertexArrayRecord->GetResourceID(), eFrameRef_Write);
|
||||
|
||||
{
|
||||
SCOPED_SERIALISE_CONTEXT(VERTEXATTRIBLPOINTER);
|
||||
Serialise_glVertexAttribLPointer(index, size, type, stride, pointer);
|
||||
|
||||
r->AddChunk(scope.Get());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool WrappedOpenGL::Serialise_glVertexAttribBinding(GLuint attribindex, GLuint bindingindex)
|
||||
{
|
||||
SERIALISE_ELEMENT(uint32_t, aidx, attribindex);
|
||||
@@ -1342,6 +1394,106 @@ void WrappedOpenGL::glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum
|
||||
}
|
||||
}
|
||||
|
||||
bool WrappedOpenGL::Serialise_glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
|
||||
{
|
||||
SERIALISE_ELEMENT(uint32_t, Index, attribindex);
|
||||
SERIALISE_ELEMENT(int32_t, Size, size);
|
||||
SERIALISE_ELEMENT(GLenum, Type, type);
|
||||
SERIALISE_ELEMENT(uint32_t, Offset, relativeoffset);
|
||||
SERIALISE_ELEMENT(ResourceId, id, m_VertexArrayRecord ? m_VertexArrayRecord->GetResourceID() : ResourceId());
|
||||
|
||||
if(m_State < WRITING)
|
||||
{
|
||||
if(id != ResourceId())
|
||||
{
|
||||
GLResource res = GetResourceManager()->GetLiveResource(id);
|
||||
m_Real.glBindVertexArray(res.name);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_Real.glBindVertexArray(0);
|
||||
}
|
||||
|
||||
m_Real.glVertexAttribLFormat(Index, Size, Type, Offset);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void WrappedOpenGL::glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
|
||||
{
|
||||
m_Real.glVertexAttribLFormat(attribindex, size, type, relativeoffset);
|
||||
|
||||
if(m_State >= WRITING)
|
||||
{
|
||||
GLResourceRecord *r = m_State == WRITING_CAPFRAME ? m_ContextRecord : m_VertexArrayRecord;
|
||||
|
||||
if(r)
|
||||
{
|
||||
if(m_State == WRITING_IDLE && !VertexArrayUpdateCheck())
|
||||
return;
|
||||
if(m_State == WRITING_CAPFRAME && m_VertexArrayRecord)
|
||||
GetResourceManager()->MarkResourceFrameReferenced(m_VertexArrayRecord->GetResourceID(), eFrameRef_Write);
|
||||
|
||||
{
|
||||
SCOPED_SERIALISE_CONTEXT(VERTEXATTRIBLFORMAT);
|
||||
Serialise_glVertexAttribLFormat(attribindex, size, type, relativeoffset);
|
||||
|
||||
r->AddChunk(scope.Get());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool WrappedOpenGL::Serialise_glVertexAttribDivisor(GLuint index, GLuint divisor)
|
||||
{
|
||||
SERIALISE_ELEMENT(uint32_t, Index, index);
|
||||
SERIALISE_ELEMENT(uint32_t, Divisor, divisor);
|
||||
SERIALISE_ELEMENT(ResourceId, id, m_VertexArrayRecord ? m_VertexArrayRecord->GetResourceID() : ResourceId());
|
||||
|
||||
if(m_State < WRITING)
|
||||
{
|
||||
if(id != ResourceId())
|
||||
{
|
||||
GLResource res = GetResourceManager()->GetLiveResource(id);
|
||||
m_Real.glBindVertexArray(res.name);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_Real.glBindVertexArray(0);
|
||||
}
|
||||
|
||||
m_Real.glVertexAttribDivisor(Index, Divisor);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void WrappedOpenGL::glVertexAttribDivisor(GLuint index, GLuint divisor)
|
||||
{
|
||||
m_Real.glVertexAttribDivisor(index, divisor);
|
||||
|
||||
if(m_State >= WRITING)
|
||||
{
|
||||
GLResourceRecord *r = m_State == WRITING_CAPFRAME ? m_ContextRecord : m_VertexArrayRecord;
|
||||
|
||||
if(r)
|
||||
{
|
||||
if(m_State == WRITING_IDLE && !VertexArrayUpdateCheck())
|
||||
return;
|
||||
if(m_State == WRITING_CAPFRAME && m_VertexArrayRecord)
|
||||
GetResourceManager()->MarkResourceFrameReferenced(m_VertexArrayRecord->GetResourceID(), eFrameRef_Write);
|
||||
|
||||
{
|
||||
SCOPED_SERIALISE_CONTEXT(VERTEXATTRIBDIVISOR);
|
||||
Serialise_glVertexAttribDivisor(index, divisor);
|
||||
|
||||
r->AddChunk(scope.Get());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool WrappedOpenGL::Serialise_glEnableVertexAttribArray(GLuint index)
|
||||
{
|
||||
SERIALISE_ELEMENT(uint32_t, Index, index);
|
||||
@@ -1580,7 +1732,7 @@ void WrappedOpenGL::glVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
|
||||
|
||||
if(m_State == WRITING_CAPFRAME)
|
||||
{
|
||||
SCOPED_SERIALISE_CONTEXT(VERTEXDIVISOR);
|
||||
SCOPED_SERIALISE_CONTEXT(VERTEXBINDINGDIVISOR);
|
||||
Serialise_glVertexBindingDivisor(bindingindex, divisor);
|
||||
|
||||
m_ContextRecord->AddChunk(scope.Get());
|
||||
@@ -1603,4 +1755,277 @@ void WrappedOpenGL::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
|
||||
GetResourceManager()->UnregisterResource(VertexArrayRes(GetCtx(), arrays[i]));
|
||||
}
|
||||
|
||||
#pragma endregion
|
||||
|
||||
#pragma region Horrible glVertexAttrib variants
|
||||
|
||||
bool WrappedOpenGL::Serialise_glVertexAttrib(GLuint index, int count, GLenum type, GLboolean normalized, const void *value, int attribtype)
|
||||
{
|
||||
SERIALISE_ELEMENT(uint32_t, idx, index);
|
||||
SERIALISE_ELEMENT(int32_t, Count, count);
|
||||
SERIALISE_ELEMENT(int, Type, attribtype);
|
||||
SERIALISE_ELEMENT(bool, norm, normalized == GL_TRUE);
|
||||
SERIALISE_ELEMENT(GLenum, packedType, type);
|
||||
|
||||
AttribType attr = AttribType(Type & Attrib_typemask);
|
||||
|
||||
size_t elemSize = 1;
|
||||
switch(attr)
|
||||
{
|
||||
case Attrib_GLdouble:
|
||||
elemSize = 8;
|
||||
break;
|
||||
case Attrib_GLfloat:
|
||||
case Attrib_GLint:
|
||||
case Attrib_GLuint:
|
||||
case Attrib_packed:
|
||||
elemSize = 4;
|
||||
break;
|
||||
case Attrib_GLshort:
|
||||
case Attrib_GLushort:
|
||||
elemSize = 2;
|
||||
break;
|
||||
case Attrib_GLbyte:
|
||||
case Attrib_GLubyte:
|
||||
elemSize = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
size_t valueSize = elemSize*Count;
|
||||
if(Type == Attrib_packed)
|
||||
valueSize = sizeof(uint32_t);
|
||||
|
||||
if(m_State >= WRITING)
|
||||
{
|
||||
m_pSerialiser->RawWriteBytes(value, valueSize);
|
||||
}
|
||||
else if(m_State <= EXECUTING)
|
||||
{
|
||||
value = m_pSerialiser->RawReadBytes(valueSize);
|
||||
|
||||
if(Type == Attrib_packed)
|
||||
{
|
||||
if(Count == 1) m_Real.glVertexAttribP1uiv(idx, packedType, norm, (GLuint*)value);
|
||||
else if(Count == 2) m_Real.glVertexAttribP2uiv(idx, packedType, norm, (GLuint*)value);
|
||||
else if(Count == 3) m_Real.glVertexAttribP3uiv(idx, packedType, norm, (GLuint*)value);
|
||||
else if(Count == 4) m_Real.glVertexAttribP4uiv(idx, packedType, norm, (GLuint*)value);
|
||||
}
|
||||
else if(Type & Attrib_I)
|
||||
{
|
||||
if(Count == 1)
|
||||
{
|
||||
if(attr == Attrib_GLint) m_Real.glVertexAttribI1iv(idx, (GLint*)value);
|
||||
else if(attr == Attrib_GLuint) m_Real.glVertexAttribI1uiv(idx, (GLuint*)value);
|
||||
}
|
||||
else if(Count == 2)
|
||||
{
|
||||
if(attr == Attrib_GLint) m_Real.glVertexAttribI2iv(idx, (GLint*)value);
|
||||
else if(attr == Attrib_GLuint) m_Real.glVertexAttribI2uiv(idx, (GLuint*)value);
|
||||
}
|
||||
else if(Count == 2)
|
||||
{
|
||||
if(attr == Attrib_GLint) m_Real.glVertexAttribI3iv(idx, (GLint*)value);
|
||||
else if(attr == Attrib_GLuint) m_Real.glVertexAttribI3uiv(idx, (GLuint*)value);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(attr == Attrib_GLbyte) m_Real.glVertexAttribI4bv(idx, (GLbyte*)value);
|
||||
else if(attr == Attrib_GLint) m_Real.glVertexAttribI4iv(idx, (GLint*)value);
|
||||
else if(attr == Attrib_GLshort) m_Real.glVertexAttribI4sv(idx, (GLshort*)value);
|
||||
else if(attr == Attrib_GLubyte) m_Real.glVertexAttribI4ubv(idx, (GLubyte*)value);
|
||||
else if(attr == Attrib_GLuint) m_Real.glVertexAttribI4uiv(idx, (GLuint*)value);
|
||||
else if(attr == Attrib_GLushort) m_Real.glVertexAttribI4usv(idx, (GLushort*)value);
|
||||
}
|
||||
}
|
||||
else if(Type & Attrib_L)
|
||||
{
|
||||
if(Count == 1) m_Real.glVertexAttribL1dv(idx, (GLdouble*)value);
|
||||
else if(Count == 2) m_Real.glVertexAttribL2dv(idx, (GLdouble*)value);
|
||||
else if(Count == 3) m_Real.glVertexAttribL3dv(idx, (GLdouble*)value);
|
||||
else if(Count == 4) m_Real.glVertexAttribL4dv(idx, (GLdouble*)value);
|
||||
}
|
||||
else if(Type & Attrib_N)
|
||||
{
|
||||
if(attr == Attrib_GLbyte) m_Real.glVertexAttrib4Nbv(idx, (GLbyte*)value);
|
||||
else if(attr == Attrib_GLint) m_Real.glVertexAttrib4Niv(idx, (GLint*)value);
|
||||
else if(attr == Attrib_GLshort) m_Real.glVertexAttrib4Nsv(idx, (GLshort*)value);
|
||||
else if(attr == Attrib_GLubyte) m_Real.glVertexAttrib4Nubv(idx, (GLubyte*)value);
|
||||
else if(attr == Attrib_GLuint) m_Real.glVertexAttrib4Nuiv(idx, (GLuint*)value);
|
||||
else if(attr == Attrib_GLushort) m_Real.glVertexAttrib4Nusv(idx, (GLushort*)value);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(Count == 1)
|
||||
{
|
||||
if(attr == Attrib_GLdouble) m_Real.glVertexAttrib1dv(idx, (GLdouble*)value);
|
||||
else if(attr == Attrib_GLfloat) m_Real.glVertexAttrib1fv(idx, (GLfloat*)value);
|
||||
else if(attr == Attrib_GLshort) m_Real.glVertexAttrib1sv(idx, (GLshort*)value);
|
||||
}
|
||||
else if(Count == 2)
|
||||
{
|
||||
if(attr == Attrib_GLdouble) m_Real.glVertexAttrib2dv(idx, (GLdouble*)value);
|
||||
else if(attr == Attrib_GLfloat) m_Real.glVertexAttrib2fv(idx, (GLfloat*)value);
|
||||
else if(attr == Attrib_GLshort) m_Real.glVertexAttrib2sv(idx, (GLshort*)value);
|
||||
}
|
||||
else if(Count == 3)
|
||||
{
|
||||
if(attr == Attrib_GLdouble) m_Real.glVertexAttrib3dv(idx, (GLdouble*)value);
|
||||
else if(attr == Attrib_GLfloat) m_Real.glVertexAttrib3fv(idx, (GLfloat*)value);
|
||||
else if(attr == Attrib_GLshort) m_Real.glVertexAttrib3sv(idx, (GLshort*)value);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(attr == Attrib_GLdouble) m_Real.glVertexAttrib4dv(idx, (GLdouble*)value);
|
||||
else if(attr == Attrib_GLfloat) m_Real.glVertexAttrib4fv(idx, (GLfloat*)value);
|
||||
else if(attr == Attrib_GLbyte) m_Real.glVertexAttrib4bv(idx, (GLbyte*)value);
|
||||
else if(attr == Attrib_GLint) m_Real.glVertexAttrib4iv(idx, (GLint*)value);
|
||||
else if(attr == Attrib_GLshort) m_Real.glVertexAttrib4sv(idx, (GLshort*)value);
|
||||
else if(attr == Attrib_GLubyte) m_Real.glVertexAttrib4ubv(idx, (GLubyte*)value);
|
||||
else if(attr == Attrib_GLuint) m_Real.glVertexAttrib4uiv(idx, (GLuint*)value);
|
||||
else if(attr == Attrib_GLushort) m_Real.glVertexAttrib4usv(idx, (GLushort*)value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
#define ATTRIB_FUNC(count, suffix, TypeOr, paramtype, ...) \
|
||||
void WrappedOpenGL::CONCAT(glVertexAttrib, suffix)(GLuint index, __VA_ARGS__) \
|
||||
{ \
|
||||
m_Real.CONCAT(glVertexAttrib, suffix)(index, ARRAYLIST); \
|
||||
\
|
||||
if(m_State >= WRITING_CAPFRAME) \
|
||||
{ \
|
||||
SCOPED_SERIALISE_CONTEXT(VERTEXATTRIB_GENERIC); \
|
||||
const paramtype vals[] = { ARRAYLIST }; \
|
||||
Serialise_glVertexAttrib(index, count, eGL_NONE, GL_FALSE, vals, TypeOr | CONCAT(Attrib_, paramtype)); \
|
||||
\
|
||||
m_ContextRecord->AddChunk(scope.Get()); \
|
||||
} \
|
||||
}
|
||||
|
||||
#define ARRAYLIST x
|
||||
|
||||
ATTRIB_FUNC(1, 1f, 0, GLfloat, GLfloat x)
|
||||
ATTRIB_FUNC(1, 1s, 0, GLshort, GLshort x)
|
||||
ATTRIB_FUNC(1, 1d, 0, GLdouble, GLdouble x)
|
||||
ATTRIB_FUNC(1, L1d, Attrib_L, GLdouble, GLdouble x)
|
||||
ATTRIB_FUNC(1, I1i, Attrib_I, GLint, GLint x)
|
||||
ATTRIB_FUNC(1, I1ui, Attrib_I, GLuint, GLuint x)
|
||||
|
||||
#undef ARRAYLIST
|
||||
#define ARRAYLIST x, y
|
||||
|
||||
ATTRIB_FUNC(2, 2f, 0, GLfloat, GLfloat x, GLfloat y)
|
||||
ATTRIB_FUNC(2, 2s, 0, GLshort, GLshort x, GLshort y)
|
||||
ATTRIB_FUNC(2, 2d, 0, GLdouble, GLdouble x, GLdouble y)
|
||||
ATTRIB_FUNC(2, L2d, Attrib_L, GLdouble, GLdouble x, GLdouble y)
|
||||
ATTRIB_FUNC(2, I2i, Attrib_I, GLint, GLint x, GLint y)
|
||||
ATTRIB_FUNC(2, I2ui, Attrib_I, GLuint, GLuint x, GLuint y)
|
||||
|
||||
#undef ARRAYLIST
|
||||
#define ARRAYLIST x, y, z
|
||||
|
||||
ATTRIB_FUNC(3, 3f, 0, GLfloat, GLfloat x, GLfloat y, GLfloat z)
|
||||
ATTRIB_FUNC(3, 3s, 0, GLshort, GLshort x, GLshort y, GLshort z)
|
||||
ATTRIB_FUNC(3, 3d, 0, GLdouble, GLdouble x, GLdouble y, GLdouble z)
|
||||
ATTRIB_FUNC(3, L3d, Attrib_L, GLdouble, GLdouble x, GLdouble y, GLdouble z)
|
||||
ATTRIB_FUNC(3, I3i, Attrib_I, GLint, GLint x, GLint y, GLint z)
|
||||
ATTRIB_FUNC(3, I3ui, Attrib_I, GLuint, GLuint x, GLuint y, GLuint z)
|
||||
|
||||
#undef ARRAYLIST
|
||||
#define ARRAYLIST x, y, z, w
|
||||
|
||||
ATTRIB_FUNC(4, 4f, 0, GLfloat, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
||||
ATTRIB_FUNC(4, 4s, 0, GLshort, GLshort x, GLshort y, GLshort z, GLshort w)
|
||||
ATTRIB_FUNC(4, 4d, 0, GLdouble, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
||||
ATTRIB_FUNC(4, L4d, Attrib_L, GLdouble, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
||||
ATTRIB_FUNC(4, I4i, Attrib_I, GLint, GLint x, GLint y, GLint z, GLint w)
|
||||
ATTRIB_FUNC(4, I4ui, Attrib_I, GLuint, GLuint x, GLuint y, GLuint z, GLuint w)
|
||||
ATTRIB_FUNC(4, 4Nub, Attrib_N, GLubyte, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
|
||||
|
||||
#undef ATTRIB_FUNC
|
||||
#define ATTRIB_FUNC(count, suffix, TypeOr, paramtype) \
|
||||
void WrappedOpenGL::CONCAT(glVertexAttrib, suffix)(GLuint index, const paramtype *value) \
|
||||
{ \
|
||||
m_Real.CONCAT(glVertexAttrib, suffix)(index, value); \
|
||||
\
|
||||
if(m_State >= WRITING_CAPFRAME) \
|
||||
{ \
|
||||
SCOPED_SERIALISE_CONTEXT(VERTEXATTRIB_GENERIC); \
|
||||
Serialise_glVertexAttrib(index, count, eGL_NONE, GL_FALSE, value, TypeOr | CONCAT(Attrib_, paramtype)); \
|
||||
\
|
||||
m_ContextRecord->AddChunk(scope.Get()); \
|
||||
} \
|
||||
}
|
||||
|
||||
ATTRIB_FUNC(1, 1dv, 0, GLdouble)
|
||||
ATTRIB_FUNC(2, 2dv, 0, GLdouble)
|
||||
ATTRIB_FUNC(3, 3dv, 0, GLdouble)
|
||||
ATTRIB_FUNC(4, 4dv, 0, GLdouble)
|
||||
ATTRIB_FUNC(1, 1sv, 0, GLshort)
|
||||
ATTRIB_FUNC(2, 2sv, 0, GLshort)
|
||||
ATTRIB_FUNC(3, 3sv, 0, GLshort)
|
||||
ATTRIB_FUNC(4, 4sv, 0, GLshort)
|
||||
ATTRIB_FUNC(1, 1fv, 0, GLfloat)
|
||||
ATTRIB_FUNC(2, 2fv, 0, GLfloat)
|
||||
ATTRIB_FUNC(3, 3fv, 0, GLfloat)
|
||||
ATTRIB_FUNC(4, 4fv, 0, GLfloat)
|
||||
ATTRIB_FUNC(4, 4bv, 0, GLbyte)
|
||||
ATTRIB_FUNC(4, 4iv, 0, GLint)
|
||||
ATTRIB_FUNC(4, 4uiv, 0, GLuint)
|
||||
ATTRIB_FUNC(4, 4usv, 0, GLushort)
|
||||
ATTRIB_FUNC(4, 4ubv, 0, GLubyte)
|
||||
|
||||
ATTRIB_FUNC(1, L1dv, Attrib_L, GLdouble)
|
||||
ATTRIB_FUNC(2, L2dv, Attrib_L, GLdouble)
|
||||
ATTRIB_FUNC(3, L3dv, Attrib_L, GLdouble)
|
||||
ATTRIB_FUNC(4, L4dv, Attrib_L, GLdouble)
|
||||
|
||||
ATTRIB_FUNC(1, I1iv, Attrib_I, GLint)
|
||||
ATTRIB_FUNC(1, I1uiv, Attrib_I, GLuint)
|
||||
ATTRIB_FUNC(2, I2iv, Attrib_I, GLint)
|
||||
ATTRIB_FUNC(2, I2uiv, Attrib_I, GLuint)
|
||||
ATTRIB_FUNC(3, I3iv, Attrib_I, GLint)
|
||||
ATTRIB_FUNC(3, I3uiv, Attrib_I, GLuint)
|
||||
|
||||
ATTRIB_FUNC(4, I4bv, Attrib_I, GLbyte)
|
||||
ATTRIB_FUNC(4, I4iv, Attrib_I, GLint)
|
||||
ATTRIB_FUNC(4, I4sv, Attrib_I, GLshort)
|
||||
ATTRIB_FUNC(4, I4ubv, Attrib_I, GLubyte)
|
||||
ATTRIB_FUNC(4, I4uiv, Attrib_I, GLuint)
|
||||
ATTRIB_FUNC(4, I4usv, Attrib_I, GLushort)
|
||||
|
||||
ATTRIB_FUNC(4, 4Nbv, Attrib_N, GLbyte)
|
||||
ATTRIB_FUNC(4, 4Niv, Attrib_N, GLint)
|
||||
ATTRIB_FUNC(4, 4Nsv, Attrib_N, GLshort)
|
||||
ATTRIB_FUNC(4, 4Nubv, Attrib_N, GLubyte)
|
||||
ATTRIB_FUNC(4, 4Nuiv, Attrib_N, GLuint)
|
||||
ATTRIB_FUNC(4, 4Nusv, Attrib_N, GLushort)
|
||||
|
||||
#undef ATTRIB_FUNC
|
||||
#define ATTRIB_FUNC(count, suffix, funcparam, passparam) \
|
||||
void WrappedOpenGL::CONCAT(CONCAT(glVertexAttribP, count), suffix)(GLuint index, GLenum type, GLboolean normalized, funcparam) \
|
||||
{ \
|
||||
m_Real.CONCAT(CONCAT(glVertexAttribP, count), suffix)(index, type, normalized, value); \
|
||||
\
|
||||
if(m_State >= WRITING_CAPFRAME) \
|
||||
{ \
|
||||
SCOPED_SERIALISE_CONTEXT(VERTEXATTRIB_GENERIC); \
|
||||
Serialise_glVertexAttrib(index, count, type, normalized, passparam, Attrib_packed); \
|
||||
\
|
||||
m_ContextRecord->AddChunk(scope.Get()); \
|
||||
} \
|
||||
}
|
||||
|
||||
ATTRIB_FUNC(1, ui, GLuint value, &value)
|
||||
ATTRIB_FUNC(2, ui, GLuint value, &value)
|
||||
ATTRIB_FUNC(3, ui, GLuint value, &value)
|
||||
ATTRIB_FUNC(4, ui, GLuint value, &value)
|
||||
ATTRIB_FUNC(1, uiv, const GLuint *value, value)
|
||||
ATTRIB_FUNC(2, uiv, const GLuint *value, value)
|
||||
ATTRIB_FUNC(3, uiv, const GLuint *value, value)
|
||||
ATTRIB_FUNC(4, uiv, const GLuint *value, value)
|
||||
|
||||
#pragma endregion
|
||||
Reference in New Issue
Block a user