Serialise a few more state change functions

renderdoc/driver/gl/gl_common.h

@@ -162,6 +162,7 @@ enum GLChunkType
 
 	CLEAR_COLOR,
 	CLEAR_DEPTH,
+	CLEAR_STENCIL,
 	CLEAR,
 	CLEARBUFFERF,
 	CLEARBUFFERI,
@@ -189,6 +190,7 @@ enum GLChunkType
 	BLEND_EQI,
 	BLEND_EQ_SEP,
 	BLEND_EQ_SEPI,
+	LOGIC_OP,
 	STENCIL_OP,
 	STENCIL_OP_SEP,
 	STENCIL_FUNC,
@@ -207,6 +209,8 @@ enum GLChunkType
 	DEPTH_BOUNDS,
 	PATCH_PARAMI,
 	PATCH_PARAMFV,
+	LINE_WIDTH,
+	POINT_SIZE,
 	POINT_PARAMF,
 	POINT_PARAMFV,
 	POINT_PARAMI,

renderdoc/driver/gl/gl_driver.cpp

@@ -111,6 +111,7 @@ const char *GLChunkNames[] =
 
 	"glClearColor",
 	"glClearDepth",
+	"glClearStencil",
 	"glClear",
 	"glClearBufferfv",
 	"glClearBufferiv",
@@ -138,6 +139,7 @@ const char *GLChunkNames[] =
 	"glBlendEquationi",
 	"glBlendEquationSeparate",
 	"glBlendEquationSeparatei",
+	"glLogicOp",
 	"glStencilOp",
 	"glStencilOpSeparate",
 	"glStencilFunc",
@@ -156,6 +158,8 @@ const char *GLChunkNames[] =
 	"glDepthBoundsEXT",
 	"glPatchParameteri",
 	"glPatchParameterfv",
+	"glLineWidth",
+	"glPointSize",
 	"glPointParameterf",
 	"glPointParameterfv",
 	"glPointParameteri",
@@ -1733,6 +1737,9 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 	case CLEAR_DEPTH:
 		Serialise_glClearDepth(0);
 		break;
+	case CLEAR_STENCIL:
+		Serialise_glClearStencil(0);
+		break;
 	case CLEAR:
 		Serialise_glClear(0);
 		break;
@@ -1809,6 +1816,10 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 		Serialise_glBlendEquationSeparatei(0, eGL_NONE, eGL_NONE);
 		break;
 
+	case LOGIC_OP:
+		Serialise_glLogicOp(eGL_NONE);
+		break;
+
 	case STENCIL_OP:
 		Serialise_glStencilOp(eGL_NONE, eGL_NONE, eGL_NONE);
 		break;
@@ -1864,6 +1875,12 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 	case PATCH_PARAMFV:
 		Serialise_glPatchParameterfv(eGL_NONE, NULL);
 		break;
+	case LINE_WIDTH:
+		Serialise_glLineWidth(0.0f);
+		break;
+	case POINT_SIZE:
+		Serialise_glPointSize(0.0f);
+		break;
 	case POINT_PARAMF:
 		Serialise_glPointParameterf(eGL_NONE, 0.0f);
 		break;

renderdoc/driver/gl/gl_driver.h

@@ -341,6 +341,7 @@ class WrappedOpenGL
 		IMPLEMENT_FUNCTION_SERIALISED(void, glBlendEquationi(GLuint buf, GLenum mode));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glLogicOp(GLenum opcode));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glStencilFunc(GLenum func, GLint ref, GLuint mask));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glStencilMask(GLuint mask));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glStencilOp(GLenum fail, GLenum zfail, GLenum zpass));
@@ -354,6 +355,7 @@ class WrappedOpenGL
 		IMPLEMENT_FUNCTION_SERIALISED(void, glClear(GLbitfield mask));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glClearDepth(GLclampd depth));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glClearStencil(GLint stencil));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glCullFace(GLenum cap));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glDepthFunc(GLenum func));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glDepthMask(GLboolean flag));
@@ -381,6 +383,8 @@ class WrappedOpenGL
 		IMPLEMENT_FUNCTION_SERIALISED(void, glPointParameterfv(GLenum pname, const GLfloat *params));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glPointParameteri(GLenum pname, GLint param));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glPointParameteriv(GLenum pname, const GLint *params));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glPointSize(GLfloat size));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glLineWidth(GLfloat width));
 		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, glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels));

renderdoc/driver/gl/gl_hookset.h

@@ -35,6 +35,7 @@ struct GLHookSet
 	PFNGLCLEARPROC glClear;
 	PFNGLCLEARCOLORPROC glClearColor;
 	PFNGLCLEARDEPTHPROC glClearDepth;
+	PFNGLCLEARSTENCILPROC glClearStencil;
 	PFNGLCOLORMASKPROC glColorMask;
 	PFNGLCULLFACEPROC glCullFace;
 	PFNGLDEPTHFUNCPROC glDepthFunc;
@@ -67,10 +68,13 @@ struct GLHookSet
 	PFNGLGETPOINTERVPROC glGetPointerv;
 	PFNGLGETSTRINGPROC glGetString;
 	PFNGLHINTPROC glHint;
+	PFNGLLOGICOPPROC glLogicOp;
 	PFNGLPIXELSTOREIPROC glPixelStorei;
 	PFNGLPIXELSTOREFPROC glPixelStoref;
 	PFNGLPOLYGONMODEPROC glPolygonMode;
 	PFNGLPOLYGONOFFSETPROC glPolygonOffset;
+	PFNGLPOINTSIZEPROC glPointSize;
+	PFNGLLINEWIDTHPROC glLineWidth;
 	PFNGLREADPIXELSPROC glReadPixels;
 	PFNGLREADBUFFERPROC glReadBuffer;
 	PFNGLSCISSORPROC glScissor;

renderdoc/driver/gl/gl_hookset_defs.h

@@ -36,6 +36,7 @@
     HookInit(glClear); \
     HookInit(glClearColor); \
     HookInit(glClearDepth); \
+    HookInit(glClearStencil); \
     HookInit(glColorMask); \
     HookInit(glCullFace); \
     HookInit(glDepthFunc); \
@@ -68,10 +69,13 @@
     HookInit(glGetPointerv); \
     HookInit(glGetString); \
     HookInit(glHint); \
+    HookInit(glLogicOp); \
     HookInit(glPixelStorei); \
     HookInit(glPixelStoref); \
     HookInit(glPolygonMode); \
     HookInit(glPolygonOffset); \
+    HookInit(glPointSize); \
+    HookInit(glLineWidth); \
     HookInit(glReadPixels); \
     HookInit(glReadBuffer); \
     HookInit(glScissor); \
@@ -638,6 +642,7 @@
     HookExtension(PFNGLCLEARPROC, glClear); \
     HookExtension(PFNGLCLEARCOLORPROC, glClearColor); \
     HookExtension(PFNGLCLEARDEPTHPROC, glClearDepth); \
+    HookExtension(PFNGLCLEARSTENCILPROC, glClearStencil); \
     HookExtension(PFNGLCOLORMASKPROC, glColorMask); \
     HookExtension(PFNGLCULLFACEPROC, glCullFace); \
     HookExtension(PFNGLDEPTHFUNCPROC, glDepthFunc); \
@@ -670,10 +675,13 @@
     HookExtension(PFNGLGETPOINTERVPROC, glGetPointerv); \
     HookExtension(PFNGLGETSTRINGPROC, glGetString); \
     HookExtension(PFNGLHINTPROC, glHint); \
+    HookExtension(PFNGLLOGICOPPROC, glLogicOp); \
     HookExtension(PFNGLPIXELSTOREIPROC, glPixelStorei); \
     HookExtension(PFNGLPIXELSTOREFPROC, glPixelStoref); \
     HookExtension(PFNGLPOLYGONMODEPROC, glPolygonMode); \
     HookExtension(PFNGLPOLYGONOFFSETPROC, glPolygonOffset); \
+    HookExtension(PFNGLPOINTSIZEPROC, glPointSize); \
+    HookExtension(PFNGLLINEWIDTHPROC, glLineWidth); \
     HookExtension(PFNGLREADPIXELSPROC, glReadPixels); \
     HookExtension(PFNGLREADBUFFERPROC, glReadBuffer); \
     HookExtension(PFNGLSCISSORPROC, glScissor); \
@@ -697,6 +705,7 @@
     HookWrapper1(void, glClear, GLbitfield, mask); \
     HookWrapper4(void, glClearColor, GLfloat, red, GLfloat, green, GLfloat, blue, GLfloat, alpha); \
     HookWrapper1(void, glClearDepth, GLdouble, depth); \
+    HookWrapper1(void, glClearStencil, GLint, s); \
     HookWrapper4(void, glColorMask, GLboolean, red, GLboolean, green, GLboolean, blue, GLboolean, alpha); \
     HookWrapper1(void, glCullFace, GLenum, mode); \
     HookWrapper1(void, glDepthFunc, GLenum, func); \
@@ -729,10 +738,13 @@
     HookWrapper2(void, glGetPointerv, GLenum, pname, void **, params); \
     HookWrapper1(const GLubyte *, glGetString, GLenum, name); \
     HookWrapper2(void, glHint, GLenum, target, GLenum, mode); \
+    HookWrapper1(void, glLogicOp, GLenum, opcode); \
     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); \
+    HookWrapper1(void, glPointSize, GLfloat, size); \
+    HookWrapper1(void, glLineWidth, GLfloat, width); \
     HookWrapper7(void, glReadPixels, GLint, x, GLint, y, GLsizei, width, GLsizei, height, GLenum, format, GLenum, type, void *, pixels); \
     HookWrapper1(void, glReadBuffer, GLenum, src); \
     HookWrapper4(void, glScissor, GLint, x, GLint, y, GLsizei, width, GLsizei, height); \

renderdoc/driver/gl/gl_renderstate.cpp

@@ -114,6 +114,8 @@ void GLRenderState::FetchState()
 	
 	m_Real->glGetFloatv(eGL_POINT_FADE_THRESHOLD_SIZE, &PointFadeThresholdSize);
 	m_Real->glGetIntegerv(eGL_POINT_SPRITE_COORD_ORIGIN, (GLint*)&PointSpriteOrigin);
+	m_Real->glGetFloatv(eGL_LINE_WIDTH, &LineWidth);
+	m_Real->glGetFloatv(eGL_POINT_SIZE, &PointSize);
 	
 	m_Real->glGetIntegerv(eGL_CURRENT_PROGRAM, (GLint *)&Program);
 	m_Real->glGetIntegerv(eGL_PROGRAM_PIPELINE_BINDING, (GLint *)&Pipeline);
@@ -215,6 +217,8 @@ void GLRenderState::FetchState()
 		m_Real->glGetIntegerv(eGL_STENCIL_PASS_DEPTH_PASS, (GLint *)&StencilFront.pass);
 		m_Real->glGetIntegerv(eGL_STENCIL_BACK_PASS_DEPTH_PASS, (GLint *)&StencilBack.pass);
 	}
+
+	m_Real->glGetIntegerv(eGL_STENCIL_CLEAR_VALUE, (GLint *)&StencilClearValue);
 	
 	for(size_t i=0; i < ARRAY_COUNT(ColorMasks); i++)
 		m_Real->glGetBooleanv(eGL_COLOR_WRITEMASK, &ColorMasks[i].red);
@@ -222,6 +226,8 @@ void GLRenderState::FetchState()
 	m_Real->glGetIntegeri_v(eGL_SAMPLE_MASK_VALUE, 0, (GLint *)&SampleMask[0]);
 	m_Real->glGetIntegerv(eGL_SAMPLE_COVERAGE_VALUE, (GLint *)&SampleCoverage);
 	m_Real->glGetIntegerv(eGL_SAMPLE_COVERAGE_INVERT, (GLint *)&boolread); SampleCoverageInvert = (boolread != 0);
+	
+	m_Real->glGetIntegerv(eGL_LOGIC_OP_MODE, (GLint *)&LogicOp);
 
 	m_Real->glGetFloatv(eGL_COLOR_CLEAR_VALUE, &ColorClearValue.red);
 	
@@ -308,6 +314,8 @@ void GLRenderState::ApplyState()
 	
 	m_Real->glPointParameterf(eGL_POINT_FADE_THRESHOLD_SIZE, PointFadeThresholdSize);
 	m_Real->glPointParameteri(eGL_POINT_SPRITE_COORD_ORIGIN, (GLint)PointSpriteOrigin);
+	m_Real->glLineWidth(LineWidth);
+	m_Real->glPointSize(PointSize);
 
 	m_Real->glUseProgram(Program);
 	m_Real->glBindProgramPipeline(Pipeline);
@@ -428,6 +436,8 @@ void GLRenderState::ApplyState()
 		m_Real->glStencilOpSeparate(eGL_FRONT, StencilFront.stencilFail, StencilFront.depthFail, StencilFront.pass);
 		m_Real->glStencilOpSeparate(eGL_BACK, StencilBack.stencilFail, StencilBack.depthFail, StencilBack.pass);
 	}
+
+	m_Real->glClearStencil((GLint)StencilClearValue);
 	
 	for(GLuint i=0; i < (GLuint)ARRAY_COUNT(ColorMasks); i++)
 		m_Real->glColorMaski(i, ColorMasks[i].red, ColorMasks[i].green, ColorMasks[i].blue, ColorMasks[i].alpha);
@@ -435,6 +445,8 @@ void GLRenderState::ApplyState()
 	m_Real->glSampleMaski(0, (GLbitfield)SampleMask[0]);
 	m_Real->glSampleCoverage(SampleCoverage, SampleCoverageInvert ? GL_TRUE : GL_FALSE);
 
+	m_Real->glLogicOp(LogicOp);
+
 	m_Real->glClearColor(ColorClearValue.red, ColorClearValue.green, ColorClearValue.blue, ColorClearValue.alpha);
 	
 	m_Real->glPatchParameteri(eGL_PATCH_VERTICES, PatchParams.numVerts);
@@ -461,6 +473,8 @@ void GLRenderState::Clear()
 	
 	RDCEraseEl(PointFadeThresholdSize);
 	RDCEraseEl(PointSpriteOrigin);
+	RDCEraseEl(LineWidth);
+	RDCEraseEl(PointSize);
 	
 	RDCEraseEl(Program);
 	RDCEraseEl(Pipeline);
@@ -490,10 +504,12 @@ void GLRenderState::Clear()
 	RDCEraseEl(DepthFunc);
 	RDCEraseEl(StencilFront);
 	RDCEraseEl(StencilBack);
+	RDCEraseEl(StencilClearValue);
 	RDCEraseEl(ColorMasks);
 	RDCEraseEl(SampleMask);
 	RDCEraseEl(SampleCoverage);
 	RDCEraseEl(SampleCoverageInvert);
+	RDCEraseEl(LogicOp);
 	RDCEraseEl(ColorClearValue);
 
 	RDCEraseEl(Hints);
@@ -550,6 +566,8 @@ void GLRenderState::Serialise(LogState state, void *ctx, WrappedOpenGL *gl)
 	
 	m_pSerialiser->Serialise("GL_POINT_FADE_THRESHOLD_SIZE", PointFadeThresholdSize);
 	m_pSerialiser->Serialise("GL_POINT_SPRITE_COORD_ORIGIN", PointSpriteOrigin);
+	m_pSerialiser->Serialise("GL_LINE_WIDTH", LineWidth);
+	m_pSerialiser->Serialise("GL_POINT_SIZE", PointSize);
 
 	for(size_t i=0; i < ARRAY_COUNT(BufferBindings); i++)
 	{
@@ -688,6 +706,8 @@ void GLRenderState::Serialise(LogState state, void *ctx, WrappedOpenGL *gl)
 		m_pSerialiser->Serialise("GL_STENCIL_BACK_PASS_DEPTH_PASS", StencilBack.pass);
 	}
 
+	m_pSerialiser->Serialise("GL_STENCIL_CLEAR_VALUE", StencilClearValue);
+
 	for(size_t i=0; i < ARRAY_COUNT(ColorMasks); i++)
 		m_pSerialiser->Serialise<4>("GL_COLOR_WRITEMASK", &ColorMasks[i].red);
 	
@@ -695,6 +715,8 @@ void GLRenderState::Serialise(LogState state, void *ctx, WrappedOpenGL *gl)
 	m_pSerialiser->Serialise("GL_SAMPLE_COVERAGE_VALUE", SampleCoverage);
 	m_pSerialiser->Serialise("GL_SAMPLE_COVERAGE_INVERT", SampleCoverageInvert);
 
+	m_pSerialiser->Serialise("GL_LOGIC_OP_MODE", LogicOp);
+
 	m_pSerialiser->Serialise<4>("GL_COLOR_CLEAR_VALUE", &ColorClearValue.red);
 
 	{

renderdoc/driver/gl/gl_renderstate.h

@@ -112,6 +112,8 @@ struct GLRenderState
 
 	float PointFadeThresholdSize;
 	GLenum PointSpriteOrigin;
+	float LineWidth;
+	float PointSize;
 
 	uint32_t BufferBindings[10];
 	struct IdxRangeBuffer
@@ -184,6 +186,7 @@ struct GLRenderState
 		GLenum depthFail;
 		GLenum pass;
 	} StencilBack, StencilFront;
+	uint32_t StencilClearValue;
 
 	struct
 	{
@@ -194,6 +197,8 @@ struct GLRenderState
 	float SampleCoverage;
 	bool SampleCoverageInvert;
 
+	GLenum LogicOp;
+
 	struct
 	{
 		float red, green, blue, alpha;

renderdoc/driver/gl/wrappers/gl_state_funcs.cpp

@@ -269,6 +269,31 @@ void WrappedOpenGL::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum
 	}
 }
 
+bool WrappedOpenGL::Serialise_glLogicOp(GLenum opcode)
+{
+	SERIALISE_ELEMENT(GLenum, Op, opcode);
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glLogicOp(Op);
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glLogicOp(GLenum opcode)
+{
+	m_Real.glLogicOp(opcode);
+	
+	if(m_State == WRITING_CAPFRAME)
+	{
+		SCOPED_SERIALISE_CONTEXT(LOGIC_OP);
+		Serialise_glLogicOp(opcode);
+
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+}
+
 bool WrappedOpenGL::Serialise_glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
 	SERIALISE_ELEMENT(GLenum, f, func);
@@ -458,6 +483,31 @@ void WrappedOpenGL::glClearColor(GLclampf red, GLclampf green, GLclampf blue, GL
 	}
 }
 
+bool WrappedOpenGL::Serialise_glClearStencil(GLint stencil)
+{
+	SERIALISE_ELEMENT(uint32_t, s, (uint32_t)stencil);
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glClearStencil((GLint)s);
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glClearStencil(GLint stencil)
+{
+	m_Real.glClearStencil(stencil);
+
+	if(m_State == WRITING_CAPFRAME)
+	{
+		SCOPED_SERIALISE_CONTEXT(CLEAR_STENCIL);
+		Serialise_glClearStencil(stencil);
+
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+}
+
 bool WrappedOpenGL::Serialise_glClearDepth(GLclampd depth)
 {
 	SERIALISE_ELEMENT(double, d, depth);
@@ -978,6 +1028,56 @@ void WrappedOpenGL::glPatchParameterfv(GLenum pname, const GLfloat *values)
 	}
 }
 
+bool WrappedOpenGL::Serialise_glLineWidth(GLfloat width)
+{
+	SERIALISE_ELEMENT(GLfloat, w, width);
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glLineWidth(w);
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glLineWidth(GLfloat width)
+{
+	m_Real.glLineWidth(width);
+	
+	if(m_State == WRITING_CAPFRAME)
+	{
+		SCOPED_SERIALISE_CONTEXT(LINE_WIDTH);
+		Serialise_glLineWidth(width);
+
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+}
+
+bool WrappedOpenGL::Serialise_glPointSize(GLfloat size)
+{
+	SERIALISE_ELEMENT(GLfloat, s, size);
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glPointSize(s);
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glPointSize(GLfloat size)
+{
+	m_Real.glPointSize(size);
+	
+	if(m_State == WRITING_CAPFRAME)
+	{
+		SCOPED_SERIALISE_CONTEXT(POINT_SIZE);
+		Serialise_glPointSize(size);
+
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+}
+
 bool WrappedOpenGL::Serialise_glPointParameteri(GLenum pname, GLint param)
 {
 	SERIALISE_ELEMENT(GLenum, PName, pname);