Add a few last buffer related hooks

renderdoc/driver/gl/gl_common.h

@@ -93,12 +93,14 @@ enum GLChunkType
 	TEXSUBIMAGE1D_COMPRESSED,
 	TEXSUBIMAGE2D_COMPRESSED,
 	TEXSUBIMAGE3D_COMPRESSED,
+	TEXBUFFER_RANGE,
 	PIXELSTORE,
 	TEXPARAMETERF,
 	TEXPARAMETERFV,
 	TEXPARAMETERI,
 	TEXPARAMETERIV,
 	GENERATE_MIPMAP,
+	COPY_SUBIMAGE,
 	TEXTURE_VIEW,
 
 	CREATE_SHADER,
@@ -207,7 +209,10 @@ enum GLChunkType
 	BIND_BUFFER,
 	BIND_BUFFER_BASE,
 	BIND_BUFFER_RANGE,
+	BUFFERSTORAGE,
 	BUFFERDATA,
+	BUFFERSUBDATA,
+	COPYBUFFERSUBDATA,
 	UNMAP,
 	GEN_VERTEXARRAY,
 	BIND_VERTEXARRAY,

renderdoc/driver/gl/gl_driver.cpp

@@ -50,12 +50,14 @@ const char *GLChunkNames[] =
 	"glCompressedTexSubImage1D",
 	"glCompressedTexSubImage2D",
 	"glCompressedTexSubImage3D",
+	"glTexBufferRange",
 	"glPixelStore",
 	"glTexParameterf",
 	"glTexParameterfv",
 	"glTexParameteri",
 	"glTexParameteriv",
 	"glGenerateMipmap",
+	"glCopyImageSubData",
 	"glTextureView",
 
 	"glCreateShader",
@@ -164,7 +166,10 @@ const char *GLChunkNames[] =
 	"glBindBuffer",
 	"glBindBufferBase",
 	"glBindBufferRange",
+	"glBufferStorage",
 	"glBufferData",
+	"glBufferSubData",
+	"glCopyBufferSubData",
 	"glUnmapBuffer",
 	"glGenVertexArrays",
 	"glBindVertexArray",
@@ -949,6 +954,9 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 	case TEXSUBIMAGE3D_COMPRESSED:
 		Serialise_glCompressedTextureSubImage3DEXT(0, eGL_UNKNOWN_ENUM, 0, 0, 0, 0, 0, 0, 0, eGL_UNKNOWN_ENUM, 0, NULL);
 		break;
+	case TEXBUFFER_RANGE:
+		Serialise_glTextureBufferRangeEXT(0, eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, 0, 0, 0);
+		break;
 	case PIXELSTORE:
 		Serialise_glPixelStorei(eGL_UNKNOWN_ENUM, 0);
 		break;
@@ -967,6 +975,9 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 	case GENERATE_MIPMAP:
 		Serialise_glGenerateTextureMipmapEXT(0, eGL_UNKNOWN_ENUM);
 		break;
+	case COPY_SUBIMAGE:
+		Serialise_glCopyImageSubData(0, eGL_UNKNOWN_ENUM, 0, 0, 0, 0, 0, eGL_UNKNOWN_ENUM, 0, 0, 0, 0, 0, 0, 0);
+		break;
 	case TEXTURE_VIEW:
 		Serialise_glTextureView(0, eGL_UNKNOWN_ENUM, 0, eGL_UNKNOWN_ENUM, 0, 0, 0, 0);
 		break;
@@ -1277,9 +1288,18 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 	case BIND_BUFFER_RANGE:
 		Serialise_glBindBufferRange(eGL_UNKNOWN_ENUM, 0, 0, 0, 0);
 		break;
+	case BUFFERSTORAGE:
+		Serialise_glNamedBufferStorageEXT(0, 0, NULL, 0);
+		break;
 	case BUFFERDATA:
 		Serialise_glNamedBufferDataEXT(eGL_UNKNOWN_ENUM, 0, NULL, eGL_UNKNOWN_ENUM);
 		break;
+	case BUFFERSUBDATA:
+		Serialise_glNamedBufferSubDataEXT(0, 0, 0, NULL);
+		break;
+	case COPYBUFFERSUBDATA:
+		Serialise_glNamedCopyBufferSubDataEXT(0, 0, 0, 0, 0);
+		break;
 	case UNMAP:
 		Serialise_glUnmapNamedBufferEXT(eGL_UNKNOWN_ENUM);
 		break;

renderdoc/driver/gl/gl_driver.h

@@ -310,6 +310,7 @@ class WrappedOpenGL
 		IMPLEMENT_FUNCTION_SERIALISED(void, glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *pixels));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * pixels));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * pixels));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTexParameterf(GLenum target, GLenum pname, GLfloat param));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTexParameteri(GLenum target, GLenum pname, GLint param));
@@ -379,6 +380,8 @@ class WrappedOpenGL
 		IMPLEMENT_FUNCTION_SERIALISED(void, glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glGenerateMipmap(GLenum target));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth));
+
 		IMPLEMENT_FUNCTION_SERIALISED(void, glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter));
 
 		IMPLEMENT_FUNCTION_SERIALISED(void, glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params));
@@ -429,7 +432,10 @@ class WrappedOpenGL
 		IMPLEMENT_FUNCTION_SERIALISED(void, glValidateProgramPipeline(GLuint pipeline));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glGenBuffers(GLsizei n, GLuint *buffers));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glBindBuffer(GLenum target, GLuint buffer));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glBufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glBindBufferBase(GLenum target, GLuint index, GLuint buffer));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size));
 		IMPLEMENT_FUNCTION_SERIALISED(void *, glMapBuffer(GLenum target, GLenum access));
@@ -529,9 +535,13 @@ class WrappedOpenGL
 		IMPLEMENT_FUNCTION_SERIALISED(void *, glMapNamedBufferEXT(GLuint buffer, GLenum access));
 		IMPLEMENT_FUNCTION_SERIALISED(void *, glMapNamedBufferRangeEXT(GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glNamedBufferDataEXT(GLuint buffer, GLsizeiptr size, const void *data, GLenum usage));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glNamedBufferStorageEXT(GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glNamedCopyBufferSubDataEXT(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glNamedFramebufferTextureEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glNamedFramebufferTexture2DEXT(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glNamedFramebufferTextureLayerEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glTextureBufferRangeEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels));

renderdoc/driver/gl/gl_hookset.h

@@ -96,8 +96,10 @@ struct GLHookSet
 	PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glCompressedTexSubImage1D;
 	PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glCompressedTexSubImage2D;
 	PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glCompressedTexSubImage3D;
+	PFNGLTEXBUFFERRANGEPROC glTexBufferRange;
 	PFNGLTEXTUREVIEWPROC glTextureView;
 	PFNGLGENERATEMIPMAPPROC glGenerateMipmap;
+	PFNGLCOPYIMAGESUBDATAPROC glCopyImageSubData;
 	PFNGLGETINTERNALFORMATIVPROC glGetInternalformativ;
 	PFNGLGETINTERNALFORMATI64VPROC glGetInternalformati64v;
 	PFNGLGETBUFFERPARAMETERIVPROC glGetBufferParameteriv;
@@ -189,6 +191,9 @@ struct GLHookSet
 	PFNGLGETQUERYOBJECTUIVPROC glGetQueryObjectuiv;
 	PFNGLDELETEQUERIESPROC glDeleteQueries;
 	PFNGLBUFFERDATAPROC glBufferData;
+	PFNGLBUFFERSTORAGEPROC glBufferStorage;
+	PFNGLBUFFERSUBDATAPROC glBufferSubData;
+	PFNGLCOPYBUFFERSUBDATAPROC glCopyBufferSubData;
 	PFNGLBINDBUFFERBASEPROC glBindBufferBase;
 	PFNGLBINDBUFFERRANGEPROC glBindBufferRange;
 	PFNGLMAPBUFFERPROC glMapBuffer;
@@ -275,9 +280,13 @@ struct GLHookSet
 	PFNGLMAPNAMEDBUFFEREXTPROC glMapNamedBufferEXT;
 	PFNGLMAPNAMEDBUFFERRANGEEXTPROC glMapNamedBufferRangeEXT;
 	PFNGLNAMEDBUFFERDATAEXTPROC glNamedBufferDataEXT;
+	PFNGLNAMEDBUFFERSTORAGEEXTPROC glNamedBufferStorageEXT;
+	PFNGLNAMEDBUFFERSUBDATAEXTPROC glNamedBufferSubDataEXT;
+	PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC glNamedCopyBufferSubDataEXT;
 	PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC glNamedFramebufferTextureEXT;
 	PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC glNamedFramebufferTexture2DEXT;
 	PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC glNamedFramebufferTextureLayerEXT;
+	PFNGLTEXTUREBUFFERRANGEEXTPROC glTextureBufferRangeEXT;
 	PFNGLTEXTUREIMAGE1DEXTPROC glTextureImage1DEXT;
 	PFNGLTEXTUREIMAGE2DEXTPROC glTextureImage2DEXT;
 	PFNGLTEXTUREIMAGE3DEXTPROC glTextureImage3DEXT;

renderdoc/driver/gl/gl_hookset_defs.h

@@ -109,8 +109,10 @@
     HookExtension(PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC, glCompressedTexSubImage1D); \
     HookExtension(PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC, glCompressedTexSubImage2D); \
     HookExtension(PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC, glCompressedTexSubImage3D); \
+    HookExtension(PFNGLTEXBUFFERRANGEPROC, glTexBufferRange); \
     HookExtension(PFNGLTEXTUREVIEWPROC, glTextureView); \
     HookExtension(PFNGLGENERATEMIPMAPPROC, glGenerateMipmap); \
+    HookExtension(PFNGLCOPYIMAGESUBDATAPROC, glCopyImageSubData); \
     HookExtension(PFNGLGETINTERNALFORMATIVPROC, glGetInternalformativ); \
     HookExtension(PFNGLGETINTERNALFORMATI64VPROC, glGetInternalformati64v); \
     HookExtension(PFNGLGETBUFFERPARAMETERIVPROC, glGetBufferParameteriv); \
@@ -203,6 +205,9 @@
     HookExtension(PFNGLGETQUERYOBJECTUIVPROC, glGetQueryObjectuiv); \
     HookExtension(PFNGLDELETEQUERIESPROC, glDeleteQueries); \
     HookExtension(PFNGLBUFFERDATAPROC, glBufferData); \
+    HookExtension(PFNGLBUFFERSTORAGEPROC, glBufferStorage); \
+    HookExtension(PFNGLBUFFERSUBDATAPROC, glBufferSubData); \
+    HookExtension(PFNGLCOPYBUFFERSUBDATAPROC, glCopyBufferSubData); \
     HookExtension(PFNGLBINDBUFFERBASEPROC, glBindBufferBase); \
     HookExtension(PFNGLBINDBUFFERRANGEPROC, glBindBufferRange); \
     HookExtension(PFNGLMAPBUFFERPROC, glMapBuffer); \
@@ -289,9 +294,13 @@
     HookExtension(PFNGLMAPNAMEDBUFFEREXTPROC, glMapNamedBufferEXT); \
     HookExtension(PFNGLMAPNAMEDBUFFERRANGEEXTPROC, glMapNamedBufferRangeEXT); \
     HookExtension(PFNGLNAMEDBUFFERDATAEXTPROC, glNamedBufferDataEXT); \
+    HookExtension(PFNGLNAMEDBUFFERSTORAGEEXTPROC, glNamedBufferStorageEXT); \
+    HookExtension(PFNGLNAMEDBUFFERSUBDATAEXTPROC, glNamedBufferSubDataEXT); \
+    HookExtension(PFNGLNAMEDCOPYBUFFERSUBDATAEXTPROC, glNamedCopyBufferSubDataEXT); \
     HookExtension(PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC, glNamedFramebufferTextureEXT); \
     HookExtension(PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC, glNamedFramebufferTexture2DEXT); \
     HookExtension(PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC, glNamedFramebufferTextureLayerEXT); \
+    HookExtension(PFNGLTEXTUREBUFFERRANGEEXTPROC, glTextureBufferRangeEXT); \
     HookExtension(PFNGLTEXTUREIMAGE1DEXTPROC, glTextureImage1DEXT); \
     HookExtension(PFNGLTEXTUREIMAGE2DEXTPROC, glTextureImage2DEXT); \
     HookExtension(PFNGLTEXTUREIMAGE3DEXTPROC, glTextureImage3DEXT); \
@@ -441,8 +450,10 @@
     HookWrapper7(void, glCompressedTexSubImage1D, GLenum, target, GLint, level, GLint, xoffset, GLsizei, width, GLenum, format, GLsizei, imageSize, const void *, data); \
     HookWrapper9(void, glCompressedTexSubImage2D, GLenum, target, GLint, level, GLint, xoffset, GLint, yoffset, GLsizei, width, GLsizei, height, GLenum, format, GLsizei, imageSize, const void *, data); \
     HookWrapper11(void, glCompressedTexSubImage3D, GLenum, target, GLint, level, GLint, xoffset, GLint, yoffset, GLint, zoffset, GLsizei, width, GLsizei, height, GLsizei, depth, GLenum, format, GLsizei, imageSize, const void *, data); \
+    HookWrapper5(void, glTexBufferRange, GLenum, target, GLenum, internalformat, GLuint, buffer, GLintptr, offset, GLsizeiptr, size); \
     HookWrapper8(void, glTextureView, GLuint, texture, GLenum, target, GLuint, origtexture, GLenum, internalformat, GLuint, minlevel, GLuint, numlevels, GLuint, minlayer, GLuint, numlayers); \
     HookWrapper1(void, glGenerateMipmap, GLenum, target); \
+    HookWrapper15(void, glCopyImageSubData, GLuint, srcName, GLenum, srcTarget, GLint, srcLevel, GLint, srcX, GLint, srcY, GLint, srcZ, GLuint, dstName, GLenum, dstTarget, GLint, dstLevel, GLint, dstX, GLint, dstY, GLint, dstZ, GLsizei, srcWidth, GLsizei, srcHeight, GLsizei, srcDepth); \
     HookWrapper5(void, glGetInternalformativ, GLenum, target, GLenum, internalformat, GLenum, pname, GLsizei, bufSize, GLint *, params); \
     HookWrapper5(void, glGetInternalformati64v, GLenum, target, GLenum, internalformat, GLenum, pname, GLsizei, bufSize, GLint64 *, params); \
     HookWrapper3(void, glGetBufferParameteriv, GLenum, target, GLenum, pname, GLint *, params); \
@@ -534,6 +545,9 @@
     HookWrapper3(void, glGetQueryObjectuiv, GLuint, id, GLenum, pname, GLuint *, params); \
     HookWrapper2(void, glDeleteQueries, GLsizei, n, const GLuint *, ids); \
     HookWrapper4(void, glBufferData, GLenum, target, GLsizeiptr, size, const void *, data, GLenum, usage); \
+    HookWrapper4(void, glBufferStorage, GLenum, target, GLsizeiptr, size, const void *, data, GLbitfield, flags); \
+    HookWrapper4(void, glBufferSubData, GLenum, target, GLintptr, offset, GLsizeiptr, size, const void *, data); \
+    HookWrapper5(void, glCopyBufferSubData, GLenum, readTarget, GLenum, writeTarget, GLintptr, readOffset, GLintptr, writeOffset, GLsizeiptr, size); \
     HookWrapper3(void, glBindBufferBase, GLenum, target, GLuint, index, GLuint, buffer); \
     HookWrapper5(void, glBindBufferRange, GLenum, target, GLuint, index, GLuint, buffer, GLintptr, offset, GLsizeiptr, size); \
     HookWrapper2(void *, glMapBuffer, GLenum, target, GLenum, access); \
@@ -620,9 +634,13 @@
     HookWrapper2(void *, glMapNamedBufferEXT, GLuint, buffer, GLenum, access); \
     HookWrapper4(void *, glMapNamedBufferRangeEXT, GLuint, buffer, GLintptr, offset, GLsizeiptr, length, GLbitfield, access); \
     HookWrapper4(void, glNamedBufferDataEXT, GLuint, buffer, GLsizeiptr, size, const void *, data, GLenum, usage); \
+    HookWrapper4(void, glNamedBufferStorageEXT, GLuint, buffer, GLsizeiptr, size, const void *, data, GLbitfield, flags); \
+    HookWrapper4(void, glNamedBufferSubDataEXT, GLuint, buffer, GLintptr, offset, GLsizeiptr, size, const void *, data); \
+    HookWrapper5(void, glNamedCopyBufferSubDataEXT, GLuint, readBuffer, GLuint, writeBuffer, GLintptr, readOffset, GLintptr, writeOffset, GLsizeiptr, size); \
     HookWrapper4(void, glNamedFramebufferTextureEXT, GLuint, framebuffer, GLenum, attachment, GLuint, texture, GLint, level); \
     HookWrapper5(void, glNamedFramebufferTexture2DEXT, GLuint, framebuffer, GLenum, attachment, GLenum, textarget, GLuint, texture, GLint, level); \
     HookWrapper5(void, glNamedFramebufferTextureLayerEXT, GLuint, framebuffer, GLenum, attachment, GLuint, texture, GLint, level, GLint, layer); \
+    HookWrapper6(void, glTextureBufferRangeEXT, GLuint, texture, GLenum, target, GLenum, internalformat, GLuint, buffer, GLintptr, offset, GLsizeiptr, size); \
     HookWrapper9(void, glTextureImage1DEXT, GLuint, texture, GLenum, target, GLint, level, GLint, internalformat, GLsizei, width, GLint, border, GLenum, format, GLenum, type, const void *, pixels); \
     HookWrapper10(void, glTextureImage2DEXT, GLuint, texture, GLenum, target, GLint, level, GLint, internalformat, GLsizei, width, GLsizei, height, GLint, border, GLenum, format, GLenum, type, const void *, pixels); \
     HookWrapper11(void, glTextureImage3DEXT, GLuint, texture, GLenum, target, GLint, level, GLint, internalformat, GLsizei, width, GLsizei, height, GLsizei, depth, GLint, border, GLenum, format, GLenum, type, const void *, pixels); \

renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp

@@ -174,6 +174,102 @@ void WrappedOpenGL::glBindBuffer(GLenum target, GLuint buffer)
 	}
 }
 
+bool WrappedOpenGL::Serialise_glNamedBufferStorageEXT(GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags)
+{
+	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(BufferRes(buffer)));
+	SERIALISE_ELEMENT(uint64_t, Bytesize, (uint64_t)size);
+
+	byte *dummy = NULL;
+
+	if(m_State >= WRITING && data == NULL)
+	{
+		dummy = new byte[size];
+		data = dummy;
+	}
+
+	SERIALISE_ELEMENT_BUF(byte *, bytes, data, (size_t)Bytesize);
+
+	uint64_t offs = m_pSerialiser->GetOffset();
+
+	SERIALISE_ELEMENT(uint32_t, Flags, flags);
+
+	if(m_State < WRITING)
+	{
+		GLResource res = GetResourceManager()->GetLiveResource(id);
+		m_Real.glNamedBufferStorageEXT(res.name, (GLsizeiptr)Bytesize, bytes, Flags);
+		
+		m_Buffers[GetResourceManager()->GetLiveID(id)].size = Bytesize;
+
+		SAFE_DELETE_ARRAY(bytes);
+	}
+	else if(m_State >= WRITING)
+	{
+		GetResourceManager()->GetResourceRecord(id)->SetDataOffset(offs - Bytesize);
+	}
+
+	if(dummy)
+		delete[] dummy;
+
+	return true;
+}
+
+void WrappedOpenGL::glNamedBufferStorageEXT(GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags)
+{
+	m_Real.glNamedBufferStorageEXT(buffer, size, data, flags);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = GetResourceManager()->GetResourceRecord(BufferRes(buffer));
+		RDCASSERT(record);
+
+		SCOPED_SERIALISE_CONTEXT(BUFFERSTORAGE);
+		Serialise_glNamedBufferStorageEXT(buffer, size, data, flags);
+
+		Chunk *chunk = scope.Get();
+
+		if(m_State == WRITING_CAPFRAME)
+		{
+			m_ContextRecord->AddChunk(chunk);
+		}
+		else
+		{
+			record->AddChunk(chunk);
+			record->SetDataPtr(chunk->GetData());
+			record->Length = (int32_t)size;
+		}
+	}
+}
+
+void WrappedOpenGL::glBufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags)
+{
+	m_Real.glBufferStorage(target, size, data, flags);
+	
+	size_t idx = BufferIdx(target);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = m_BufferRecord[BufferIdx(target)];
+		RDCASSERT(record);
+
+		SCOPED_SERIALISE_CONTEXT(BUFFERSTORAGE);
+		Serialise_glNamedBufferStorageEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name,
+																   size, data, flags);
+
+		Chunk *chunk = scope.Get();
+
+		if(m_State == WRITING_CAPFRAME)
+		{
+			m_ContextRecord->AddChunk(chunk);
+		}
+		else
+		{
+			record->AddChunk(chunk);
+			record->SetDataPtr(chunk->GetData());
+			record->Length = (int32_t)size;
+		}
+	}
+}
+
 bool WrappedOpenGL::Serialise_glNamedBufferDataEXT(GLuint buffer, GLsizeiptr size, const void *data, GLenum usage)
 {
 	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(BufferRes(buffer)));
@@ -270,6 +366,141 @@ void WrappedOpenGL::glBufferData(GLenum target, GLsizeiptr size, const void *dat
 	}
 }
 
+bool WrappedOpenGL::Serialise_glNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data)
+{
+	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(BufferRes(buffer)));
+	SERIALISE_ELEMENT(uint64_t, Offset, (uint64_t)offset);
+	SERIALISE_ELEMENT(uint64_t, Bytesize, (uint64_t)size);
+	SERIALISE_ELEMENT_BUF(byte *, bytes, data, (size_t)Bytesize);
+
+	if(m_State < WRITING)
+	{
+		GLResource res = GetResourceManager()->GetLiveResource(id);
+		m_Real.glNamedBufferSubDataEXT(res.name, (GLintptr)Offset, (GLsizeiptr)Bytesize, bytes);
+
+		SAFE_DELETE_ARRAY(bytes);
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data)
+{
+	m_Real.glNamedBufferSubDataEXT(buffer, offset, size, data);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = GetResourceManager()->GetResourceRecord(BufferRes(buffer));
+		RDCASSERT(record);
+
+		SCOPED_SERIALISE_CONTEXT(BUFFERDATA);
+		Serialise_glNamedBufferSubDataEXT(buffer, offset, size, data);
+
+		Chunk *chunk = scope.Get();
+
+		if(m_State == WRITING_CAPFRAME)
+			m_ContextRecord->AddChunk(chunk);
+		else
+			record->AddChunk(chunk);
+	}
+}
+
+void WrappedOpenGL::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data)
+{
+	m_Real.glBufferSubData(target, offset, size, data);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = m_BufferRecord[BufferIdx(target)];
+		RDCASSERT(record);
+
+		SCOPED_SERIALISE_CONTEXT(BUFFERSUBDATA);
+		Serialise_glNamedBufferSubDataEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name,
+																      offset, size, data);
+
+		Chunk *chunk = scope.Get();
+
+		if(m_State == WRITING_CAPFRAME)
+			m_ContextRecord->AddChunk(chunk);
+		else
+			record->AddChunk(chunk);
+	}
+}
+
+bool WrappedOpenGL::Serialise_glNamedCopyBufferSubDataEXT(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
+{
+	SERIALISE_ELEMENT(ResourceId, readid, GetResourceManager()->GetID(BufferRes(readBuffer)));
+	SERIALISE_ELEMENT(ResourceId, writeid, GetResourceManager()->GetID(BufferRes(writeBuffer)));
+	SERIALISE_ELEMENT(uint64_t, ReadOffset, (uint64_t)readOffset);
+	SERIALISE_ELEMENT(uint64_t, WriteOffset, (uint64_t)writeOffset);
+	SERIALISE_ELEMENT(uint64_t, Bytesize, (uint64_t)size);
+	
+	if(m_State < WRITING)
+	{
+		GLResource readres = GetResourceManager()->GetLiveResource(readid);
+		GLResource writeres = GetResourceManager()->GetLiveResource(writeid);
+		m_Real.glNamedCopyBufferSubDataEXT(readres.name, writeres.name, (GLintptr)ReadOffset, (GLintptr)WriteOffset, (GLsizeiptr)Bytesize);
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glNamedCopyBufferSubDataEXT(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
+{
+	m_Real.glNamedCopyBufferSubDataEXT(readBuffer, writeBuffer, readOffset, writeOffset, size);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *readrecord = GetResourceManager()->GetResourceRecord(BufferRes(readBuffer));
+		GLResourceRecord *writerecord = GetResourceManager()->GetResourceRecord(BufferRes(writeBuffer));
+		RDCASSERT(readrecord && writerecord);
+
+		SCOPED_SERIALISE_CONTEXT(COPYBUFFERSUBDATA);
+		Serialise_glNamedCopyBufferSubDataEXT(readBuffer, writeBuffer, readOffset, writeOffset, size);
+
+		Chunk *chunk = scope.Get();
+
+		if(m_State == WRITING_CAPFRAME)
+		{
+			m_ContextRecord->AddChunk(chunk);
+		}
+		else
+		{
+			writerecord->AddChunk(chunk);
+			writerecord->AddParent(readrecord);
+		}
+	}
+}
+
+void WrappedOpenGL::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
+{
+	m_Real.glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *readrecord = m_BufferRecord[BufferIdx(readTarget)];
+		GLResourceRecord *writerecord = m_BufferRecord[BufferIdx(writeTarget)];
+		RDCASSERT(readrecord && writerecord);
+
+		SCOPED_SERIALISE_CONTEXT(COPYBUFFERSUBDATA);
+		Serialise_glNamedCopyBufferSubDataEXT(GetResourceManager()->GetCurrentResource(readrecord->GetResourceID()).name,
+																          GetResourceManager()->GetCurrentResource(writerecord->GetResourceID()).name,
+																          readOffset, writeOffset, size);
+
+		Chunk *chunk = scope.Get();
+
+		if(m_State == WRITING_CAPFRAME)
+		{
+			m_ContextRecord->AddChunk(chunk);
+		}
+		else
+		{
+			writerecord->AddChunk(chunk);
+			writerecord->AddParent(readrecord);
+		}
+	}
+}
+
 bool WrappedOpenGL::Serialise_glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 {
 	SERIALISE_ELEMENT(GLenum, Target, target);

renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp

@@ -271,6 +271,70 @@ void WrappedOpenGL::glGenerateMipmap(GLenum target)
 	}
 }
 
+bool WrappedOpenGL::Serialise_glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ,
+												                         GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ,
+												                         GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
+{
+	SERIALISE_ELEMENT(ResourceId, srcid, GetResourceManager()->GetID(BufferRes(srcName)));
+	SERIALISE_ELEMENT(ResourceId, dstid, GetResourceManager()->GetID(BufferRes(dstName)));
+	SERIALISE_ELEMENT(GLenum, SourceTarget, srcTarget);
+	SERIALISE_ELEMENT(GLenum, DestTarget, dstTarget);
+	SERIALISE_ELEMENT(uint32_t, SourceLevel, srcLevel);
+	SERIALISE_ELEMENT(uint32_t, SourceX, srcX);
+	SERIALISE_ELEMENT(uint32_t, SourceY, srcY);
+	SERIALISE_ELEMENT(uint32_t, SourceZ, srcZ);
+	SERIALISE_ELEMENT(uint32_t, SourceWidth, srcWidth);
+	SERIALISE_ELEMENT(uint32_t, SourceHeight, srcHeight);
+	SERIALISE_ELEMENT(uint32_t, SourceDepth, srcDepth);
+	SERIALISE_ELEMENT(uint32_t, DestLevel, dstLevel);
+	SERIALISE_ELEMENT(uint32_t, DestX, dstX);
+	SERIALISE_ELEMENT(uint32_t, DestY, dstY);
+	SERIALISE_ELEMENT(uint32_t, DestZ, dstZ);
+	
+	if(m_State < WRITING)
+	{
+		GLResource srcres = GetResourceManager()->GetLiveResource(srcid);
+		GLResource dstres = GetResourceManager()->GetLiveResource(dstid);
+		m_Real.glCopyImageSubData(srcres.name, SourceTarget, SourceLevel, SourceX, SourceY, SourceZ,
+															dstres.name, DestTarget, DestLevel, DestX, DestY, DestZ,
+															SourceWidth, SourceHeight, SourceDepth);
+	}
+	return true;
+}
+
+void WrappedOpenGL::glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ,
+												               GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ,
+												               GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
+{
+	m_Real.glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ,
+												    dstName, dstTarget, dstLevel, dstX, dstY, dstZ,
+												    srcWidth, srcHeight, srcDepth);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *srcrecord = GetResourceManager()->GetResourceRecord(TextureRes(srcName));
+		GLResourceRecord *dstrecord = GetResourceManager()->GetResourceRecord(TextureRes(dstName));
+		RDCASSERT(srcrecord && dstrecord);
+
+		SCOPED_SERIALISE_CONTEXT(COPY_SUBIMAGE);
+		Serialise_glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ,
+												         dstName, dstTarget, dstLevel, dstX, dstY, dstZ,
+												         srcWidth, srcHeight, srcDepth);
+
+		Chunk *chunk = scope.Get();
+
+		if(m_State == WRITING_CAPFRAME)
+		{
+			m_ContextRecord->AddChunk(chunk);
+		}
+		else
+		{
+			dstrecord->AddChunk(chunk);
+			dstrecord->AddParent(srcrecord);
+		}
+	}
+}
+
 bool WrappedOpenGL::Serialise_glTextureParameteriEXT(GLuint texture, GLenum target, GLenum pname, GLint param)
 {
 	SERIALISE_ELEMENT(GLenum, Target, target);
@@ -1215,4 +1279,57 @@ void WrappedOpenGL::glCompressedTexSubImage3D(GLenum target, GLint level, GLint
 	}
 }
 
+bool WrappedOpenGL::Serialise_glTextureBufferRangeEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
+{
+	SERIALISE_ELEMENT(GLenum, Target, target);
+	SERIALISE_ELEMENT(uint64_t, offs, (uint64_t)offset);
+	SERIALISE_ELEMENT(uint64_t, Size, (uint64_t)size);
+	SERIALISE_ELEMENT(GLenum, fmt, internalformat);
+	SERIALISE_ELEMENT(ResourceId, texid, GetResourceManager()->GetID(TextureRes(texture)));
+	SERIALISE_ELEMENT(ResourceId, bufid, GetResourceManager()->GetID(TextureRes(buffer)));
+	
+	if(m_State == READING)
+	{
+		m_Real.glTextureBufferRangeEXT(GetResourceManager()->GetLiveResource(texid).name,
+																	 Target, fmt,
+																	 GetResourceManager()->GetLiveResource(bufid).name,
+																	 (GLintptr)offs, (GLsizeiptr)Size);
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glTextureBufferRangeEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
+{
+	m_Real.glTextureBufferRangeEXT(texture, target, internalformat, buffer, offset, size);
+		
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = GetResourceManager()->GetResourceRecord(TextureRes(texture));
+		RDCASSERT(record);
+
+		SCOPED_SERIALISE_CONTEXT(TEXBUFFER_RANGE);
+		Serialise_glTextureBufferRangeEXT(texture, target, internalformat, buffer, offset, size);
+
+		record->AddChunk(scope.Get());
+	}
+}
+
+void WrappedOpenGL::glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
+{
+	m_Real.glTexBufferRange(target, internalformat, buffer, offset, size);
+		
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = m_TextureRecord[m_TextureUnit];
+		RDCASSERT(record);
+
+		SCOPED_SERIALISE_CONTEXT(TEXBUFFER_RANGE);
+		Serialise_glTextureBufferRangeEXT(GetResourceManager()->GetCurrentResource(record->GetResourceID()).name,
+																		  target, internalformat, buffer, offset, size);
+
+		record->AddChunk(scope.Get());
+	}
+}
+
 #pragma endregion

renderdoc/hooks/gl_linux_hooks.cpp

@@ -101,67 +101,96 @@ typedef void (*PFNGLXSWAPBUFFERSPROC)(Display *dpy, GLXDrawable drawable);
 	extern "C" __attribute__ ((visibility ("default"))) \
 	ret function() \
 	{ return OpenGLHook::glhooks.GetDriver()->function(); }
+
 #define HookWrapper1(ret, function, t1, p1) \
 	typedef ret (*CONCAT(function, _hooktype)) (t1); \
 	extern "C" __attribute__ ((visibility ("default"))) \
 	ret function(t1 p1) \
 	{ return OpenGLHook::glhooks.GetDriver()->function(p1); }
+
 #define HookWrapper2(ret, function, t1, p1, t2, p2) \
 	typedef ret (*CONCAT(function, _hooktype)) (t1, t2); \
 	extern "C" __attribute__ ((visibility ("default"))) \
 	ret function(t1 p1, t2 p2) \
 	{ return OpenGLHook::glhooks.GetDriver()->function(p1, p2); }
+
 #define HookWrapper3(ret, function, t1, p1, t2, p2, t3, p3) \
 	typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3); \
 	extern "C" __attribute__ ((visibility ("default"))) \
 	ret function(t1 p1, t2 p2, t3 p3) \
 	{ return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3); }
+
 #define HookWrapper4(ret, function, t1, p1, t2, p2, t3, p3, t4, p4) \
 	typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4); \
 	extern "C" __attribute__ ((visibility ("default"))) \
 	ret function(t1 p1, t2 p2, t3 p3, t4 p4) \
 	{ return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4); }
+
 #define HookWrapper5(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5) \
 	typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5); \
 	extern "C" __attribute__ ((visibility ("default"))) \
 	ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5) \
 	{ return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5); }
+
 #define HookWrapper6(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6) \
 	typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6); \
 	extern "C" __attribute__ ((visibility ("default"))) \
 	ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6) \
 	{ return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6); }
+
 #define HookWrapper7(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7) \
 	typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7); \
 	extern "C" __attribute__ ((visibility ("default"))) \
 	ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7) \
 	{ return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7); }
+
 #define HookWrapper8(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8) \
 	typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8); \
 	extern "C" __attribute__ ((visibility ("default"))) \
 	ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8) \
 	{ return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8); }
+
 #define HookWrapper9(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9) \
 	typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9); \
 	extern "C" __attribute__ ((visibility ("default"))) \
 	ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9) \
 	{ return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9); }
+
 #define HookWrapper10(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10) \
 	typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10); \
 	extern "C" __attribute__ ((visibility ("default"))) \
 	ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10) \
 	{ return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
+
 #define HookWrapper11(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11) \
 	typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11); \
 	extern "C" __attribute__ ((visibility ("default"))) \
 	ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11) \
 	{ return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); }
-#define HookWrapper11(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12 p12) \
+
+#define HookWrapper12(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12, p12) \
 	typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12); \
 	extern "C" __attribute__ ((visibility ("default"))) \
 	ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11, t12 p12) \
 	{ return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); }
 
+#define HookWrapper13(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12, p12, t13, p13) \
+	typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13); \
+	extern "C" __attribute__ ((visibility ("default"))) \
+	ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11, t12 p12, t13 p13) \
+	{ return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); }
+
+#define HookWrapper14(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12, p12, t13, p13, t14, p14) \
+	typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14); \
+	extern "C" __attribute__ ((visibility ("default"))) \
+	ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11, t12 p12, t13 p13, t14 p14) \
+	{ return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); }
+
+#define HookWrapper15(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12, p12, t13, p13, t14, p14, t15, p15) \
+	typedef ret (*CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15); \
+	extern "C" __attribute__ ((visibility ("default"))) \
+	ret function(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11, t12 p12, t13 p13, t14 p14, t15 p15) \
+	{ return OpenGLHook::glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); }
 
 class OpenGLHook : LibraryHook
 {
@@ -412,3 +441,4 @@ bool OpenGLHook::PopulateHooks()
 OpenGLHook OpenGLHook::glhooks;
 
 const GLHookSet &GetRealFunctions() { return OpenGLHook::glhooks.GetRealFunctions(); }
+

renderdoc/hooks/gl_win32_hooks.cpp

@@ -94,82 +94,101 @@
 #endif
 
 #define HookWrapper0(ret, function) \
-        Hook<ret (WINAPI *) ()> CONCAT(function, _hook); \
-        typedef ret (WINAPI *CONCAT(function, _hooktype)) (); \
-        static ret WINAPI CONCAT(function, _hooked)() \
-        { return glhooks.GetDriver()->function(); }
+	Hook<ret (WINAPI *) ()> CONCAT(function, _hook); \
+	typedef ret (WINAPI *CONCAT(function, _hooktype)) (); \
+	static ret WINAPI CONCAT(function, _hooked)() \
+	{ return glhooks.GetDriver()->function(); }
 
 #define HookWrapper1(ret, function, t1, p1) \
-        Hook<ret (WINAPI *) (t1)> CONCAT(function, _hook); \
-        typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1); \
-        static ret WINAPI CONCAT(function, _hooked)(t1 p1) \
-        { return glhooks.GetDriver()->function(p1); }
+	Hook<ret (WINAPI *) (t1)> CONCAT(function, _hook); \
+	typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1); \
+	static ret WINAPI CONCAT(function, _hooked)(t1 p1) \
+	{ return glhooks.GetDriver()->function(p1); }
 
 #define HookWrapper2(ret, function, t1, p1, t2, p2) \
-        Hook<ret (WINAPI *) (t1, t2)> CONCAT(function, _hook); \
-        typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2); \
-        static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2) \
-        { return glhooks.GetDriver()->function(p1, p2); }
+	Hook<ret (WINAPI *) (t1, t2)> CONCAT(function, _hook); \
+	typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2); \
+	static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2) \
+	{ return glhooks.GetDriver()->function(p1, p2); }
 
 #define HookWrapper3(ret, function, t1, p1, t2, p2, t3, p3) \
-        Hook<ret (WINAPI *) (t1, t2, t3)> CONCAT(function, _hook); \
-        typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3); \
-        static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3) \
-        { return glhooks.GetDriver()->function(p1, p2, p3); }
+	Hook<ret (WINAPI *) (t1, t2, t3)> CONCAT(function, _hook); \
+	typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3); \
+	static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3) \
+	{ return glhooks.GetDriver()->function(p1, p2, p3); }
 
 #define HookWrapper4(ret, function, t1, p1, t2, p2, t3, p3, t4, p4) \
-        Hook<ret (WINAPI *) (t1, t2, t3, t4)> CONCAT(function, _hook); \
-        typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4); \
-        static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4) \
-        { return glhooks.GetDriver()->function(p1, p2, p3, p4); }
+	Hook<ret (WINAPI *) (t1, t2, t3, t4)> CONCAT(function, _hook); \
+	typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4); \
+	static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4) \
+	{ return glhooks.GetDriver()->function(p1, p2, p3, p4); }
 
 #define HookWrapper5(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5) \
-        Hook<ret (WINAPI *) (t1, t2, t3, t4, t5)> CONCAT(function, _hook); \
-        typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5); \
-        static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5) \
-        { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5); }
+	Hook<ret (WINAPI *) (t1, t2, t3, t4, t5)> CONCAT(function, _hook); \
+	typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5); \
+	static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5) \
+	{ return glhooks.GetDriver()->function(p1, p2, p3, p4, p5); }
 
 #define HookWrapper6(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6) \
-        Hook<ret (WINAPI *) (t1, t2, t3, t4, t5, t6)> CONCAT(function, _hook); \
-        typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6); \
-        static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6) \
-        { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6); }
+	Hook<ret (WINAPI *) (t1, t2, t3, t4, t5, t6)> CONCAT(function, _hook); \
+	typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6); \
+	static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6) \
+	{ return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6); }
 
 #define HookWrapper7(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7) \
-        Hook<ret (WINAPI *) (t1, t2, t3, t4, t5, t6, t7)> CONCAT(function, _hook); \
-        typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7); \
-        static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7) \
-        { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7); }
+	Hook<ret (WINAPI *) (t1, t2, t3, t4, t5, t6, t7)> CONCAT(function, _hook); \
+	typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7); \
+	static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7) \
+	{ return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7); }
 
 #define HookWrapper8(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8) \
-        Hook<ret (WINAPI *) (t1, t2, t3, t4, t5, t6, t7, t8)> CONCAT(function, _hook); \
-        typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8); \
-        static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8) \
-        { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8); }
+	Hook<ret (WINAPI *) (t1, t2, t3, t4, t5, t6, t7, t8)> CONCAT(function, _hook); \
+	typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8); \
+	static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8) \
+	{ return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8); }
 
 #define HookWrapper9(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9) \
-        Hook<ret (WINAPI *) (t1, t2, t3, t4, t5, t6, t7, t8, t9)> CONCAT(function, _hook); \
-        typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9); \
-        static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9) \
-        { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9); }
+	Hook<ret (WINAPI *) (t1, t2, t3, t4, t5, t6, t7, t8, t9)> CONCAT(function, _hook); \
+	typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9); \
+	static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9) \
+	{ return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9); }
 
 #define HookWrapper10(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10) \
-        Hook<ret (WINAPI *) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)> CONCAT(function, _hook); \
-        typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10); \
-        static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10) \
-        { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
+	Hook<ret (WINAPI *) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)> CONCAT(function, _hook); \
+	typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10); \
+	static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10) \
+	{ return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }
 
 #define HookWrapper11(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11) \
-        Hook<ret (WINAPI *) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11)> CONCAT(function, _hook); \
-        typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11); \
-        static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11) \
-        { return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); }
+	Hook<ret (WINAPI *) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11)> CONCAT(function, _hook); \
+	typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11); \
+	static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11) \
+	{ return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); }
 
 #define HookWrapper12(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12, p12) \
-        Hook<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); }
+	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); }
+
+#define HookWrapper13(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12, p12, t13, p13) \
+	Hook<ret (WINAPI *) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13)> CONCAT(function, _hook); \
+	typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13); \
+	static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11, t12 p12, t13 p13) \
+	{ return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); }
+
+#define HookWrapper14(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12, p12, t13, p13, t14, p14) \
+	Hook<ret (WINAPI *) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14)> CONCAT(function, _hook); \
+	typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14); \
+	static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11, t12 p12, t13 p13, t14 p14) \
+	{ return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); }
+
+#define HookWrapper15(ret, function, t1, p1, t2, p2, t3, p3, t4, p4, t5, p5, t6, p6, t7, p7, t8, p8, t9, p9, t10, p10, t11, p11, t12, p12, t13, p13, t14, p14, t15, p15) \
+	Hook<ret (WINAPI *) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15)> CONCAT(function, _hook); \
+	typedef ret (WINAPI *CONCAT(function, _hooktype)) (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15); \
+	static ret WINAPI CONCAT(function, _hooked)(t1 p1, t2 p2, t3 p3, t4 p4, t5 p5, t6 p6, t7 p7, t8 p8, t9 p9, t10 p10, t11 p11, t12 p12, t13 p13, t14 p14, t15 p15) \
+	{ return glhooks.GetDriver()->function(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); }
+
 
 class OpenGLHook : LibraryHook
 {