Add functions for separable programs and program pipelines.

renderdoc/driver/gl/gl_common.h

@@ -95,11 +95,19 @@ enum GLChunkType
 
 	CREATE_SHADER,
 	CREATE_PROGRAM,
+	CREATE_SHADERPROGRAM,
 	COMPILESHADER,
 	SHADERSOURCE,
 	ATTACHSHADER,
+	USEPROGRAM,
+	PROGRAMPARAMETER,
+	PROGRAMUNIFORM_VECTOR,
 	LINKPROGRAM,
 
+	GEN_PROGRAMPIPE,
+	USE_PROGRAMSTAGES,
+	BIND_PROGRAMPIPE,
+
 	// legacy/immediate mode chunks
 	LIGHTFV,
 	MATERIALFV,
@@ -155,7 +163,6 @@ enum GLChunkType
 	VIEWPORT_ARRAY,
 	SCISSOR,
 	SCISSOR_ARRAY,
-	USEPROGRAM,
 	BINDVERTEXARRAY,
 	UNIFORM_MATRIX,
 	UNIFORM_VECTOR,

renderdoc/driver/gl/gl_device_driver.cpp

@@ -1154,7 +1154,7 @@ GLenum WrappedOpenGL::glCheckFramebufferStatus(GLenum target)
 
 #pragma endregion
 
-#pragma region Shaders / Programs
+#pragma region Shaders
 
 bool WrappedOpenGL::Serialise_glCreateShader(GLuint shader, GLenum type)
 {
@@ -1297,6 +1297,11 @@ void WrappedOpenGL::glCompileShader(GLuint shader)
 	}
 }
 
+void WrappedOpenGL::glReleaseShaderCompiler()
+{
+	m_Real.glReleaseShaderCompiler();
+}
+
 void WrappedOpenGL::glDeleteShader(GLuint shader)
 {
 	m_Real.glDeleteShader(shader);
@@ -1342,6 +1347,77 @@ void WrappedOpenGL::glAttachShader(GLuint program, GLuint shader)
 	}
 }
 
+#pragma endregion
+
+#pragma region Programs
+
+bool WrappedOpenGL::Serialise_glCreateShaderProgramv(GLuint program, GLenum type, GLsizei count, const GLchar *const*strings)
+{
+	SERIALISE_ELEMENT(GLenum, Type, type);
+	SERIALISE_ELEMENT(int32_t, Count, count);
+	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(program)));
+
+	vector<string> src;
+
+	for(int32_t i=0; i < Count; i++)
+	{
+		string s;
+		if(m_State >= WRITING) s = strings[i];
+		m_pSerialiser->SerialiseString("Source", s);
+		if(m_State < WRITING) src.push_back(s);
+	}
+
+	if(m_State == READING)
+	{
+		char **sources = new char*[Count];
+		
+		for(int32_t i=0; i < Count; i++)
+			sources[i] = &src[i][0];
+
+		GLuint real = m_Real.glCreateShaderProgramv(Type, Count, sources);
+
+		delete[] sources;
+		
+		GLResource res = ProgramRes(program);
+
+		m_ResourceManager->RegisterResource(res);
+		GetResourceManager()->AddLiveResource(id, res);
+	}
+
+	return true;
+}
+
+GLuint WrappedOpenGL::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const*strings)
+{
+	GLuint real = m_Real.glCreateShaderProgramv(type, count, strings);
+	
+	GLResource res = ProgramRes(real);
+	ResourceId id = GetResourceManager()->RegisterResource(res);
+		
+	if(m_State >= WRITING)
+	{
+		Chunk *chunk = NULL;
+
+		{
+			SCOPED_SERIALISE_CONTEXT(CREATE_SHADERPROGRAM);
+			Serialise_glCreateShaderProgramv(real, type, count, strings);
+
+			chunk = scope.Get();
+		}
+
+		GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id);
+		RDCASSERT(record);
+
+		record->AddChunk(chunk);
+	}
+	else
+	{
+		GetResourceManager()->AddLiveResource(id, res);
+	}
+
+	return real;
+}
+
 bool WrappedOpenGL::Serialise_glCreateProgram(GLuint program)
 {
 	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(program)));
@@ -1419,6 +1495,37 @@ void WrappedOpenGL::glLinkProgram(GLuint program)
 	}
 }
 
+bool WrappedOpenGL::Serialise_glProgramParameteri(GLuint program, GLenum pname, GLint value)
+{
+	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(program)));
+	SERIALISE_ELEMENT(GLenum, PName, pname);
+	SERIALISE_ELEMENT(int32_t, Value, value);
+
+	if(m_State == READING)
+	{
+		m_Real.glProgramParameteri(GetResourceManager()->GetLiveResource(id).name, PName, Value);
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glProgramParameteri(GLuint program, GLenum pname, GLint value)
+{
+	m_Real.glProgramParameteri(program, pname, value);
+	
+	if(m_State >= WRITING)
+	{
+		GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program));
+		RDCASSERT(record);
+		{
+			SCOPED_SERIALISE_CONTEXT(PROGRAMPARAMETER);
+			Serialise_glProgramParameteri(program, pname, value);
+
+			record->AddChunk(scope.Get());
+		}
+	}
+}
+
 void WrappedOpenGL::glDeleteProgram(GLuint program)
 {
 	m_Real.glDeleteProgram(program);
@@ -1451,6 +1558,143 @@ void WrappedOpenGL::glUseProgram(GLuint program)
 	}
 }
 
+void WrappedOpenGL::glValidateProgram(GLuint program)
+{
+	m_Real.glValidateProgram(program);
+}
+
+void WrappedOpenGL::glValidateProgramPipeline(GLuint pipeline)
+{
+	m_Real.glValidateProgramPipeline(pipeline);
+}
+
+#pragma endregion
+
+#pragma region Program Pipelines
+
+bool WrappedOpenGL::Serialise_glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
+{
+	SERIALISE_ELEMENT(ResourceId, pipe, GetResourceManager()->GetID(ProgramPipeRes(pipeline)));
+	SERIALISE_ELEMENT(uint32_t, Stages, stages);
+	SERIALISE_ELEMENT(ResourceId, prog, GetResourceManager()->GetID(ProgramRes(program)));
+
+	if(m_State < WRITING)
+	{
+		m_Real.glUseProgramStages(GetResourceManager()->GetLiveResource(pipe).name,
+															stages,
+															GetResourceManager()->GetLiveResource(prog).name);
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
+{
+	m_Real.glUseProgramStages(pipeline, stages, program);
+
+	if(m_State > WRITING)
+	{
+		SCOPED_SERIALISE_CONTEXT(USE_PROGRAMSTAGES);
+		Serialise_glUseProgramStages(pipeline, stages, program);
+		
+		if(m_State == WRITING_CAPFRAME)
+		{
+			GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramPipeRes(pipeline));
+			RDCASSERT(record);
+			record->AddChunk(scope.Get());
+		}
+		else
+		{
+			m_ContextRecord->AddChunk(scope.Get());
+		}
+	}
+}
+
+bool WrappedOpenGL::Serialise_glGenProgramPipelines(GLsizei n, GLuint* pipelines)
+{
+	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramPipeRes(*pipelines)));
+
+	if(m_State == READING)
+	{
+		GLuint real = 0;
+		m_Real.glGenProgramPipelines(1, &real);
+		
+		GLResource res = ProgramPipeRes(real);
+
+		ResourceId live = m_ResourceManager->RegisterResource(res);
+		GetResourceManager()->AddLiveResource(id, res);
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
+{
+	m_Real.glGenProgramPipelines(n, pipelines);
+
+	for(GLsizei i=0; i < n; i++)
+	{
+		GLResource res = ProgramPipeRes(pipelines[i]);
+		ResourceId id = GetResourceManager()->RegisterResource(res);
+
+		if(m_State >= WRITING)
+		{
+			Chunk *chunk = NULL;
+
+			{
+				SCOPED_SERIALISE_CONTEXT(GEN_PROGRAMPIPE);
+				Serialise_glGenProgramPipelines(1, pipelines+i);
+
+				chunk = scope.Get();
+			}
+
+			GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id);
+			RDCASSERT(record);
+
+			record->AddChunk(chunk);
+		}
+		else
+		{
+			GetResourceManager()->AddLiveResource(id, res);
+		}
+	}
+}
+
+bool WrappedOpenGL::Serialise_glBindProgramPipeline(GLuint pipeline)
+{
+	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramPipeRes(pipeline)));
+
+	if(m_State <= EXECUTING)
+	{
+		m_Real.glBindProgramPipeline(GetResourceManager()->GetLiveResource(id).name);
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glBindProgramPipeline(GLuint pipeline)
+{
+	m_Real.glBindProgramPipeline(pipeline);
+
+	if(m_State == WRITING_CAPFRAME)
+	{
+		SCOPED_SERIALISE_CONTEXT(BIND_PROGRAMPIPE);
+		Serialise_glBindProgramPipeline(pipeline);
+
+		m_ContextRecord->AddChunk(scope.Get());
+	}
+}
+
+void WrappedOpenGL::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
+{
+	m_Real.glDeleteProgramPipelines(n, pipelines);
+	
+	for(GLsizei i=0; i < n; i++)
+		GetResourceManager()->UnregisterResource(ProgramPipeRes(pipelines[i]));
+}
+
+#pragma endregion
+
 #pragma region Uniforms
 
 bool WrappedOpenGL::Serialise_glUniformMatrix(GLint location, GLsizei count, GLboolean transpose, const void *value, UniformType type)
@@ -1574,6 +1818,30 @@ bool WrappedOpenGL::Serialise_glUniformVector(GLint location, GLsizei count, con
 	{
 		switch(Type)
 		{
+			case VEC1FV:
+			{
+				float *f = (float *)value;
+				m_pSerialiser->DebugPrint("value: {%f}\n", f[0]);
+				break;
+			}
+			case VEC1IV:
+			{
+				int32_t *i = (int32_t *)value;
+				m_pSerialiser->DebugPrint("value: {%d}\n", i[0]);
+				break;
+			}
+			case VEC1UIV:
+			{
+				uint32_t *u = (uint32_t *)value;
+				m_pSerialiser->DebugPrint("value: {%u}\n", u[0]);
+				break;
+			}
+			case VEC2FV:
+			{
+				float *f = (float *)value;
+				m_pSerialiser->DebugPrint("value: {%f %f}\n", f[0], f[1]);
+				break;
+			}
 			case VEC3FV:
 			{
 				float *f = (float *)value;
@@ -1711,7 +1979,251 @@ void WrappedOpenGL::glUniform4fv(GLint location, GLsizei count, const GLfloat *v
 	}
 }
 
-#pragma endregion
+bool WrappedOpenGL::Serialise_glProgramUniformVector(GLuint program, GLint location, GLsizei count, const void *value, UniformType type)
+{
+	SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(program)));
+	SERIALISE_ELEMENT(UniformType, Type, type);
+	SERIALISE_ELEMENT(int32_t, Loc, location);
+	SERIALISE_ELEMENT(uint32_t, Count, count);
+	
+	size_t elemsPerVec = 0;
+
+	switch(Type)
+	{
+		case VEC1IV:
+		case VEC1UIV:
+		case VEC1FV: elemsPerVec = 1; break;
+		case VEC2FV: elemsPerVec = 2; break;
+		case VEC3FV: elemsPerVec = 3; break;
+		case VEC4FV: elemsPerVec = 4; break;
+		default:
+			RDCERR("Unexpected uniform type to Serialise_glProgramUniformVector: %d", Type);
+	}
+
+	if(m_State >= WRITING)
+	{
+		m_pSerialiser->RawWriteBytes(value, sizeof(float)*elemsPerVec*Count);
+	}
+	else if(m_State <= EXECUTING)
+	{
+		value = m_pSerialiser->RawReadBytes(sizeof(float)*elemsPerVec*Count);
+
+		GLuint live = GetResourceManager()->GetLiveResource(id).name;
+
+		switch(Type)
+		{
+			case VEC1IV: m_Real.glProgramUniform1iv(live, Loc, Count, (const GLint *)value); break;
+			case VEC1UIV: m_Real.glProgramUniform1uiv(live, Loc, Count, (const GLuint *)value); break;
+			case VEC1FV: m_Real.glProgramUniform1fv(live, Loc, Count, (const GLfloat *)value); break;
+			case VEC2FV: m_Real.glProgramUniform2fv(live, Loc, Count, (const GLfloat *)value); break;
+			case VEC3FV: m_Real.glProgramUniform3fv(live, Loc, Count, (const GLfloat *)value); break;
+			case VEC4FV: m_Real.glProgramUniform4fv(live, Loc, Count, (const GLfloat *)value); break;
+			default:
+				RDCERR("Unexpected uniform type to Serialise_glProgramUniformVector: %d", Type);
+		}
+	}
+
+	if(m_pSerialiser->GetDebugText())
+	{
+		switch(Type)
+		{
+			case VEC1FV:
+			{
+				float *f = (float *)value;
+				m_pSerialiser->DebugPrint("value: {%f}\n", f[0]);
+				break;
+			}
+			case VEC1IV:
+			{
+				int32_t *i = (int32_t *)value;
+				m_pSerialiser->DebugPrint("value: {%d}\n", i[0]);
+				break;
+			}
+			case VEC1UIV:
+			{
+				uint32_t *u = (uint32_t *)value;
+				m_pSerialiser->DebugPrint("value: {%u}\n", u[0]);
+				break;
+			}
+			case VEC2FV:
+			{
+				float *f = (float *)value;
+				m_pSerialiser->DebugPrint("value: {%f %f}\n", f[0], f[1]);
+				break;
+			}
+			case VEC3FV:
+			{
+				float *f = (float *)value;
+				m_pSerialiser->DebugPrint("value: {%f %f %f}\n", f[0], f[1], f[2]);
+				break;
+			}
+			case VEC4FV:
+			{
+				float *f = (float *)value;
+				m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[0], f[1], f[2], f[3]);
+				break;
+			}
+			default:
+				RDCERR("Unexpected uniform type to Serialise_glProgramUniformVector: %d", Type);
+		}
+	}
+
+	return true;
+}
+
+void WrappedOpenGL::glProgramUniform1i(GLuint program, GLint location, GLint v0)
+{
+	m_Real.glProgramUniform1i(program, location, v0);
+
+	if(m_State > WRITING)
+	{
+		SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
+		Serialise_glProgramUniformVector(program, location, 1, &v0, VEC1IV);
+		
+		if(m_State == WRITING_CAPFRAME)
+		{
+			GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program));
+			RDCASSERT(record);
+			record->AddChunk(scope.Get());
+		}
+		else
+		{
+			m_ContextRecord->AddChunk(scope.Get());
+		}
+	}
+}
+
+void WrappedOpenGL::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
+{
+	m_Real.glProgramUniform1iv(program, location, count, value);
+
+	if(m_State > WRITING)
+	{
+		SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
+		Serialise_glProgramUniformVector(program, location, count, value, VEC1IV);
+		
+		if(m_State == WRITING_CAPFRAME)
+		{
+			GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program));
+			RDCASSERT(record);
+			record->AddChunk(scope.Get());
+		}
+		else
+		{
+			m_ContextRecord->AddChunk(scope.Get());
+		}
+	}
+}
+
+void WrappedOpenGL::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
+{
+	m_Real.glProgramUniform1fv(program, location, count, value);
+
+	if(m_State > WRITING)
+	{
+		SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
+		Serialise_glProgramUniformVector(program, location, count, value, VEC1FV);
+		
+		if(m_State == WRITING_CAPFRAME)
+		{
+			GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program));
+			RDCASSERT(record);
+			record->AddChunk(scope.Get());
+		}
+		else
+		{
+			m_ContextRecord->AddChunk(scope.Get());
+		}
+	}
+}
+
+void WrappedOpenGL::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
+{
+	m_Real.glProgramUniform1uiv(program, location, count, value);
+
+	if(m_State > WRITING)
+	{
+		SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
+		Serialise_glProgramUniformVector(program, location, count, value, VEC1UIV);
+		
+		if(m_State == WRITING_CAPFRAME)
+		{
+			GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program));
+			RDCASSERT(record);
+			record->AddChunk(scope.Get());
+		}
+		else
+		{
+			m_ContextRecord->AddChunk(scope.Get());
+		}
+	}
+}
+
+void WrappedOpenGL::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
+{
+	m_Real.glProgramUniform2fv(program, location, count, value);
+
+	if(m_State > WRITING)
+	{
+		SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
+		Serialise_glProgramUniformVector(program, location, count, value, VEC2FV);
+		
+		if(m_State == WRITING_CAPFRAME)
+		{
+			GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program));
+			RDCASSERT(record);
+			record->AddChunk(scope.Get());
+		}
+		else
+		{
+			m_ContextRecord->AddChunk(scope.Get());
+		}
+	}
+}
+
+void WrappedOpenGL::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
+{
+	m_Real.glProgramUniform3fv(program, location, count, value);
+
+	if(m_State > WRITING)
+	{
+		SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
+		Serialise_glProgramUniformVector(program, location, count, value, VEC3FV);
+		
+		if(m_State == WRITING_CAPFRAME)
+		{
+			GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program));
+			RDCASSERT(record);
+			record->AddChunk(scope.Get());
+		}
+		else
+		{
+			m_ContextRecord->AddChunk(scope.Get());
+		}
+	}
+}
+
+void WrappedOpenGL::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
+{
+	m_Real.glProgramUniform4fv(program, location, count, value);
+
+	if(m_State > WRITING)
+	{
+		SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR);
+		Serialise_glProgramUniformVector(program, location, count, value, VEC4FV);
+		
+		if(m_State == WRITING_CAPFRAME)
+		{
+			GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program));
+			RDCASSERT(record);
+			record->AddChunk(scope.Get());
+		}
+		else
+		{
+			m_ContextRecord->AddChunk(scope.Get());
+		}
+	}
+}
 
 #pragma endregion
 

renderdoc/driver/gl/gl_driver.cpp

@@ -52,10 +52,18 @@ const char *GLChunkNames[] =
 
 	"glCreateShader",
 	"glCreateProgram",
+	"glCreateShaderProgramv",
 	"glCompileShader",
 	"glShaderSource",
 	"glAttachShader",
+	"glUseProgram",
+	"glProgramParameter",
+	"glProgramUniformVector*",
 	"glLinkProgram",
+	
+	"glGenProgramPipelines",
+	"glUseProgramStages",
+	"glBindProgramPipeline",
 
 	// legacy/immediate mode chunks
 	"glLightfv",
@@ -112,7 +120,6 @@ const char *GLChunkNames[] =
 	"glViewportArrayv",
 	"glScissor",
 	"glScissorArrayv",
-	"glUseProgram",
 	"glBindVertexArray",
 	"glUniformMatrix*",
 	"glUniformVector*",
@@ -1042,6 +1049,9 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 	case CREATE_PROGRAM:
 		Serialise_glCreateProgram(0);
 		break;
+	case CREATE_SHADERPROGRAM:
+		Serialise_glCreateShaderProgramv(0, eGL_UNKNOWN_ENUM, 0, NULL);
+		break;
 	case COMPILESHADER:
 		Serialise_glCompileShader(0);
 		break;
@@ -1051,10 +1061,28 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 	case ATTACHSHADER:
 		Serialise_glAttachShader(0, 0);
 		break;
+	case USEPROGRAM:
+		Serialise_glUseProgram(0);
+		break;
+	case PROGRAMPARAMETER:
+		Serialise_glProgramParameteri(0, eGL_UNKNOWN_ENUM, 0);
+		break;
+	case PROGRAMUNIFORM_VECTOR:
+		Serialise_glProgramUniformVector(0, eGL_UNKNOWN_ENUM, 0, 0, UNIFORM_UNKNOWN);
+		break;
 	case LINKPROGRAM:
 		Serialise_glLinkProgram(0);
 		break;
 		
+	case GEN_PROGRAMPIPE:
+		Serialise_glGenProgramPipelines(0, NULL);
+		break;
+	case USE_PROGRAMSTAGES:
+		Serialise_glUseProgramStages(0, 0, 0);
+		break;
+	case BIND_PROGRAMPIPE:
+		Serialise_glBindProgramPipeline(0);
+		break;
 
 	// legacy/immediate mode chunks
 	case LIGHTFV:
@@ -1259,9 +1287,6 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context)
 	case SCISSOR_ARRAY:
 		Serialise_glScissorArrayv(0, 0, 0);
 		break;
-	case USEPROGRAM:
-		Serialise_glUseProgram(0);
-		break;
 	case BINDVERTEXARRAY:
 		Serialise_glBindVertexArray(0);
 		break;
@@ -1835,6 +1860,16 @@ void WrappedOpenGL::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei
 	m_Real.glGetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
+void WrappedOpenGL::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
+{
+	m_Real.glGetProgramPipelineiv(pipeline, pname, params);
+}
+
+void WrappedOpenGL::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
+{
+	m_Real.glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
+}
+
 void WrappedOpenGL::glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params)
 {
 	m_Real.glGetProgramInterfaceiv(program, programInterface, pname, params);

renderdoc/driver/gl/gl_driver.h

@@ -374,23 +374,36 @@ class WrappedOpenGL
 		bool Serialise_glCreateShader(GLuint real, GLenum type);
 		GLuint glCreateShader(GLenum type);
 
+		bool Serialise_glCreateShaderProgramv(GLuint real, GLenum type, GLsizei count, const GLchar *const*strings);
+		GLuint glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const*strings);
+
 		bool Serialise_glCreateProgram(GLuint real);
 		GLuint glCreateProgram();
-
+		
 		IMPLEMENT_FUNCTION_SERIALISED(void, glDeleteShader(GLuint shader));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glShaderSource(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glCompileShader(GLuint shader));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glGetShaderiv(GLuint shader, GLenum pname, GLint *params));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glAttachShader(GLuint program, GLuint shader));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glReleaseShaderCompiler());
 		IMPLEMENT_FUNCTION_SERIALISED(void, glDeleteProgram(GLuint program));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glLinkProgram(GLuint program));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glProgramParameteri(GLuint program, GLenum pname, GLint value));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glUseProgram(GLuint program));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glValidateProgram(GLuint program));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glGetProgramiv(GLuint program, GLenum pname, GLint *params));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glGenProgramPipelines(GLsizei n, GLuint *pipelines));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glBindProgramPipeline(GLuint pipeline));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog));
+		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, glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage));
@@ -436,6 +449,8 @@ class WrappedOpenGL
 
 		bool Serialise_glUniformMatrix(GLint location, GLsizei count, GLboolean transpose, const void *value, UniformType type);
 		bool Serialise_glUniformVector(GLint location, GLsizei count, const void *value, UniformType type);
+		
+		bool Serialise_glProgramUniformVector(GLuint program, GLint location, GLsizei count, const void *value, UniformType type);
 
 		IMPLEMENT_FUNCTION_SERIALISED(void, glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glUniform1f(GLint location, GLfloat value));
@@ -447,6 +462,14 @@ class WrappedOpenGL
 		IMPLEMENT_FUNCTION_SERIALISED(void, glUniform2fv(GLint location, GLsizei count, const GLfloat *value));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glUniform3fv(GLint location, GLsizei count, const GLfloat *value));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glUniform4fv(GLint location, GLsizei count, const GLfloat *value));
+		
+		IMPLEMENT_FUNCTION_SERIALISED(void, glProgramUniform1i(GLuint program, GLint location, GLint v0));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value));
+		IMPLEMENT_FUNCTION_SERIALISED(void, glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value));
 
 		IMPLEMENT_FUNCTION_SERIALISED(void, glDrawArrays(GLenum mode, GLint first, GLsizei count));
 		IMPLEMENT_FUNCTION_SERIALISED(void, glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount));

renderdoc/driver/gl/gl_hookset.h

@@ -128,18 +128,36 @@ struct GLHookSet
 	PFNGLDELETESHADERPROC glDeleteShader;
 	PFNGLSHADERSOURCEPROC glShaderSource;
 	PFNGLCOMPILESHADERPROC glCompileShader;
+	PFNGLCREATESHADERPROGRAMVPROC glCreateShaderProgramv;
 	PFNGLGETSHADERIVPROC glGetShaderiv;
 	PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;
 	PFNGLCREATEPROGRAMPROC glCreateProgram;
 	PFNGLDELETEPROGRAMPROC glDeleteProgram;
 	PFNGLATTACHSHADERPROC glAttachShader;
+	PFNGLRELEASESHADERCOMPILERPROC glReleaseShaderCompiler;
 	PFNGLLINKPROGRAMPROC glLinkProgram;
+	PFNGLPROGRAMPARAMETERIPROC glProgramParameteri;
+	PFNGLPROGRAMUNIFORM1IPROC glProgramUniform1i;
+	PFNGLPROGRAMUNIFORM1FVPROC glProgramUniform1fv;
+	PFNGLPROGRAMUNIFORM1IVPROC glProgramUniform1iv;
+	PFNGLPROGRAMUNIFORM1UIVPROC glProgramUniform1uiv;
+	PFNGLPROGRAMUNIFORM2FVPROC glProgramUniform2fv;
+	PFNGLPROGRAMUNIFORM3FVPROC glProgramUniform3fv;
+	PFNGLPROGRAMUNIFORM4FVPROC glProgramUniform4fv;
 	PFNGLUSEPROGRAMPROC glUseProgram;
+	PFNGLUSEPROGRAMSTAGESPROC glUseProgramStages;
+	PFNGLVALIDATEPROGRAMPROC glValidateProgram;
 	PFNGLGETPROGRAMIVPROC glGetProgramiv;
 	PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog;
 	PFNGLGETPROGRAMINTERFACEIVPROC glGetProgramInterfaceiv;
 	PFNGLGETPROGRAMRESOURCEIVPROC glGetProgramResourceiv;
 	PFNGLGETPROGRAMRESOURCENAMEPROC glGetProgramResourceName;
+	PFNGLGENPROGRAMPIPELINESPROC glGenProgramPipelines;
+	PFNGLBINDPROGRAMPIPELINEPROC glBindProgramPipeline;
+	PFNGLDELETEPROGRAMPIPELINESPROC glDeleteProgramPipelines;
+	PFNGLGETPROGRAMPIPELINEIVPROC glGetProgramPipelineiv;
+	PFNGLGETPROGRAMPIPELINEINFOLOGPROC glGetProgramPipelineInfoLog;
+	PFNGLVALIDATEPROGRAMPIPELINEPROC glValidateProgramPipeline;
 	PFNGLDEBUGMESSAGECALLBACKPROC glDebugMessageCallback; // aliases glDebugMessageCallbackARB
 	PFNGLDEBUGMESSAGECONTROLPROC glDebugMessageControl;
 	PFNGLDEBUGMESSAGEINSERTPROC glDebugMessageInsert;

renderdoc/driver/gl/gl_hookset_defs.h

@@ -139,18 +139,36 @@
     HookExtension(PFNGLDELETESHADERPROC, glDeleteShader); \
     HookExtension(PFNGLSHADERSOURCEPROC, glShaderSource); \
     HookExtension(PFNGLCOMPILESHADERPROC, glCompileShader); \
+    HookExtension(PFNGLCREATESHADERPROGRAMVPROC, glCreateShaderProgramv); \
     HookExtension(PFNGLGETSHADERIVPROC, glGetShaderiv); \
     HookExtension(PFNGLGETSHADERINFOLOGPROC, glGetShaderInfoLog); \
     HookExtension(PFNGLCREATEPROGRAMPROC, glCreateProgram); \
     HookExtension(PFNGLDELETEPROGRAMPROC, glDeleteProgram); \
     HookExtension(PFNGLATTACHSHADERPROC, glAttachShader); \
+    HookExtension(PFNGLRELEASESHADERCOMPILERPROC, glReleaseShaderCompiler); \
     HookExtension(PFNGLLINKPROGRAMPROC, glLinkProgram); \
+    HookExtension(PFNGLPROGRAMPARAMETERIPROC, glProgramParameteri); \
+    HookExtension(PFNGLPROGRAMUNIFORM1IPROC, glProgramUniform1i); \
+    HookExtension(PFNGLPROGRAMUNIFORM1FVPROC, glProgramUniform1fv); \
+    HookExtension(PFNGLPROGRAMUNIFORM1IVPROC, glProgramUniform1iv); \
+    HookExtension(PFNGLPROGRAMUNIFORM1UIVPROC, glProgramUniform1uiv); \
+    HookExtension(PFNGLPROGRAMUNIFORM2FVPROC, glProgramUniform2fv); \
+    HookExtension(PFNGLPROGRAMUNIFORM3FVPROC, glProgramUniform3fv); \
+    HookExtension(PFNGLPROGRAMUNIFORM4FVPROC, glProgramUniform4fv); \
     HookExtension(PFNGLUSEPROGRAMPROC, glUseProgram); \
+    HookExtension(PFNGLUSEPROGRAMSTAGESPROC, glUseProgramStages); \
+    HookExtension(PFNGLVALIDATEPROGRAMPROC, glValidateProgram); \
     HookExtension(PFNGLGETPROGRAMIVPROC, glGetProgramiv); \
     HookExtension(PFNGLGETPROGRAMINFOLOGPROC, glGetProgramInfoLog); \
     HookExtension(PFNGLGETPROGRAMINTERFACEIVPROC, glGetProgramInterfaceiv); \
     HookExtension(PFNGLGETPROGRAMRESOURCEIVPROC, glGetProgramResourceiv); \
     HookExtension(PFNGLGETPROGRAMRESOURCENAMEPROC, glGetProgramResourceName); \
+    HookExtension(PFNGLGENPROGRAMPIPELINESPROC, glGenProgramPipelines); \
+    HookExtension(PFNGLBINDPROGRAMPIPELINEPROC, glBindProgramPipeline); \
+    HookExtension(PFNGLDELETEPROGRAMPIPELINESPROC, glDeleteProgramPipelines); \
+    HookExtension(PFNGLGETPROGRAMPIPELINEIVPROC, glGetProgramPipelineiv); \
+    HookExtension(PFNGLGETPROGRAMPIPELINEINFOLOGPROC, glGetProgramPipelineInfoLog); \
+    HookExtension(PFNGLVALIDATEPROGRAMPIPELINEPROC, glValidateProgramPipeline); \
     HookExtension(PFNGLDEBUGMESSAGECALLBACKPROC, glDebugMessageCallback); \
     HookExtensionAlias(PFNGLDEBUGMESSAGECALLBACKPROC, glDebugMessageCallback, glDebugMessageCallbackARB); \
     HookExtension(PFNGLDEBUGMESSAGECONTROLPROC, glDebugMessageControl); \
@@ -403,18 +421,36 @@
     HookWrapper1(void, glDeleteShader, GLuint, shader); \
     HookWrapper4(void, glShaderSource, GLuint, shader, GLsizei, count, const GLchar *const*, string, const GLint *, length); \
     HookWrapper1(void, glCompileShader, GLuint, shader); \
+    HookWrapper3(GLuint, glCreateShaderProgramv, GLenum, type, GLsizei, count, const GLchar *const*, strings); \
     HookWrapper3(void, glGetShaderiv, GLuint, shader, GLenum, pname, GLint *, params); \
     HookWrapper4(void, glGetShaderInfoLog, GLuint, shader, GLsizei, bufSize, GLsizei *, length, GLchar *, infoLog); \
     HookWrapper0(GLuint, glCreateProgram); \
     HookWrapper1(void, glDeleteProgram, GLuint, program); \
     HookWrapper2(void, glAttachShader, GLuint, program, GLuint, shader); \
+    HookWrapper0(void, glReleaseShaderCompiler); \
     HookWrapper1(void, glLinkProgram, GLuint, program); \
+    HookWrapper3(void, glProgramParameteri, GLuint, program, GLenum, pname, GLint, value); \
+    HookWrapper3(void, glProgramUniform1i, GLuint, program, GLint, location, GLint, v0); \
+    HookWrapper4(void, glProgramUniform1fv, GLuint, program, GLint, location, GLsizei, count, const GLfloat *, value); \
+    HookWrapper4(void, glProgramUniform1iv, GLuint, program, GLint, location, GLsizei, count, const GLint *, value); \
+    HookWrapper4(void, glProgramUniform1uiv, GLuint, program, GLint, location, GLsizei, count, const GLuint *, value); \
+    HookWrapper4(void, glProgramUniform2fv, GLuint, program, GLint, location, GLsizei, count, const GLfloat *, value); \
+    HookWrapper4(void, glProgramUniform3fv, GLuint, program, GLint, location, GLsizei, count, const GLfloat *, value); \
+    HookWrapper4(void, glProgramUniform4fv, GLuint, program, GLint, location, GLsizei, count, const GLfloat *, value); \
     HookWrapper1(void, glUseProgram, GLuint, program); \
+    HookWrapper3(void, glUseProgramStages, GLuint, pipeline, GLbitfield, stages, GLuint, program); \
+    HookWrapper1(void, glValidateProgram, GLuint, program); \
     HookWrapper3(void, glGetProgramiv, GLuint, program, GLenum, pname, GLint *, params); \
     HookWrapper4(void, glGetProgramInfoLog, GLuint, program, GLsizei, bufSize, GLsizei *, length, GLchar *, infoLog); \
     HookWrapper4(void, glGetProgramInterfaceiv, GLuint, program, GLenum, programInterface, GLenum, pname, GLint *, params); \
     HookWrapper8(void, glGetProgramResourceiv, GLuint, program, GLenum, programInterface, GLuint, index, GLsizei, propCount, const GLenum *, props, GLsizei, bufSize, GLsizei *, length, GLint *, params); \
     HookWrapper6(void, glGetProgramResourceName, GLuint, program, GLenum, programInterface, GLuint, index, GLsizei, bufSize, GLsizei *, length, GLchar *, name); \
+    HookWrapper2(void, glGenProgramPipelines, GLsizei, n, GLuint *, pipelines); \
+    HookWrapper1(void, glBindProgramPipeline, GLuint, pipeline); \
+    HookWrapper2(void, glDeleteProgramPipelines, GLsizei, n, const GLuint *, pipelines); \
+    HookWrapper3(void, glGetProgramPipelineiv, GLuint, pipeline, GLenum, pname, GLint *, params); \
+    HookWrapper4(void, glGetProgramPipelineInfoLog, GLuint, pipeline, GLsizei, bufSize, GLsizei *, length, GLchar *, infoLog); \
+    HookWrapper1(void, glValidateProgramPipeline, GLuint, pipeline); \
     HookWrapper2(void, glDebugMessageCallback, GLDEBUGPROC, callback, const void *, userParam); \
     HookWrapper6(void, glDebugMessageControl, GLenum, source, GLenum, type, GLenum, severity, GLsizei, count, const GLuint *, ids, GLboolean, enabled); \
     HookWrapper6(void, glDebugMessageInsert, GLenum, source, GLenum, type, GLuint, id, GLenum, severity, GLsizei, length, const GLchar *, buf); \

renderdoc/driver/gl/gl_resources.h

@@ -42,6 +42,7 @@ enum GLNamespace
 	eResVertexArray,
 	eResShader,
 	eResProgram,
+	eResProgramPipe,
 	eResDisplayList,
 };
 
@@ -85,6 +86,7 @@ inline GLResource BufferRes(GLuint i) { return GLResource(eResBuffer, i); }
 inline GLResource VertexArrayRes(GLuint i) { return GLResource(eResVertexArray, i); }
 inline GLResource ShaderRes(GLuint i) { return GLResource(eResShader, i); }
 inline GLResource ProgramRes(GLuint i) { return GLResource(eResProgram, i); }
+inline GLResource ProgramPipeRes(GLuint i) { return GLResource(eResProgramPipe, i); }
 inline GLResource DisplayListRes(GLuint i) { return GLResource(eResDisplayList, i); }
 
 struct GLResourceRecord : public ResourceRecord