lee/renderdoc
1
0
Fork 0
mirror of https://github.com/baldurk/renderdoc.git synced 2026-08-15 11:06:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Hook the EXT_direct_state_access functions.

Browse Source 
* 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.
This commit is contained in:
Baldur Karlsson
2014-06-19 12:05:49 +01:00
parent acb36a5308
commit b345b9ceb7
10 changed files with 985 additions and 384 deletions
Download Patch File Download Diff File Expand all files Collapse all files
renderdoc/driver/gl/gl_driver.cpp
+20 -20
View File
@@ -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);
renderdoc/driver/gl/gl_driver.h
+37
View File
@@ -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));
};
renderdoc/driver/gl/gl_hookset.h
+35
View File
@@ -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
renderdoc/driver/gl/gl_hookset_defs.h
+70
View File
@@ -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); \
renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp
+146 -95
View File
@@ -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);
}
renderdoc/driver/gl/wrappers/gl_framebuffer_funcs.cpp
+158 -167
View File
@@ -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);
}
renderdoc/driver/gl/wrappers/gl_get_funcs.cpp
+45
View File
@@ -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);
renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp
+463 -102
View File
@@ -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());
}
}
renderdoc/hooks/gl_linux_hooks.cpp
+5
View File
@@ -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
renderdoc/hooks/gl_win32_hooks.cpp
+6
View File
@@ -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<ret (WINAPI *) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12)> 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: