From b345b9ceb73f466bdbf9e9f5f650baf4a5dd69a8 Mon Sep 17 00:00:00 2001 From: Baldur Karlsson Date: Thu, 19 Jun 2014 12:05:49 +0100 Subject: [PATCH] Hook the EXT_direct_state_access functions. * Normal selector functions are implemented via these, which requires EXT_direct_state_access to be available, but this isn't hard to work around with some wrapper functions should that become necessary. --- renderdoc/driver/gl/gl_driver.cpp | 40 +- renderdoc/driver/gl/gl_driver.h | 37 ++ renderdoc/driver/gl/gl_hookset.h | 35 ++ renderdoc/driver/gl/gl_hookset_defs.h | 70 +++ .../driver/gl/wrappers/gl_buffer_funcs.cpp | 241 +++++--- .../gl/wrappers/gl_framebuffer_funcs.cpp | 325 +++++----- renderdoc/driver/gl/wrappers/gl_get_funcs.cpp | 45 ++ .../driver/gl/wrappers/gl_texture_funcs.cpp | 565 ++++++++++++++---- renderdoc/hooks/gl_linux_hooks.cpp | 5 + renderdoc/hooks/gl_win32_hooks.cpp | 6 + 10 files changed, 985 insertions(+), 384 deletions(-) diff --git a/renderdoc/driver/gl/gl_driver.cpp b/renderdoc/driver/gl/gl_driver.cpp index b36bdd53c..188773644 100644 --- a/renderdoc/driver/gl/gl_driver.cpp +++ b/renderdoc/driver/gl/gl_driver.cpp @@ -923,49 +923,49 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) Serialise_glBindTexture(eGL_UNKNOWN_ENUM, 0); break; case TEXSTORAGE1D: - Serialise_glTexStorage1D(eGL_UNKNOWN_ENUM, 0, eGL_UNKNOWN_ENUM, 0); + Serialise_glTextureStorage1DEXT(0, eGL_UNKNOWN_ENUM, 0, eGL_UNKNOWN_ENUM, 0); break; case TEXSTORAGE2D: - Serialise_glTexStorage2D(eGL_UNKNOWN_ENUM, 0, eGL_UNKNOWN_ENUM, 0, 0); + Serialise_glTextureStorage2DEXT(0, eGL_UNKNOWN_ENUM, 0, eGL_UNKNOWN_ENUM, 0, 0); break; case TEXSTORAGE3D: - Serialise_glTexStorage3D(eGL_UNKNOWN_ENUM, 0, eGL_UNKNOWN_ENUM, 0, 0, 0); + Serialise_glTextureStorage3DEXT(0, eGL_UNKNOWN_ENUM, 0, eGL_UNKNOWN_ENUM, 0, 0, 0); break; case TEXSUBIMAGE1D: - Serialise_glTexSubImage1D(eGL_UNKNOWN_ENUM, 0, 0, 0, eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, NULL); + Serialise_glTextureSubImage1DEXT(0, eGL_UNKNOWN_ENUM, 0, 0, 0, eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, NULL); break; case TEXSUBIMAGE2D: - Serialise_glTexSubImage2D(eGL_UNKNOWN_ENUM, 0, 0, 0, 0, 0, eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, NULL); + Serialise_glTextureSubImage2DEXT(0, eGL_UNKNOWN_ENUM, 0, 0, 0, 0, 0, eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, NULL); break; case TEXSUBIMAGE3D: - Serialise_glTexSubImage3D(eGL_UNKNOWN_ENUM, 0, 0, 0, 0, 0, 0, 0, eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, NULL); + Serialise_glTextureSubImage3DEXT(0, eGL_UNKNOWN_ENUM, 0, 0, 0, 0, 0, 0, 0, eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, NULL); break; case TEXSUBIMAGE1D_COMPRESSED: - Serialise_glCompressedTexSubImage1D(eGL_UNKNOWN_ENUM, 0, 0, 0, eGL_UNKNOWN_ENUM, 0, NULL); + Serialise_glCompressedTextureSubImage1DEXT(0, eGL_UNKNOWN_ENUM, 0, 0, 0, eGL_UNKNOWN_ENUM, 0, NULL); break; case TEXSUBIMAGE2D_COMPRESSED: - Serialise_glCompressedTexSubImage2D(eGL_UNKNOWN_ENUM, 0, 0, 0, 0, 0, eGL_UNKNOWN_ENUM, 0, NULL); + Serialise_glCompressedTextureSubImage2DEXT(0, eGL_UNKNOWN_ENUM, 0, 0, 0, 0, 0, eGL_UNKNOWN_ENUM, 0, NULL); break; case TEXSUBIMAGE3D_COMPRESSED: - Serialise_glCompressedTexSubImage3D(eGL_UNKNOWN_ENUM, 0, 0, 0, 0, 0, 0, 0, eGL_UNKNOWN_ENUM, 0, NULL); + Serialise_glCompressedTextureSubImage3DEXT(0, eGL_UNKNOWN_ENUM, 0, 0, 0, 0, 0, 0, 0, eGL_UNKNOWN_ENUM, 0, NULL); break; case PIXELSTORE: Serialise_glPixelStorei(eGL_UNKNOWN_ENUM, 0); break; case TEXPARAMETERF: - Serialise_glTexParameterf(eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, 0); + Serialise_glTextureParameterfEXT(0, eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, 0); break; case TEXPARAMETERFV: - Serialise_glTexParameterfv(eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, NULL); + Serialise_glTextureParameterfvEXT(0, eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, NULL); break; case TEXPARAMETERI: - Serialise_glTexParameteri(eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, 0); + Serialise_glTextureParameteriEXT(0, eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, 0); break; case TEXPARAMETERIV: - Serialise_glTexParameteriv(eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, NULL); + Serialise_glTextureParameterivEXT(0, eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, NULL); break; case GENERATE_MIPMAP: - Serialise_glGenerateMipmap(eGL_UNKNOWN_ENUM); + Serialise_glGenerateTextureMipmapEXT(0, eGL_UNKNOWN_ENUM); break; case TEXTURE_VIEW: Serialise_glTextureView(0, eGL_UNKNOWN_ENUM, 0, eGL_UNKNOWN_ENUM, 0, 0, 0, 0); @@ -1216,13 +1216,13 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) Serialise_glGenFramebuffers(0, NULL); break; case FRAMEBUFFER_TEX: - Serialise_glFramebufferTexture(eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, 0, 0); + Serialise_glNamedFramebufferTextureEXT(0, eGL_UNKNOWN_ENUM, 0, 0); break; case FRAMEBUFFER_TEX2D: - Serialise_glFramebufferTexture2D(eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, 0, 0); + Serialise_glNamedFramebufferTexture2DEXT(0, eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, 0, 0); break; case FRAMEBUFFER_TEXLAYER: - Serialise_glFramebufferTextureLayer(eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, 0, 0, 0); + Serialise_glNamedFramebufferTextureLayerEXT(0, eGL_UNKNOWN_ENUM, 0, 0, 0); break; case READ_BUFFER: Serialise_glReadBuffer(eGL_UNKNOWN_ENUM); @@ -1234,7 +1234,7 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) Serialise_glDrawBuffer(eGL_UNKNOWN_ENUM); break; case DRAW_BUFFERS: - Serialise_glDrawBuffers(0, NULL); + Serialise_glFramebufferDrawBuffersEXT(0, 0, NULL); break; case BLIT_FRAMEBUFFER: Serialise_glBlitFramebuffer(0, 0, 0, 0, 0, 0, 0, 0, 0, eGL_UNKNOWN_ENUM); @@ -1278,10 +1278,10 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) Serialise_glBindBufferRange(eGL_UNKNOWN_ENUM, 0, 0, 0, 0); break; case BUFFERDATA: - Serialise_glBufferData(eGL_UNKNOWN_ENUM, 0, NULL, eGL_UNKNOWN_ENUM); + Serialise_glNamedBufferDataEXT(eGL_UNKNOWN_ENUM, 0, NULL, eGL_UNKNOWN_ENUM); break; case UNMAP: - Serialise_glUnmapBuffer(eGL_UNKNOWN_ENUM); + Serialise_glUnmapNamedBufferEXT(eGL_UNKNOWN_ENUM); break; case GEN_VERTEXARRAY: Serialise_glGenVertexArrays(0, NULL); diff --git a/renderdoc/driver/gl/gl_driver.h b/renderdoc/driver/gl/gl_driver.h index 5d3a170a6..0b47dbc42 100644 --- a/renderdoc/driver/gl/gl_driver.h +++ b/renderdoc/driver/gl/gl_driver.h @@ -509,4 +509,41 @@ class WrappedOpenGL IMPLEMENT_FUNCTION_SERIALISED(void, glDeleteBuffers(GLsizei n, const GLuint *buffers)); IMPLEMENT_FUNCTION_SERIALISED(void, glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data)); IMPLEMENT_FUNCTION_SERIALISED(void, glDeleteVertexArrays(GLsizei n, const GLuint *arrays)); + + // EXT_direct_state_access + IMPLEMENT_FUNCTION_SERIALISED(GLenum, glCheckNamedFramebufferStatusEXT(GLuint framebuffer, GLenum target)); + IMPLEMENT_FUNCTION_SERIALISED(void, glCompressedTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits)); + IMPLEMENT_FUNCTION_SERIALISED(void, glCompressedTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits)); + IMPLEMENT_FUNCTION_SERIALISED(void, glCompressedTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits)); + IMPLEMENT_FUNCTION_SERIALISED(void, glCompressedTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits)); + IMPLEMENT_FUNCTION_SERIALISED(void, glCompressedTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits)); + IMPLEMENT_FUNCTION_SERIALISED(void, glCompressedTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *bits)); + IMPLEMENT_FUNCTION_SERIALISED(void, glFramebufferDrawBuffersEXT(GLuint framebuffer, GLsizei n, const GLenum *bufs)); + IMPLEMENT_FUNCTION_SERIALISED(void, glGenerateTextureMipmapEXT(GLuint texture, GLenum target)); + IMPLEMENT_FUNCTION_SERIALISED(void, glGetCompressedTextureImageEXT(GLuint texture, GLenum target, GLint lod, void *img)); + IMPLEMENT_FUNCTION_SERIALISED(void, glGetNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, void *data)); + IMPLEMENT_FUNCTION_SERIALISED(void, glGetNamedBufferParameterivEXT(GLuint buffer, GLenum pname, GLint *params)); + IMPLEMENT_FUNCTION_SERIALISED(void, glGetNamedFramebufferAttachmentParameterivEXT(GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params)); + IMPLEMENT_FUNCTION_SERIALISED(void, glGetTextureImageEXT(GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void *pixels)); + IMPLEMENT_FUNCTION_SERIALISED(void, glGetTextureLevelParameterivEXT(GLuint texture, GLenum target, GLint level, GLenum pname, GLint *params)); + 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, 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, 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)); + IMPLEMENT_FUNCTION_SERIALISED(void, glTextureParameterfEXT(GLuint texture, GLenum target, GLenum pname, GLfloat param)); + IMPLEMENT_FUNCTION_SERIALISED(void, glTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, const GLfloat *params)); + IMPLEMENT_FUNCTION_SERIALISED(void, glTextureParameteriEXT(GLuint texture, GLenum target, GLenum pname, GLint param)); + IMPLEMENT_FUNCTION_SERIALISED(void, glTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, const GLint *params)); + IMPLEMENT_FUNCTION_SERIALISED(void, glTextureStorage1DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)); + IMPLEMENT_FUNCTION_SERIALISED(void, glTextureStorage2DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)); + IMPLEMENT_FUNCTION_SERIALISED(void, glTextureStorage3DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)); + IMPLEMENT_FUNCTION_SERIALISED(void, glTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)); + IMPLEMENT_FUNCTION_SERIALISED(void, glTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)); + IMPLEMENT_FUNCTION_SERIALISED(void, glTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)); + IMPLEMENT_FUNCTION_SERIALISED(GLboolean, glUnmapNamedBufferEXT(GLuint buffer)); }; diff --git a/renderdoc/driver/gl/gl_hookset.h b/renderdoc/driver/gl/gl_hookset.h index 97c07ec22..1481ece7a 100644 --- a/renderdoc/driver/gl/gl_hookset.h +++ b/renderdoc/driver/gl/gl_hookset.h @@ -257,6 +257,41 @@ struct GLHookSet PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glDrawElementsInstancedBaseVertex; PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC glDrawElementsInstancedBaseVertexBaseInstance; PFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer; + PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC glCheckNamedFramebufferStatusEXT; + PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC glCompressedTextureImage1DEXT; + PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC glCompressedTextureImage2DEXT; + PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC glCompressedTextureImage3DEXT; + PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC glCompressedTextureSubImage1DEXT; + PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC glCompressedTextureSubImage2DEXT; + PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC glCompressedTextureSubImage3DEXT; + PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC glFramebufferDrawBuffersEXT; + PFNGLGENERATETEXTUREMIPMAPEXTPROC glGenerateTextureMipmapEXT; + PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC glGetCompressedTextureImageEXT; + PFNGLGETNAMEDBUFFERSUBDATAEXTPROC glGetNamedBufferSubDataEXT; + PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC glGetNamedBufferParameterivEXT; + PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC glGetNamedFramebufferAttachmentParameterivEXT; + PFNGLGETTEXTUREIMAGEEXTPROC glGetTextureImageEXT; + PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC glGetTextureLevelParameterivEXT; + PFNGLMAPNAMEDBUFFEREXTPROC glMapNamedBufferEXT; + PFNGLMAPNAMEDBUFFERRANGEEXTPROC glMapNamedBufferRangeEXT; + PFNGLNAMEDBUFFERDATAEXTPROC glNamedBufferDataEXT; + PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC glNamedFramebufferTextureEXT; + PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC glNamedFramebufferTexture2DEXT; + PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC glNamedFramebufferTextureLayerEXT; + PFNGLTEXTUREIMAGE1DEXTPROC glTextureImage1DEXT; + PFNGLTEXTUREIMAGE2DEXTPROC glTextureImage2DEXT; + PFNGLTEXTUREIMAGE3DEXTPROC glTextureImage3DEXT; + PFNGLTEXTUREPARAMETERFEXTPROC glTextureParameterfEXT; + PFNGLTEXTUREPARAMETERFVEXTPROC glTextureParameterfvEXT; + PFNGLTEXTUREPARAMETERIEXTPROC glTextureParameteriEXT; + PFNGLTEXTUREPARAMETERIVEXTPROC glTextureParameterivEXT; + PFNGLTEXTURESTORAGE1DEXTPROC glTextureStorage1DEXT; + PFNGLTEXTURESTORAGE2DEXTPROC glTextureStorage2DEXT; + PFNGLTEXTURESTORAGE3DEXTPROC glTextureStorage3DEXT; + PFNGLTEXTURESUBIMAGE1DEXTPROC glTextureSubImage1DEXT; + PFNGLTEXTURESUBIMAGE2DEXTPROC glTextureSubImage2DEXT; + PFNGLTEXTURESUBIMAGE3DEXTPROC glTextureSubImage3DEXT; + PFNGLUNMAPNAMEDBUFFEREXTPROC glUnmapNamedBufferEXT; // -- // ++ wgl diff --git a/renderdoc/driver/gl/gl_hookset_defs.h b/renderdoc/driver/gl/gl_hookset_defs.h index 9b184e661..49efd5028 100644 --- a/renderdoc/driver/gl/gl_hookset_defs.h +++ b/renderdoc/driver/gl/gl_hookset_defs.h @@ -271,6 +271,41 @@ HookExtension(PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC, glDrawElementsInstancedBaseVertex); \ HookExtension(PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC, glDrawElementsInstancedBaseVertexBaseInstance); \ HookExtension(PFNGLBLITFRAMEBUFFERPROC, glBlitFramebuffer); \ + HookExtension(PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC, glCheckNamedFramebufferStatusEXT); \ + HookExtension(PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC, glCompressedTextureImage1DEXT); \ + HookExtension(PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC, glCompressedTextureImage2DEXT); \ + HookExtension(PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC, glCompressedTextureImage3DEXT); \ + HookExtension(PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC, glCompressedTextureSubImage1DEXT); \ + HookExtension(PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC, glCompressedTextureSubImage2DEXT); \ + HookExtension(PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC, glCompressedTextureSubImage3DEXT); \ + HookExtension(PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC, glFramebufferDrawBuffersEXT); \ + HookExtension(PFNGLGENERATETEXTUREMIPMAPEXTPROC, glGenerateTextureMipmapEXT); \ + HookExtension(PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC, glGetCompressedTextureImageEXT); \ + HookExtension(PFNGLGETNAMEDBUFFERSUBDATAEXTPROC, glGetNamedBufferSubDataEXT); \ + HookExtension(PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC, glGetNamedBufferParameterivEXT); \ + HookExtension(PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC, glGetNamedFramebufferAttachmentParameterivEXT); \ + HookExtension(PFNGLGETTEXTUREIMAGEEXTPROC, glGetTextureImageEXT); \ + HookExtension(PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC, glGetTextureLevelParameterivEXT); \ + HookExtension(PFNGLMAPNAMEDBUFFEREXTPROC, glMapNamedBufferEXT); \ + HookExtension(PFNGLMAPNAMEDBUFFERRANGEEXTPROC, glMapNamedBufferRangeEXT); \ + HookExtension(PFNGLNAMEDBUFFERDATAEXTPROC, glNamedBufferDataEXT); \ + HookExtension(PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC, glNamedFramebufferTextureEXT); \ + HookExtension(PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC, glNamedFramebufferTexture2DEXT); \ + HookExtension(PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC, glNamedFramebufferTextureLayerEXT); \ + HookExtension(PFNGLTEXTUREIMAGE1DEXTPROC, glTextureImage1DEXT); \ + HookExtension(PFNGLTEXTUREIMAGE2DEXTPROC, glTextureImage2DEXT); \ + HookExtension(PFNGLTEXTUREIMAGE3DEXTPROC, glTextureImage3DEXT); \ + HookExtension(PFNGLTEXTUREPARAMETERFEXTPROC, glTextureParameterfEXT); \ + HookExtension(PFNGLTEXTUREPARAMETERFVEXTPROC, glTextureParameterfvEXT); \ + HookExtension(PFNGLTEXTUREPARAMETERIEXTPROC, glTextureParameteriEXT); \ + HookExtension(PFNGLTEXTUREPARAMETERIVEXTPROC, glTextureParameterivEXT); \ + HookExtension(PFNGLTEXTURESTORAGE1DEXTPROC, glTextureStorage1DEXT); \ + HookExtension(PFNGLTEXTURESTORAGE2DEXTPROC, glTextureStorage2DEXT); \ + HookExtension(PFNGLTEXTURESTORAGE3DEXTPROC, glTextureStorage3DEXT); \ + HookExtension(PFNGLTEXTURESUBIMAGE1DEXTPROC, glTextureSubImage1DEXT); \ + HookExtension(PFNGLTEXTURESUBIMAGE2DEXTPROC, glTextureSubImage2DEXT); \ + HookExtension(PFNGLTEXTURESUBIMAGE3DEXTPROC, glTextureSubImage3DEXT); \ + HookExtension(PFNGLUNMAPNAMEDBUFFEREXTPROC, glUnmapNamedBufferEXT); \ HookExtension(PFNGLBINDTEXTUREPROC, glBindTexture); \ HookExtension(PFNGLBLENDFUNCPROC, glBlendFunc); \ HookExtension(PFNGLCLEARPROC, glClear); \ @@ -567,6 +602,41 @@ HookWrapper6(void, glDrawElementsInstancedBaseVertex, GLenum, mode, GLsizei, count, GLenum, type, const void *, indices, GLsizei, instancecount, GLint, basevertex); \ HookWrapper7(void, glDrawElementsInstancedBaseVertexBaseInstance, GLenum, mode, GLsizei, count, GLenum, type, const void *, indices, GLsizei, instancecount, GLint, basevertex, GLuint, baseinstance); \ HookWrapper10(void, glBlitFramebuffer, GLint, srcX0, GLint, srcY0, GLint, srcX1, GLint, srcY1, GLint, dstX0, GLint, dstY0, GLint, dstX1, GLint, dstY1, GLbitfield, mask, GLenum, filter); \ + HookWrapper2(GLenum, glCheckNamedFramebufferStatusEXT, GLuint, framebuffer, GLenum, target); \ + HookWrapper8(void, glCompressedTextureImage1DEXT, GLuint, texture, GLenum, target, GLint, level, GLenum, internalformat, GLsizei, width, GLint, border, GLsizei, imageSize, const void *, bits); \ + HookWrapper9(void, glCompressedTextureImage2DEXT, GLuint, texture, GLenum, target, GLint, level, GLenum, internalformat, GLsizei, width, GLsizei, height, GLint, border, GLsizei, imageSize, const void *, bits); \ + HookWrapper10(void, glCompressedTextureImage3DEXT, GLuint, texture, GLenum, target, GLint, level, GLenum, internalformat, GLsizei, width, GLsizei, height, GLsizei, depth, GLint, border, GLsizei, imageSize, const void *, bits); \ + HookWrapper8(void, glCompressedTextureSubImage1DEXT, GLuint, texture, GLenum, target, GLint, level, GLint, xoffset, GLsizei, width, GLenum, format, GLsizei, imageSize, const void *, bits); \ + HookWrapper10(void, glCompressedTextureSubImage2DEXT, GLuint, texture, GLenum, target, GLint, level, GLint, xoffset, GLint, yoffset, GLsizei, width, GLsizei, height, GLenum, format, GLsizei, imageSize, const void *, bits); \ + HookWrapper12(void, glCompressedTextureSubImage3DEXT, GLuint, texture, GLenum, target, GLint, level, GLint, xoffset, GLint, yoffset, GLint, zoffset, GLsizei, width, GLsizei, height, GLsizei, depth, GLenum, format, GLsizei, imageSize, const void *, bits); \ + HookWrapper3(void, glFramebufferDrawBuffersEXT, GLuint, framebuffer, GLsizei, n, const GLenum *, bufs); \ + HookWrapper2(void, glGenerateTextureMipmapEXT, GLuint, texture, GLenum, target); \ + HookWrapper4(void, glGetCompressedTextureImageEXT, GLuint, texture, GLenum, target, GLint, lod, void *, img); \ + HookWrapper4(void, glGetNamedBufferSubDataEXT, GLuint, buffer, GLintptr, offset, GLsizeiptr, size, void *, data); \ + HookWrapper3(void, glGetNamedBufferParameterivEXT, GLuint, buffer, GLenum, pname, GLint *, params); \ + HookWrapper4(void, glGetNamedFramebufferAttachmentParameterivEXT, GLuint, framebuffer, GLenum, attachment, GLenum, pname, GLint *, params); \ + HookWrapper6(void, glGetTextureImageEXT, GLuint, texture, GLenum, target, GLint, level, GLenum, format, GLenum, type, void *, pixels); \ + HookWrapper5(void, glGetTextureLevelParameterivEXT, GLuint, texture, GLenum, target, GLint, level, GLenum, pname, GLint *, params); \ + 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, 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); \ + 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); \ + HookWrapper4(void, glTextureParameterfEXT, GLuint, texture, GLenum, target, GLenum, pname, GLfloat, param); \ + HookWrapper4(void, glTextureParameterfvEXT, GLuint, texture, GLenum, target, GLenum, pname, const GLfloat *, params); \ + HookWrapper4(void, glTextureParameteriEXT, GLuint, texture, GLenum, target, GLenum, pname, GLint, param); \ + HookWrapper4(void, glTextureParameterivEXT, GLuint, texture, GLenum, target, GLenum, pname, const GLint *, params); \ + HookWrapper5(void, glTextureStorage1DEXT, GLuint, texture, GLenum, target, GLsizei, levels, GLenum, internalformat, GLsizei, width); \ + HookWrapper6(void, glTextureStorage2DEXT, GLuint, texture, GLenum, target, GLsizei, levels, GLenum, internalformat, GLsizei, width, GLsizei, height); \ + HookWrapper7(void, glTextureStorage3DEXT, GLuint, texture, GLenum, target, GLsizei, levels, GLenum, internalformat, GLsizei, width, GLsizei, height, GLsizei, depth); \ + HookWrapper8(void, glTextureSubImage1DEXT, GLuint, texture, GLenum, target, GLint, level, GLint, xoffset, GLsizei, width, GLenum, format, GLenum, type, const void *, pixels); \ + HookWrapper10(void, glTextureSubImage2DEXT, GLuint, texture, GLenum, target, GLint, level, GLint, xoffset, GLint, yoffset, GLsizei, width, GLsizei, height, GLenum, format, GLenum, type, const void *, pixels); \ + HookWrapper12(void, glTextureSubImage3DEXT, GLuint, texture, GLenum, target, GLint, level, GLint, xoffset, GLint, yoffset, GLint, zoffset, GLsizei, width, GLsizei, height, GLsizei, depth, GLenum, format, GLenum, type, const void *, pixels); \ + HookWrapper1(GLboolean, glUnmapNamedBufferEXT, GLuint, buffer); \ diff --git a/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp index 34f5c1ca8..d302bdc67 100644 --- a/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp @@ -174,9 +174,9 @@ void WrappedOpenGL::glBindBuffer(GLenum target, GLuint buffer) } } -bool WrappedOpenGL::Serialise_glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage) +bool WrappedOpenGL::Serialise_glNamedBufferDataEXT(GLuint buffer, GLsizeiptr size, const void *data, GLenum usage) { - SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(BufferRes(buffer))); SERIALISE_ELEMENT(uint64_t, Bytesize, (uint64_t)size); byte *dummy = NULL; @@ -192,13 +192,11 @@ bool WrappedOpenGL::Serialise_glBufferData(GLenum target, GLsizeiptr size, const uint64_t offs = m_pSerialiser->GetOffset(); SERIALISE_ELEMENT(GLenum, Usage, usage); - SERIALISE_ELEMENT(ResourceId, id, m_BufferRecord[BufferIdx(target)]->GetResourceID()); - if(m_State == READING) + if(m_State < WRITING) { GLResource res = GetResourceManager()->GetLiveResource(id); - m_Real.glBindBuffer(Target, res.name); - m_Real.glBufferData(Target, (GLsizeiptr)Bytesize, bytes, Usage); + m_Real.glNamedBufferDataEXT(res.name, (GLsizeiptr)Bytesize, bytes, Usage); m_Buffers[GetResourceManager()->GetLiveID(id)].size = Bytesize; @@ -206,7 +204,7 @@ bool WrappedOpenGL::Serialise_glBufferData(GLenum target, GLsizeiptr size, const } else if(m_State >= WRITING) { - m_BufferRecord[BufferIdx(target)]->SetDataOffset(offs - Bytesize); + GetResourceManager()->GetResourceRecord(id)->SetDataOffset(offs - Bytesize); } if(dummy) @@ -215,6 +213,33 @@ bool WrappedOpenGL::Serialise_glBufferData(GLenum target, GLsizeiptr size, const return true; } +void WrappedOpenGL::glNamedBufferDataEXT(GLuint buffer, GLsizeiptr size, const void *data, GLenum usage) +{ + m_Real.glNamedBufferDataEXT(buffer, size, data, usage); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(BufferRes(buffer)); + RDCASSERT(record); + + SCOPED_SERIALISE_CONTEXT(BUFFERDATA); + Serialise_glNamedBufferDataEXT(buffer, size, data, usage); + + 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::glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage) { m_Real.glBufferData(target, size, data, usage); @@ -223,16 +248,25 @@ void WrappedOpenGL::glBufferData(GLenum target, GLsizeiptr size, const void *dat if(m_State >= WRITING) { - RDCASSERT(m_BufferRecord[idx]); + GLResourceRecord *record = m_BufferRecord[BufferIdx(target)]; + RDCASSERT(record); SCOPED_SERIALISE_CONTEXT(BUFFERDATA); - Serialise_glBufferData(target, size, data, usage); + Serialise_glNamedBufferDataEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, + size, data, usage); Chunk *chunk = scope.Get(); - m_BufferRecord[idx]->AddChunk(chunk); - m_BufferRecord[idx]->SetDataPtr(chunk->GetData()); - m_BufferRecord[idx]->Length = (int32_t)size; + if(m_State == WRITING_CAPFRAME) + { + m_ContextRecord->AddChunk(chunk); + } + else + { + record->AddChunk(chunk); + record->SetDataPtr(chunk->GetData()); + record->Length = (int32_t)size; + } } } @@ -294,28 +328,30 @@ void WrappedOpenGL::glBindBufferRange(GLenum target, GLuint index, GLuint buffer m_Real.glBindBufferRange(target, index, buffer, offset, size); } -void *WrappedOpenGL::glMapBuffer(GLenum target, GLenum access) +void *WrappedOpenGL::glMapNamedBufferEXT(GLuint buffer, GLenum access) { if(m_State >= WRITING) { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(BufferRes(buffer)); + GLint length; - m_Real.glGetBufferParameteriv(target, eGL_BUFFER_SIZE, &length); + m_Real.glGetNamedBufferParameterivEXT(buffer, eGL_BUFFER_SIZE, &length); // TODO align return pointer to GL_MIN_MAP_BUFFER_ALIGNMENT (min 64) - m_BufferRecord[BufferIdx(target)]->Map.offset = 0; - m_BufferRecord[BufferIdx(target)]->Map.length = length; - if(access == eGL_READ_ONLY) m_BufferRecord[BufferIdx(target)]->Map.access = GL_MAP_READ_BIT; - else if(access == eGL_WRITE_ONLY) m_BufferRecord[BufferIdx(target)]->Map.access = GL_MAP_WRITE_BIT; - else if(access == eGL_READ_WRITE) m_BufferRecord[BufferIdx(target)]->Map.access = GL_MAP_READ_BIT|GL_MAP_WRITE_BIT; + record->Map.offset = 0; + record->Map.length = length; + if(access == eGL_READ_ONLY) record->Map.access = GL_MAP_READ_BIT; + else if(access == eGL_WRITE_ONLY) record->Map.access = GL_MAP_WRITE_BIT; + else if(access == eGL_READ_WRITE) record->Map.access = GL_MAP_READ_BIT|GL_MAP_WRITE_BIT; if(access == eGL_READ_ONLY) { - m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Mapped_Read_Real; - return m_Real.glMapBuffer(target, access); + record->Map.status = GLResourceRecord::Mapped_Read_Real; + return m_Real.glMapNamedBufferEXT(buffer, access); } - byte *ptr = m_BufferRecord[BufferIdx(target)]->GetDataPtr(); + byte *ptr = record->GetDataPtr(); if(ptr == NULL) { @@ -323,25 +359,43 @@ void *WrappedOpenGL::glMapBuffer(GLenum target, GLenum access) RDCWARN("Mapping buffer that hasn't been allocated"); - m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Mapped_Write_Alloc; + record->Map.status = GLResourceRecord::Mapped_Write_Alloc; } else { - m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Mapped_Write; + record->Map.status = GLResourceRecord::Mapped_Write; } - m_Real.glGetBufferSubData(target, 0, length, ptr); + m_Real.glGetNamedBufferSubDataEXT(buffer, 0, length, ptr); return ptr; } + return m_Real.glMapNamedBufferEXT(buffer, access); +} + +void *WrappedOpenGL::glMapBuffer(GLenum target, GLenum access) +{ + if(m_State >= WRITING) + { + GLResourceRecord *record = m_BufferRecord[BufferIdx(target)]; + RDCASSERT(m_BufferRecord[BufferIdx(target)]); + + if(record) + return glMapNamedBufferEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, access); + + RDCERR("glMapBuffer: Couldn't get resource record for target %x - no buffer bound?", target); + } + return m_Real.glMapBuffer(target, access); } -void *WrappedOpenGL::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) +void *WrappedOpenGL::glMapNamedBufferRangeEXT(GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access) { if(m_State >= WRITING) { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(BufferRes(buffer)); + // TODO align return pointer to GL_MIN_MAP_BUFFER_ALIGNMENT (min 64) if((access & (GL_MAP_INVALIDATE_BUFFER_BIT|GL_MAP_INVALIDATE_RANGE_BIT|GL_MAP_READ_BIT)) == 0) @@ -350,41 +404,41 @@ void *WrappedOpenGL::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr if((access & (GL_MAP_COHERENT_BIT|GL_MAP_PERSISTENT_BIT)) != 0) RDCUNIMPLEMENTED("haven't implemented coherent/persistant glMap calls"); - m_BufferRecord[BufferIdx(target)]->Map.offset = offset; - m_BufferRecord[BufferIdx(target)]->Map.length = length; - m_BufferRecord[BufferIdx(target)]->Map.access = access; + record->Map.offset = offset; + record->Map.length = length; + record->Map.access = access; if((access & GL_MAP_READ_BIT) != 0) { - byte *ptr = m_BufferRecord[BufferIdx(target)]->GetDataPtr(); + byte *ptr = record->GetDataPtr(); if(ptr == NULL) { RDCWARN("Mapping buffer that hasn't been allocated"); - m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Mapped_Read_Real; - return m_Real.glMapBufferRange(target, offset, length, access); + record->Map.status = GLResourceRecord::Mapped_Read_Real; + return m_Real.glMapNamedBufferRangeEXT(buffer, offset, length, access); } ptr += offset; - m_Real.glGetBufferSubData(target, offset, length, ptr); + m_Real.glGetNamedBufferSubDataEXT(buffer, offset, length, ptr); - m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Mapped_Read; + record->Map.status = GLResourceRecord::Mapped_Read; return ptr; } - byte *ptr = m_BufferRecord[BufferIdx(target)]->GetDataPtr(); + byte *ptr = record->GetDataPtr(); if(ptr == NULL) { RDCWARN("Mapping buffer that hasn't been allocated"); - ptr = (byte *)m_Real.glMapBufferRange(target, offset, length, access); + ptr = (byte *)m_Real.glMapNamedBufferRangeEXT(buffer, offset, length, access); - m_BufferRecord[BufferIdx(target)]->Map.ptr = ptr; - m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Mapped_Write_Real; + record->Map.ptr = ptr; + record->Map.status = GLResourceRecord::Mapped_Write_Real; } else { @@ -392,52 +446,53 @@ void *WrappedOpenGL::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr { ptr = new byte[length]; - m_BufferRecord[BufferIdx(target)]->Map.ptr = ptr; - m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Mapped_Write_Alloc; + record->Map.ptr = ptr; + record->Map.status = GLResourceRecord::Mapped_Write_Alloc; } else { ptr += offset; - m_BufferRecord[BufferIdx(target)]->Map.ptr = ptr; - m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Mapped_Write; + record->Map.ptr = ptr; + record->Map.status = GLResourceRecord::Mapped_Write; } } return ptr; } + return m_Real.glMapNamedBufferRangeEXT(buffer, offset, length, access); +} + +void *WrappedOpenGL::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) +{ + if(m_State >= WRITING) + { + GLResourceRecord *record = m_BufferRecord[BufferIdx(target)]; + RDCASSERT(m_BufferRecord[BufferIdx(target)]); + + if(record) + return glMapNamedBufferRangeEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, offset, length, access); + + RDCERR("glMapBufferRange: Couldn't get resource record for target %x - no buffer bound?", target); + } + return m_Real.glMapBufferRange(target, offset, length, access); } -bool WrappedOpenGL::Serialise_glUnmapBuffer(GLenum target) +bool WrappedOpenGL::Serialise_glUnmapNamedBufferEXT(GLuint buffer) { GLResourceRecord *record = NULL; if(m_State >= WRITING) - record = m_BufferRecord[BufferIdx(target)]; + record = GetResourceManager()->GetResourceRecord(BufferRes(buffer)); - SERIALISE_ELEMENT(GLenum, Target, target); SERIALISE_ELEMENT(ResourceId, bufID, record->GetResourceID()); SERIALISE_ELEMENT(uint64_t, offs, record->Map.offset); SERIALISE_ELEMENT(uint64_t, len, record->Map.length); uint64_t bufBindStart = 0; - if(m_State >= WRITING) - { - if(Target == eGL_ATOMIC_COUNTER_BUFFER) - m_Real.glGetInteger64i_v(eGL_ATOMIC_COUNTER_BUFFER_START, 0, (GLint64 *)&bufBindStart); - if(Target == eGL_SHADER_STORAGE_BUFFER) - m_Real.glGetInteger64i_v(eGL_SHADER_STORAGE_BUFFER_START, 0, (GLint64 *)&bufBindStart); - if(Target == eGL_TRANSFORM_FEEDBACK_BUFFER) - m_Real.glGetInteger64i_v(eGL_TRANSFORM_FEEDBACK_BUFFER_START, 0, (GLint64 *)&bufBindStart); - if(Target == eGL_UNIFORM_BUFFER) - m_Real.glGetInteger64i_v(eGL_UNIFORM_BUFFER_START, 0, (GLint64 *)&bufBindStart); - } - - SERIALISE_ELEMENT(uint64_t, bufOffs, bufBindStart); - SERIALISE_ELEMENT_BUF(byte *, data, record->Map.ptr, (size_t)len); if(m_State >= WRITING && record && record->GetDataPtr() == NULL) @@ -449,30 +504,11 @@ bool WrappedOpenGL::Serialise_glUnmapBuffer(GLenum target) ) ) { - GLuint oldBuf = 0; - GLuint64 oldBufBase = 0; - GLuint64 oldBufSize = 0; + GLResource res = GetResourceManager()->GetLiveResource(bufID); - if(m_State == READING) - { - GLResource res = GetResourceManager()->GetLiveResource(bufID); - m_Real.glGetIntegeri_v(eGL_UNIFORM_BUFFER_BINDING, 0, (GLint *)&oldBuf); - m_Real.glGetInteger64i_v(eGL_UNIFORM_BUFFER_START, 0, (GLint64 *)&oldBufBase); - m_Real.glGetInteger64i_v(eGL_UNIFORM_BUFFER_SIZE, 0, (GLint64 *)&oldBufSize); - m_Real.glBindBufferRange(eGL_UNIFORM_BUFFER, 0, res.name, (GLintptr)bufOffs, (GLsizeiptr)len); - } - - void *ptr = m_Real.glMapBufferRange(Target, (GLintptr)offs, (GLsizeiptr)len, GL_MAP_WRITE_BIT); + void *ptr = m_Real.glMapNamedBufferRangeEXT(res.name, (GLintptr)offs, (GLsizeiptr)len, GL_MAP_WRITE_BIT); memcpy(ptr, data, (size_t)len); - m_Real.glUnmapBuffer(Target); - - if(m_State == READING) - { - if(oldBufBase == 0 && oldBufSize == 0) - m_Real.glBindBufferBase(eGL_UNIFORM_BUFFER, 0, oldBuf); - else - m_Real.glBindBufferRange(eGL_UNIFORM_BUFFER, 0, oldBuf, (GLintptr)oldBufBase, (GLsizeiptr)oldBufSize); - } + m_Real.glUnmapNamedBufferEXT(res.name); } if(m_State < WRITING) @@ -481,13 +517,12 @@ bool WrappedOpenGL::Serialise_glUnmapBuffer(GLenum target) return true; } -GLboolean WrappedOpenGL::glUnmapBuffer(GLenum target) +GLboolean WrappedOpenGL::glUnmapNamedBufferEXT(GLuint buffer) { if(m_State >= WRITING) { - RDCASSERT(m_BufferRecord[BufferIdx(target)]); - - auto status = m_BufferRecord[BufferIdx(target)]->Map.status; + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(BufferRes(buffer)); + auto status = record->Map.status; GLboolean ret = GL_TRUE; @@ -501,7 +536,7 @@ GLboolean WrappedOpenGL::glUnmapBuffer(GLenum target) break; case GLResourceRecord::Mapped_Read_Real: // need to do real unmap - ret = m_Real.glUnmapBuffer(target); + ret = m_Real.glUnmapNamedBufferEXT(buffer); break; case GLResourceRecord::Mapped_Write: { @@ -509,19 +544,19 @@ GLboolean WrappedOpenGL::glUnmapBuffer(GLenum target) RDCWARN("Failed to cap frame - uncapped Map/Unmap"); SCOPED_SERIALISE_CONTEXT(UNMAP); - Serialise_glUnmapBuffer(target); + Serialise_glUnmapNamedBufferEXT(buffer); if(m_State == WRITING_CAPFRAME) m_ContextRecord->AddChunk(scope.Get()); else - m_BufferRecord[BufferIdx(target)]->AddChunk(scope.Get()); + record->AddChunk(scope.Get()); break; } case GLResourceRecord::Mapped_Write_Alloc: { SCOPED_SERIALISE_CONTEXT(UNMAP); - Serialise_glUnmapBuffer(target); + Serialise_glUnmapNamedBufferEXT(buffer); if(m_State == WRITING_CAPFRAME) { @@ -530,11 +565,11 @@ GLboolean WrappedOpenGL::glUnmapBuffer(GLenum target) else { Chunk *chunk = scope.Get(); - m_BufferRecord[BufferIdx(target)]->AddChunk(chunk); - m_BufferRecord[BufferIdx(target)]->SetDataPtr(chunk->GetData()); + record->AddChunk(chunk); + record->SetDataPtr(chunk->GetData()); } - delete[] m_BufferRecord[BufferIdx(target)]->Map.ptr; + delete[] record->Map.ptr; break; } @@ -542,17 +577,33 @@ GLboolean WrappedOpenGL::glUnmapBuffer(GLenum target) { // Throwing away map contents as we don't have datastore allocated // Could init chunk here using known data (although maybe it's only partial). - ret = m_Real.glUnmapBuffer(target); + ret = m_Real.glUnmapNamedBufferEXT(buffer); - GetResourceManager()->MarkDirtyResource(m_BufferRecord[BufferIdx(target)]->GetResourceID()); + GetResourceManager()->MarkDirtyResource(record->GetResourceID()); break; } } - m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Unmapped; + record->Map.status = GLResourceRecord::Unmapped; return ret; } + + return m_Real.glUnmapNamedBufferEXT(buffer); +} + +GLboolean WrappedOpenGL::glUnmapBuffer(GLenum target) +{ + if(m_State >= WRITING) + { + GLResourceRecord *record = m_BufferRecord[BufferIdx(target)]; + RDCASSERT(m_BufferRecord[BufferIdx(target)]); + + if(record) + return glUnmapNamedBufferEXT( GetResourceManager()->GetCurrentResource(record->GetResourceID()).name ); + + RDCERR("glUnmapBuffer: Couldn't get resource record for target %x - no buffer bound?", target); + } return m_Real.glUnmapBuffer(target); } diff --git a/renderdoc/driver/gl/wrappers/gl_framebuffer_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_framebuffer_funcs.cpp index daa5932b3..d4487c68e 100644 --- a/renderdoc/driver/gl/wrappers/gl_framebuffer_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_framebuffer_funcs.cpp @@ -76,237 +76,213 @@ void WrappedOpenGL::glGenFramebuffers(GLsizei n, GLuint *framebuffers) } } -bool WrappedOpenGL::Serialise_glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level) +bool WrappedOpenGL::Serialise_glNamedFramebufferTextureEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level) { - SERIALISE_ELEMENT(GLenum, Target, target); SERIALISE_ELEMENT(GLenum, Attach, attachment); SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(texture))); SERIALISE_ELEMENT(int32_t, Level, level); - - ResourceId curFrameBuffer; - - if(m_State == WRITING_IDLE) - { - if(target == eGL_DRAW_FRAMEBUFFER || target == eGL_FRAMEBUFFER) - { - if(m_DrawFramebufferRecord) - curFrameBuffer = m_DrawFramebufferRecord->GetResourceID(); - } - else - { - if(m_ReadFramebufferRecord) - curFrameBuffer = m_ReadFramebufferRecord->GetResourceID(); - } - } - - SERIALISE_ELEMENT(ResourceId, fbid, curFrameBuffer); + SERIALISE_ELEMENT(ResourceId, fbid, (framebuffer == 0 ? ResourceId() : GetResourceManager()->GetID(FramebufferRes(framebuffer)))); if(m_State < WRITING) { - if(m_State == READING) - { - if(fbid != ResourceId()) - { - GLResource res = GetResourceManager()->GetLiveResource(fbid); - m_Real.glBindFramebuffer(Target, res.name); - } - else - { - m_Real.glBindFramebuffer(Target, 0); - } - } - GLResource res = GetResourceManager()->GetLiveResource(id); - glFramebufferTexture(Target, Attach, res.name, Level); + if(fbid == ResourceId()) + { + glNamedFramebufferTextureEXT(0, Attach, res.name, Level); + } + else + { + GLResource fbres = GetResourceManager()->GetLiveResource(fbid); + glNamedFramebufferTextureEXT(fbres.name, Attach, res.name, Level); + } } return true; } +void WrappedOpenGL::glNamedFramebufferTextureEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level) +{ + m_Real.glNamedFramebufferTextureEXT(framebuffer, attachment, texture, level); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(FramebufferRes(framebuffer)); + + SCOPED_SERIALISE_CONTEXT(FRAMEBUFFER_TEX); + Serialise_glNamedFramebufferTextureEXT(framebuffer, attachment, texture, level); + + if(m_State == WRITING_IDLE) + record->AddChunk(scope.Get()); + else + m_ContextRecord->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level) { m_Real.glFramebufferTexture(target, attachment, texture, level); if(m_State >= WRITING) { - SCOPED_SERIALISE_CONTEXT(FRAMEBUFFER_TEX); - Serialise_glFramebufferTexture(target, attachment, texture, level); + GLResourceRecord *record = m_DeviceRecord; - if(m_State == WRITING_IDLE) + if(target == eGL_DRAW_FRAMEBUFFER || target == eGL_FRAMEBUFFER) { - if(target == eGL_DRAW_FRAMEBUFFER || target == eGL_FRAMEBUFFER) - { - if(m_DrawFramebufferRecord) - m_DrawFramebufferRecord->AddChunk(scope.Get()); - else - m_DeviceRecord->AddChunk(scope.Get()); - } - else - { - if(m_ReadFramebufferRecord) - m_ReadFramebufferRecord->AddChunk(scope.Get()); - else - m_DeviceRecord->AddChunk(scope.Get()); - } + if(m_DrawFramebufferRecord) record = m_DrawFramebufferRecord; } + else + { + if(m_ReadFramebufferRecord) record = m_ReadFramebufferRecord; + } + + SCOPED_SERIALISE_CONTEXT(FRAMEBUFFER_TEX); + Serialise_glNamedFramebufferTextureEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, + attachment, texture, level); + + if(m_State == WRITING_IDLE) + record->AddChunk(scope.Get()); else m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +bool WrappedOpenGL::Serialise_glNamedFramebufferTexture2DEXT(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { - SERIALISE_ELEMENT(GLenum, Target, target); SERIALISE_ELEMENT(GLenum, Attach, attachment); - SERIALISE_ELEMENT(GLenum, TexTarget, textarget); SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(texture))); + SERIALISE_ELEMENT(GLenum, TexTarget, textarget); SERIALISE_ELEMENT(int32_t, Level, level); - - ResourceId curFrameBuffer; - - if(m_State == WRITING_IDLE) - { - if(target == eGL_DRAW_FRAMEBUFFER || target == eGL_FRAMEBUFFER) - { - if(m_DrawFramebufferRecord) - curFrameBuffer = m_DrawFramebufferRecord->GetResourceID(); - } - else - { - if(m_ReadFramebufferRecord) - curFrameBuffer = m_ReadFramebufferRecord->GetResourceID(); - } - } - - SERIALISE_ELEMENT(ResourceId, fbid, curFrameBuffer); + SERIALISE_ELEMENT(ResourceId, fbid, (framebuffer == 0 ? ResourceId() : GetResourceManager()->GetID(FramebufferRes(framebuffer)))); if(m_State < WRITING) { - if(m_State == READING) - { - if(fbid != ResourceId()) - { - GLResource res = GetResourceManager()->GetLiveResource(fbid); - m_Real.glBindFramebuffer(Target, res.name); - } - else - { - m_Real.glBindFramebuffer(Target, 0); - } - } - GLResource res = GetResourceManager()->GetLiveResource(id); - glFramebufferTexture2D(Target, Attach, TexTarget, res.name, Level); + if(fbid == ResourceId()) + { + glNamedFramebufferTexture2DEXT(0, Attach, TexTarget, res.name, Level); + } + else + { + GLResource fbres = GetResourceManager()->GetLiveResource(fbid); + glNamedFramebufferTexture2DEXT(fbres.name, Attach, TexTarget, res.name, Level); + } } return true; } +void WrappedOpenGL::glNamedFramebufferTexture2DEXT(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + m_Real.glNamedFramebufferTexture2DEXT(framebuffer, attachment, textarget, texture, level); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(FramebufferRes(framebuffer)); + + SCOPED_SERIALISE_CONTEXT(FRAMEBUFFER_TEX2D); + Serialise_glNamedFramebufferTexture2DEXT(framebuffer, attachment, textarget, texture, level); + + if(m_State == WRITING_IDLE) + record->AddChunk(scope.Get()); + else + m_ContextRecord->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { m_Real.glFramebufferTexture2D(target, attachment, textarget, texture, level); if(m_State >= WRITING) { - SCOPED_SERIALISE_CONTEXT(FRAMEBUFFER_TEX2D); - Serialise_glFramebufferTexture2D(target, attachment, textarget, texture, level); + GLResourceRecord *record = m_DeviceRecord; - if(m_State == WRITING_IDLE) + if(target == eGL_DRAW_FRAMEBUFFER || target == eGL_FRAMEBUFFER) { - if(target == eGL_DRAW_FRAMEBUFFER || target == eGL_FRAMEBUFFER) - { - if(m_DrawFramebufferRecord) - m_DrawFramebufferRecord->AddChunk(scope.Get()); - else - m_DeviceRecord->AddChunk(scope.Get()); - } - else - { - if(m_ReadFramebufferRecord) - m_ReadFramebufferRecord->AddChunk(scope.Get()); - else - m_DeviceRecord->AddChunk(scope.Get()); - } + if(m_DrawFramebufferRecord) record = m_DrawFramebufferRecord; } + else + { + if(m_ReadFramebufferRecord) record = m_ReadFramebufferRecord; + } + + SCOPED_SERIALISE_CONTEXT(FRAMEBUFFER_TEX2D); + Serialise_glNamedFramebufferTexture2DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, + attachment, textarget, texture, level); + + if(m_State == WRITING_IDLE) + record->AddChunk(scope.Get()); else m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) +bool WrappedOpenGL::Serialise_glNamedFramebufferTextureLayerEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer) { - SERIALISE_ELEMENT(GLenum, Target, target); SERIALISE_ELEMENT(GLenum, Attach, attachment); SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(texture))); SERIALISE_ELEMENT(int32_t, Level, level); SERIALISE_ELEMENT(int32_t, Layer, layer); - - ResourceId curFrameBuffer; - - if(m_State == WRITING_IDLE) - { - if(target == eGL_DRAW_FRAMEBUFFER || target == eGL_FRAMEBUFFER) - { - if(m_DrawFramebufferRecord) - curFrameBuffer = m_DrawFramebufferRecord->GetResourceID(); - } - else - { - if(m_ReadFramebufferRecord) - curFrameBuffer = m_ReadFramebufferRecord->GetResourceID(); - } - } - - SERIALISE_ELEMENT(ResourceId, fbid, curFrameBuffer); + SERIALISE_ELEMENT(ResourceId, fbid, (framebuffer == 0 ? ResourceId() : GetResourceManager()->GetID(FramebufferRes(framebuffer)))); if(m_State < WRITING) { - if(m_State == READING) - { - if(fbid != ResourceId()) - { - GLResource res = GetResourceManager()->GetLiveResource(fbid); - m_Real.glBindFramebuffer(Target, res.name); - } - else - { - m_Real.glBindFramebuffer(Target, 0); - } - } - GLResource res = GetResourceManager()->GetLiveResource(id); - glFramebufferTextureLayer(Target, Attach, res.name, Level, Layer); + if(fbid == ResourceId()) + { + glNamedFramebufferTextureLayerEXT(0, Attach, res.name, Level, Layer); + } + else + { + GLResource fbres = GetResourceManager()->GetLiveResource(fbid); + glNamedFramebufferTextureLayerEXT(fbres.name, Attach, res.name, Level, Layer); + } } return true; } +void WrappedOpenGL::glNamedFramebufferTextureLayerEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer) +{ + m_Real.glNamedFramebufferTextureLayerEXT(framebuffer, attachment, texture, level, layer); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(FramebufferRes(framebuffer)); + + SCOPED_SERIALISE_CONTEXT(FRAMEBUFFER_TEXLAYER); + Serialise_glNamedFramebufferTextureLayerEXT(framebuffer, attachment, texture, level, layer); + + if(m_State == WRITING_IDLE) + record->AddChunk(scope.Get()); + else + m_ContextRecord->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) { m_Real.glFramebufferTextureLayer(target, attachment, texture, level, layer); if(m_State >= WRITING) { - SCOPED_SERIALISE_CONTEXT(FRAMEBUFFER_TEXLAYER); - Serialise_glFramebufferTextureLayer(target, attachment, texture, level, layer); + GLResourceRecord *record = m_DeviceRecord; - if(m_State == WRITING_IDLE) + if(target == eGL_DRAW_FRAMEBUFFER || target == eGL_FRAMEBUFFER) { - if(target == eGL_DRAW_FRAMEBUFFER || target == eGL_FRAMEBUFFER) - { - if(m_DrawFramebufferRecord) - m_DrawFramebufferRecord->AddChunk(scope.Get()); - else - m_DeviceRecord->AddChunk(scope.Get()); - } - else - { - if(m_ReadFramebufferRecord) - m_ReadFramebufferRecord->AddChunk(scope.Get()); - else - m_DeviceRecord->AddChunk(scope.Get()); - } + if(m_DrawFramebufferRecord) record = m_DrawFramebufferRecord; } + else + { + if(m_ReadFramebufferRecord) record = m_ReadFramebufferRecord; + } + + SCOPED_SERIALISE_CONTEXT(FRAMEBUFFER_TEXLAYER); + Serialise_glNamedFramebufferTextureLayerEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, + attachment, texture, level, layer); + + if(m_State == WRITING_IDLE) + record->AddChunk(scope.Get()); else m_ContextRecord->AddChunk(scope.Get()); } @@ -423,14 +399,15 @@ void WrappedOpenGL::glDrawBuffer(GLenum buf) m_Real.glDrawBuffer(buf); } -bool WrappedOpenGL::Serialise_glDrawBuffers(GLsizei n, const GLenum *bufs) +bool WrappedOpenGL::Serialise_glFramebufferDrawBuffersEXT(GLuint framebuffer, GLsizei n, const GLenum *bufs) { + SERIALISE_ELEMENT(ResourceId, Id, GetResourceManager()->GetID(FramebufferRes(framebuffer))); SERIALISE_ELEMENT(uint32_t, num, n); SERIALISE_ELEMENT_ARR(GLenum, buffers, bufs, num); if(m_State < WRITING) { - m_Real.glDrawBuffers(num, buffers); + m_Real.glFramebufferDrawBuffersEXT(GetResourceManager()->GetLiveResource(Id).name, num, buffers); } delete[] buffers; @@ -438,12 +415,36 @@ bool WrappedOpenGL::Serialise_glDrawBuffers(GLsizei n, const GLenum *bufs) return true; } +void WrappedOpenGL::glFramebufferDrawBuffersEXT(GLuint framebuffer, GLsizei n, const GLenum *bufs) +{ + m_Real.glFramebufferDrawBuffersEXT(framebuffer, n, bufs); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DRAW_BUFFERS); + Serialise_glFramebufferDrawBuffersEXT(framebuffer, n, bufs); + + m_ContextRecord->AddChunk(scope.Get()); + } + else if(m_State == WRITING_IDLE && framebuffer != 0) + { + SCOPED_SERIALISE_CONTEXT(DRAW_BUFFERS); + Serialise_glFramebufferDrawBuffersEXT(framebuffer, n, bufs); + + ResourceRecord *record = GetResourceManager()->GetResourceRecord(FramebufferRes(framebuffer)); + record->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glDrawBuffers(GLsizei n, const GLenum *bufs) { if(m_State == WRITING_CAPFRAME) { SCOPED_SERIALISE_CONTEXT(DRAW_BUFFERS); - Serialise_glDrawBuffers(n, bufs); + if(m_DrawFramebufferRecord) + Serialise_glFramebufferDrawBuffersEXT(GetResourceManager()->GetCurrentResource(m_DrawFramebufferRecord->GetResourceID()).name, n, bufs); + else + Serialise_glFramebufferDrawBuffersEXT(0, n, bufs); m_ContextRecord->AddChunk(scope.Get()); } @@ -492,13 +493,3 @@ void WrappedOpenGL::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers) for(GLsizei i=0; i < n; i++) GetResourceManager()->UnregisterResource(FramebufferRes(framebuffers[i])); } - -void WrappedOpenGL::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params) -{ - m_Real.glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); -} - -GLenum WrappedOpenGL::glCheckFramebufferStatus(GLenum target) -{ - return m_Real.glCheckFramebufferStatus(target); -} diff --git a/renderdoc/driver/gl/wrappers/gl_get_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_get_funcs.cpp index e50518590..b9ad1648e 100644 --- a/renderdoc/driver/gl/wrappers/gl_get_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_get_funcs.cpp @@ -109,6 +109,11 @@ void WrappedOpenGL::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum m_Real.glGetTexLevelParameteriv(target, level, pname, params); } +void WrappedOpenGL::glGetTextureLevelParameterivEXT(GLuint texture, GLenum target, GLint level, GLenum pname, GLint *params) +{ + m_Real.glGetTextureLevelParameterivEXT(texture, target, level, pname, params); +} + void WrappedOpenGL::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) { m_Real.glGetTexLevelParameterfv(target, level, pname, params); @@ -129,11 +134,21 @@ void WrappedOpenGL::glGetTexImage(GLenum target, GLint level, GLenum format, GLe m_Real.glGetTexImage(target, level, format, type, pixels); } +void WrappedOpenGL::glGetTextureImageEXT(GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void *pixels) +{ + m_Real.glGetTextureImageEXT(texture, target, level, format, type, pixels); +} + void WrappedOpenGL::glGetCompressedTexImage(GLenum target, GLint level, void *img) { m_Real.glGetCompressedTexImage(target, level, img); } +void WrappedOpenGL::glGetCompressedTextureImageEXT(GLuint texture, GLenum target, GLint level, void *img) +{ + m_Real.glGetCompressedTextureImageEXT(texture, target, level, img); +} + void WrappedOpenGL::glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params) { m_Real.glGetInternalformativ(target, internalformat, pname, bufSize, params); @@ -149,11 +164,21 @@ void WrappedOpenGL::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *p m_Real.glGetBufferParameteriv(target, pname, params); } +void WrappedOpenGL::glGetNamedBufferParameterivEXT(GLuint buffer, GLenum pname, GLint *params) +{ + m_Real.glGetNamedBufferParameterivEXT(buffer, pname, params); +} + void WrappedOpenGL::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data) { m_Real.glGetBufferSubData(target, offset, size, data); } +void WrappedOpenGL::glGetNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, void *data) +{ + m_Real.glGetNamedBufferSubDataEXT(buffer, offset, size, data); +} + void WrappedOpenGL::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params) { m_Real.glGetQueryObjectuiv(id, pname, params); @@ -185,6 +210,26 @@ const GLubyte *WrappedOpenGL::glGetStringi(GLenum name, GLuint i) return m_Real.glGetStringi(name, i); } +void WrappedOpenGL::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params) +{ + m_Real.glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); +} + +void WrappedOpenGL::glGetNamedFramebufferAttachmentParameterivEXT(GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params) +{ + m_Real.glGetNamedFramebufferAttachmentParameterivEXT(framebuffer, attachment, pname, params); +} + +GLenum WrappedOpenGL::glCheckFramebufferStatus(GLenum target) +{ + return m_Real.glCheckFramebufferStatus(target); +} + +GLenum WrappedOpenGL::glCheckNamedFramebufferStatusEXT(GLuint framebuffer, GLenum target) +{ + return m_Real.glCheckNamedFramebufferStatusEXT(framebuffer, target); +} + void WrappedOpenGL::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params) { m_Real.glGetVertexAttribiv(index, pname, params); diff --git a/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp index 5f645dc38..b709e6dee 100644 --- a/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp @@ -208,81 +208,134 @@ void WrappedOpenGL::glTextureView(GLuint texture, GLenum target, GLuint origtext } } -bool WrappedOpenGL::Serialise_glGenerateMipmap(GLenum target) +bool WrappedOpenGL::Serialise_glGenerateTextureMipmapEXT(GLuint texture, GLenum target) { SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(texture))); if(m_State == READING) { - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - m_Real.glGenerateMipmap(Target); + m_Real.glGenerateTextureMipmapEXT(GetResourceManager()->GetLiveResource(id).name, Target); } return true; } +void WrappedOpenGL::glGenerateTextureMipmapEXT(GLuint texture, GLenum target) +{ + m_Real.glGenerateTextureMipmapEXT(texture, target); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(GENERATE_MIPMAP); + Serialise_glGenerateTextureMipmapEXT(texture, target); + + m_ContextRecord->AddChunk(scope.Get()); + } + else if(m_State == WRITING_IDLE) + { + SCOPED_SERIALISE_CONTEXT(GENERATE_MIPMAP); + Serialise_glGenerateTextureMipmapEXT(texture, target); + + ResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(texture)); + RDCASSERT(record); + if(record) + record->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glGenerateMipmap(GLenum target) { m_Real.glGenerateMipmap(target); + + ResourceRecord *record = m_TextureRecord[m_TextureUnit]; - RDCASSERT(m_TextureRecord[m_TextureUnit]); + RDCASSERT(record); + if(!record) return; + + GLuint texture = GetResourceManager()->GetCurrentResource(record->GetResourceID()).name; + + if(m_State == WRITING_CAPFRAME) { SCOPED_SERIALISE_CONTEXT(GENERATE_MIPMAP); - Serialise_glGenerateMipmap(target); + Serialise_glGenerateTextureMipmapEXT(texture, target); + + m_ContextRecord->AddChunk(scope.Get()); + } + else if(m_State == WRITING_IDLE) + { + SCOPED_SERIALISE_CONTEXT(GENERATE_MIPMAP); + Serialise_glGenerateTextureMipmapEXT(texture, target); - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + record->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glTexParameteri(GLenum target, GLenum pname, GLint param) +bool WrappedOpenGL::Serialise_glTextureParameteriEXT(GLuint texture, GLenum target, GLenum pname, GLint param) { SERIALISE_ELEMENT(GLenum, Target, target); SERIALISE_ELEMENT(GLenum, PName, pname); SERIALISE_ELEMENT(int32_t, Param, param); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(texture))); if(m_State < WRITING) { - if(m_State == READING) - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - glTexParameteri(Target, PName, Param); + m_Real.glTextureParameteriEXT(GetResourceManager()->GetLiveResource(id).name, Target, PName, Param); } return true; } +void WrappedOpenGL::glTextureParameteriEXT(GLuint texture, GLenum target, GLenum pname, GLint param) +{ + m_Real.glTextureParameteriEXT(texture, target, pname, param); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(texture)); + RDCASSERT(record); + + SCOPED_SERIALISE_CONTEXT(TEXPARAMETERI); + Serialise_glTextureParameteriEXT(texture, target, pname, param); + + if(m_State == WRITING_IDLE) + record->AddChunk(scope.Get()); + else + m_ContextRecord->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glTexParameteri(GLenum target, GLenum pname, GLint param) { m_Real.glTexParameteri(target, pname, param); if(m_State >= WRITING) { - RDCASSERT(m_TextureRecord[m_TextureUnit]); + GLResourceRecord *record = m_TextureRecord[m_TextureUnit]; + RDCASSERT(record); SCOPED_SERIALISE_CONTEXT(TEXPARAMETERI); - Serialise_glTexParameteri(target, pname, param); + Serialise_glTextureParameteriEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, + target, pname, param); if(m_State == WRITING_IDLE) - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + record->AddChunk(scope.Get()); else m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glTexParameteriv(GLenum target, GLenum pname, const GLint *params) +bool WrappedOpenGL::Serialise_glTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, const GLint *params) { SERIALISE_ELEMENT(GLenum, Target, target); SERIALISE_ELEMENT(GLenum, PName, pname); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(texture))); const size_t nParams = (PName == eGL_TEXTURE_BORDER_COLOR ? 4U : 1U); SERIALISE_ELEMENT_ARR(int32_t, Params, params, nParams); if(m_State < WRITING) { - if(m_State == READING) - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - glTexParameteriv(Target, PName, Params); + m_Real.glTextureParameterivEXT(GetResourceManager()->GetLiveResource(id).name, Target, PName, Params); } delete[] Params; @@ -290,72 +343,110 @@ bool WrappedOpenGL::Serialise_glTexParameteriv(GLenum target, GLenum pname, cons return true; } +void WrappedOpenGL::glTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, const GLint *params) +{ + m_Real.glTextureParameterivEXT(texture, target, pname, params); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(texture)); + RDCASSERT(record); + + SCOPED_SERIALISE_CONTEXT(TEXPARAMETERIV); + Serialise_glTextureParameterivEXT(texture, target, pname, params); + + if(m_State == WRITING_IDLE) + record->AddChunk(scope.Get()); + else + m_ContextRecord->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glTexParameteriv(GLenum target, GLenum pname, const GLint *params) { m_Real.glTexParameteriv(target, pname, params); if(m_State >= WRITING) { - RDCASSERT(m_TextureRecord[m_TextureUnit]); + GLResourceRecord *record = m_TextureRecord[m_TextureUnit]; + RDCASSERT(record); SCOPED_SERIALISE_CONTEXT(TEXPARAMETERIV); - Serialise_glTexParameteriv(target, pname, params); + Serialise_glTextureParameterivEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, + target, pname, params); if(m_State == WRITING_IDLE) - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + record->AddChunk(scope.Get()); else m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glTexParameterf(GLenum target, GLenum pname, GLfloat param) +bool WrappedOpenGL::Serialise_glTextureParameterfEXT(GLuint texture, GLenum target, GLenum pname, GLfloat param) { SERIALISE_ELEMENT(GLenum, Target, target); SERIALISE_ELEMENT(GLenum, PName, pname); SERIALISE_ELEMENT(float, Param, param); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(texture))); if(m_State < WRITING) { - if(m_State == READING) - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - glTexParameterf(Target, PName, Param); + m_Real.glTextureParameterfEXT(GetResourceManager()->GetLiveResource(id).name, Target, PName, Param); } return true; } +void WrappedOpenGL::glTextureParameterfEXT(GLuint texture, GLenum target, GLenum pname, GLfloat param) +{ + m_Real.glTextureParameterfEXT(texture, target, pname, param); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(texture)); + RDCASSERT(record); + + SCOPED_SERIALISE_CONTEXT(TEXPARAMETERF); + Serialise_glTextureParameterfEXT(texture, target, pname, param); + + if(m_State == WRITING_IDLE) + record->AddChunk(scope.Get()); + else + m_ContextRecord->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glTexParameterf(GLenum target, GLenum pname, GLfloat param) { m_Real.glTexParameterf(target, pname, param); if(m_State >= WRITING) { - RDCASSERT(m_TextureRecord[m_TextureUnit]); + GLResourceRecord *record = m_TextureRecord[m_TextureUnit]; + RDCASSERT(record); SCOPED_SERIALISE_CONTEXT(TEXPARAMETERF); - Serialise_glTexParameterf(target, pname, param); + Serialise_glTextureParameterfEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, + target, pname, param); if(m_State == WRITING_IDLE) - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + record->AddChunk(scope.Get()); else m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) +bool WrappedOpenGL::Serialise_glTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, const GLfloat *params) { SERIALISE_ELEMENT(GLenum, Target, target); SERIALISE_ELEMENT(GLenum, PName, pname); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(texture))); const size_t nParams = (PName == eGL_TEXTURE_BORDER_COLOR ? 4U : 1U); SERIALISE_ELEMENT_ARR(float, Params, params, nParams); if(m_State < WRITING) { - if(m_State == READING) - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - glTexParameterfv(Target, PName, Params); + m_Real.glTextureParameterfvEXT(GetResourceManager()->GetLiveResource(id).name, Target, PName, Params); } delete[] Params; @@ -363,19 +454,40 @@ bool WrappedOpenGL::Serialise_glTexParameterfv(GLenum target, GLenum pname, cons return true; } +void WrappedOpenGL::glTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, const GLfloat *params) +{ + m_Real.glTextureParameterfvEXT(texture, target, pname, params); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(texture)); + RDCASSERT(record); + + SCOPED_SERIALISE_CONTEXT(TEXPARAMETERFV); + Serialise_glTextureParameterfvEXT(texture, target, pname, params); + + if(m_State == WRITING_IDLE) + record->AddChunk(scope.Get()); + else + m_ContextRecord->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) { m_Real.glTexParameterfv(target, pname, params); if(m_State >= WRITING) { - RDCASSERT(m_TextureRecord[m_TextureUnit]); + GLResourceRecord *record = m_TextureRecord[m_TextureUnit]; + RDCASSERT(record); SCOPED_SERIALISE_CONTEXT(TEXPARAMETERFV); - Serialise_glTexParameterfv(target, pname, params); + Serialise_glTextureParameterfvEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, + target, pname, params); if(m_State == WRITING_IDLE) - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + record->AddChunk(scope.Get()); else m_ContextRecord->AddChunk(scope.Get()); } @@ -464,6 +576,27 @@ void WrappedOpenGL::glTexImage3D(GLenum target, GLint level, GLint internalforma RDCUNIMPLEMENTED("Old glTexImage3D API not implemented"); } +void WrappedOpenGL::glTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels) +{ + m_Real.glTextureImage1DEXT(texture, target, level, internalformat, width, border, format, type, pixels); + + RDCUNIMPLEMENTED("Old glTexImage1D API not implemented"); +} + +void WrappedOpenGL::glTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) +{ + m_Real.glTextureImage2DEXT(texture, target, level, internalformat, width, height, border, format, type, pixels); + + RDCUNIMPLEMENTED("Old glTexImage2D API not implemented"); +} + +void WrappedOpenGL::glTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels) +{ + m_Real.glTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, format, type, pixels); + + RDCUNIMPLEMENTED("Old glTexImage3D API not implemented"); +} + void WrappedOpenGL::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *pixels) { m_Real.glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, pixels); @@ -485,13 +618,34 @@ void WrappedOpenGL::glCompressedTexImage3D(GLenum target, GLint level, GLenum in RDCUNIMPLEMENTED("Old glCompressedTexImage3D API not implemented"); } -bool WrappedOpenGL::Serialise_glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) +void WrappedOpenGL::glCompressedTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *pixels) +{ + m_Real.glCompressedTextureImage1DEXT(texture, target, level, internalformat, width, border, imageSize, pixels); + + RDCUNIMPLEMENTED("Old glCompressedTexImage1D API not implemented"); +} + +void WrappedOpenGL::glCompressedTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * pixels) +{ + m_Real.glCompressedTextureImage2DEXT(texture, target, level, internalformat, width, height, border, imageSize, pixels); + + RDCUNIMPLEMENTED("Old glCompressedTexImage2D API not implemented"); +} + +void WrappedOpenGL::glCompressedTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * pixels) +{ + m_Real.glCompressedTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, imageSize, pixels); + + RDCUNIMPLEMENTED("Old glCompressedTexImage3D API not implemented"); +} + +bool WrappedOpenGL::Serialise_glTextureStorage1DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) { SERIALISE_ELEMENT(GLenum, Target, target); SERIALISE_ELEMENT(uint32_t, Levels, levels); SERIALISE_ELEMENT(GLenum, Format, internalformat); SERIALISE_ELEMENT(uint32_t, Width, width); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(texture))); if(m_State == READING) { @@ -500,36 +654,59 @@ bool WrappedOpenGL::Serialise_glTexStorage1D(GLenum target, GLsizei levels, GLen m_Textures[liveId].height = 1; m_Textures[liveId].depth = 1; - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - m_Real.glTexStorage1D(Target, Levels, Format, Width); + m_Real.glTextureStorage1DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Levels, Format, Width); } return true; } +void WrappedOpenGL::glTextureStorage1DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) +{ + m_Real.glTextureStorage1DEXT(texture, target, levels, internalformat, width); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(texture)); + RDCASSERT(record); + + SCOPED_SERIALISE_CONTEXT(TEXSTORAGE1D); + Serialise_glTextureStorage1DEXT(texture, target, levels, internalformat, width); + + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(scope.Get()); + else + record->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) { m_Real.glTexStorage1D(target, levels, internalformat, width); if(m_State >= WRITING) { - RDCASSERT(m_TextureRecord[m_TextureUnit]); + GLResourceRecord *record = m_TextureRecord[m_TextureUnit]; + RDCASSERT(record); SCOPED_SERIALISE_CONTEXT(TEXSTORAGE1D); - Serialise_glTexStorage1D(target, levels, internalformat, width); + Serialise_glTextureStorage1DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, + target, levels, internalformat, width); - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(scope.Get()); + else + record->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) +bool WrappedOpenGL::Serialise_glTextureStorage2DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) { SERIALISE_ELEMENT(GLenum, Target, target); SERIALISE_ELEMENT(uint32_t, Levels, levels); SERIALISE_ELEMENT(GLenum, Format, internalformat); SERIALISE_ELEMENT(uint32_t, Width, width); SERIALISE_ELEMENT(uint32_t, Height, height); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(texture))); if(m_State == READING) { @@ -538,29 +715,52 @@ bool WrappedOpenGL::Serialise_glTexStorage2D(GLenum target, GLsizei levels, GLen m_Textures[liveId].height = Height; m_Textures[liveId].depth = 1; - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - m_Real.glTexStorage2D(Target, Levels, Format, Width, Height); + m_Real.glTextureStorage2DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Levels, Format, Width, Height); } return true; } +void WrappedOpenGL::glTextureStorage2DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) +{ + m_Real.glTextureStorage2DEXT(texture, target, levels, internalformat, width, height); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(texture)); + RDCASSERT(record); + + SCOPED_SERIALISE_CONTEXT(TEXSTORAGE2D); + Serialise_glTextureStorage2DEXT(texture, target, levels, internalformat, width, height); + + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(scope.Get()); + else + record->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) { m_Real.glTexStorage2D(target, levels, internalformat, width, height); if(m_State >= WRITING) { - RDCASSERT(m_TextureRecord[m_TextureUnit]); + GLResourceRecord *record = m_TextureRecord[m_TextureUnit]; + RDCASSERT(record); SCOPED_SERIALISE_CONTEXT(TEXSTORAGE2D); - Serialise_glTexStorage2D(target, levels, internalformat, width, height); + Serialise_glTextureStorage2DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, + target, levels, internalformat, width, height); - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(scope.Get()); + else + record->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) +bool WrappedOpenGL::Serialise_glTextureStorage3DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) { SERIALISE_ELEMENT(GLenum, Target, target); SERIALISE_ELEMENT(uint32_t, Levels, levels); @@ -568,7 +768,7 @@ bool WrappedOpenGL::Serialise_glTexStorage3D(GLenum target, GLsizei levels, GLen SERIALISE_ELEMENT(uint32_t, Width, width); SERIALISE_ELEMENT(uint32_t, Height, height); SERIALISE_ELEMENT(uint32_t, Depth, depth); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(texture))); if(m_State == READING) { @@ -577,29 +777,52 @@ bool WrappedOpenGL::Serialise_glTexStorage3D(GLenum target, GLsizei levels, GLen m_Textures[liveId].height = Height; m_Textures[liveId].depth = Depth; - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - m_Real.glTexStorage3D(Target, Levels, Format, Width, Height, Depth); + m_Real.glTextureStorage3DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Levels, Format, Width, Height, Depth); } return true; } +void WrappedOpenGL::glTextureStorage3DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) +{ + m_Real.glTextureStorage3DEXT(texture, target, levels, internalformat, width, height, depth); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(texture)); + RDCASSERT(record); + + SCOPED_SERIALISE_CONTEXT(TEXSTORAGE3D); + Serialise_glTextureStorage3DEXT(texture, target, levels, internalformat, width, height, depth); + + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(scope.Get()); + else + record->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) { m_Real.glTexStorage3D(target, levels, internalformat, width, height, depth); if(m_State >= WRITING) { - RDCASSERT(m_TextureRecord[m_TextureUnit]); + GLResourceRecord *record = m_TextureRecord[m_TextureUnit]; + RDCASSERT(record); SCOPED_SERIALISE_CONTEXT(TEXSTORAGE3D); - Serialise_glTexStorage3D(target, levels, internalformat, width, height, depth); + Serialise_glTextureStorage3DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, + target, levels, internalformat, width, height, depth); - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(scope.Get()); + else + record->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) +bool WrappedOpenGL::Serialise_glTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) { SERIALISE_ELEMENT(GLenum, Target, target); SERIALISE_ELEMENT(int32_t, Level, level); @@ -607,7 +830,7 @@ bool WrappedOpenGL::Serialise_glTexSubImage1D(GLenum target, GLint level, GLint SERIALISE_ELEMENT(uint32_t, Width, width); SERIALISE_ELEMENT(GLenum, Format, format); SERIALISE_ELEMENT(GLenum, Type, type); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(texture))); GLint align = 1; m_Real.glGetIntegerv(eGL_UNPACK_ALIGNMENT, &align); @@ -618,14 +841,32 @@ bool WrappedOpenGL::Serialise_glTexSubImage1D(GLenum target, GLint level, GLint if(m_State == READING) { - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - m_Real.glTexSubImage1D(Target, Level, xoff, Width, Format, Type, buf); + m_Real.glTextureSubImage1DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, xoff, Width, Format, Type, buf); delete[] buf; } return true; } + +void WrappedOpenGL::glTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) +{ + m_Real.glTextureSubImage1DEXT(texture, target, level, xoffset, width, format, type, pixels); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(texture)); + RDCASSERT(record); + + SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE1D); + Serialise_glTextureSubImage1DEXT(texture, target, level, xoffset, width, format, type, pixels); + + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(scope.Get()); + else + record->AddChunk(scope.Get()); + } +} void WrappedOpenGL::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) { @@ -633,16 +874,21 @@ void WrappedOpenGL::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, G if(m_State >= WRITING) { - RDCASSERT(m_TextureRecord[m_TextureUnit]); + GLResourceRecord *record = m_TextureRecord[m_TextureUnit]; + RDCASSERT(record); SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE1D); - Serialise_glTexSubImage1D(target, level, xoffset, width, format, type, pixels); + Serialise_glTextureSubImage1DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, + target, level, xoffset, width, format, type, pixels); - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(scope.Get()); + else + record->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) +bool WrappedOpenGL::Serialise_glTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) { SERIALISE_ELEMENT(GLenum, Target, target); SERIALISE_ELEMENT(int32_t, Level, level); @@ -652,7 +898,7 @@ bool WrappedOpenGL::Serialise_glTexSubImage2D(GLenum target, GLint level, GLint SERIALISE_ELEMENT(uint32_t, Height, height); SERIALISE_ELEMENT(GLenum, Format, format); SERIALISE_ELEMENT(GLenum, Type, type); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(texture))); GLint align = 1; m_Real.glGetIntegerv(eGL_UNPACK_ALIGNMENT, &align); @@ -663,8 +909,7 @@ bool WrappedOpenGL::Serialise_glTexSubImage2D(GLenum target, GLint level, GLint if(m_State == READING) { - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - m_Real.glTexSubImage2D(Target, Level, xoff, yoff, Width, Height, Format, Type, buf); + m_Real.glTextureSubImage2DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, xoff, yoff, Width, Height, Format, Type, buf); delete[] buf; } @@ -672,22 +917,46 @@ bool WrappedOpenGL::Serialise_glTexSubImage2D(GLenum target, GLint level, GLint return true; } +void WrappedOpenGL::glTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) +{ + m_Real.glTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, type, pixels); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(texture)); + RDCASSERT(record); + + SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE2D); + Serialise_glTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, type, pixels); + + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(scope.Get()); + else + record->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) { m_Real.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); if(m_State >= WRITING) { - RDCASSERT(m_TextureRecord[m_TextureUnit]); + GLResourceRecord *record = m_TextureRecord[m_TextureUnit]; + RDCASSERT(record); SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE2D); - Serialise_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); + Serialise_glTextureSubImage2DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, + target, level, xoffset, yoffset, width, height, format, type, pixels); - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(scope.Get()); + else + record->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) +bool WrappedOpenGL::Serialise_glTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) { SERIALISE_ELEMENT(GLenum, Target, target); SERIALISE_ELEMENT(int32_t, Level, level); @@ -699,7 +968,7 @@ bool WrappedOpenGL::Serialise_glTexSubImage3D(GLenum target, GLint level, GLint SERIALISE_ELEMENT(uint32_t, Depth, depth); SERIALISE_ELEMENT(GLenum, Format, format); SERIALISE_ELEMENT(GLenum, Type, type); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(texture))); GLint align = 1; m_Real.glGetIntegerv(eGL_UNPACK_ALIGNMENT, &align); @@ -710,8 +979,7 @@ bool WrappedOpenGL::Serialise_glTexSubImage3D(GLenum target, GLint level, GLint if(m_State == READING) { - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - m_Real.glTexSubImage3D(Target, Level, xoff, yoff, zoff, Width, Height, Depth, Format, Type, buf); + m_Real.glTextureSubImage3DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, xoff, yoff, zoff, Width, Height, Depth, Format, Type, buf); delete[] buf; } @@ -719,22 +987,46 @@ bool WrappedOpenGL::Serialise_glTexSubImage3D(GLenum target, GLint level, GLint return true; } +void WrappedOpenGL::glTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) +{ + m_Real.glTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(texture)); + RDCASSERT(record); + + SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE3D); + Serialise_glTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); + + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(scope.Get()); + else + record->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) { m_Real.glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); if(m_State >= WRITING) { - RDCASSERT(m_TextureRecord[m_TextureUnit]); + GLResourceRecord *record = m_TextureRecord[m_TextureUnit]; + RDCASSERT(record); SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE3D); - Serialise_glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); + Serialise_glTextureSubImage3DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, + target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(scope.Get()); + else + record->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *pixels) +bool WrappedOpenGL::Serialise_glCompressedTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *pixels) { SERIALISE_ELEMENT(GLenum, Target, target); SERIALISE_ELEMENT(int32_t, Level, level); @@ -742,14 +1034,13 @@ bool WrappedOpenGL::Serialise_glCompressedTexSubImage1D(GLenum target, GLint lev SERIALISE_ELEMENT(uint32_t, Width, width); SERIALISE_ELEMENT(GLenum, fmt, format); SERIALISE_ELEMENT(uint32_t, byteSize, imageSize); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(texture))); SERIALISE_ELEMENT_BUF(byte *, buf, pixels, byteSize); if(m_State == READING) { - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - m_Real.glCompressedTexSubImage1D(Target, Level, xoff, Width, fmt, byteSize, buf); + m_Real.glCompressedTextureSubImage1DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, xoff, Width, fmt, byteSize, buf); delete[] buf; } @@ -757,22 +1048,46 @@ bool WrappedOpenGL::Serialise_glCompressedTexSubImage1D(GLenum target, GLint lev return true; } +void WrappedOpenGL::glCompressedTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *pixels) +{ + m_Real.glCompressedTextureSubImage1DEXT(texture, target, level, xoffset, width, format, imageSize, pixels); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(texture)); + RDCASSERT(record); + + SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE1D_COMPRESSED); + Serialise_glCompressedTextureSubImage1DEXT(texture, target, level, xoffset, width, format, imageSize, pixels); + + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(scope.Get()); + else + record->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *pixels) { m_Real.glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, pixels); if(m_State >= WRITING) { - RDCASSERT(m_TextureRecord[m_TextureUnit]); + GLResourceRecord *record = m_TextureRecord[m_TextureUnit]; + RDCASSERT(record); SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE1D_COMPRESSED); - Serialise_glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, pixels); + Serialise_glCompressedTextureSubImage1DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, + target, level, xoffset, width, format, imageSize, pixels); - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(scope.Get()); + else + record->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) +bool WrappedOpenGL::Serialise_glCompressedTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) { SERIALISE_ELEMENT(GLenum, Target, target); SERIALISE_ELEMENT(int32_t, Level, level); @@ -782,14 +1097,13 @@ bool WrappedOpenGL::Serialise_glCompressedTexSubImage2D(GLenum target, GLint lev SERIALISE_ELEMENT(uint32_t, Height, height); SERIALISE_ELEMENT(GLenum, fmt, format); SERIALISE_ELEMENT(uint32_t, byteSize, imageSize); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(texture))); SERIALISE_ELEMENT_BUF(byte *, buf, pixels, byteSize); if(m_State == READING) { - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - m_Real.glCompressedTexSubImage2D(Target, Level, xoff, yoff, Width, Height, fmt, byteSize, buf); + m_Real.glCompressedTextureSubImage2DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, xoff, yoff, Width, Height, fmt, byteSize, buf); delete[] buf; } @@ -797,22 +1111,46 @@ bool WrappedOpenGL::Serialise_glCompressedTexSubImage2D(GLenum target, GLint lev return true; } +void WrappedOpenGL::glCompressedTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) +{ + m_Real.glCompressedTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, imageSize, pixels); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(texture)); + RDCASSERT(record); + + SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE2D_COMPRESSED); + Serialise_glCompressedTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, imageSize, pixels); + + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(scope.Get()); + else + record->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) { m_Real.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, pixels); if(m_State >= WRITING) { - RDCASSERT(m_TextureRecord[m_TextureUnit]); + GLResourceRecord *record = m_TextureRecord[m_TextureUnit]; + RDCASSERT(record); SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE2D_COMPRESSED); - Serialise_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, pixels); + Serialise_glCompressedTextureSubImage2DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, + target, level, xoffset, yoffset, width, height, format, imageSize, pixels); - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(scope.Get()); + else + record->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) +bool WrappedOpenGL::Serialise_glCompressedTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) { SERIALISE_ELEMENT(GLenum, Target, target); SERIALISE_ELEMENT(int32_t, Level, level); @@ -824,14 +1162,13 @@ bool WrappedOpenGL::Serialise_glCompressedTexSubImage3D(GLenum target, GLint lev SERIALISE_ELEMENT(uint32_t, Depth, depth); SERIALISE_ELEMENT(GLenum, fmt, format); SERIALISE_ELEMENT(uint32_t, byteSize, imageSize); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(texture))); SERIALISE_ELEMENT_BUF(byte *, buf, pixels, byteSize); if(m_State == READING) { - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - m_Real.glCompressedTexSubImage3D(Target, Level, xoff, yoff, zoff, Width, Height, Depth, fmt, byteSize, buf); + m_Real.glCompressedTextureSubImage3DEXT(GetResourceManager()->GetLiveResource(id).name, Target, Level, xoff, yoff, zoff, Width, Height, Depth, fmt, byteSize, buf); delete[] buf; } @@ -839,18 +1176,42 @@ bool WrappedOpenGL::Serialise_glCompressedTexSubImage3D(GLenum target, GLint lev return true; } +void WrappedOpenGL::glCompressedTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) +{ + m_Real.glCompressedTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(texture)); + RDCASSERT(record); + + SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE3D_COMPRESSED); + Serialise_glCompressedTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); + + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(scope.Get()); + else + record->AddChunk(scope.Get()); + } +} + void WrappedOpenGL::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) { m_Real.glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); if(m_State >= WRITING) { - RDCASSERT(m_TextureRecord[m_TextureUnit]); + GLResourceRecord *record = m_TextureRecord[m_TextureUnit]; + RDCASSERT(record); SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE3D_COMPRESSED); - Serialise_glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); + Serialise_glCompressedTextureSubImage3DEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name, + target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(scope.Get()); + else + record->AddChunk(scope.Get()); } } diff --git a/renderdoc/hooks/gl_linux_hooks.cpp b/renderdoc/hooks/gl_linux_hooks.cpp index 325f8c866..768724685 100644 --- a/renderdoc/hooks/gl_linux_hooks.cpp +++ b/renderdoc/hooks/gl_linux_hooks.cpp @@ -156,6 +156,11 @@ typedef void (*PFNGLXSWAPBUFFERSPROC)(Display *dpy, GLXDrawable drawable); 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) \ + 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); } class OpenGLHook : LibraryHook diff --git a/renderdoc/hooks/gl_win32_hooks.cpp b/renderdoc/hooks/gl_win32_hooks.cpp index cb1d50a06..e1efc7f56 100644 --- a/renderdoc/hooks/gl_win32_hooks.cpp +++ b/renderdoc/hooks/gl_win32_hooks.cpp @@ -165,6 +165,12 @@ 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); } + class OpenGLHook : LibraryHook { public: