Fill in some functions that were implemented but not serialised

renderdoc/driver/gl/gl_common.h

@@ -127,6 +127,7 @@ enum GLChunkType
 	POLYGON_MODE,
 	POLYGON_OFFSET,
 	CULL_FACE,
+	HINT,
 	ENABLE,
 	DISABLE,
 	ENABLEI,
@@ -157,9 +158,12 @@ enum GLChunkType
 
 	GEN_FRAMEBUFFERS,
 	FRAMEBUFFER_TEX,
+	READ_BUFFER,
 	BIND_FRAMEBUFFER,
 	BLIT_FRAMEBUFFER,
 
+	GEN_SAMPLERS,
+	SAMPLER_PARAMETERI,
 	BIND_SAMPLER,
 
 	GEN_BUFFER,

renderdoc/driver/gl/gl_context_driver.cpp

@@ -536,11 +536,30 @@ void WrappedOpenGL::glCullFace(GLenum mode)
 	}
 }
 
+bool WrappedOpenGL::Serialise_glHint(GLenum target, GLenum mode)
+{
+	SERIALISE_ELEMENT(GLenum, t, target);
+	SERIALISE_ELEMENT(GLenum, m, mode);
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glHint(t, m);
+	}
+
+	return true;
+}
+
 void WrappedOpenGL::glHint(GLenum target, GLenum mode)
 {
 	m_Real.glHint(target, mode);
 
-	RDCUNIMPLEMENTED();
+	if(m_State == WRITING_CAPFRAME)
+	{
+		SCOPED_SERIALISE_CONTEXT(HINT);
+		Serialise_glHint(target, mode);
+
+		m_ContextRecord->AddChunk(scope.Get());
+	}
 }
 
 bool WrappedOpenGL::Serialise_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
@@ -788,77 +807,6 @@ void WrappedOpenGL::glPolygonOffset(GLfloat factor, GLfloat units)
 	}
 }
 
-bool WrappedOpenGL::Serialise_glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-	SERIALISE_ELEMENT(GLenum, Target, target);
-	SERIALISE_ELEMENT(ResourceId, Id, GetResourceManager()->GetID(FramebufferRes(framebuffer)));
-
-	if(m_State <= EXECUTING)
-	{
-		if(Id == ResourceId())
-		{
-			m_Real.glBindFramebuffer(Target, m_FakeBB_FBO);
-		}
-		else
-		{
-			GLResource res = GetResourceManager()->GetLiveResource(Id);
-			m_Real.glBindFramebuffer(Target, res.name);
-		}
-	}
-
-	return true;
-}
-
-void WrappedOpenGL::glBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-	if(m_State == WRITING_CAPFRAME)
-	{
-		SCOPED_SERIALISE_CONTEXT(BIND_FRAMEBUFFER);
-		Serialise_glBindFramebuffer(target, framebuffer);
-		
-		m_ContextRecord->AddChunk(scope.Get());
-	}
-
-	if(framebuffer == 0 && (m_State == READING || m_State == EXECUTING))
-		framebuffer = m_FakeBB_FBO;
-
-	m_Real.glBindFramebuffer(target, framebuffer);
-}
-
-bool WrappedOpenGL::Serialise_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-	SERIALISE_ELEMENT(int32_t, sX0, srcX0);
-	SERIALISE_ELEMENT(int32_t, sY0, srcY0);
-	SERIALISE_ELEMENT(int32_t, sX1, srcX1);
-	SERIALISE_ELEMENT(int32_t, sY1, srcY1);
-	SERIALISE_ELEMENT(int32_t, dX0, dstX0);
-	SERIALISE_ELEMENT(int32_t, dY0, dstY0);
-	SERIALISE_ELEMENT(int32_t, dX1, dstX1);
-	SERIALISE_ELEMENT(int32_t, dY1, dstY1);
-	SERIALISE_ELEMENT(uint32_t, msk, mask);
-	SERIALISE_ELEMENT(GLenum, flt, filter);
-	
-	if(m_State <= EXECUTING)
-	{
-		m_Real.glBlitFramebuffer(sX0, sY0, sX1, sY1, dX0, dY0, dX1, dY1, msk, flt);
-	}
-
-	return true;
-}
-
-void WrappedOpenGL::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-	if(m_State == WRITING_CAPFRAME)
-	{
-		SCOPED_SERIALISE_CONTEXT(BLIT_FRAMEBUFFER);
-		Serialise_glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-		
-		m_ContextRecord->AddChunk(scope.Get());
-	}
-	
-	m_Real.glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
 #pragma endregion
 
 #pragma region Debugging annotation

renderdoc/driver/gl/gl_device_driver.cpp

@@ -278,7 +278,7 @@ bool WrappedOpenGL::Serialise_glTexParameteri(GLenum target, GLenum pname, GLint
 	SERIALISE_ELEMENT(GLenum, PName, pname);
 	SERIALISE_ELEMENT(int32_t, Param, param);
 	
-	if(m_State == READING)
+	if(m_State < WRITING)
 	{
 		glTexParameteri(Target, PName, Param);
 	}
@@ -297,10 +297,31 @@ void WrappedOpenGL::glTexParameteri(GLenum target, GLenum pname, GLint param)
 		SCOPED_SERIALISE_CONTEXT(TEXPARAMETERI);
 		Serialise_glTexParameteri(target, pname, param);
 
-		m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get());
+		if(m_State == WRITING_IDLE)
+			m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get());
+		else
+			m_ContextRecord->AddChunk(scope.Get());
 	}
 }
 
+bool WrappedOpenGL::Serialise_glGenSamplers(GLsizei n, GLuint* samplers)
+{
+	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(*samplers)));
+
+	if(m_State == READING)
+	{
+		GLuint real = 0;
+		m_Real.glGenSamplers(1, &real);
+		
+		GLResource res = SamplerRes(real);
+
+		ResourceId live = m_ResourceManager->RegisterResource(res);
+		GetResourceManager()->AddLiveResource(id, res);
+	}
+
+	return true;
+}
+
 void WrappedOpenGL::glGenSamplers(GLsizei count, GLuint *samplers)
 {
 	m_Real.glGenSamplers(count, samplers);
@@ -312,7 +333,19 @@ void WrappedOpenGL::glGenSamplers(GLsizei count, GLuint *samplers)
 
 		if(m_State >= WRITING)
 		{
-			RDCUNIMPLEMENTED();
+			Chunk *chunk = NULL;
+
+			{
+				SCOPED_SERIALISE_CONTEXT(GEN_SAMPLERS);
+				Serialise_glGenSamplers(1, samplers+i);
+
+				chunk = scope.Get();
+			}
+
+			GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id);
+			RDCASSERT(record);
+
+			record->AddChunk(chunk);
 		}
 		else
 		{
@@ -348,13 +381,34 @@ void WrappedOpenGL::glBindSampler(GLuint unit, GLuint sampler)
 	}
 }
 
+bool WrappedOpenGL::Serialise_glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
+{
+	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(sampler)));
+	SERIALISE_ELEMENT(GLenum, PName, pname);
+	SERIALISE_ELEMENT(int32_t, Param, param);
+
+	if(m_State < WRITING)
+	{
+		GLResource res = GetResourceManager()->GetLiveResource(id);
+		glSamplerParameteri(res.name, pname, param);
+	}
+
+	return true;
+}
+
 void WrappedOpenGL::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
 {
 	m_Real.glSamplerParameteri(sampler, pname, param);
 	
 	if(m_State >= WRITING)
 	{
-		RDCUNIMPLEMENTED();
+		SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERI);
+		Serialise_glSamplerParameteri(sampler, pname, param);
+
+		if(m_State == WRITING_IDLE)
+			GetResourceManager()->GetResourceRecord(SamplerRes(sampler))->AddChunk(scope.Get());
+		else
+			m_ContextRecord->AddChunk(scope.Get());
 	}
 }
 
@@ -363,7 +417,7 @@ bool WrappedOpenGL::Serialise_glPixelStorei(GLenum pname, GLint param)
 	SERIALISE_ELEMENT(GLenum, PName, pname);
 	SERIALISE_ELEMENT(int32_t, Param, param);
 
-	if(m_State == READING)
+	if(m_State < WRITING)
 		m_Real.glPixelStorei(PName, Param);
 
 	return true;
@@ -390,6 +444,8 @@ void WrappedOpenGL::glPixelStoref(GLenum pname, GLfloat param)
 void WrappedOpenGL::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
 	m_Real.glTexImage1D(target, level, internalformat, width, border, format, type, pixels);
+
+	RDCUNIMPLEMENTED();
 }
 
 void WrappedOpenGL::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
@@ -434,6 +490,24 @@ void WrappedOpenGL::glActiveTexture(GLenum texture)
 
 #pragma region Framebuffers
 
+bool WrappedOpenGL::Serialise_glGenFramebuffers(GLsizei n, GLuint* framebuffers)
+{
+	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(FramebufferRes(*framebuffers)));
+
+	if(m_State == READING)
+	{
+		GLuint real = 0;
+		m_Real.glGenFramebuffers(1, &real);
+		
+		GLResource res = FramebufferRes(real);
+
+		ResourceId live = m_ResourceManager->RegisterResource(res);
+		GetResourceManager()->AddLiveResource(id, res);
+	}
+
+	return true;
+}
+
 void WrappedOpenGL::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 {
 	m_Real.glGenFramebuffers(n, framebuffers);
@@ -445,7 +519,19 @@ void WrappedOpenGL::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 		
 		if(m_State >= WRITING)
 		{
-			RDCUNIMPLEMENTED();
+			Chunk *chunk = NULL;
+
+			{
+				SCOPED_SERIALISE_CONTEXT(GEN_FRAMEBUFFERS);
+				Serialise_glGenFramebuffers(1, framebuffers+i);
+
+				chunk = scope.Get();
+			}
+
+			GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id);
+			RDCASSERT(record);
+
+			record->AddChunk(chunk);
 		}
 		else
 		{
@@ -454,20 +540,163 @@ void WrappedOpenGL::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 	}
 }
 
+bool WrappedOpenGL::Serialise_glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
+{
+	SERIALISE_ELEMENT(GLenum, Target, target);
+	SERIALISE_ELEMENT(GLenum, Attach, attachment);
+	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(texture)));
+	SERIALISE_ELEMENT(int32_t, Level, level);
+	
+	if(m_State < WRITING)
+	{
+		GLResource res = GetResourceManager()->GetLiveResource(id);
+		glFramebufferTexture(Target, Attach, res.name, Level);
+	}
+
+	return true;
+}
+
 void WrappedOpenGL::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
 {
 	m_Real.glFramebufferTexture(target, attachment, texture, level);
 	
 	if(m_State >= WRITING)
-		RDCUNIMPLEMENTED();
+	{
+		SCOPED_SERIALISE_CONTEXT(FRAMEBUFFER_TEX);
+		Serialise_glFramebufferTexture(target, attachment, texture, level);
+
+		if(m_State == WRITING_IDLE)
+		{
+			if(target == eGL_DRAW_FRAMEBUFFER || target == eGL_FRAMEBUFFER)
+			{
+				if(m_DrawFramebufferRecord)
+					m_DeviceRecord->AddChunk(scope.Get());
+				else
+					m_DrawFramebufferRecord->AddChunk(scope.Get());
+			}
+			else
+			{
+				if(m_ReadFramebufferRecord)
+					m_DeviceRecord->AddChunk(scope.Get());
+				else
+					m_ReadFramebufferRecord->AddChunk(scope.Get());
+			}
+		}
+		else
+			m_ContextRecord->AddChunk(scope.Get());
+	}
+}
+
+bool WrappedOpenGL::Serialise_glReadBuffer(GLenum mode)
+{
+	SERIALISE_ELEMENT(GLenum, m, mode);
+
+	if(m_State < WRITING)
+		m_Real.glReadBuffer(m);
+	
+	return true;
+}
+
+void WrappedOpenGL::glReadBuffer(GLenum mode)
+{
+	m_Real.glReadBuffer(mode);
+	
+	if(m_State >= WRITING)
+	{
+		SCOPED_SERIALISE_CONTEXT(READ_BUFFER);
+		Serialise_glReadBuffer(mode);
+
+		if(m_State == WRITING_IDLE)
+		{
+			if(m_ReadFramebufferRecord)
+				m_ReadFramebufferRecord->AddChunk(scope.Get());
+			else
+				m_DeviceRecord->AddChunk(scope.Get());
+		}
+		else
+			m_ContextRecord->AddChunk(scope.Get());
+	}
+}
+
+bool WrappedOpenGL::Serialise_glBindFramebuffer(GLenum target, GLuint framebuffer)
+{
+	SERIALISE_ELEMENT(GLenum, Target, target);
+	SERIALISE_ELEMENT(ResourceId, Id, GetResourceManager()->GetID(FramebufferRes(framebuffer)));
+
+	if(m_State <= EXECUTING)
+	{
+		if(Id == ResourceId())
+		{
+			m_Real.glBindFramebuffer(Target, m_FakeBB_FBO);
+		}
+		else
+		{
+			GLResource res = GetResourceManager()->GetLiveResource(Id);
+			m_Real.glBindFramebuffer(Target, res.name);
+		}
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glBindFramebuffer(GLenum target, GLuint framebuffer)
+{
+	if(m_State == WRITING_CAPFRAME)
+	{
+		SCOPED_SERIALISE_CONTEXT(BIND_FRAMEBUFFER);
+		Serialise_glBindFramebuffer(target, framebuffer);
+		
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+
+	if(framebuffer == 0 && m_State < WRITING)
+		framebuffer = m_FakeBB_FBO;
+
+	if(target == eGL_DRAW_FRAMEBUFFER || target == eGL_FRAMEBUFFER)
+		m_DrawFramebufferRecord = GetResourceManager()->GetResourceRecord(FramebufferRes(framebuffer));
+	else
+		m_ReadFramebufferRecord = GetResourceManager()->GetResourceRecord(FramebufferRes(framebuffer));
+
+	m_Real.glBindFramebuffer(target, framebuffer);
+}
+
+bool WrappedOpenGL::Serialise_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
+{
+	SERIALISE_ELEMENT(int32_t, sX0, srcX0);
+	SERIALISE_ELEMENT(int32_t, sY0, srcY0);
+	SERIALISE_ELEMENT(int32_t, sX1, srcX1);
+	SERIALISE_ELEMENT(int32_t, sY1, srcY1);
+	SERIALISE_ELEMENT(int32_t, dX0, dstX0);
+	SERIALISE_ELEMENT(int32_t, dY0, dstY0);
+	SERIALISE_ELEMENT(int32_t, dX1, dstX1);
+	SERIALISE_ELEMENT(int32_t, dY1, dstY1);
+	SERIALISE_ELEMENT(uint32_t, msk, mask);
+	SERIALISE_ELEMENT(GLenum, flt, filter);
+	
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glBlitFramebuffer(sX0, sY0, sX1, sY1, dX0, dY0, dX1, dY1, msk, flt);
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
+{
+	if(m_State == WRITING_CAPFRAME)
+	{
+		SCOPED_SERIALISE_CONTEXT(BLIT_FRAMEBUFFER);
+		Serialise_glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+		
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+	
+	m_Real.glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 void WrappedOpenGL::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 {
 	m_Real.glDeleteFramebuffers(n, framebuffers);
-	
-	if(m_State >= WRITING)
-		RDCUNIMPLEMENTED();
 
 	for(GLsizei i=0; i < n; i++)
 		GetResourceManager()->UnregisterResource(FramebufferRes(framebuffers[i]));

renderdoc/driver/gl/gl_driver.cpp

@@ -84,6 +84,7 @@ const char *GLChunkNames[] =
 	"glPolygonMode",
 	"glPolygonOffset",
 	"glCullFace",
+	"glHint",
 	"glEnable",
 	"glDisable",
 	"glEnablei",
@@ -114,9 +115,12 @@ const char *GLChunkNames[] =
 
 	"glGenFramebuffers",
 	"glFramebufferTexture",
+	"glReadBuffer",
 	"glBindFramebuffer",
 	"glBlitFramebuffer",
 
+	"glGenSamplers",
+	"glSamplerParameteri",
 	"glBindSampler",
 
 	"glGenBuffers",
@@ -224,6 +228,10 @@ WrappedOpenGL::WrappedOpenGL(const wchar_t *logfile, const GLHookSet &funcs)
 	m_CurDrawcallID = 1;
 
 	RDCEraseEl(m_TextureRecord);
+	RDCEraseEl(m_BufferRecord);
+	m_VertexArrayRecord = NULL;
+	m_DrawFramebufferRecord = NULL;
+	m_ReadFramebufferRecord = NULL;
 	m_TextureUnit = 0;
 	
 	m_LastIndexSize = eGL_UNKNOWN_ENUM;
@@ -973,17 +981,32 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 		Serialise_glRotatef(0, 0, 0, 0);
 		break;
 	//
-
+		
+	case GEN_FRAMEBUFFERS:
+		Serialise_glGenFramebuffers(0, NULL);
+		break;
 	case BIND_FRAMEBUFFER:
 		Serialise_glBindFramebuffer(eGL_UNKNOWN_ENUM, 0);
 		break;
+	case READ_BUFFER:
+		Serialise_glReadBuffer(eGL_UNKNOWN_ENUM);
+		break;
+	case FRAMEBUFFER_TEX:
+		Serialise_glFramebufferTexture(eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, 0, 0);
+		break;
 	case BLIT_FRAMEBUFFER:
 		Serialise_glBlitFramebuffer(0, 0, 0, 0, 0, 0, 0, 0, 0, eGL_UNKNOWN_ENUM);
 		break;
-
+		
+	case GEN_SAMPLERS:
+		Serialise_glGenSamplers(0, NULL);
+		break;
 	case BIND_SAMPLER:
 		Serialise_glBindSampler(0, 0);
 		break;
+	case SAMPLER_PARAMETERI:
+		Serialise_glSamplerParameteri(0, eGL_UNKNOWN_ENUM, 0);
+		break;
 		
 	case CLEAR_COLOR:
 		Serialise_glClearColor(0, 0, 0, 0);
@@ -1018,6 +1041,9 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 	case DISABLE:
 		Serialise_glDisable(eGL_UNKNOWN_ENUM);
 		break;
+	case HINT:
+		Serialise_glHint(eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM);
+		break;
 	case ENABLE:
 		Serialise_glEnable(eGL_UNKNOWN_ENUM);
 		break;
@@ -1450,7 +1476,7 @@ void WrappedOpenGL::ReplayLog(uint32_t frameID, uint32_t startEventID, uint32_t
 	}
 }
 
-#pragma region Get functions
+#pragma region Read-only functions
 
 GLenum WrappedOpenGL::glGetError()
 {
@@ -1670,9 +1696,4 @@ void WrappedOpenGL::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height
 	m_Real.glReadPixels(x, y, width, height, format, type, pixels);
 }
 
-void WrappedOpenGL::glReadBuffer(GLenum mode)
-{
-	m_Real.glReadBuffer(mode);
-}
-
 #pragma endregion

renderdoc/driver/gl/gl_driver.h

@@ -102,6 +102,8 @@ class WrappedOpenGL
 		GLResourceRecord *m_TextureRecord[128];
 		GLResourceRecord *m_BufferRecord[16];
 		GLResourceRecord *m_VertexArrayRecord;
+		GLResourceRecord *m_DrawFramebufferRecord;
+		GLResourceRecord *m_ReadFramebufferRecord;
 		GLint m_TextureUnit;
 
 		size_t BufferIdx(GLenum buf);