Add a few more functions :)

renderdoc/driver/gl/gl_common.h

@@ -124,11 +124,16 @@ enum GLChunkType
 	CLEARBUFFERI,
 	CLEARBUFFERUI,
 	CLEARBUFFERFI,
+	POLYGON_MODE,
+	POLYGON_OFFSET,
 	CULL_FACE,
 	ENABLE,
 	DISABLE,
+	ENABLEI,
+	DISABLEI,
 	FRONT_FACE,
 	BLEND_FUNC,
+	BLEND_FUNCI,
 	BLEND_COLOR,
 	BLEND_FUNC_SEP,
 	BLEND_FUNC_SEPI,
@@ -137,8 +142,12 @@ enum GLChunkType
 	COLOR_MASK,
 	COLOR_MASKI,
 	DEPTH_FUNC,
+	DEPTH_MASK,
+	DEPTH_RANGEARRAY,
 	VIEWPORT,
 	VIEWPORT_ARRAY,
+	SCISSOR,
+	SCISSOR_ARRAY,
 	USEPROGRAM,
 	BINDVERTEXARRAY,
 	UNIFORM_MATRIX,
@@ -162,6 +171,7 @@ enum GLChunkType
 	BIND_VERTEXARRAY,
 	VERTEXATTRIBPOINTER,
 	ENABLEVERTEXATTRIBARRAY,
+	DISABLEVERTEXATTRIBARRAY,
 	DELETE_VERTEXARRAY,
 	DELETE_BUFFER,
 	

renderdoc/driver/gl/gl_context_driver.cpp

@@ -55,6 +55,33 @@ void WrappedOpenGL::glBlendFunc(GLenum sfactor, GLenum dfactor)
 	}
 }
 
+bool WrappedOpenGL::Serialise_glBlendFunci(GLuint buf, GLenum src, GLenum dst)
+{
+	SERIALISE_ELEMENT(GLuint, b, buf);
+	SERIALISE_ELEMENT(GLenum, s, src);
+	SERIALISE_ELEMENT(GLenum, d, dst);
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glBlendFunci(b, s, d);
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
+{
+	m_Real.glBlendFunci(buf, src, dst);
+	
+	if(m_State >= WRITING)
+	{
+		SCOPED_SERIALISE_CONTEXT(BLEND_FUNCI);
+		Serialise_glBlendFunci(buf, src, dst);
+
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+}
+
 bool WrappedOpenGL::Serialise_glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
 	SERIALISE_ELEMENT(float, r, red);
@@ -271,6 +298,60 @@ void WrappedOpenGL::glDepthFunc(GLenum func)
 	}
 }
 
+bool WrappedOpenGL::Serialise_glDepthMask(GLboolean flag)
+{
+	SERIALISE_ELEMENT(uint8_t, f, flag);
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glDepthMask(f);
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glDepthMask(GLboolean flag)
+{
+	m_Real.glDepthMask(flag);
+
+	if(m_State == WRITING_CAPFRAME)
+	{
+		SCOPED_SERIALISE_CONTEXT(DEPTH_MASK);
+		Serialise_glDepthMask(flag);
+
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+}
+
+bool WrappedOpenGL::Serialise_glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
+{
+	SERIALISE_ELEMENT(uint32_t, idx, first);
+	SERIALISE_ELEMENT(uint32_t, cnt, count);
+	SERIALISE_ELEMENT_ARR(GLdouble, ranges, v, cnt*2);
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glDepthRangeArrayv(idx, cnt, ranges);
+	}
+
+	delete[] ranges;
+
+	return true;
+}
+
+void WrappedOpenGL::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
+{
+	m_Real.glDepthRangeArrayv(first, count, v);
+
+	if(m_State == WRITING_CAPFRAME)
+	{
+		SCOPED_SERIALISE_CONTEXT(DEPTH_RANGEARRAY);
+		Serialise_glDepthRangeArrayv(first, count, v);
+
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+}
+
 bool WrappedOpenGL::Serialise_glDisable(GLenum cap)
 {
 	SERIALISE_ELEMENT(GLenum, c, cap);
@@ -294,6 +375,7 @@ void WrappedOpenGL::glDisable(GLenum cap)
 
 		m_ContextRecord->AddChunk(scope.Get());
 	}
+	// TODO replace this with glIsEnabled() for the relevant states
 	if(m_State == WRITING_IDLE)
 	{
 		SCOPED_SERIALISE_CONTEXT(DISABLE);
@@ -336,6 +418,74 @@ void WrappedOpenGL::glEnable(GLenum cap)
 	}
 }
 
+bool WrappedOpenGL::Serialise_glDisablei(GLenum cap, GLuint index)
+{
+	SERIALISE_ELEMENT(GLenum, c, cap);
+	SERIALISE_ELEMENT(uint32_t, i, index);
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glDisablei(c, i);
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glDisablei(GLenum cap, GLuint index)
+{
+	m_Real.glDisablei(cap, index);
+
+	if(m_State == WRITING_CAPFRAME)
+	{
+		SCOPED_SERIALISE_CONTEXT(DISABLEI);
+		Serialise_glDisablei(cap, index);
+
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+	// TODO replace this with glIsEnabled() for the relevant states
+	if(m_State == WRITING_IDLE)
+	{
+		SCOPED_SERIALISE_CONTEXT(DISABLEI);
+		Serialise_glDisablei(cap, index);
+
+		m_DeviceRecord->AddChunk(scope.Get());
+	}
+}
+
+bool WrappedOpenGL::Serialise_glEnablei(GLenum cap, GLuint index)
+{
+	SERIALISE_ELEMENT(GLenum, c, cap);
+	SERIALISE_ELEMENT(uint32_t, i, index);
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glEnablei(c, i);
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glEnablei(GLenum cap, GLuint index)
+{
+	m_Real.glEnablei(cap, index);
+
+	if(m_State == WRITING_CAPFRAME)
+	{
+		SCOPED_SERIALISE_CONTEXT(ENABLEI);
+		Serialise_glEnablei(cap, index);
+
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+	// TODO replace this with glIsEnabled() for the relevant states
+	if(m_State == WRITING_IDLE)
+	{
+		SCOPED_SERIALISE_CONTEXT(ENABLEI);
+		Serialise_glEnablei(cap, index);
+
+		m_DeviceRecord->AddChunk(scope.Get());
+	}
+}
+
 bool WrappedOpenGL::Serialise_glFrontFace(GLenum mode)
 {
 	SERIALISE_ELEMENT(GLenum, m, mode);
@@ -454,8 +604,8 @@ bool WrappedOpenGL::Serialise_glViewport(GLint x, GLint y, GLsizei width, GLsize
 {
 	SERIALISE_ELEMENT(int32_t, X, x);
 	SERIALISE_ELEMENT(int32_t, Y, y);
-	SERIALISE_ELEMENT(int32_t, W, width);
-	SERIALISE_ELEMENT(int32_t, H, height);
+	SERIALISE_ELEMENT(uint32_t, W, width);
+	SERIALISE_ELEMENT(uint32_t, H, height);
 
 	if(m_State <= EXECUTING)
 	{
@@ -518,9 +668,124 @@ void WrappedOpenGL::glViewportIndexedfv(GLuint index, const GLfloat *v)
 	glViewportArrayv(index, 1, v);
 }
 
+bool WrappedOpenGL::Serialise_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	SERIALISE_ELEMENT(int32_t, X, x);
+	SERIALISE_ELEMENT(int32_t, Y, y);
+	SERIALISE_ELEMENT(uint32_t, W, width);
+	SERIALISE_ELEMENT(uint32_t, H, height);
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glScissor(X, Y, W, H);
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	m_Real.glScissor(x, y, width, height);
+
+	if(m_State == WRITING_CAPFRAME)
+	{
+		SCOPED_SERIALISE_CONTEXT(SCISSOR);
+		Serialise_glScissor(x, y, width, height);
+		
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+}
+
+bool WrappedOpenGL::Serialise_glScissorArrayv(GLuint index, GLsizei count, const GLint *v)
+{
+	SERIALISE_ELEMENT(uint32_t, idx, index);
+	SERIALISE_ELEMENT(uint32_t, cnt, count);
+	SERIALISE_ELEMENT_ARR(GLint, scissors, v, cnt*4);
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glScissorArrayv(idx, cnt, scissors);
+	}
+
+	delete[] scissors;
+
+	return true;
+}
+
+void WrappedOpenGL::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
+{
+	m_Real.glScissorArrayv(first, count, v);
+
+	if(m_State == WRITING_CAPFRAME)
+	{
+		SCOPED_SERIALISE_CONTEXT(SCISSOR_ARRAY);
+		Serialise_glScissorArrayv(first, count, v);
+		
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+}
+
+void WrappedOpenGL::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
+{
+	const GLint v[4] = { left, bottom, width, height };
+	glScissorArrayv(index, 1, v);
+}
+
+void WrappedOpenGL::glScissorIndexedv(GLuint index, const GLint *v)
+{
+	glScissorArrayv(index, 1, v);
+}
+
+bool WrappedOpenGL::Serialise_glPolygonMode(GLenum face, GLenum mode)
+{
+	SERIALISE_ELEMENT(GLenum, f, face);
+	SERIALISE_ELEMENT(GLenum, m, mode);
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glPolygonMode(f, m);
+	}
+
+	return true;
+}
+
 void WrappedOpenGL::glPolygonMode(GLenum face, GLenum mode)
 {
 	m_Real.glPolygonMode(face, mode);
+	
+	if(m_State == WRITING_CAPFRAME)
+	{
+		SCOPED_SERIALISE_CONTEXT(POLYGON_MODE);
+		Serialise_glPolygonMode(face, mode);
+		
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+}
+
+bool WrappedOpenGL::Serialise_glPolygonOffset(GLfloat factor, GLfloat units)
+{
+	SERIALISE_ELEMENT(float, f, factor);
+	SERIALISE_ELEMENT(float, u, units);
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glPolygonOffset(f, u);
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glPolygonOffset(GLfloat factor, GLfloat units)
+{
+	m_Real.glPolygonOffset(factor, units);
+	
+	if(m_State == WRITING_CAPFRAME)
+	{
+		SCOPED_SERIALISE_CONTEXT(POLYGON_OFFSET);
+		Serialise_glPolygonOffset(factor, units);
+		
+		m_ContextRecord->AddChunk(scope.Get());
+	}
 }
 
 bool WrappedOpenGL::Serialise_glBindFramebuffer(GLenum target, GLuint framebuffer)

renderdoc/driver/gl/gl_device_driver.cpp

@@ -1282,6 +1282,32 @@ void WrappedOpenGL::glEnableVertexAttribArray(GLuint index)
 	}
 }
 
+bool WrappedOpenGL::Serialise_glDisableVertexAttribArray(GLuint index)
+{
+	SERIALISE_ELEMENT(uint32_t, Index, index);
+	
+	if(m_State < WRITING)
+	{
+		m_Real.glDisableVertexAttribArray(Index);
+	}
+	return true;
+}
+
+void WrappedOpenGL::glDisableVertexAttribArray(GLuint index)
+{
+	m_Real.glDisableVertexAttribArray(index);
+	
+	GLResourceRecord *r = m_VertexArrayRecord ? m_VertexArrayRecord : m_DeviceRecord;
+	RDCASSERT(r);
+	if(m_State >= WRITING)
+	{
+		SCOPED_SERIALISE_CONTEXT(DISABLEVERTEXATTRIBARRAY);
+		Serialise_glDisableVertexAttribArray(index);
+
+		r->AddChunk(scope.Get());
+	}
+}
+
 bool WrappedOpenGL::Serialise_glGenVertexArrays(GLsizei n, GLuint* arrays)
 {
 	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(VertexArrayRes(*arrays)));

renderdoc/driver/gl/gl_driver.cpp

@@ -81,11 +81,16 @@ const char *GLChunkNames[] =
 	"glClearBufferiv",
 	"glClearBufferuiv",
 	"glClearBufferfi",
+	"glPolygonMode",
+	"glPolygonOffset",
 	"glCullFace",
 	"glEnable",
 	"glDisable",
+	"glEnablei",
+	"glDisablei",
 	"glFrontFace",
 	"glBlendFunc",
+	"glBlendFunci",
 	"glBlendColor",
 	"glBlendFuncSeparate",
 	"glBlendFuncSeparatei",
@@ -94,8 +99,12 @@ const char *GLChunkNames[] =
 	"glColorMask",
 	"glColorMaski",
 	"glDepthFunc",
+	"glDepthMask",
+	"glDepthRangeArrayv",
 	"glViewport",
 	"glViewportArrayv",
+	"glScissor",
+	"glScissorArrayv",
 	"glUseProgram",
 	"glBindVertexArray",
 	"glUniformMatrix*",
@@ -119,6 +128,7 @@ const char *GLChunkNames[] =
 	"glBindVertexArray",
 	"glVertexAttribPointer",
 	"glEnableVertexAttribArray",
+	"glDisableVertexAttribArray",
 	"glDeleteVertexArray",
 	"glDeleteBuffer",
 	
@@ -987,6 +997,12 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 	case CULL_FACE:
 		Serialise_glCullFace(eGL_UNKNOWN_ENUM);
 		break;
+	case POLYGON_MODE:
+		glPolygonMode(eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM);
+		break;
+	case POLYGON_OFFSET:
+		glPolygonOffset(0, 0);
+		break;
 	case CLEARBUFFERF:
 		Serialise_glClearBufferfv(eGL_UNKNOWN_ENUM, 0, NULL);
 		break;
@@ -1005,6 +1021,12 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 	case ENABLE:
 		Serialise_glEnable(eGL_UNKNOWN_ENUM);
 		break;
+	case DISABLEI:
+		Serialise_glDisablei(eGL_UNKNOWN_ENUM, 0);
+		break;
+	case ENABLEI:
+		Serialise_glEnablei(eGL_UNKNOWN_ENUM, 0);
+		break;
 	case FRONT_FACE:
 		Serialise_glFrontFace(eGL_UNKNOWN_ENUM);
 		break;
@@ -1035,12 +1057,24 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 	case DEPTH_FUNC:
 		Serialise_glDepthFunc(eGL_UNKNOWN_ENUM);
 		break;
+	case DEPTH_MASK:
+		Serialise_glDepthMask(0);
+		break;
+	case DEPTH_RANGEARRAY:
+		Serialise_glDepthRangeArrayv(0, 0, NULL);
+		break;
 	case VIEWPORT:
 		Serialise_glViewport(0, 0, 0, 0);
 		break;
 	case VIEWPORT_ARRAY:
 		Serialise_glViewportArrayv(0, 0, 0);
 		break;
+	case SCISSOR:
+		Serialise_glScissor(0, 0, 0, 0);
+		break;
+	case SCISSOR_ARRAY:
+		Serialise_glScissorArrayv(0, 0, 0);
+		break;
 	case USEPROGRAM:
 		Serialise_glUseProgram(0);
 		break;
@@ -1084,6 +1118,9 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 	case ENABLEVERTEXATTRIBARRAY:
 		Serialise_glEnableVertexAttribArray(0);
 		break;
+	case DISABLEVERTEXATTRIBARRAY:
+		Serialise_glDisableVertexAttribArray(0);
+		break;
 
 	case DELETE_VERTEXARRAY:
 	case DELETE_BUFFER:
@@ -1420,6 +1457,16 @@ GLenum WrappedOpenGL::glGetError()
 	return m_Real.glGetError();
 }
 
+void WrappedOpenGL::glFlush()
+{
+	m_Real.glFlush();
+}
+
+void WrappedOpenGL::glFinish()
+{
+	m_Real.glFinish();
+}
+
 void WrappedOpenGL::glGetFloatv(GLenum pname, GLfloat *params)
 {
 	m_Real.glGetFloatv(pname, params);

renderdoc/driver/gl/gl_driver.h

@@ -265,7 +265,9 @@ class WrappedOpenGL
 		//
 
 		IMPLEMENT_FUNCTION_SERIALISED(void, glBindTexture(GLenum target, GLuint texture));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format));
 		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));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glBlendFuncSeparatei(GLuint buf, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha));
@@ -278,10 +280,16 @@ class WrappedOpenGL
 		IMPLEMENT_FUNCTION_SERIALISED(void, glClearDepth(GLclampd depth));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glCullFace(GLenum cap));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glDepthFunc(GLenum func));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glDepthMask(GLboolean flag));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glDisable(GLenum cap));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glEnable(GLenum cap));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glDisablei(GLenum cap, GLuint index));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glEnablei(GLenum cap, GLuint index));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glFrontFace(GLenum cap));
 		IMPLEMENT_FUNCTION_SERIALISED(GLenum, glGetError());
+		IMPLEMENT_FUNCTION_SERIALISED(void, glFinish());
+		IMPLEMENT_FUNCTION_SERIALISED(void, glFlush());
 		IMPLEMENT_FUNCTION_SERIALISED(void, glGetFloatv(GLenum pname, GLfloat *params));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glGetIntegerv(GLenum pname, GLint *params));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glGetBooleanv(GLenum pname, GLboolean *data));
@@ -297,6 +305,7 @@ class WrappedOpenGL
 		IMPLEMENT_FUNCTION_SERIALISED(void, glPixelStorei(GLenum pname, GLint param));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glPixelStoref(GLenum pname, GLfloat param));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glPolygonMode(GLenum face, GLenum mode));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glPolygonOffset(GLfloat factor, GLfloat units));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glTexParameteri(GLenum target, GLenum pname, GLint param));
@@ -307,6 +316,10 @@ class WrappedOpenGL
 		IMPLEMENT_FUNCTION_SERIALISED(void, glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glViewportIndexedfv(GLuint index, const GLfloat *v));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glViewportArrayv(GLuint first, GLuint count, const GLfloat *v));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glScissor(GLint x, GLint y, GLsizei width, GLsizei height));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glScissorArrayv(GLuint first, GLsizei count, const GLint *v));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glScissorIndexedv(GLuint index, const GLint *v));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glReadBuffer(GLenum mode));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glGenFramebuffers(GLsizei n, GLuint *framebuffers));
@@ -370,6 +383,7 @@ class WrappedOpenGL
 		IMPLEMENT_FUNCTION_SERIALISED(void, glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glEnableVertexAttribArray(GLuint index));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glDisableVertexAttribArray(GLuint index));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glGetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glGenVertexArrays(GLsizei n, GLuint *arrays));

renderdoc/driver/gl/gl_hookset.h

@@ -43,6 +43,8 @@ struct GLHookSet
 	PFNGLDISABLEPROC glDisable;
 	PFNGLDRAWARRAYSPROC glDrawArrays;
 	PFNGLENABLEPROC glEnable;
+	PFNGLFLUSHPROC glFlush;
+	PFNGLFINISHPROC glFinish;
 	PFNGLFRONTFACEPROC glFrontFace;
 	PFNGLGENTEXTURESPROC glGenTextures;
 	PFNGLDELETETEXTURESPROC glDeleteTextures;
@@ -60,8 +62,10 @@ struct GLHookSet
 	PFNGLPIXELSTOREIPROC glPixelStorei;
 	PFNGLPIXELSTOREFPROC glPixelStoref;
 	PFNGLPOLYGONMODEPROC glPolygonMode;
+	PFNGLPOLYGONOFFSETPROC glPolygonOffset;
 	PFNGLREADPIXELSPROC glReadPixels;
 	PFNGLREADBUFFERPROC glReadBuffer;
+	PFNGLSCISSORPROC glScissor;
 	PFNGLTEXIMAGE1DPROC glTexImage1D;
 	PFNGLTEXIMAGE2DPROC glTexImage2D;
 	PFNGLTEXPARAMETERIPROC glTexParameteri;
@@ -101,11 +105,14 @@ struct GLHookSet
 	PFNGLGETFLOATI_VPROC glGetFloati_v;
 	PFNGLGETINTEGER64I_VPROC glGetInteger64i_v;
 	PFNGLCHECKFRAMEBUFFERSTATUSPROC glCheckFramebufferStatus;
+	PFNGLBLENDFUNCIPROC glBlendFunci;
 	PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate;
 	PFNGLBLENDFUNCSEPARATEIPROC glBlendFuncSeparatei;
 	PFNGLBLENDEQUATIONSEPARATEPROC glBlendEquationSeparate;
 	PFNGLBLENDEQUATIONSEPARATEIPROC glBlendEquationSeparatei;
 	PFNGLCOLORMASKIPROC glColorMaski;
+	PFNGLDEPTHMASKPROC glDepthMask;
+	PFNGLDEPTHRANGEARRAYVPROC glDepthRangeArrayv;
 	PFNGLCREATESHADERPROC glCreateShader;
 	PFNGLDELETESHADERPROC glDeleteShader;
 	PFNGLSHADERSOURCEPROC glShaderSource;
@@ -125,6 +132,8 @@ struct GLHookSet
 	PFNGLDEBUGMESSAGECALLBACKPROC glDebugMessageCallback; // aliases glDebugMessageCallbackARB
 	PFNGLGETOBJECTLABELPROC glGetObjectLabel;
 	PFNGLOBJECTLABELPROC glObjectLabel;
+	PFNGLENABLEIPROC glEnablei;
+	PFNGLDISABLEIPROC glDisablei;
 	PFNGLGENBUFFERSPROC glGenBuffers;
 	PFNGLBINDBUFFERPROC glBindBuffer;
 	PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers;
@@ -144,6 +153,7 @@ struct GLHookSet
 	PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays;
 	PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer;
 	PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray;
+	PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray;
 	PFNGLGETVERTEXATTRIBIVPROC glGetVertexAttribiv;
 	PFNGLGETVERTEXATTRIBPOINTERVPROC glGetVertexAttribPointerv;
 	PFNGLGENSAMPLERSPROC glGenSamplers;
@@ -153,6 +163,9 @@ struct GLHookSet
 	PFNGLCLEARBUFFERIVPROC glClearBufferiv;
 	PFNGLCLEARBUFFERUIVPROC glClearBufferuiv;
 	PFNGLCLEARBUFFERFIPROC glClearBufferfi;
+	PFNGLSCISSORARRAYVPROC glScissorArrayv;
+	PFNGLSCISSORINDEXEDPROC glScissorIndexed;
+	PFNGLSCISSORINDEXEDVPROC glScissorIndexedv;
 	PFNGLVIEWPORTINDEXEDFPROC glViewportIndexedf;
 	PFNGLVIEWPORTINDEXEDFVPROC glViewportIndexedfv;
 	PFNGLVIEWPORTARRAYVPROC glViewportArrayv;

renderdoc/driver/gl/gl_hookset_defs.h

@@ -43,6 +43,8 @@
     HookInit(glDisable); \
     HookInit(glDrawArrays); \
     HookInit(glEnable); \
+    HookInit(glFlush); \
+    HookInit(glFinish); \
     HookInit(glFrontFace); \
     HookInit(glGenTextures); \
     HookInit(glDeleteTextures); \
@@ -60,8 +62,10 @@
     HookInit(glPixelStorei); \
     HookInit(glPixelStoref); \
     HookInit(glPolygonMode); \
+    HookInit(glPolygonOffset); \
     HookInit(glReadPixels); \
     HookInit(glReadBuffer); \
+    HookInit(glScissor); \
     HookInit(glTexImage1D); \
     HookInit(glTexImage2D); \
     HookInit(glTexParameteri); \
@@ -112,11 +116,14 @@
     HookExtension(PFNGLGETFLOATI_VPROC, glGetFloati_v); \
     HookExtension(PFNGLGETINTEGER64I_VPROC, glGetInteger64i_v); \
     HookExtension(PFNGLCHECKFRAMEBUFFERSTATUSPROC, glCheckFramebufferStatus); \
+    HookExtension(PFNGLBLENDFUNCIPROC, glBlendFunci); \
     HookExtension(PFNGLBLENDFUNCSEPARATEPROC, glBlendFuncSeparate); \
     HookExtension(PFNGLBLENDFUNCSEPARATEIPROC, glBlendFuncSeparatei); \
     HookExtension(PFNGLBLENDEQUATIONSEPARATEPROC, glBlendEquationSeparate); \
     HookExtension(PFNGLBLENDEQUATIONSEPARATEIPROC, glBlendEquationSeparatei); \
     HookExtension(PFNGLCOLORMASKIPROC, glColorMaski); \
+    HookExtension(PFNGLDEPTHMASKPROC, glDepthMask); \
+    HookExtension(PFNGLDEPTHRANGEARRAYVPROC, glDepthRangeArrayv); \
     HookExtension(PFNGLCREATESHADERPROC, glCreateShader); \
     HookExtension(PFNGLDELETESHADERPROC, glDeleteShader); \
     HookExtension(PFNGLSHADERSOURCEPROC, glShaderSource); \
@@ -137,6 +144,8 @@
     HookExtensionAlias(PFNGLDEBUGMESSAGECALLBACKPROC, glDebugMessageCallback, glDebugMessageCallbackARB); \
     HookExtension(PFNGLGETOBJECTLABELPROC, glGetObjectLabel); \
     HookExtension(PFNGLOBJECTLABELPROC, glObjectLabel); \
+    HookExtension(PFNGLENABLEIPROC, glEnablei); \
+    HookExtension(PFNGLDISABLEIPROC, glDisablei); \
     HookExtension(PFNGLGENBUFFERSPROC, glGenBuffers); \
     HookExtension(PFNGLBINDBUFFERPROC, glBindBuffer); \
     HookExtension(PFNGLGENFRAMEBUFFERSPROC, glGenFramebuffers); \
@@ -156,6 +165,7 @@
     HookExtension(PFNGLDELETEVERTEXARRAYSPROC, glDeleteVertexArrays); \
     HookExtension(PFNGLVERTEXATTRIBPOINTERPROC, glVertexAttribPointer); \
     HookExtension(PFNGLENABLEVERTEXATTRIBARRAYPROC, glEnableVertexAttribArray); \
+    HookExtension(PFNGLDISABLEVERTEXATTRIBARRAYPROC, glDisableVertexAttribArray); \
     HookExtension(PFNGLGETVERTEXATTRIBIVPROC, glGetVertexAttribiv); \
     HookExtension(PFNGLGETVERTEXATTRIBPOINTERVPROC, glGetVertexAttribPointerv); \
     HookExtension(PFNGLGENSAMPLERSPROC, glGenSamplers); \
@@ -165,6 +175,9 @@
     HookExtension(PFNGLCLEARBUFFERIVPROC, glClearBufferiv); \
     HookExtension(PFNGLCLEARBUFFERUIVPROC, glClearBufferuiv); \
     HookExtension(PFNGLCLEARBUFFERFIPROC, glClearBufferfi); \
+    HookExtension(PFNGLSCISSORARRAYVPROC, glScissorArrayv); \
+    HookExtension(PFNGLSCISSORINDEXEDPROC, glScissorIndexed); \
+    HookExtension(PFNGLSCISSORINDEXEDVPROC, glScissorIndexedv); \
     HookExtension(PFNGLVIEWPORTINDEXEDFPROC, glViewportIndexedf); \
     HookExtension(PFNGLVIEWPORTINDEXEDFVPROC, glViewportIndexedfv); \
     HookExtension(PFNGLVIEWPORTARRAYVPROC, glViewportArrayv); \
@@ -194,6 +207,8 @@
     HookExtension(PFNGLDISABLEPROC, glDisable); \
     HookExtension(PFNGLDRAWARRAYSPROC, glDrawArrays); \
     HookExtension(PFNGLENABLEPROC, glEnable); \
+    HookExtension(PFNGLFLUSHPROC, glFlush); \
+    HookExtension(PFNGLFINISHPROC, glFinish); \
     HookExtension(PFNGLFRONTFACEPROC, glFrontFace); \
     HookExtension(PFNGLGENTEXTURESPROC, glGenTextures); \
     HookExtension(PFNGLDELETETEXTURESPROC, glDeleteTextures); \
@@ -211,8 +226,10 @@
     HookExtension(PFNGLPIXELSTOREIPROC, glPixelStorei); \
     HookExtension(PFNGLPIXELSTOREFPROC, glPixelStoref); \
     HookExtension(PFNGLPOLYGONMODEPROC, glPolygonMode); \
+    HookExtension(PFNGLPOLYGONOFFSETPROC, glPolygonOffset); \
     HookExtension(PFNGLREADPIXELSPROC, glReadPixels); \
     HookExtension(PFNGLREADBUFFERPROC, glReadBuffer); \
+    HookExtension(PFNGLSCISSORPROC, glScissor); \
     HookExtension(PFNGLTEXIMAGE1DPROC, glTexImage1D); \
     HookExtension(PFNGLTEXIMAGE2DPROC, glTexImage2D); \
     HookExtension(PFNGLTEXPARAMETERIPROC, glTexParameteri); \
@@ -252,6 +269,8 @@
     HookWrapper1(void, glDisable, GLenum, cap); \
     HookWrapper3(void, glDrawArrays, GLenum, mode, GLint, first, GLsizei, count); \
     HookWrapper1(void, glEnable, GLenum, cap); \
+    HookWrapper0(void, glFlush); \
+    HookWrapper0(void, glFinish); \
     HookWrapper1(void, glFrontFace, GLenum, mode); \
     HookWrapper2(void, glGenTextures, GLsizei, n, GLuint *, textures); \
     HookWrapper2(void, glDeleteTextures, GLsizei, n, const GLuint *, textures); \
@@ -269,8 +288,10 @@
     HookWrapper2(void, glPixelStorei, GLenum, pname, GLint, param); \
     HookWrapper2(void, glPixelStoref, GLenum, pname, GLfloat, param); \
     HookWrapper2(void, glPolygonMode, GLenum, face, GLenum, mode); \
+    HookWrapper2(void, glPolygonOffset, GLfloat, factor, GLfloat, units); \
     HookWrapper7(void, glReadPixels, GLint, x, GLint, y, GLsizei, width, GLsizei, height, GLenum, format, GLenum, type, void *, pixels); \
     HookWrapper1(void, glReadBuffer, GLenum, mode); \
+    HookWrapper4(void, glScissor, GLint, x, GLint, y, GLsizei, width, GLsizei, height); \
     HookWrapper8(void, glTexImage1D, GLenum, target, GLint, level, GLint, internalformat, GLsizei, width, GLint, border, GLenum, format, GLenum, type, const void *, pixels); \
     HookWrapper9(void, glTexImage2D, GLenum, target, GLint, level, GLint, internalformat, GLsizei, width, GLsizei, height, GLint, border, GLenum, format, GLenum, type, const void *, pixels); \
     HookWrapper3(void, glTexParameteri, GLenum, target, GLenum, pname, GLint, param); \
@@ -321,11 +342,14 @@
     HookWrapper3(void, glGetFloati_v, GLenum, target, GLuint, index, GLfloat *, data); \
     HookWrapper3(void, glGetInteger64i_v, GLenum, target, GLuint, index, GLint64 *, data); \
     HookWrapper1(GLenum, glCheckFramebufferStatus, GLenum, target); \
+    HookWrapper3(void, glBlendFunci, GLuint, buf, GLenum, src, GLenum, dst); \
     HookWrapper4(void, glBlendFuncSeparate, GLenum, sfactorRGB, GLenum, dfactorRGB, GLenum, sfactorAlpha, GLenum, dfactorAlpha); \
     HookWrapper5(void, glBlendFuncSeparatei, GLuint, buf, GLenum, srcRGB, GLenum, dstRGB, GLenum, srcAlpha, GLenum, dstAlpha); \
     HookWrapper2(void, glBlendEquationSeparate, GLenum, modeRGB, GLenum, modeAlpha); \
     HookWrapper3(void, glBlendEquationSeparatei, GLuint, buf, GLenum, modeRGB, GLenum, modeAlpha); \
     HookWrapper5(void, glColorMaski, GLuint, index, GLboolean, r, GLboolean, g, GLboolean, b, GLboolean, a); \
+    HookWrapper1(void, glDepthMask, GLboolean, flag); \
+    HookWrapper3(void, glDepthRangeArrayv, GLuint, first, GLsizei, count, const GLdouble *, v); \
     HookWrapper1(GLuint, glCreateShader, GLenum, type); \
     HookWrapper1(void, glDeleteShader, GLuint, shader); \
     HookWrapper4(void, glShaderSource, GLuint, shader, GLsizei, count, const GLchar *const*, string, const GLint *, length); \
@@ -345,6 +369,8 @@
     HookWrapper2(void, glDebugMessageCallback, GLDEBUGPROC, callback, const void *, userParam); \
     HookWrapper5(void, glGetObjectLabel, GLenum, identifier, GLuint, name, GLsizei, bufSize, GLsizei *, length, GLchar *, label); \
     HookWrapper4(void, glObjectLabel, GLenum, identifier, GLuint, name, GLsizei, length, const GLchar *, label); \
+    HookWrapper2(void, glEnablei, GLenum, target, GLuint, index); \
+    HookWrapper2(void, glDisablei, GLenum, target, GLuint, index); \
     HookWrapper2(void, glGenBuffers, GLsizei, n, GLuint *, buffers); \
     HookWrapper2(void, glBindBuffer, GLenum, target, GLuint, buffer); \
     HookWrapper2(void, glGenFramebuffers, GLsizei, n, GLuint *, framebuffers); \
@@ -364,6 +390,7 @@
     HookWrapper2(void, glDeleteVertexArrays, GLsizei, n, const GLuint *, arrays); \
     HookWrapper6(void, glVertexAttribPointer, GLuint, index, GLint, size, GLenum, type, GLboolean, normalized, GLsizei, stride, const void *, pointer); \
     HookWrapper1(void, glEnableVertexAttribArray, GLuint, index); \
+    HookWrapper1(void, glDisableVertexAttribArray, GLuint, index); \
     HookWrapper3(void, glGetVertexAttribiv, GLuint, index, GLenum, pname, GLint *, params); \
     HookWrapper3(void, glGetVertexAttribPointerv, GLuint, index, GLenum, pname, void **, pointer); \
     HookWrapper2(void, glGenSamplers, GLsizei, count, GLuint *, samplers); \
@@ -373,6 +400,9 @@
     HookWrapper3(void, glClearBufferiv, GLenum, buffer, GLint, drawbuffer, const GLint *, value); \
     HookWrapper3(void, glClearBufferuiv, GLenum, buffer, GLint, drawbuffer, const GLuint *, value); \
     HookWrapper4(void, glClearBufferfi, GLenum, buffer, GLint, drawbuffer, GLfloat, depth, GLint, stencil); \
+    HookWrapper3(void, glScissorArrayv, GLuint, first, GLsizei, count, const GLint *, v); \
+    HookWrapper5(void, glScissorIndexed, GLuint, index, GLint, left, GLint, bottom, GLsizei, width, GLsizei, height); \
+    HookWrapper2(void, glScissorIndexedv, GLuint, index, const GLint *, v); \
     HookWrapper5(void, glViewportIndexedf, GLuint, index, GLfloat, x, GLfloat, y, GLfloat, w, GLfloat, h); \
     HookWrapper2(void, glViewportIndexedfv, GLuint, index, const GLfloat *, v); \
     HookWrapper3(void, glViewportArrayv, GLuint, first, GLsizei, count, const GLfloat *, v); \