From c9d8ab2dcff7019bc1c8facd08edef129dfe19a0 Mon Sep 17 00:00:00 2001 From: Baldur Karlsson Date: Thu, 19 Jun 2014 13:00:33 +0100 Subject: [PATCH] Add a few last buffer related hooks --- renderdoc/driver/gl/gl_common.h | 5 + renderdoc/driver/gl/gl_driver.cpp | 20 ++ renderdoc/driver/gl/gl_driver.h | 10 + renderdoc/driver/gl/gl_hookset.h | 9 + renderdoc/driver/gl/gl_hookset_defs.h | 18 ++ .../driver/gl/wrappers/gl_buffer_funcs.cpp | 231 ++++++++++++++++++ .../driver/gl/wrappers/gl_texture_funcs.cpp | 117 +++++++++ renderdoc/hooks/gl_linux_hooks.cpp | 32 ++- renderdoc/hooks/gl_win32_hooks.cpp | 123 ++++++---- 9 files changed, 512 insertions(+), 53 deletions(-) diff --git a/renderdoc/driver/gl/gl_common.h b/renderdoc/driver/gl/gl_common.h index d6719e5b4..5de79af9c 100644 --- a/renderdoc/driver/gl/gl_common.h +++ b/renderdoc/driver/gl/gl_common.h @@ -93,12 +93,14 @@ enum GLChunkType TEXSUBIMAGE1D_COMPRESSED, TEXSUBIMAGE2D_COMPRESSED, TEXSUBIMAGE3D_COMPRESSED, + TEXBUFFER_RANGE, PIXELSTORE, TEXPARAMETERF, TEXPARAMETERFV, TEXPARAMETERI, TEXPARAMETERIV, GENERATE_MIPMAP, + COPY_SUBIMAGE, TEXTURE_VIEW, CREATE_SHADER, @@ -207,7 +209,10 @@ enum GLChunkType BIND_BUFFER, BIND_BUFFER_BASE, BIND_BUFFER_RANGE, + BUFFERSTORAGE, BUFFERDATA, + BUFFERSUBDATA, + COPYBUFFERSUBDATA, UNMAP, GEN_VERTEXARRAY, BIND_VERTEXARRAY, diff --git a/renderdoc/driver/gl/gl_driver.cpp b/renderdoc/driver/gl/gl_driver.cpp index 188773644..0ad5d204d 100644 --- a/renderdoc/driver/gl/gl_driver.cpp +++ b/renderdoc/driver/gl/gl_driver.cpp @@ -50,12 +50,14 @@ const char *GLChunkNames[] = "glCompressedTexSubImage1D", "glCompressedTexSubImage2D", "glCompressedTexSubImage3D", + "glTexBufferRange", "glPixelStore", "glTexParameterf", "glTexParameterfv", "glTexParameteri", "glTexParameteriv", "glGenerateMipmap", + "glCopyImageSubData", "glTextureView", "glCreateShader", @@ -164,7 +166,10 @@ const char *GLChunkNames[] = "glBindBuffer", "glBindBufferBase", "glBindBufferRange", + "glBufferStorage", "glBufferData", + "glBufferSubData", + "glCopyBufferSubData", "glUnmapBuffer", "glGenVertexArrays", "glBindVertexArray", @@ -949,6 +954,9 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) case TEXSUBIMAGE3D_COMPRESSED: Serialise_glCompressedTextureSubImage3DEXT(0, eGL_UNKNOWN_ENUM, 0, 0, 0, 0, 0, 0, 0, eGL_UNKNOWN_ENUM, 0, NULL); break; + case TEXBUFFER_RANGE: + Serialise_glTextureBufferRangeEXT(0, eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, 0, 0, 0); + break; case PIXELSTORE: Serialise_glPixelStorei(eGL_UNKNOWN_ENUM, 0); break; @@ -967,6 +975,9 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) case GENERATE_MIPMAP: Serialise_glGenerateTextureMipmapEXT(0, eGL_UNKNOWN_ENUM); break; + case COPY_SUBIMAGE: + Serialise_glCopyImageSubData(0, eGL_UNKNOWN_ENUM, 0, 0, 0, 0, 0, eGL_UNKNOWN_ENUM, 0, 0, 0, 0, 0, 0, 0); + break; case TEXTURE_VIEW: Serialise_glTextureView(0, eGL_UNKNOWN_ENUM, 0, eGL_UNKNOWN_ENUM, 0, 0, 0, 0); break; @@ -1277,9 +1288,18 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) case BIND_BUFFER_RANGE: Serialise_glBindBufferRange(eGL_UNKNOWN_ENUM, 0, 0, 0, 0); break; + case BUFFERSTORAGE: + Serialise_glNamedBufferStorageEXT(0, 0, NULL, 0); + break; case BUFFERDATA: Serialise_glNamedBufferDataEXT(eGL_UNKNOWN_ENUM, 0, NULL, eGL_UNKNOWN_ENUM); break; + case BUFFERSUBDATA: + Serialise_glNamedBufferSubDataEXT(0, 0, 0, NULL); + break; + case COPYBUFFERSUBDATA: + Serialise_glNamedCopyBufferSubDataEXT(0, 0, 0, 0, 0); + break; case UNMAP: Serialise_glUnmapNamedBufferEXT(eGL_UNKNOWN_ENUM); break; diff --git a/renderdoc/driver/gl/gl_driver.h b/renderdoc/driver/gl/gl_driver.h index 0b47dbc42..9d5517371 100644 --- a/renderdoc/driver/gl/gl_driver.h +++ b/renderdoc/driver/gl/gl_driver.h @@ -310,6 +310,7 @@ class WrappedOpenGL IMPLEMENT_FUNCTION_SERIALISED(void, glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *pixels)); IMPLEMENT_FUNCTION_SERIALISED(void, glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * pixels)); IMPLEMENT_FUNCTION_SERIALISED(void, glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * pixels)); + IMPLEMENT_FUNCTION_SERIALISED(void, glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)); IMPLEMENT_FUNCTION_SERIALISED(void, glTexParameterf(GLenum target, GLenum pname, GLfloat param)); IMPLEMENT_FUNCTION_SERIALISED(void, glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)); IMPLEMENT_FUNCTION_SERIALISED(void, glTexParameteri(GLenum target, GLenum pname, GLint param)); @@ -379,6 +380,8 @@ class WrappedOpenGL IMPLEMENT_FUNCTION_SERIALISED(void, glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)); IMPLEMENT_FUNCTION_SERIALISED(void, glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)); IMPLEMENT_FUNCTION_SERIALISED(void, glGenerateMipmap(GLenum target)); + IMPLEMENT_FUNCTION_SERIALISED(void, glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)); + IMPLEMENT_FUNCTION_SERIALISED(void, glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)); IMPLEMENT_FUNCTION_SERIALISED(void, glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)); @@ -429,7 +432,10 @@ class WrappedOpenGL IMPLEMENT_FUNCTION_SERIALISED(void, glValidateProgramPipeline(GLuint pipeline)); IMPLEMENT_FUNCTION_SERIALISED(void, glGenBuffers(GLsizei n, GLuint *buffers)); IMPLEMENT_FUNCTION_SERIALISED(void, glBindBuffer(GLenum target, GLuint buffer)); + IMPLEMENT_FUNCTION_SERIALISED(void, glBufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags)); IMPLEMENT_FUNCTION_SERIALISED(void, glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage)); + IMPLEMENT_FUNCTION_SERIALISED(void, glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data)); + IMPLEMENT_FUNCTION_SERIALISED(void, glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)); IMPLEMENT_FUNCTION_SERIALISED(void, glBindBufferBase(GLenum target, GLuint index, GLuint buffer)); IMPLEMENT_FUNCTION_SERIALISED(void, glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)); IMPLEMENT_FUNCTION_SERIALISED(void *, glMapBuffer(GLenum target, GLenum access)); @@ -529,9 +535,13 @@ class WrappedOpenGL IMPLEMENT_FUNCTION_SERIALISED(void *, glMapNamedBufferEXT(GLuint buffer, GLenum access)); IMPLEMENT_FUNCTION_SERIALISED(void *, glMapNamedBufferRangeEXT(GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access)); IMPLEMENT_FUNCTION_SERIALISED(void, glNamedBufferDataEXT(GLuint buffer, GLsizeiptr size, const void *data, GLenum usage)); + IMPLEMENT_FUNCTION_SERIALISED(void, glNamedBufferStorageEXT(GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags)); + IMPLEMENT_FUNCTION_SERIALISED(void, glNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data)); + IMPLEMENT_FUNCTION_SERIALISED(void, glNamedCopyBufferSubDataEXT(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)); IMPLEMENT_FUNCTION_SERIALISED(void, glNamedFramebufferTextureEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level)); IMPLEMENT_FUNCTION_SERIALISED(void, glNamedFramebufferTexture2DEXT(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level)); IMPLEMENT_FUNCTION_SERIALISED(void, glNamedFramebufferTextureLayerEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer)); + IMPLEMENT_FUNCTION_SERIALISED(void, glTextureBufferRangeEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)); IMPLEMENT_FUNCTION_SERIALISED(void, glTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)); IMPLEMENT_FUNCTION_SERIALISED(void, glTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)); IMPLEMENT_FUNCTION_SERIALISED(void, glTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)); diff --git a/renderdoc/driver/gl/gl_hookset.h b/renderdoc/driver/gl/gl_hookset.h index 1481ece7a..ea8d92847 100644 --- a/renderdoc/driver/gl/gl_hookset.h +++ b/renderdoc/driver/gl/gl_hookset.h @@ -96,8 +96,10 @@ struct GLHookSet PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glCompressedTexSubImage1D; PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glCompressedTexSubImage2D; PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glCompressedTexSubImage3D; + PFNGLTEXBUFFERRANGEPROC glTexBufferRange; PFNGLTEXTUREVIEWPROC glTextureView; PFNGLGENERATEMIPMAPPROC glGenerateMipmap; + PFNGLCOPYIMAGESUBDATAPROC glCopyImageSubData; PFNGLGETINTERNALFORMATIVPROC glGetInternalformativ; PFNGLGETINTERNALFORMATI64VPROC glGetInternalformati64v; PFNGLGETBUFFERPARAMETERIVPROC glGetBufferParameteriv; @@ -189,6 +191,9 @@ struct GLHookSet PFNGLGETQUERYOBJECTUIVPROC glGetQueryObjectuiv; PFNGLDELETEQUERIESPROC glDeleteQueries; PFNGLBUFFERDATAPROC glBufferData; + PFNGLBUFFERSTORAGEPROC glBufferStorage; + PFNGLBUFFERSUBDATAPROC glBufferSubData; + PFNGLCOPYBUFFERSUBDATAPROC glCopyBufferSubData; PFNGLBINDBUFFERBASEPROC glBindBufferBase; PFNGLBINDBUFFERRANGEPROC glBindBufferRange; PFNGLMAPBUFFERPROC glMapBuffer; @@ -275,9 +280,13 @@ struct GLHookSet PFNGLMAPNAMEDBUFFEREXTPROC glMapNamedBufferEXT; PFNGLMAPNAMEDBUFFERRANGEEXTPROC glMapNamedBufferRangeEXT; PFNGLNAMEDBUFFERDATAEXTPROC glNamedBufferDataEXT; + PFNGLNAMEDBUFFERSTORAGEEXTPROC glNamedBufferStorageEXT; + PFNGLNAMEDBUFFERSUBDATAEXTPROC glNamedBufferSubDataEXT; + PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC glNamedCopyBufferSubDataEXT; PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC glNamedFramebufferTextureEXT; PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC glNamedFramebufferTexture2DEXT; PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC glNamedFramebufferTextureLayerEXT; + PFNGLTEXTUREBUFFERRANGEEXTPROC glTextureBufferRangeEXT; PFNGLTEXTUREIMAGE1DEXTPROC glTextureImage1DEXT; PFNGLTEXTUREIMAGE2DEXTPROC glTextureImage2DEXT; PFNGLTEXTUREIMAGE3DEXTPROC glTextureImage3DEXT; diff --git a/renderdoc/driver/gl/gl_hookset_defs.h b/renderdoc/driver/gl/gl_hookset_defs.h index 49efd5028..92b44ac45 100644 --- a/renderdoc/driver/gl/gl_hookset_defs.h +++ b/renderdoc/driver/gl/gl_hookset_defs.h @@ -109,8 +109,10 @@ HookExtension(PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC, glCompressedTexSubImage1D); \ HookExtension(PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC, glCompressedTexSubImage2D); \ HookExtension(PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC, glCompressedTexSubImage3D); \ + HookExtension(PFNGLTEXBUFFERRANGEPROC, glTexBufferRange); \ HookExtension(PFNGLTEXTUREVIEWPROC, glTextureView); \ HookExtension(PFNGLGENERATEMIPMAPPROC, glGenerateMipmap); \ + HookExtension(PFNGLCOPYIMAGESUBDATAPROC, glCopyImageSubData); \ HookExtension(PFNGLGETINTERNALFORMATIVPROC, glGetInternalformativ); \ HookExtension(PFNGLGETINTERNALFORMATI64VPROC, glGetInternalformati64v); \ HookExtension(PFNGLGETBUFFERPARAMETERIVPROC, glGetBufferParameteriv); \ @@ -203,6 +205,9 @@ HookExtension(PFNGLGETQUERYOBJECTUIVPROC, glGetQueryObjectuiv); \ HookExtension(PFNGLDELETEQUERIESPROC, glDeleteQueries); \ HookExtension(PFNGLBUFFERDATAPROC, glBufferData); \ + HookExtension(PFNGLBUFFERSTORAGEPROC, glBufferStorage); \ + HookExtension(PFNGLBUFFERSUBDATAPROC, glBufferSubData); \ + HookExtension(PFNGLCOPYBUFFERSUBDATAPROC, glCopyBufferSubData); \ HookExtension(PFNGLBINDBUFFERBASEPROC, glBindBufferBase); \ HookExtension(PFNGLBINDBUFFERRANGEPROC, glBindBufferRange); \ HookExtension(PFNGLMAPBUFFERPROC, glMapBuffer); \ @@ -289,9 +294,13 @@ HookExtension(PFNGLMAPNAMEDBUFFEREXTPROC, glMapNamedBufferEXT); \ HookExtension(PFNGLMAPNAMEDBUFFERRANGEEXTPROC, glMapNamedBufferRangeEXT); \ HookExtension(PFNGLNAMEDBUFFERDATAEXTPROC, glNamedBufferDataEXT); \ + HookExtension(PFNGLNAMEDBUFFERSTORAGEEXTPROC, glNamedBufferStorageEXT); \ + HookExtension(PFNGLNAMEDBUFFERSUBDATAEXTPROC, glNamedBufferSubDataEXT); \ + HookExtension(PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC, glNamedCopyBufferSubDataEXT); \ HookExtension(PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC, glNamedFramebufferTextureEXT); \ HookExtension(PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC, glNamedFramebufferTexture2DEXT); \ HookExtension(PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC, glNamedFramebufferTextureLayerEXT); \ + HookExtension(PFNGLTEXTUREBUFFERRANGEEXTPROC, glTextureBufferRangeEXT); \ HookExtension(PFNGLTEXTUREIMAGE1DEXTPROC, glTextureImage1DEXT); \ HookExtension(PFNGLTEXTUREIMAGE2DEXTPROC, glTextureImage2DEXT); \ HookExtension(PFNGLTEXTUREIMAGE3DEXTPROC, glTextureImage3DEXT); \ @@ -441,8 +450,10 @@ HookWrapper7(void, glCompressedTexSubImage1D, GLenum, target, GLint, level, GLint, xoffset, GLsizei, width, GLenum, format, GLsizei, imageSize, const void *, data); \ HookWrapper9(void, glCompressedTexSubImage2D, GLenum, target, GLint, level, GLint, xoffset, GLint, yoffset, GLsizei, width, GLsizei, height, GLenum, format, GLsizei, imageSize, const void *, data); \ HookWrapper11(void, glCompressedTexSubImage3D, GLenum, target, GLint, level, GLint, xoffset, GLint, yoffset, GLint, zoffset, GLsizei, width, GLsizei, height, GLsizei, depth, GLenum, format, GLsizei, imageSize, const void *, data); \ + HookWrapper5(void, glTexBufferRange, GLenum, target, GLenum, internalformat, GLuint, buffer, GLintptr, offset, GLsizeiptr, size); \ HookWrapper8(void, glTextureView, GLuint, texture, GLenum, target, GLuint, origtexture, GLenum, internalformat, GLuint, minlevel, GLuint, numlevels, GLuint, minlayer, GLuint, numlayers); \ HookWrapper1(void, glGenerateMipmap, GLenum, target); \ + HookWrapper15(void, glCopyImageSubData, GLuint, srcName, GLenum, srcTarget, GLint, srcLevel, GLint, srcX, GLint, srcY, GLint, srcZ, GLuint, dstName, GLenum, dstTarget, GLint, dstLevel, GLint, dstX, GLint, dstY, GLint, dstZ, GLsizei, srcWidth, GLsizei, srcHeight, GLsizei, srcDepth); \ HookWrapper5(void, glGetInternalformativ, GLenum, target, GLenum, internalformat, GLenum, pname, GLsizei, bufSize, GLint *, params); \ HookWrapper5(void, glGetInternalformati64v, GLenum, target, GLenum, internalformat, GLenum, pname, GLsizei, bufSize, GLint64 *, params); \ HookWrapper3(void, glGetBufferParameteriv, GLenum, target, GLenum, pname, GLint *, params); \ @@ -534,6 +545,9 @@ HookWrapper3(void, glGetQueryObjectuiv, GLuint, id, GLenum, pname, GLuint *, params); \ HookWrapper2(void, glDeleteQueries, GLsizei, n, const GLuint *, ids); \ HookWrapper4(void, glBufferData, GLenum, target, GLsizeiptr, size, const void *, data, GLenum, usage); \ + HookWrapper4(void, glBufferStorage, GLenum, target, GLsizeiptr, size, const void *, data, GLbitfield, flags); \ + HookWrapper4(void, glBufferSubData, GLenum, target, GLintptr, offset, GLsizeiptr, size, const void *, data); \ + HookWrapper5(void, glCopyBufferSubData, GLenum, readTarget, GLenum, writeTarget, GLintptr, readOffset, GLintptr, writeOffset, GLsizeiptr, size); \ HookWrapper3(void, glBindBufferBase, GLenum, target, GLuint, index, GLuint, buffer); \ HookWrapper5(void, glBindBufferRange, GLenum, target, GLuint, index, GLuint, buffer, GLintptr, offset, GLsizeiptr, size); \ HookWrapper2(void *, glMapBuffer, GLenum, target, GLenum, access); \ @@ -620,9 +634,13 @@ HookWrapper2(void *, glMapNamedBufferEXT, GLuint, buffer, GLenum, access); \ HookWrapper4(void *, glMapNamedBufferRangeEXT, GLuint, buffer, GLintptr, offset, GLsizeiptr, length, GLbitfield, access); \ HookWrapper4(void, glNamedBufferDataEXT, GLuint, buffer, GLsizeiptr, size, const void *, data, GLenum, usage); \ + HookWrapper4(void, glNamedBufferStorageEXT, GLuint, buffer, GLsizeiptr, size, const void *, data, GLbitfield, flags); \ + HookWrapper4(void, glNamedBufferSubDataEXT, GLuint, buffer, GLintptr, offset, GLsizeiptr, size, const void *, data); \ + HookWrapper5(void, glNamedCopyBufferSubDataEXT, GLuint, readBuffer, GLuint, writeBuffer, GLintptr, readOffset, GLintptr, writeOffset, GLsizeiptr, size); \ HookWrapper4(void, glNamedFramebufferTextureEXT, GLuint, framebuffer, GLenum, attachment, GLuint, texture, GLint, level); \ HookWrapper5(void, glNamedFramebufferTexture2DEXT, GLuint, framebuffer, GLenum, attachment, GLenum, textarget, GLuint, texture, GLint, level); \ HookWrapper5(void, glNamedFramebufferTextureLayerEXT, GLuint, framebuffer, GLenum, attachment, GLuint, texture, GLint, level, GLint, layer); \ + HookWrapper6(void, glTextureBufferRangeEXT, GLuint, texture, GLenum, target, GLenum, internalformat, GLuint, buffer, GLintptr, offset, GLsizeiptr, size); \ HookWrapper9(void, glTextureImage1DEXT, GLuint, texture, GLenum, target, GLint, level, GLint, internalformat, GLsizei, width, GLint, border, GLenum, format, GLenum, type, const void *, pixels); \ HookWrapper10(void, glTextureImage2DEXT, GLuint, texture, GLenum, target, GLint, level, GLint, internalformat, GLsizei, width, GLsizei, height, GLint, border, GLenum, format, GLenum, type, const void *, pixels); \ HookWrapper11(void, glTextureImage3DEXT, GLuint, texture, GLenum, target, GLint, level, GLint, internalformat, GLsizei, width, GLsizei, height, GLsizei, depth, GLint, border, GLenum, format, GLenum, type, const void *, pixels); \ diff --git a/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp index d302bdc67..9bd42284a 100644 --- a/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp @@ -174,6 +174,102 @@ void WrappedOpenGL::glBindBuffer(GLenum target, GLuint buffer) } } +bool WrappedOpenGL::Serialise_glNamedBufferStorageEXT(GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(BufferRes(buffer))); + SERIALISE_ELEMENT(uint64_t, Bytesize, (uint64_t)size); + + byte *dummy = NULL; + + if(m_State >= WRITING && data == NULL) + { + dummy = new byte[size]; + data = dummy; + } + + SERIALISE_ELEMENT_BUF(byte *, bytes, data, (size_t)Bytesize); + + uint64_t offs = m_pSerialiser->GetOffset(); + + SERIALISE_ELEMENT(uint32_t, Flags, flags); + + if(m_State < WRITING) + { + GLResource res = GetResourceManager()->GetLiveResource(id); + m_Real.glNamedBufferStorageEXT(res.name, (GLsizeiptr)Bytesize, bytes, Flags); + + m_Buffers[GetResourceManager()->GetLiveID(id)].size = Bytesize; + + SAFE_DELETE_ARRAY(bytes); + } + else if(m_State >= WRITING) + { + GetResourceManager()->GetResourceRecord(id)->SetDataOffset(offs - Bytesize); + } + + if(dummy) + delete[] dummy; + + return true; +} + +void WrappedOpenGL::glNamedBufferStorageEXT(GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags) +{ + m_Real.glNamedBufferStorageEXT(buffer, size, data, flags); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(BufferRes(buffer)); + RDCASSERT(record); + + SCOPED_SERIALISE_CONTEXT(BUFFERSTORAGE); + Serialise_glNamedBufferStorageEXT(buffer, size, data, flags); + + Chunk *chunk = scope.Get(); + + if(m_State == WRITING_CAPFRAME) + { + m_ContextRecord->AddChunk(chunk); + } + else + { + record->AddChunk(chunk); + record->SetDataPtr(chunk->GetData()); + record->Length = (int32_t)size; + } + } +} + +void WrappedOpenGL::glBufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags) +{ + m_Real.glBufferStorage(target, size, data, flags); + + size_t idx = BufferIdx(target); + + if(m_State >= WRITING) + { + GLResourceRecord *record = m_BufferRecord[BufferIdx(target)]; + RDCASSERT(record); + + SCOPED_SERIALISE_CONTEXT(BUFFERSTORAGE); + Serialise_glNamedBufferStorageEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, + size, data, flags); + + Chunk *chunk = scope.Get(); + + if(m_State == WRITING_CAPFRAME) + { + m_ContextRecord->AddChunk(chunk); + } + else + { + record->AddChunk(chunk); + record->SetDataPtr(chunk->GetData()); + record->Length = (int32_t)size; + } + } +} + bool WrappedOpenGL::Serialise_glNamedBufferDataEXT(GLuint buffer, GLsizeiptr size, const void *data, GLenum usage) { SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(BufferRes(buffer))); @@ -270,6 +366,141 @@ void WrappedOpenGL::glBufferData(GLenum target, GLsizeiptr size, const void *dat } } +bool WrappedOpenGL::Serialise_glNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(BufferRes(buffer))); + SERIALISE_ELEMENT(uint64_t, Offset, (uint64_t)offset); + SERIALISE_ELEMENT(uint64_t, Bytesize, (uint64_t)size); + SERIALISE_ELEMENT_BUF(byte *, bytes, data, (size_t)Bytesize); + + if(m_State < WRITING) + { + GLResource res = GetResourceManager()->GetLiveResource(id); + m_Real.glNamedBufferSubDataEXT(res.name, (GLintptr)Offset, (GLsizeiptr)Bytesize, bytes); + + SAFE_DELETE_ARRAY(bytes); + } + + return true; +} + +void WrappedOpenGL::glNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data) +{ + m_Real.glNamedBufferSubDataEXT(buffer, offset, size, data); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(BufferRes(buffer)); + RDCASSERT(record); + + SCOPED_SERIALISE_CONTEXT(BUFFERDATA); + Serialise_glNamedBufferSubDataEXT(buffer, offset, size, data); + + Chunk *chunk = scope.Get(); + + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(chunk); + else + record->AddChunk(chunk); + } +} + +void WrappedOpenGL::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data) +{ + m_Real.glBufferSubData(target, offset, size, data); + + if(m_State >= WRITING) + { + GLResourceRecord *record = m_BufferRecord[BufferIdx(target)]; + RDCASSERT(record); + + SCOPED_SERIALISE_CONTEXT(BUFFERSUBDATA); + Serialise_glNamedBufferSubDataEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, + offset, size, data); + + Chunk *chunk = scope.Get(); + + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(chunk); + else + record->AddChunk(chunk); + } +} + +bool WrappedOpenGL::Serialise_glNamedCopyBufferSubDataEXT(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) +{ + SERIALISE_ELEMENT(ResourceId, readid, GetResourceManager()->GetID(BufferRes(readBuffer))); + SERIALISE_ELEMENT(ResourceId, writeid, GetResourceManager()->GetID(BufferRes(writeBuffer))); + SERIALISE_ELEMENT(uint64_t, ReadOffset, (uint64_t)readOffset); + SERIALISE_ELEMENT(uint64_t, WriteOffset, (uint64_t)writeOffset); + SERIALISE_ELEMENT(uint64_t, Bytesize, (uint64_t)size); + + if(m_State < WRITING) + { + GLResource readres = GetResourceManager()->GetLiveResource(readid); + GLResource writeres = GetResourceManager()->GetLiveResource(writeid); + m_Real.glNamedCopyBufferSubDataEXT(readres.name, writeres.name, (GLintptr)ReadOffset, (GLintptr)WriteOffset, (GLsizeiptr)Bytesize); + } + + return true; +} + +void WrappedOpenGL::glNamedCopyBufferSubDataEXT(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) +{ + m_Real.glNamedCopyBufferSubDataEXT(readBuffer, writeBuffer, readOffset, writeOffset, size); + + if(m_State >= WRITING) + { + GLResourceRecord *readrecord = GetResourceManager()->GetResourceRecord(BufferRes(readBuffer)); + GLResourceRecord *writerecord = GetResourceManager()->GetResourceRecord(BufferRes(writeBuffer)); + RDCASSERT(readrecord && writerecord); + + SCOPED_SERIALISE_CONTEXT(COPYBUFFERSUBDATA); + Serialise_glNamedCopyBufferSubDataEXT(readBuffer, writeBuffer, readOffset, writeOffset, size); + + Chunk *chunk = scope.Get(); + + if(m_State == WRITING_CAPFRAME) + { + m_ContextRecord->AddChunk(chunk); + } + else + { + writerecord->AddChunk(chunk); + writerecord->AddParent(readrecord); + } + } +} + +void WrappedOpenGL::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) +{ + m_Real.glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); + + if(m_State >= WRITING) + { + GLResourceRecord *readrecord = m_BufferRecord[BufferIdx(readTarget)]; + GLResourceRecord *writerecord = m_BufferRecord[BufferIdx(writeTarget)]; + RDCASSERT(readrecord && writerecord); + + SCOPED_SERIALISE_CONTEXT(COPYBUFFERSUBDATA); + Serialise_glNamedCopyBufferSubDataEXT(GetResourceManager()->GetCurrentResource(readrecord->GetResourceID()).name, + GetResourceManager()->GetCurrentResource(writerecord->GetResourceID()).name, + readOffset, writeOffset, size); + + Chunk *chunk = scope.Get(); + + if(m_State == WRITING_CAPFRAME) + { + m_ContextRecord->AddChunk(chunk); + } + else + { + writerecord->AddChunk(chunk); + writerecord->AddParent(readrecord); + } + } +} + bool WrappedOpenGL::Serialise_glBindBufferBase(GLenum target, GLuint index, GLuint buffer) { SERIALISE_ELEMENT(GLenum, Target, target); diff --git a/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp index b709e6dee..e2d357fa1 100644 --- a/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp @@ -271,6 +271,70 @@ void WrappedOpenGL::glGenerateMipmap(GLenum target) } } +bool WrappedOpenGL::Serialise_glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, + GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, + GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth) +{ + SERIALISE_ELEMENT(ResourceId, srcid, GetResourceManager()->GetID(BufferRes(srcName))); + SERIALISE_ELEMENT(ResourceId, dstid, GetResourceManager()->GetID(BufferRes(dstName))); + SERIALISE_ELEMENT(GLenum, SourceTarget, srcTarget); + SERIALISE_ELEMENT(GLenum, DestTarget, dstTarget); + SERIALISE_ELEMENT(uint32_t, SourceLevel, srcLevel); + SERIALISE_ELEMENT(uint32_t, SourceX, srcX); + SERIALISE_ELEMENT(uint32_t, SourceY, srcY); + SERIALISE_ELEMENT(uint32_t, SourceZ, srcZ); + SERIALISE_ELEMENT(uint32_t, SourceWidth, srcWidth); + SERIALISE_ELEMENT(uint32_t, SourceHeight, srcHeight); + SERIALISE_ELEMENT(uint32_t, SourceDepth, srcDepth); + SERIALISE_ELEMENT(uint32_t, DestLevel, dstLevel); + SERIALISE_ELEMENT(uint32_t, DestX, dstX); + SERIALISE_ELEMENT(uint32_t, DestY, dstY); + SERIALISE_ELEMENT(uint32_t, DestZ, dstZ); + + if(m_State < WRITING) + { + GLResource srcres = GetResourceManager()->GetLiveResource(srcid); + GLResource dstres = GetResourceManager()->GetLiveResource(dstid); + m_Real.glCopyImageSubData(srcres.name, SourceTarget, SourceLevel, SourceX, SourceY, SourceZ, + dstres.name, DestTarget, DestLevel, DestX, DestY, DestZ, + SourceWidth, SourceHeight, SourceDepth); + } + return true; +} + +void WrappedOpenGL::glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, + GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, + GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth) +{ + m_Real.glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, + dstName, dstTarget, dstLevel, dstX, dstY, dstZ, + srcWidth, srcHeight, srcDepth); + + if(m_State >= WRITING) + { + GLResourceRecord *srcrecord = GetResourceManager()->GetResourceRecord(TextureRes(srcName)); + GLResourceRecord *dstrecord = GetResourceManager()->GetResourceRecord(TextureRes(dstName)); + RDCASSERT(srcrecord && dstrecord); + + SCOPED_SERIALISE_CONTEXT(COPY_SUBIMAGE); + Serialise_glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, + dstName, dstTarget, dstLevel, dstX, dstY, dstZ, + srcWidth, srcHeight, srcDepth); + + Chunk *chunk = scope.Get(); + + if(m_State == WRITING_CAPFRAME) + { + m_ContextRecord->AddChunk(chunk); + } + else + { + dstrecord->AddChunk(chunk); + dstrecord->AddParent(srcrecord); + } + } +} + bool WrappedOpenGL::Serialise_glTextureParameteriEXT(GLuint texture, GLenum target, GLenum pname, GLint param) { SERIALISE_ELEMENT(GLenum, Target, target); @@ -1215,4 +1279,57 @@ void WrappedOpenGL::glCompressedTexSubImage3D(GLenum target, GLint level, GLint } } +bool WrappedOpenGL::Serialise_glTextureBufferRangeEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(uint64_t, offs, (uint64_t)offset); + SERIALISE_ELEMENT(uint64_t, Size, (uint64_t)size); + SERIALISE_ELEMENT(GLenum, fmt, internalformat); + SERIALISE_ELEMENT(ResourceId, texid, GetResourceManager()->GetID(TextureRes(texture))); + SERIALISE_ELEMENT(ResourceId, bufid, GetResourceManager()->GetID(TextureRes(buffer))); + + if(m_State == READING) + { + m_Real.glTextureBufferRangeEXT(GetResourceManager()->GetLiveResource(texid).name, + Target, fmt, + GetResourceManager()->GetLiveResource(bufid).name, + (GLintptr)offs, (GLsizeiptr)Size); + } + + return true; +} + +void WrappedOpenGL::glTextureBufferRangeEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + m_Real.glTextureBufferRangeEXT(texture, target, internalformat, buffer, offset, size); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(texture)); + RDCASSERT(record); + + SCOPED_SERIALISE_CONTEXT(TEXBUFFER_RANGE); + Serialise_glTextureBufferRangeEXT(texture, target, internalformat, buffer, offset, size); + + record->AddChunk(scope.Get()); + } +} + +void WrappedOpenGL::glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + m_Real.glTexBufferRange(target, internalformat, buffer, offset, size); + + if(m_State >= WRITING) + { + GLResourceRecord *record = m_TextureRecord[m_TextureUnit]; + RDCASSERT(record); + + SCOPED_SERIALISE_CONTEXT(TEXBUFFER_RANGE); + Serialise_glTextureBufferRangeEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, + target, internalformat, buffer, offset, size); + + record->AddChunk(scope.Get()); + } +} + #pragma endregion diff --git a/renderdoc/hooks/gl_linux_hooks.cpp b/renderdoc/hooks/gl_linux_hooks.cpp index 768724685..efbe898c2 100644 --- a/renderdoc/hooks/gl_linux_hooks.cpp +++ b/renderdoc/hooks/gl_linux_hooks.cpp @@ -101,67 +101,96 @@ typedef void (*PFNGLXSWAPBUFFERSPROC)(Display *dpy, GLXDrawable drawable); extern "C" __attribute__ ((visibility ("default"))) \ ret function() \ { return OpenGLHook::glhooks.GetDriver()->function(); } + #define HookWrapper1(ret, function, t1, p1) \ typedef ret (*CONCAT(function, _hooktype)) (t1); \ extern "C" __attribute__ ((visibility ("default"))) \ ret function(t1 p1) \ { return OpenGLHook::glhooks.GetDriver()->function(p1); } + #define HookWrapper2(ret, function, t1, p1, t2, p2) \ typedef ret (*CONCAT(function, _hooktype)) (t1, t2); \ extern "C" __attribute__ ((visibility ("default"))) \ ret function(t1 p1, t2 p2) \ { return OpenGLHook::glhooks.GetDriver()->function(p1, p2); } + #define HookWrapper3(ret, function, t1, p1, t2, p2, t3, p3) \ typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3); \ extern "C" __attribute__ ((visibility ("default"))) \ ret function(t1 p1, t2 p2, t3 p3) \ { return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3); } + #define HookWrapper4(ret, function, t1, p1, t2, p2, t3, p3, t4, p4) \ typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4); \ extern "C" __attribute__ ((visibility ("default"))) \ ret function(t1 p1, t2 p2, t3 p3, t4 p4) \ { return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4); } + #define HookWrapper5(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5) \ typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5); \ extern "C" __attribute__ ((visibility ("default"))) \ ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5) \ { return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5); } + #define HookWrapper6(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6) \ typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6); \ extern "C" __attribute__ ((visibility ("default"))) \ ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6) \ { return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6); } + #define HookWrapper7(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7) \ typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7); \ extern "C" __attribute__ ((visibility ("default"))) \ ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7) \ { return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7); } + #define HookWrapper8(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8) \ typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8); \ extern "C" __attribute__ ((visibility ("default"))) \ ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8) \ { return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8); } + #define HookWrapper9(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9) \ typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9); \ extern "C" __attribute__ ((visibility ("default"))) \ ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9) \ { return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9); } + #define HookWrapper10(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10) \ typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10); \ extern "C" __attribute__ ((visibility ("default"))) \ ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10) \ { return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); } + #define HookWrapper11(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11) \ typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11); \ extern "C" __attribute__ ((visibility ("default"))) \ ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11) \ { return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); } -#define HookWrapper11(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12 p12) \ + +#define HookWrapper12(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12, p12) \ typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12); \ extern "C" __attribute__ ((visibility ("default"))) \ ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11, t12 p12) \ { return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); } +#define HookWrapper13(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12, p12, t13, p13) \ + typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13); \ + extern "C" __attribute__ ((visibility ("default"))) \ + ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11, t12 p12, t13 p13) \ + { return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); } + +#define HookWrapper14(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12, p12, t13, p13, t14, p14) \ + typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14); \ + extern "C" __attribute__ ((visibility ("default"))) \ + ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11, t12 p12, t13 p13, t14 p14) \ + { return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); } + +#define HookWrapper15(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12, p12, t13, p13, t14, p14, t15, p15) \ + typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15); \ + extern "C" __attribute__ ((visibility ("default"))) \ + ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11, t12 p12, t13 p13, t14 p14, t15 p15) \ + { return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); } class OpenGLHook : LibraryHook { @@ -412,3 +441,4 @@ bool OpenGLHook::PopulateHooks() OpenGLHook OpenGLHook::glhooks; const GLHookSet &GetRealFunctions() { return OpenGLHook::glhooks.GetRealFunctions(); } + diff --git a/renderdoc/hooks/gl_win32_hooks.cpp b/renderdoc/hooks/gl_win32_hooks.cpp index e1efc7f56..d842508d9 100644 --- a/renderdoc/hooks/gl_win32_hooks.cpp +++ b/renderdoc/hooks/gl_win32_hooks.cpp @@ -94,82 +94,101 @@ #endif #define HookWrapper0(ret, function) \ - Hook CONCAT(function, _hook); \ - typedef ret (WINAPI *CONCAT(function, _hooktype)) (); \ - static ret WINAPI CONCAT(function, _hooked)() \ - { return glhooks.GetDriver()->function(); } + Hook CONCAT(function, _hook); \ + typedef ret (WINAPI *CONCAT(function, _hooktype)) (); \ + static ret WINAPI CONCAT(function, _hooked)() \ + { return glhooks.GetDriver()->function(); } #define HookWrapper1(ret, function, t1, p1) \ - Hook CONCAT(function, _hook); \ - typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1); \ - static ret WINAPI CONCAT(function, _hooked)(t1 p1) \ - { return glhooks.GetDriver()->function(p1); } + Hook CONCAT(function, _hook); \ + typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1); \ + static ret WINAPI CONCAT(function, _hooked)(t1 p1) \ + { return glhooks.GetDriver()->function(p1); } #define HookWrapper2(ret, function, t1, p1, t2, p2) \ - Hook CONCAT(function, _hook); \ - typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2); \ - static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2) \ - { return glhooks.GetDriver()->function(p1, p2); } + Hook CONCAT(function, _hook); \ + typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2); \ + static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2) \ + { return glhooks.GetDriver()->function(p1, p2); } #define HookWrapper3(ret, function, t1, p1, t2, p2, t3, p3) \ - Hook CONCAT(function, _hook); \ - typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3); \ - static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3) \ - { return glhooks.GetDriver()->function(p1, p2, p3); } + Hook CONCAT(function, _hook); \ + typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3); \ + static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3) \ + { return glhooks.GetDriver()->function(p1, p2, p3); } #define HookWrapper4(ret, function, t1, p1, t2, p2, t3, p3, t4, p4) \ - Hook CONCAT(function, _hook); \ - typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4); \ - static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4) \ - { return glhooks.GetDriver()->function(p1, p2, p3, p4); } + Hook CONCAT(function, _hook); \ + typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4); \ + static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4) \ + { return glhooks.GetDriver()->function(p1, p2, p3, p4); } #define HookWrapper5(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5) \ - Hook CONCAT(function, _hook); \ - typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5); \ - static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5) \ - { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5); } + Hook CONCAT(function, _hook); \ + typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5); \ + static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5) \ + { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5); } #define HookWrapper6(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6) \ - Hook CONCAT(function, _hook); \ - typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6); \ - static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6) \ - { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6); } + Hook CONCAT(function, _hook); \ + typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6); \ + static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6) \ + { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6); } #define HookWrapper7(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7) \ - Hook CONCAT(function, _hook); \ - typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7); \ - static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7) \ - { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7); } + Hook CONCAT(function, _hook); \ + typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7); \ + static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7) \ + { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7); } #define HookWrapper8(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8) \ - Hook CONCAT(function, _hook); \ - typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8); \ - static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8) \ - { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8); } + Hook CONCAT(function, _hook); \ + typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8); \ + static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8) \ + { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8); } #define HookWrapper9(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9) \ - Hook CONCAT(function, _hook); \ - typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9); \ - static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9) \ - { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9); } + Hook CONCAT(function, _hook); \ + typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9); \ + static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9) \ + { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9); } #define HookWrapper10(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10) \ - Hook CONCAT(function, _hook); \ - typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10); \ - static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10) \ - { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); } + Hook CONCAT(function, _hook); \ + typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10); \ + static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10) \ + { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); } #define HookWrapper11(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11) \ - Hook CONCAT(function, _hook); \ - typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11); \ - static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11) \ - { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); } + Hook CONCAT(function, _hook); \ + typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11); \ + static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11) \ + { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); } #define HookWrapper12(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12, p12) \ - Hook CONCAT(function, _hook); \ - typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12); \ - static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11, t12 p12) \ - { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); } + Hook CONCAT(function, _hook); \ + typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12); \ + static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11, t12 p12) \ + { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); } + +#define HookWrapper13(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12, p12, t13, p13) \ + Hook CONCAT(function, _hook); \ + typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13); \ + static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11, t12 p12, t13 p13) \ + { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); } + +#define HookWrapper14(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12, p12, t13, p13, t14, p14) \ + Hook CONCAT(function, _hook); \ + typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14); \ + static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11, t12 p12, t13 p13, t14 p14) \ + { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); } + +#define HookWrapper15(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12, p12, t13, p13, t14, p14, t15, p15) \ + Hook CONCAT(function, _hook); \ + typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15); \ + static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11, t12 p12, t13 p13, t14 p14, t15 p15) \ + { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); } + class OpenGLHook : LibraryHook {