diff --git a/renderdoc/driver/gl/gl_common.cpp b/renderdoc/driver/gl/gl_common.cpp
index 1b94bb9c8..c5e7f76aa 100644
--- a/renderdoc/driver/gl/gl_common.cpp
+++ b/renderdoc/driver/gl/gl_common.cpp
@@ -43,6 +43,107 @@ namespace TrackedResource
 	}
 };
 
+size_t BufferIdx(GLenum buf)
+{
+	switch(buf)
+	{
+		case eGL_ARRAY_BUFFER:              return 0;
+		case eGL_ATOMIC_COUNTER_BUFFER:     return 1;
+		case eGL_COPY_READ_BUFFER:          return 2;
+		case eGL_COPY_WRITE_BUFFER:         return 3;
+		case eGL_DRAW_INDIRECT_BUFFER:      return 4;
+		case eGL_DISPATCH_INDIRECT_BUFFER:  return 5;
+		case eGL_ELEMENT_ARRAY_BUFFER:      return 6;
+		case eGL_PIXEL_PACK_BUFFER:         return 7;
+		case eGL_PIXEL_UNPACK_BUFFER:       return 8;
+		case eGL_QUERY_BUFFER:              return 9;
+		case eGL_SHADER_STORAGE_BUFFER:     return 10;
+		case eGL_TEXTURE_BUFFER:            return 11;
+		case eGL_TRANSFORM_FEEDBACK_BUFFER: return 12;
+		case eGL_UNIFORM_BUFFER:            return 13;
+		default:
+			RDCERR("Unexpected enum as buffer target: %hs", ToStr::Get(buf).c_str());
+	}
+
+	return 0;
+}
+
+GLenum BufferEnum(size_t idx)
+{
+	GLenum enums[] = {
+		eGL_ARRAY_BUFFER,
+		eGL_ATOMIC_COUNTER_BUFFER,
+		eGL_COPY_READ_BUFFER,
+		eGL_COPY_WRITE_BUFFER,
+		eGL_DRAW_INDIRECT_BUFFER,
+		eGL_DISPATCH_INDIRECT_BUFFER,
+		eGL_ELEMENT_ARRAY_BUFFER,
+		eGL_PIXEL_PACK_BUFFER,
+		eGL_PIXEL_UNPACK_BUFFER,
+		eGL_QUERY_BUFFER,
+		eGL_SHADER_STORAGE_BUFFER,
+		eGL_TEXTURE_BUFFER,
+		eGL_TRANSFORM_FEEDBACK_BUFFER,
+		eGL_UNIFORM_BUFFER,
+	};
+
+	if(idx < ARRAY_COUNT(enums))
+		return enums[idx];
+
+	return eGL_NONE;
+}
+
+size_t ShaderIdx(GLenum buf)
+{
+	switch(buf)
+	{
+		case eGL_VERTEX_SHADER:           return 0;
+		case eGL_TESS_CONTROL_SHADER:     return 1;
+		case eGL_TESS_EVALUATION_SHADER:  return 2;
+		case eGL_GEOMETRY_SHADER:         return 3;
+		case eGL_FRAGMENT_SHADER:         return 4;
+		case eGL_COMPUTE_SHADER:          return 5;
+		default:
+			RDCERR("Unexpected enum as shader enum: %hs", ToStr::Get(buf).c_str());
+	}
+
+	return 0;
+}
+
+GLenum ShaderBit(size_t idx)
+{
+	GLenum enums[] = {
+		eGL_VERTEX_SHADER_BIT,
+		eGL_TESS_CONTROL_SHADER_BIT,
+		eGL_TESS_EVALUATION_SHADER_BIT,
+		eGL_GEOMETRY_SHADER_BIT,
+		eGL_FRAGMENT_SHADER_BIT,
+		eGL_COMPUTE_SHADER_BIT,
+	};
+
+	if(idx < ARRAY_COUNT(enums))
+		return enums[idx];
+
+	return eGL_NONE;
+}
+
+GLenum ShaderEnum(size_t idx)
+{
+	GLenum enums[] = {
+		eGL_VERTEX_SHADER,
+		eGL_TESS_CONTROL_SHADER,
+		eGL_TESS_EVALUATION_SHADER,
+		eGL_GEOMETRY_SHADER,
+		eGL_FRAGMENT_SHADER,
+		eGL_COMPUTE_SHADER,
+	};
+
+	if(idx < ARRAY_COUNT(enums))
+		return enums[idx];
+
+	return eGL_NONE;
+}
+
 ResourceFormat MakeResourceFormat(WrappedOpenGL &gl, GLenum target, GLenum fmt)
 {
 	ResourceFormat ret;
diff --git a/renderdoc/driver/gl/gl_common.h b/renderdoc/driver/gl/gl_common.h
index b00ebdd30..37dde47a5 100644
--- a/renderdoc/driver/gl/gl_common.h
+++ b/renderdoc/driver/gl/gl_common.h
@@ -71,6 +71,13 @@ struct GLWindowingData
 
 class WrappedOpenGL;
 
+size_t BufferIdx(GLenum buf);
+GLenum BufferEnum(size_t idx);
+
+size_t ShaderIdx(GLenum buf);
+GLenum ShaderBit(size_t idx);
+GLenum ShaderEnum(size_t idx);
+
 ResourceFormat MakeResourceFormat(WrappedOpenGL &gl, GLenum target, GLenum fmt);
 GLenum MakeGLFormat(WrappedOpenGL &gl, GLenum target, ResourceFormat fmt);
 
diff --git a/renderdoc/driver/gl/gl_driver.h b/renderdoc/driver/gl/gl_driver.h
index 12776984d..829ff11df 100644
--- a/renderdoc/driver/gl/gl_driver.h
+++ b/renderdoc/driver/gl/gl_driver.h
@@ -114,8 +114,6 @@ class WrappedOpenGL
 		GLResourceRecord *m_ReadFramebufferRecord;
 		GLint m_TextureUnit;
 
-		size_t BufferIdx(GLenum buf);
-
 		// internals
 		Serialiser *m_pSerialiser;
 		LogState m_State;
diff --git a/renderdoc/driver/gl/gl_replay.cpp b/renderdoc/driver/gl/gl_replay.cpp
index 90423509e..334cc7999 100644
--- a/renderdoc/driver/gl/gl_replay.cpp
+++ b/renderdoc/driver/gl/gl_replay.cpp
@@ -910,20 +910,7 @@ void GLReplay::SavePipelineState()
 	};
 	ShaderReflection *refls[6] = { NULL };
 	ShaderBindpointMapping *mappings[6] = { NULL };
-	
-	struct
-	{
-		GLenum bit;
-		GLenum type;
-	} shaders[] = {
-		{ eGL_VERTEX_SHADER_BIT, eGL_VERTEX_SHADER },
-		{ eGL_TESS_CONTROL_SHADER_BIT, eGL_TESS_CONTROL_SHADER },
-		{ eGL_TESS_EVALUATION_SHADER_BIT, eGL_TESS_EVALUATION_SHADER },
-		{ eGL_GEOMETRY_SHADER_BIT, eGL_GEOMETRY_SHADER },
-		{ eGL_FRAGMENT_SHADER_BIT, eGL_FRAGMENT_SHADER },
-		{ eGL_COMPUTE_SHADER_BIT, eGL_COMPUTE_SHADER },
-	};
-
+		
 	if(curProg == 0)
 	{
 		gl.glGetIntegerv(eGL_PROGRAM_PIPELINE_BINDING, (GLint*)&curProg);
@@ -1307,9 +1294,6 @@ void GLReplay::FillCBufferVariables(ResourceId shader, uint32_t cbufSlot, vector
 	
 	MakeCurrentReplayContext(&m_ReplayCtx);
 
-	GLuint curProg = 0;
-	gl.glGetIntegerv(eGL_CURRENT_PROGRAM, (GLint*)&curProg);
-
 	auto &shaderDetails = m_pDriver->m_Shaders[shader];
 
 	if((int32_t)cbufSlot >= shaderDetails.reflection.ConstantBlocks.count)
@@ -1317,6 +1301,29 @@ void GLReplay::FillCBufferVariables(ResourceId shader, uint32_t cbufSlot, vector
 		RDCERR("Requesting invalid constant block");
 		return;
 	}
+	
+	GLuint curProg = 0;
+	gl.glGetIntegerv(eGL_CURRENT_PROGRAM, (GLint*)&curProg);
+
+	if(curProg == 0)
+	{
+		gl.glGetIntegerv(eGL_PROGRAM_PIPELINE_BINDING, (GLint*)&curProg);
+	
+		if(curProg == 0)
+		{
+			RDCERR("No program or pipeline bound");
+			return;
+		}
+		else
+		{
+			ResourceId id = m_pDriver->GetResourceManager()->GetID(ProgramPipeRes(m_ReplayCtx.ctx, curProg));
+			auto &pipeDetails = m_pDriver->m_Pipelines[id];
+
+			size_t s = ShaderIdx(shaderDetails.type);
+
+			curProg = m_pDriver->GetResourceManager()->GetCurrentResource(pipeDetails.stagePrograms[s]).name;
+		}
+	}
 
 	auto cblock = shaderDetails.reflection.ConstantBlocks.elems[cbufSlot];
 	
diff --git a/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp
index adcbd4d56..20fff0f90 100644
--- a/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp
+++ b/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp
@@ -81,31 +81,6 @@ void WrappedOpenGL::glGenBuffers(GLsizei n, GLuint *buffers)
 	}
 }
 
-size_t WrappedOpenGL::BufferIdx(GLenum buf)
-{
-	switch(buf)
-	{
-		case eGL_ARRAY_BUFFER:              return 0;
-		case eGL_ATOMIC_COUNTER_BUFFER:     return 1;
-		case eGL_COPY_READ_BUFFER:          return 2;
-		case eGL_COPY_WRITE_BUFFER:         return 3;
-		case eGL_DRAW_INDIRECT_BUFFER:      return 4;
-		case eGL_DISPATCH_INDIRECT_BUFFER:  return 5;
-		case eGL_ELEMENT_ARRAY_BUFFER:      return 6;
-		case eGL_PIXEL_PACK_BUFFER:         return 7;
-		case eGL_PIXEL_UNPACK_BUFFER:       return 8;
-		case eGL_QUERY_BUFFER:              return 9;
-		case eGL_SHADER_STORAGE_BUFFER:     return 10;
-		case eGL_TEXTURE_BUFFER:            return 11;
-		case eGL_TRANSFORM_FEEDBACK_BUFFER: return 12;
-		case eGL_UNIFORM_BUFFER:            return 13;
-		default:
-			RDCERR("Unexpected enum as buffer target: %hs", ToStr::Get(buf).c_str());
-	}
-
-	return 0;
-}
-
 bool WrappedOpenGL::Serialise_glBindBuffer(GLenum target, GLuint buffer)
 {
 	SERIALISE_ELEMENT(GLenum, Target, target);
diff --git a/renderdoc/driver/gl/wrappers/gl_shader_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_shader_funcs.cpp
index ec653f75d..7bf50e371 100644
--- a/renderdoc/driver/gl/wrappers/gl_shader_funcs.cpp
+++ b/renderdoc/driver/gl/wrappers/gl_shader_funcs.cpp
@@ -441,24 +441,11 @@ bool WrappedOpenGL::Serialise_glLinkProgram(GLuint program)
 
 		progDetails.linked = true;
 		
-		struct
-		{
-			GLenum bit;
-			GLenum type;
-		} shaders[] = {
-			{ eGL_VERTEX_SHADER_BIT, eGL_VERTEX_SHADER },
-			{ eGL_TESS_CONTROL_SHADER_BIT, eGL_TESS_CONTROL_SHADER },
-			{ eGL_TESS_EVALUATION_SHADER_BIT, eGL_TESS_EVALUATION_SHADER },
-			{ eGL_GEOMETRY_SHADER_BIT, eGL_GEOMETRY_SHADER },
-			{ eGL_FRAGMENT_SHADER_BIT, eGL_FRAGMENT_SHADER },
-			{ eGL_COMPUTE_SHADER_BIT, eGL_COMPUTE_SHADER },
-		};
-
-		for(size_t s=0; s < ARRAY_COUNT(shaders); s++)
+		for(size_t s=0; s < 6; s++)
 		{
 			for(size_t sh=0; sh < progDetails.shaders.size(); sh++)
 			{
-				if(m_Shaders[ progDetails.shaders[sh] ].type == shaders[s].type)
+				if(m_Shaders[ progDetails.shaders[sh] ].type == ShaderEnum(s))
 					progDetails.stageShaders[s] = progDetails.shaders[sh];
 			}
 		}
@@ -643,26 +630,13 @@ bool WrappedOpenGL::Serialise_glUseProgramStages(GLuint pipeline, GLbitfield sta
 
 		pipeDetails.programs.push_back(PipelineData::ProgramUse(liveProgId, Stages));
 
-		struct
+		for(size_t s=0; s < 6; s++)
 		{
-			GLenum bit;
-			GLenum type;
-		} shaders[] = {
-			{ eGL_VERTEX_SHADER_BIT, eGL_VERTEX_SHADER },
-			{ eGL_TESS_CONTROL_SHADER_BIT, eGL_TESS_CONTROL_SHADER },
-			{ eGL_TESS_EVALUATION_SHADER_BIT, eGL_TESS_EVALUATION_SHADER },
-			{ eGL_GEOMETRY_SHADER_BIT, eGL_GEOMETRY_SHADER },
-			{ eGL_FRAGMENT_SHADER_BIT, eGL_FRAGMENT_SHADER },
-			{ eGL_COMPUTE_SHADER_BIT, eGL_COMPUTE_SHADER },
-		};
-
-		for(size_t s=0; s < ARRAY_COUNT(shaders); s++)
-		{
-			if(Stages & shaders[s].bit)
+			if(Stages & ShaderBit(s))
 			{
 				for(size_t sh=0; sh < progDetails.shaders.size(); sh++)
 				{
-					if(m_Shaders[ progDetails.shaders[sh] ].type == shaders[s].type)
+					if(m_Shaders[ progDetails.shaders[sh] ].type == ShaderEnum(s))
 					{
 						pipeDetails.stagePrograms[s] = liveProgId;
 						pipeDetails.stageShaders[s] = progDetails.shaders[sh];