Implement some multi-binding functions.

renderdoc/driver/gl/gl_common.h

@@ -90,7 +90,9 @@ enum GLChunkType
 
 	GEN_TEXTURE,
 	BIND_TEXTURE,
+	BIND_TEXTURES,
 	BIND_IMAGE_TEXTURE,
+	BIND_IMAGE_TEXTURES,
 	ACTIVE_TEXTURE,
 	TEXSTORAGE1D,
 	TEXSTORAGE2D,
@@ -208,8 +210,8 @@ enum GLChunkType
 	VIEWPORT_ARRAY,
 	SCISSOR,
 	SCISSOR_ARRAY,
-	BINDVERTEXARRAY,
-	BINDVERTEXBUFFER,
+	BIND_VERTEXBUFFER,
+	BIND_VERTEXBUFFERS,
 	VERTEXBINDINGDIVISOR,
 	DISPATCH_COMPUTE,
 	DISPATCH_COMPUTE_INDIRECT,
@@ -254,11 +256,14 @@ enum GLChunkType
 	SAMPLER_PARAMETERIIV,
 	SAMPLER_PARAMETERIUIV,
 	BIND_SAMPLER,
+	BIND_SAMPLERS,
 
 	GEN_BUFFER,
 	BIND_BUFFER,
 	BIND_BUFFER_BASE,
 	BIND_BUFFER_RANGE,
+	BIND_BUFFERS_BASE,
+	BIND_BUFFERS_RANGE,
 	BUFFERSTORAGE,
 	BUFFERDATA,
 	BUFFERSUBDATA,

renderdoc/driver/gl/gl_driver.cpp

@@ -43,7 +43,9 @@ const char *GLChunkNames[] =
 
 	"glGenTextures",
 	"glBindTexture",
+	"glBindTextures",
 	"glBindImageTexture",
+	"glBindImageTextures",
 	"glActiveTexture",
 	"glTexStorage1D",
 	"glTexStorage2D",
@@ -115,6 +117,8 @@ const char *GLChunkNames[] =
 	"glClearBufferfi",
 	"glClearBufferData",
 	"glClearBufferSubData",
+	"glClearTexImage",
+	"glClearTexSubImage",
 	"glPolygonMode",
 	"glPolygonOffset",
 	"glCullFace",
@@ -159,8 +163,8 @@ const char *GLChunkNames[] =
 	"glViewportArrayv",
 	"glScissor",
 	"glScissorArrayv",
-	"glBindVertexArray",
 	"glBindVertexBuffer",
+	"glBindVertexBuffers",
 	"glVertexBindingDivisor",
 	"glDispatchCompute",
 	"glDispatchComputeIndirect",
@@ -205,11 +209,14 @@ const char *GLChunkNames[] =
 	"glSamplerParameterIiv",
 	"glSamplerParameterIuiv",
 	"glBindSampler",
+	"glBindSamplers",
 
 	"glGenBuffers",
 	"glBindBuffer",
 	"glBindBufferBase",
 	"glBindBufferRange",
+	"glBindBuffersBase",
+	"glBindBuffersRange",
 	"glBufferStorage",
 	"glBufferData",
 	"glBufferSubData",
@@ -1534,9 +1541,15 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 	case BIND_TEXTURE:
 		Serialise_glBindTexture(eGL_NONE, 0);
 		break;
+	case BIND_TEXTURES:
+		Serialise_glBindTextures(0, 0, NULL);
+		break;
 	case BIND_IMAGE_TEXTURE:
 		Serialise_glBindImageTexture(0, 0, 0, 0, 0, eGL_NONE, eGL_NONE);
 		break;
+	case BIND_IMAGE_TEXTURES:
+		Serialise_glBindImageTextures(0, 0, NULL);
+		break;
 	case TEXSTORAGE1D:
 		Serialise_glTextureStorage1DEXT(0, eGL_NONE, 0, eGL_NONE, 0);
 		break;
@@ -1871,12 +1884,12 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 	case SCISSOR_ARRAY:
 		Serialise_glScissorArrayv(0, 0, 0);
 		break;
-	case BINDVERTEXARRAY:
-		Serialise_glBindVertexArray(0);
-		break;
-	case BINDVERTEXBUFFER:
+	case BIND_VERTEXBUFFER:
 		Serialise_glBindVertexBuffer(0, 0, 0, 0);
 		break;
+	case BIND_VERTEXBUFFERS:
+		Serialise_glBindVertexBuffers(0, 0, NULL, NULL, NULL);
+		break;
 	case VERTEXBINDINGDIVISOR:
 		Serialise_glVertexBindingDivisor(0, 0);
 		break;
@@ -2003,6 +2016,9 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 	case BIND_SAMPLER:
 		Serialise_glBindSampler(0, 0);
 		break;
+	case BIND_SAMPLERS:
+		Serialise_glBindSamplers(0, 0, NULL);
+		break;
 		
 	case GEN_BUFFER:
 		Serialise_glGenBuffers(0, NULL);
@@ -2016,6 +2032,12 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 	case BIND_BUFFER_RANGE:
 		Serialise_glBindBufferRange(eGL_NONE, 0, 0, 0, 0);
 		break;
+	case BIND_BUFFERS_BASE:
+		Serialise_glBindBuffersBase(eGL_NONE, 0, 0, NULL);
+		break;
+	case BIND_BUFFERS_RANGE:
+		Serialise_glBindBuffersRange(eGL_NONE, 0, 0, NULL, NULL, NULL);
+		break;
 	case BUFFERSTORAGE:
 		Serialise_glNamedBufferStorageEXT(0, 0, NULL, 0);
 		break;

renderdoc/driver/gl/gl_driver.h

@@ -329,7 +329,9 @@ class WrappedOpenGL
 		void Present(void *windowHandle);
 
 		IMPLEMENT_FUNCTION_SERIALISED(void, glBindTexture(GLenum target, GLuint texture));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glBindTextures(GLuint first, GLsizei count, const GLuint *textures));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glBindImageTextures(GLuint first, GLsizei count, const GLuint *textures));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glBlendFunc(GLenum sfactor, GLenum dfactor));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glBlendFunci(GLuint buf, GLenum sfactor, GLenum dfactor));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha));
@@ -394,6 +396,7 @@ class WrappedOpenGL
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTexParameteriv(GLenum target, GLenum pname, const GLint *params));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glGenSamplers(GLsizei count, GLuint *samplers));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glBindSampler(GLuint unit, GLuint sampler));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glDeleteSamplers(GLsizei n, const GLuint *ids));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glSamplerParameteri(GLuint sampler, GLenum pname, GLint param));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param));
@@ -509,6 +512,8 @@ class WrappedOpenGL
 		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, glBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint *buffers));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes));
 		IMPLEMENT_FUNCTION_SERIALISED(void *, glMapBuffer(GLenum target, GLenum access));
 		IMPLEMENT_FUNCTION_SERIALISED(void *, glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length));
@@ -523,6 +528,8 @@ class WrappedOpenGL
 		IMPLEMENT_FUNCTION_SERIALISED(void, glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void *data));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glClearTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data));
 
 		enum AttribType
 		{
@@ -630,6 +637,7 @@ class WrappedOpenGL
 		IMPLEMENT_FUNCTION_SERIALISED(void, glGenVertexArrays(GLsizei n, GLuint *arrays));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glBindVertexArray(GLuint array));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glBindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glVertexBindingDivisor(GLuint bindingindex, GLuint divisor));
 
 		IMPLEMENT_FUNCTION_SERIALISED(GLboolean, glIsEnabled(GLenum cap));

renderdoc/driver/gl/gl_hookset.h

@@ -313,6 +313,8 @@ struct GLHookSet
 	PFNGLCOPYBUFFERSUBDATAPROC glCopyBufferSubData;
 	PFNGLBINDBUFFERBASEPROC glBindBufferBase;
 	PFNGLBINDBUFFERRANGEPROC glBindBufferRange;
+	PFNGLBINDBUFFERSBASEPROC glBindBuffersBase;
+	PFNGLBINDBUFFERSRANGEPROC glBindBuffersRange;
 	PFNGLMAPBUFFERPROC glMapBuffer;
 	PFNGLMAPBUFFERRANGEPROC glMapBufferRange;
 	PFNGLFLUSHMAPPEDBUFFERRANGEPROC glFlushMappedBufferRange;
@@ -406,10 +408,14 @@ struct GLHookSet
 	PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray;
 	PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray;
 	PFNGLBINDVERTEXBUFFERPROC glBindVertexBuffer;
+	PFNGLBINDVERTEXBUFFERSPROC glBindVertexBuffers;
 	PFNGLVERTEXBINDINGDIVISORPROC glVertexBindingDivisor;
 	PFNGLBINDIMAGETEXTUREPROC glBindImageTexture;
+	PFNGLBINDIMAGETEXTURESPROC glBindImageTextures;
 	PFNGLGENSAMPLERSPROC glGenSamplers;
 	PFNGLBINDSAMPLERPROC glBindSampler;
+	PFNGLBINDSAMPLERSPROC glBindSamplers;
+	PFNGLBINDTEXTURESPROC glBindTextures;
 	PFNGLDELETESAMPLERSPROC glDeleteSamplers;
 	PFNGLSAMPLERPARAMETERIPROC glSamplerParameteri;
 	PFNGLSAMPLERPARAMETERFPROC glSamplerParameterf;

renderdoc/driver/gl/gl_hookset_defs.h

@@ -332,6 +332,8 @@
     HookExtension(PFNGLCOPYBUFFERSUBDATAPROC, glCopyBufferSubData); \
     HookExtension(PFNGLBINDBUFFERBASEPROC, glBindBufferBase); \
     HookExtension(PFNGLBINDBUFFERRANGEPROC, glBindBufferRange); \
+    HookExtension(PFNGLBINDBUFFERSBASEPROC, glBindBuffersBase); \
+    HookExtension(PFNGLBINDBUFFERSRANGEPROC, glBindBuffersRange); \
     HookExtension(PFNGLMAPBUFFERPROC, glMapBuffer); \
     HookExtension(PFNGLMAPBUFFERRANGEPROC, glMapBufferRange); \
     HookExtension(PFNGLFLUSHMAPPEDBUFFERRANGEPROC, glFlushMappedBufferRange); \
@@ -425,10 +427,14 @@
     HookExtension(PFNGLENABLEVERTEXATTRIBARRAYPROC, glEnableVertexAttribArray); \
     HookExtension(PFNGLDISABLEVERTEXATTRIBARRAYPROC, glDisableVertexAttribArray); \
     HookExtension(PFNGLBINDVERTEXBUFFERPROC, glBindVertexBuffer); \
+    HookExtension(PFNGLBINDVERTEXBUFFERSPROC, glBindVertexBuffers); \
     HookExtension(PFNGLVERTEXBINDINGDIVISORPROC, glVertexBindingDivisor); \
     HookExtension(PFNGLBINDIMAGETEXTUREPROC, glBindImageTexture); \
+    HookExtension(PFNGLBINDIMAGETEXTURESPROC, glBindImageTextures); \
     HookExtension(PFNGLGENSAMPLERSPROC, glGenSamplers); \
     HookExtension(PFNGLBINDSAMPLERPROC, glBindSampler); \
+    HookExtension(PFNGLBINDSAMPLERSPROC, glBindSamplers); \
+    HookExtension(PFNGLBINDTEXTURESPROC, glBindTextures); \
     HookExtension(PFNGLDELETESAMPLERSPROC, glDeleteSamplers); \
     HookExtension(PFNGLSAMPLERPARAMETERIPROC, glSamplerParameteri); \
     HookExtension(PFNGLSAMPLERPARAMETERFPROC, glSamplerParameterf); \
@@ -961,6 +967,8 @@
     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); \
+    HookWrapper4(void, glBindBuffersBase, GLenum, target, GLuint, first, GLsizei, count, const GLuint *, buffers); \
+    HookWrapper6(void, glBindBuffersRange, GLenum, target, GLuint, first, GLsizei, count, const GLuint *, buffers, const GLintptr *, offsets, const GLsizeiptr *, sizes); \
     HookWrapper2(void *, glMapBuffer, GLenum, target, GLenum, access); \
     HookWrapper4(void *, glMapBufferRange, GLenum, target, GLintptr, offset, GLsizeiptr, length, GLbitfield, access); \
     HookWrapper3(void, glFlushMappedBufferRange, GLenum, target, GLintptr, offset, GLsizeiptr, length); \
@@ -1054,10 +1062,14 @@
     HookWrapper1(void, glEnableVertexAttribArray, GLuint, index); \
     HookWrapper1(void, glDisableVertexAttribArray, GLuint, index); \
     HookWrapper4(void, glBindVertexBuffer, GLuint, bindingindex, GLuint, buffer, GLintptr, offset, GLsizei, stride); \
+    HookWrapper5(void, glBindVertexBuffers, GLuint, first, GLsizei, count, const GLuint *, buffers, const GLintptr *, offsets, const GLsizei *, strides); \
     HookWrapper2(void, glVertexBindingDivisor, GLuint, bindingindex, GLuint, divisor); \
     HookWrapper7(void, glBindImageTexture, GLuint, unit, GLuint, texture, GLint, level, GLboolean, layered, GLint, layer, GLenum, access, GLenum, format); \
+    HookWrapper3(void, glBindImageTextures, GLuint, first, GLsizei, count, const GLuint *, textures); \
     HookWrapper2(void, glGenSamplers, GLsizei, count, GLuint *, samplers); \
     HookWrapper2(void, glBindSampler, GLuint, unit, GLuint, sampler); \
+    HookWrapper3(void, glBindSamplers, GLuint, first, GLsizei, count, const GLuint *, samplers); \
+    HookWrapper3(void, glBindTextures, GLuint, first, GLsizei, count, const GLuint *, textures); \
     HookWrapper2(void, glDeleteSamplers, GLsizei, count, const GLuint *, samplers); \
     HookWrapper3(void, glSamplerParameteri, GLuint, sampler, GLenum, pname, GLint, param); \
     HookWrapper3(void, glSamplerParameterf, GLuint, sampler, GLenum, pname, GLfloat, param); \

renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp

@@ -563,7 +563,7 @@ bool WrappedOpenGL::Serialise_glBindBufferBase(GLenum target, GLuint index, GLui
 
 void WrappedOpenGL::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 {
-	if(m_State >= WRITING)
+	if(m_State >= WRITING && index == 0)
 	{
 		size_t idx = BufferIdx(target);
 
@@ -610,7 +610,7 @@ bool WrappedOpenGL::Serialise_glBindBufferRange(GLenum target, GLuint index, GLu
 
 void WrappedOpenGL::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-	if(m_State >= WRITING)
+	if(m_State >= WRITING && index == 0)
 	{
 		size_t idx = BufferIdx(target);
 
@@ -631,6 +631,130 @@ void WrappedOpenGL::glBindBufferRange(GLenum target, GLuint index, GLuint buffer
 	m_Real.glBindBufferRange(target, index, buffer, offset, size);
 }
 
+bool WrappedOpenGL::Serialise_glBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint *buffers)
+{
+	SERIALISE_ELEMENT(GLenum, Target, target);
+	SERIALISE_ELEMENT(uint32_t, First, first);
+	SERIALISE_ELEMENT(int32_t, Count, count);
+
+	GLuint *bufs = NULL;
+	if(m_State <= EXECUTING) bufs = new GLuint[Count];
+	
+	for(int32_t i=0; i < Count; i++)
+	{
+		SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(BufferRes(GetCtx(), buffers[i])));
+		
+		if(m_State <= EXECUTING)
+		{
+			if(id != ResourceId())
+				bufs[i] = GetResourceManager()->GetLiveResource(id).name;
+			else
+				bufs[i] = 0;
+		}
+	}
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glBindBuffersBase(Target, First, Count, bufs);
+
+		delete[] bufs;
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint *buffers)
+{
+	m_Real.glBindBuffersBase(target, first, count, buffers);
+
+	if(m_State >= WRITING && first == 0 && count > 0)
+	{
+		size_t idx = BufferIdx(target);
+
+		if(buffers[0] == 0)
+			m_BufferRecord[idx] = NULL;
+		else
+			m_BufferRecord[idx] = GetResourceManager()->GetResourceRecord(BufferRes(GetCtx(), buffers[0]));
+	}
+
+	if(m_State == WRITING_CAPFRAME)
+	{
+		SCOPED_SERIALISE_CONTEXT(BIND_BUFFERS_BASE);
+		Serialise_glBindBuffersBase(target, first, count, buffers);
+
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+}
+
+bool WrappedOpenGL::Serialise_glBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes)
+{
+	SERIALISE_ELEMENT(GLenum, Target, target);
+	SERIALISE_ELEMENT(uint32_t, First, first);
+	SERIALISE_ELEMENT(int32_t, Count, count);
+	
+	GLuint *bufs = NULL;
+	GLintptr *offs = NULL;
+	GLsizeiptr *sz = NULL;
+	
+	if(m_State <= EXECUTING)
+	{
+		bufs = new GLuint[Count];
+		offs = new GLintptr[Count];
+		sz = new GLsizeiptr[Count];
+	}
+	
+	for(int32_t i=0; i < Count; i++)
+	{
+		SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(BufferRes(GetCtx(), buffers[i])));
+		SERIALISE_ELEMENT(uint64_t, offset, (uint64_t)offsets[i]);
+		SERIALISE_ELEMENT(uint64_t, size, (uint64_t)sizes[i]);
+		
+		if(m_State <= EXECUTING)
+		{
+			if(id != ResourceId())
+				bufs[i] = GetResourceManager()->GetLiveResource(id).name;
+			else
+				bufs[i] = 0;
+			offs[i] = (GLintptr)offset;
+			sz[i] = (GLsizeiptr)sizes;
+		}
+	}
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glBindBuffersRange(Target, First, Count, bufs, offs, sz);
+
+		delete[] bufs;
+		delete[] offs;
+		delete[] sz;
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes)
+{
+	m_Real.glBindBuffersRange(target, first, count, buffers, offsets, sizes);
+
+	if(m_State >= WRITING && first == 0 && count > 0)
+	{
+		size_t idx = BufferIdx(target);
+
+		if(buffers[0] == 0)
+			m_BufferRecord[idx] = NULL;
+		else
+			m_BufferRecord[idx] = GetResourceManager()->GetResourceRecord(BufferRes(GetCtx(), buffers[0]));
+	}
+
+	if(m_State == WRITING_CAPFRAME)
+	{
+		SCOPED_SERIALISE_CONTEXT(BIND_BUFFERS_RANGE);
+		Serialise_glBindBuffersRange(target, first, count, buffers, offsets, sizes);
+
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+}
+
 #pragma endregion
 
 #pragma region Mapping
@@ -1699,7 +1823,7 @@ void WrappedOpenGL::glBindVertexArray(GLuint array)
 
 	if(m_State == WRITING_CAPFRAME)
 	{
-		SCOPED_SERIALISE_CONTEXT(BINDVERTEXARRAY);
+		SCOPED_SERIALISE_CONTEXT(BIND_VERTEXARRAY);
 		Serialise_glBindVertexArray(array);
 
 		m_ContextRecord->AddChunk(scope.Get());
@@ -1731,13 +1855,71 @@ void WrappedOpenGL::glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLint
 
 	if(m_State == WRITING_CAPFRAME)
 	{
-		SCOPED_SERIALISE_CONTEXT(BINDVERTEXBUFFER);
+		SCOPED_SERIALISE_CONTEXT(BIND_VERTEXBUFFER);
 		Serialise_glBindVertexBuffer(bindingindex, buffer, offset, stride);
 
 		m_ContextRecord->AddChunk(scope.Get());
 	}
 }
 
+bool WrappedOpenGL::Serialise_glBindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
+{
+	SERIALISE_ELEMENT(uint32_t, First, first);
+	SERIALISE_ELEMENT(int32_t, Count, count);
+
+	GLuint *bufs = NULL;
+	GLintptr *offs = NULL;
+	GLsizei *str = NULL;
+	
+	if(m_State <= EXECUTING)
+	{
+		bufs = new GLuint[Count];
+		offs = new GLintptr[Count];
+		str = new GLsizei[Count];
+	}
+	
+	for(int32_t i=0; i < Count; i++)
+	{
+		SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(BufferRes(GetCtx(), buffers[i])));
+		SERIALISE_ELEMENT(uint64_t, offset, (uint64_t)offsets[i]);
+		SERIALISE_ELEMENT(uint64_t, stride, (uint64_t)strides[i]);
+		
+		if(m_State <= EXECUTING)
+		{
+			if(id != ResourceId())
+				bufs[i] = GetResourceManager()->GetLiveResource(id).name;
+			else
+				bufs[i] = 0;
+			offs[i] = (GLintptr)offset;
+			str[i] = (GLsizei)stride;
+		}
+	}
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glBindVertexBuffers(First, Count, bufs, offs, str);
+
+		delete[] bufs;
+		delete[] offs;
+		delete[] str;
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glBindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
+{
+	m_Real.glBindVertexBuffers(first, count, buffers, offsets, strides);
+
+	if(m_State == WRITING_CAPFRAME)
+	{
+		SCOPED_SERIALISE_CONTEXT(BIND_VERTEXBUFFERS);
+		Serialise_glBindVertexBuffers(first, count, buffers, offsets, strides);
+
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+}
+
 bool WrappedOpenGL::Serialise_glVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
 {
 	SERIALISE_ELEMENT(uint32_t, idx, bindingindex);

renderdoc/driver/gl/wrappers/gl_sampler_funcs.cpp

@@ -110,6 +110,50 @@ void WrappedOpenGL::glBindSampler(GLuint unit, GLuint sampler)
 	}
 }
 
+bool WrappedOpenGL::Serialise_glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers)
+{
+	SERIALISE_ELEMENT(uint32_t, First, first);
+	SERIALISE_ELEMENT(int32_t, Count, count);
+
+	GLuint *samps = NULL;
+	if(m_State <= EXECUTING) samps = new GLuint[Count];
+	
+	for(int32_t i=0; i < Count; i++)
+	{
+		SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), samplers[i])));
+		
+		if(m_State <= EXECUTING)
+		{
+			if(id != ResourceId())
+				samps[i] = GetResourceManager()->GetLiveResource(id).name;
+			else
+				samps[i] = 0;
+		}
+	}
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glBindSamplers(First, Count, samps);
+
+		delete[] samps;
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers)
+{
+	m_Real.glBindSamplers(first, count, samplers);
+	
+	if(m_State >= WRITING)
+	{
+		SCOPED_SERIALISE_CONTEXT(BIND_SAMPLERS);
+		Serialise_glBindSamplers(first, count, samplers);
+		
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+}
+
 bool WrappedOpenGL::Serialise_glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
 {
 	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), sampler)));

renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp

@@ -176,6 +176,69 @@ void WrappedOpenGL::glBindTexture(GLenum target, GLuint texture)
 	}
 }
 
+bool WrappedOpenGL::Serialise_glBindTextures(GLuint first, GLsizei count, const GLuint *textures)
+{
+	SERIALISE_ELEMENT(uint32_t, First, first);
+	SERIALISE_ELEMENT(int32_t, Count, count);
+
+	GLuint *texs = NULL;
+	if(m_State <= EXECUTING) texs = new GLuint[Count];
+	
+	for(int32_t i=0; i < Count; i++)
+	{
+		SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(GetCtx(), textures[i])));
+		
+		if(m_State <= EXECUTING)
+		{
+			if(id != ResourceId())
+			{
+				texs[i] = GetResourceManager()->GetLiveResource(id).name;
+				if(m_State == READING)
+					m_Textures[GetResourceManager()->GetLiveID(id)].creationFlags |= eTextureCreate_SRV;
+			}
+			else
+			{
+				texs[i] = 0;
+			}
+		}
+	}
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glBindTextures(First, Count, texs);
+
+		delete[] texs;
+	}
+
+	return true;
+}
+
+// glBindTextures doesn't provide a target, so can't be used to "init" a texture from glGenTextures
+// which makes our lives a bit easier
+void WrappedOpenGL::glBindTextures(GLuint first, GLsizei count, const GLuint *textures)
+{
+	m_Real.glBindTextures(first, count, textures);
+
+	if(m_State == WRITING_CAPFRAME)
+	{
+		SCOPED_SERIALISE_CONTEXT(BIND_TEXTURES);
+		Serialise_glBindTextures(first, count, textures);
+
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+
+	if(m_State >= WRITING)
+	{
+		for(GLsizei i=0; i < count; i++)
+		{
+			if(textures[i] == 0)
+				m_TextureRecord[first + i] = 0;
+			else
+				m_TextureRecord[first + i] = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), textures[i]));
+		}
+	}
+}
+
 bool WrappedOpenGL::Serialise_glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
 {
 	SERIALISE_ELEMENT(uint32_t, Unit, unit);
@@ -191,6 +254,9 @@ bool WrappedOpenGL::Serialise_glBindImageTexture(GLuint unit, GLuint texture, GL
 		GLResource tex = GetResourceManager()->GetLiveResource(texid);
 
 		m_Real.glBindImageTexture(Unit, tex.name, Level, Layered, Layer, Access, Format);
+
+		if(m_State == READING)
+			m_Textures[GetResourceManager()->GetLiveID(texid)].creationFlags |= eTextureCreate_UAV;
 	}
 
 	return true;
@@ -215,6 +281,56 @@ void WrappedOpenGL::glBindImageTexture(GLuint unit, GLuint texture, GLint level,
 	}
 }
 
+bool WrappedOpenGL::Serialise_glBindImageTextures(GLuint first, GLsizei count, const GLuint *textures)
+{
+	SERIALISE_ELEMENT(uint32_t, First, first);
+	SERIALISE_ELEMENT(int32_t, Count, count);
+
+	GLuint *texs = NULL;
+	if(m_State <= EXECUTING) texs = new GLuint[Count];
+	
+	for(int32_t i=0; i < Count; i++)
+	{
+		SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(GetCtx(), textures[i])));
+		
+		if(m_State <= EXECUTING)
+		{
+			if(id != ResourceId())
+			{
+				texs[i] = GetResourceManager()->GetLiveResource(id).name;
+				if(m_State == READING)
+					m_Textures[GetResourceManager()->GetLiveID(id)].creationFlags |= eTextureCreate_UAV;
+			}
+			else
+			{
+				texs[i] = 0;
+			}
+		}
+	}
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glBindImageTextures(First, Count, texs);
+
+		delete[] texs;
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glBindImageTextures(GLuint first, GLsizei count, const GLuint *textures)
+{
+	m_Real.glBindImageTextures(first, count, textures);
+	
+	if(m_State >= WRITING)
+	{
+		SCOPED_SERIALISE_CONTEXT(BIND_IMAGE_TEXTURES);
+		Serialise_glBindImageTextures(first, count, textures);
+		
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+}
+
 bool WrappedOpenGL::Serialise_glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
 {
 	SERIALISE_ELEMENT(GLenum, Target, target);