diff --git a/renderdoc/driver/gl/gl_common.h b/renderdoc/driver/gl/gl_common.h index 68733b087..4b7bfd13d 100644 --- a/renderdoc/driver/gl/gl_common.h +++ b/renderdoc/driver/gl/gl_common.h @@ -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, diff --git a/renderdoc/driver/gl/gl_driver.cpp b/renderdoc/driver/gl/gl_driver.cpp index f1836db28..b94c71b5a 100644 --- a/renderdoc/driver/gl/gl_driver.cpp +++ b/renderdoc/driver/gl/gl_driver.cpp @@ -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; diff --git a/renderdoc/driver/gl/gl_driver.h b/renderdoc/driver/gl/gl_driver.h index 3dba4d159..4193bf593 100644 --- a/renderdoc/driver/gl/gl_driver.h +++ b/renderdoc/driver/gl/gl_driver.h @@ -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)); diff --git a/renderdoc/driver/gl/gl_hookset.h b/renderdoc/driver/gl/gl_hookset.h index aafb833fe..6044c48e0 100644 --- a/renderdoc/driver/gl/gl_hookset.h +++ b/renderdoc/driver/gl/gl_hookset.h @@ -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; diff --git a/renderdoc/driver/gl/gl_hookset_defs.h b/renderdoc/driver/gl/gl_hookset_defs.h index 286a15306..df974643d 100644 --- a/renderdoc/driver/gl/gl_hookset_defs.h +++ b/renderdoc/driver/gl/gl_hookset_defs.h @@ -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); \ diff --git a/renderdoc/driver/gl/gl_renderstate.cpp b/renderdoc/driver/gl/gl_renderstate.cpp index 7312f5194..bd452d957 100644 --- a/renderdoc/driver/gl/gl_renderstate.cpp +++ b/renderdoc/driver/gl/gl_renderstate.cpp @@ -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); diff --git a/renderdoc/driver/gl/gl_renderstate.h b/renderdoc/driver/gl/gl_renderstate.h index 2f04238f9..93fe791c9 100644 --- a/renderdoc/driver/gl/gl_renderstate.h +++ b/renderdoc/driver/gl/gl_renderstate.h @@ -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; diff --git a/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp index 966f09194..5293f959b 100644 --- a/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp @@ -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 \ No newline at end of file