From bc3a1d8e0a42937b71fdcb17f87e217f7aa97185 Mon Sep 17 00:00:00 2001 From: Baldur Karlsson Date: Wed, 18 Jun 2014 11:01:08 +0100 Subject: [PATCH] Add functions for separable programs and program pipelines. --- renderdoc/driver/gl/gl_common.h | 9 +- renderdoc/driver/gl/gl_device_driver.cpp | 516 ++++++++++++++++++++++- renderdoc/driver/gl/gl_driver.cpp | 43 +- renderdoc/driver/gl/gl_driver.h | 25 +- renderdoc/driver/gl/gl_hookset.h | 18 + renderdoc/driver/gl/gl_hookset_defs.h | 36 ++ renderdoc/driver/gl/gl_resources.h | 2 + 7 files changed, 641 insertions(+), 8 deletions(-) diff --git a/renderdoc/driver/gl/gl_common.h b/renderdoc/driver/gl/gl_common.h index e1d975e77..badd07bf8 100644 --- a/renderdoc/driver/gl/gl_common.h +++ b/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, diff --git a/renderdoc/driver/gl/gl_device_driver.cpp b/renderdoc/driver/gl/gl_device_driver.cpp index 674f4dd83..501692ec6 100644 --- a/renderdoc/driver/gl/gl_device_driver.cpp +++ b/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 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 diff --git a/renderdoc/driver/gl/gl_driver.cpp b/renderdoc/driver/gl/gl_driver.cpp index 2e25685ac..826d36732 100644 --- a/renderdoc/driver/gl/gl_driver.cpp +++ b/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); diff --git a/renderdoc/driver/gl/gl_driver.h b/renderdoc/driver/gl/gl_driver.h index 4663a06a4..66644c1bf 100644 --- a/renderdoc/driver/gl/gl_driver.h +++ b/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)); diff --git a/renderdoc/driver/gl/gl_hookset.h b/renderdoc/driver/gl/gl_hookset.h index b3ce0f93c..995348b12 100644 --- a/renderdoc/driver/gl/gl_hookset.h +++ b/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; diff --git a/renderdoc/driver/gl/gl_hookset_defs.h b/renderdoc/driver/gl/gl_hookset_defs.h index 52e35edcd..2e539421e 100644 --- a/renderdoc/driver/gl/gl_hookset_defs.h +++ b/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); \ diff --git a/renderdoc/driver/gl/gl_resources.h b/renderdoc/driver/gl/gl_resources.h index 67fc76e6e..6edfedbff 100644 --- a/renderdoc/driver/gl/gl_resources.h +++ b/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