void WrappedOpenGL::glLinkProgram(GLuint program) { m_Real.glLinkProgram(program); if(m_State >= WRITING) { GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), program)); RDCASSERT(record); { SCOPED_SERIALISE_CONTEXT(LINKPROGRAM); Serialise_glLinkProgram(program); record->AddChunk(scope.Get()); } } else { ResourceId progid = GetResourceManager()->GetID(ProgramRes(GetCtx(), program)); ProgramData &progDetails = m_Programs[progid]; progDetails.linked = true; 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 == ShaderEnum(s)) progDetails.stageShaders[s] = progDetails.shaders[sh]; } } } }
void WrappedOpenGL::glAttachShader(GLuint program, GLuint shader) { m_Real.glAttachShader(program, shader); if(m_State >= WRITING && program != 0 && shader != 0) { GLResourceRecord *progRecord = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), program)); GLResourceRecord *shadRecord = GetResourceManager()->GetResourceRecord(ShaderRes(GetCtx(), shader)); RDCASSERT(progRecord && shadRecord); if(progRecord && shadRecord) { SCOPED_SERIALISE_CONTEXT(ATTACHSHADER); Serialise_glAttachShader(program, shader); progRecord->AddParent(shadRecord); progRecord->AddChunk(scope.Get()); } } else { ResourceId progid = GetResourceManager()->GetID(ProgramRes(GetCtx(), program)); ResourceId shadid = GetResourceManager()->GetID(ShaderRes(GetCtx(), shader)); m_Programs[progid].shaders.push_back(shadid); } }
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(GetCtx(), 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); // we want a separate program that we can mess about with for making overlays // and relink without having to worry about restoring the 'real' program state. GLuint sepprog = MakeSeparableShaderProgram(*this, Type, src, NULL); delete[] sources; GLResource res = ProgramRes(GetCtx(), real); ResourceId liveId = m_ResourceManager->RegisterResource(res); auto &progDetails = m_Programs[liveId]; progDetails.linked = true; progDetails.shaders.push_back(liveId); progDetails.stageShaders[ShaderIdx(Type)] = liveId; auto &shadDetails = m_Shaders[liveId]; shadDetails.type = Type; shadDetails.sources.swap(src); shadDetails.prog = sepprog; shadDetails.Compile(*this); GetResourceManager()->AddLiveResource(id, res); } return true; }
GLuint WrappedOpenGL::glCreateProgram() { GLuint real = m_Real.glCreateProgram(); GLResource res = ProgramRes(GetCtx(), real); ResourceId id = GetResourceManager()->RegisterResource(res); if(m_State >= WRITING) { Chunk *chunk = NULL; { SCOPED_SERIALISE_CONTEXT(CREATE_PROGRAM); Serialise_glCreateProgram(real); chunk = scope.Get(); } GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id); RDCASSERT(record); // we always want to mark programs as dirty so we can serialise their // locations as initial state (and form a remapping table) GetResourceManager()->MarkDirtyResource(id); record->AddChunk(chunk); } else { GetResourceManager()->AddLiveResource(id, res); } return real; }
bool WrappedOpenGL::Serialise_glLinkProgram(GLuint program) { SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(GetCtx(), program))); if(m_State == READING) { ResourceId progid = GetResourceManager()->GetLiveID(id); ProgramData &progDetails = m_Programs[progid]; progDetails.linked = true; 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 == ShaderEnum(s)) progDetails.stageShaders[s] = progDetails.shaders[sh]; } } m_Real.glLinkProgram(GetResourceManager()->GetLiveResource(id).name); } return true; }
bool WrappedOpenGL::Serialise_glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const *varyings, GLenum bufferMode) { SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(GetCtx(), program))); SERIALISE_ELEMENT(uint32_t, Count, count); SERIALISE_ELEMENT(GLenum, Mode, bufferMode); string *vars = m_State >= WRITING ? NULL : new string[Count]; char **varstrs = m_State >= WRITING ? NULL : new char *[Count]; for(uint32_t c = 0; c < Count; c++) { string v = varyings && varyings[c] ? varyings[c] : ""; m_pSerialiser->Serialise("Varying", v); if(vars) { vars[c] = v; varstrs[c] = (char *)vars[c].c_str(); } } if(m_State == READING) { m_Real.glTransformFeedbackVaryings(GetResourceManager()->GetLiveResource(id).name, Count, varstrs, Mode); } SAFE_DELETE_ARRAY(vars); SAFE_DELETE_ARRAY(varstrs); return true; }
bool WrappedOpenGL::Serialise_glDetachShader(GLuint program, GLuint shader) { SERIALISE_ELEMENT(ResourceId, progid, GetResourceManager()->GetID(ProgramRes(GetCtx(), program))); SERIALISE_ELEMENT(ResourceId, shadid, GetResourceManager()->GetID(ShaderRes(GetCtx(), shader))); if(m_State == READING) { ResourceId liveProgId = GetResourceManager()->GetLiveID(progid); ResourceId liveShadId = GetResourceManager()->GetLiveID(shadid); if(!m_Programs[liveProgId].linked) { for(auto it = m_Programs[liveProgId].shaders.begin(); it != m_Programs[liveProgId].shaders.end(); ++it) { if(*it == liveShadId) { m_Programs[liveProgId].shaders.erase(it); break; } } } m_Real.glDetachShader(GetResourceManager()->GetLiveResource(progid).name, GetResourceManager()->GetLiveResource(shadid).name); } return true; }
bool WrappedOpenGL::Serialise_glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program) { SERIALISE_ELEMENT(ResourceId, pipe, GetResourceManager()->GetID(ProgramPipeRes(GetCtx(), pipeline))); SERIALISE_ELEMENT(uint32_t, Stages, stages); SERIALISE_ELEMENT(ResourceId, prog, (program ? GetResourceManager()->GetID(ProgramRes(GetCtx(), program)) : ResourceId())); if(m_State < WRITING) { if(prog != ResourceId()) { ResourceId livePipeId = GetResourceManager()->GetLiveID(pipe); ResourceId liveProgId = GetResourceManager()->GetLiveID(prog); PipelineData &pipeDetails = m_Pipelines[livePipeId]; ProgramData &progDetails = m_Programs[liveProgId]; for(size_t s=0; s < 6; s++) { if(Stages & ShaderBit(s)) { for(size_t sh=0; sh < progDetails.shaders.size(); sh++) { if(m_Shaders[ progDetails.shaders[sh] ].type == ShaderEnum(s)) { pipeDetails.stagePrograms[s] = liveProgId; pipeDetails.stageShaders[s] = progDetails.shaders[sh]; break; } } } } m_Real.glUseProgramStages(GetResourceManager()->GetLiveResource(pipe).name, Stages, GetResourceManager()->GetLiveResource(prog).name); } else { ResourceId livePipeId = GetResourceManager()->GetLiveID(pipe); PipelineData &pipeDetails = m_Pipelines[livePipeId]; for(size_t s=0; s < 6; s++) { if(Stages & ShaderBit(s)) { pipeDetails.stagePrograms[s] = ResourceId(); pipeDetails.stageShaders[s] = ResourceId(); } } m_Real.glUseProgramStages(GetResourceManager()->GetLiveResource(pipe).name, Stages, 0); } } return true; }
bool WrappedOpenGL::Serialise_glCreateProgram(GLuint program) { SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(GetCtx(), program))); if(m_State == READING) { GLuint real = m_Real.glCreateProgram(); GLResource res = ProgramRes(GetCtx(), real); ResourceId liveId = m_ResourceManager->RegisterResource(res); m_Programs[liveId].linked = false; 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(GetCtx(), 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); // we always want to mark programs as dirty so we can serialise their // locations as initial state (and form a remapping table) GetResourceManager()->MarkDirtyResource(id); record->AddChunk(chunk); } else { GetResourceManager()->AddLiveResource(id, res); vector<string> src; for(GLsizei i = 0; i < count; i++) src.push_back(strings[i]); GLuint sepprog = MakeSeparableShaderProgram(*this, type, src, NULL); auto &progDetails = m_Programs[id]; progDetails.linked = true; progDetails.shaders.push_back(id); progDetails.stageShaders[ShaderIdx(type)] = id; auto &shadDetails = m_Shaders[id]; shadDetails.type = type; shadDetails.sources.swap(src); shadDetails.prog = sepprog; shadDetails.Compile(*this); } return real; }
void WrappedOpenGL::glDeleteProgram(GLuint program) { m_Real.glDeleteProgram(program); GLResource res = ProgramRes(GetCtx(), program); if(GetResourceManager()->HasCurrentResource(res)) { GetResourceManager()->MarkCleanResource(res); if(GetResourceManager()->HasResourceRecord(res)) GetResourceManager()->GetResourceRecord(res)->Delete(GetResourceManager()); GetResourceManager()->UnregisterResource(res); } }
bool WrappedOpenGL::Serialise_glProgramParameteri(GLuint program, GLenum pname, GLint value) { SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(GetCtx(), 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; }
bool WrappedOpenGL::Serialise_glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding) { SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(GetCtx(), program))); SERIALISE_ELEMENT(uint32_t, index, storageBlockIndex); SERIALISE_ELEMENT(uint32_t, binding, storageBlockBinding); if(m_State == READING) { m_Real.glShaderStorageBlockBinding(GetResourceManager()->GetLiveResource(id).name, index, binding); } return true; }
bool WrappedOpenGL::Serialise_glUseProgram(GLuint program) { SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(GetCtx(), program))); if(m_State <= EXECUTING) { if(id == ResourceId()) m_Real.glUseProgram(0); else m_Real.glUseProgram(GetResourceManager()->GetLiveResource(id).name); } return true; }
void WrappedOpenGL::glDetachShader(GLuint program, GLuint shader) { m_Real.glDetachShader(program, shader); // check that shader still exists, it might have been deleted. If it has, it's not too important // that we detach the shader (only important if the program will attach it elsewhere). if(m_State >= WRITING && program != 0 && shader != 0 && GetResourceManager()->HasCurrentResource(ShaderRes(GetCtx(), shader))) { GLResourceRecord *progRecord = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), program)); RDCASSERT(progRecord); { SCOPED_SERIALISE_CONTEXT(DETACHSHADER); Serialise_glDetachShader(program, shader); progRecord->AddChunk(scope.Get()); } } else { ResourceId progid = GetResourceManager()->GetID(ProgramRes(GetCtx(), program)); ResourceId shadid = GetResourceManager()->GetID(ShaderRes(GetCtx(), shader)); if(!m_Programs[progid].linked) { for(auto it = m_Programs[progid].shaders.begin(); it != m_Programs[progid].shaders.end(); ++it) { if(*it == shadid) { m_Programs[progid].shaders.erase(it); break; } } } } }
bool WrappedOpenGL::Serialise_glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name_) { SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(GetCtx(), program))); SERIALISE_ELEMENT(uint32_t, col, color); string name = name_ ? name_ : ""; m_pSerialiser->Serialise("Name", name); if(m_State == READING) { m_Real.glBindFragDataLocation(GetResourceManager()->GetLiveResource(id).name, col, name.c_str()); } return true; }
void WrappedOpenGL::glUseProgram(GLuint program) { m_Real.glUseProgram(program); GetCtxData().m_Program = program; if(m_State == WRITING_CAPFRAME) { SCOPED_SERIALISE_CONTEXT(USEPROGRAM); Serialise_glUseProgram(program); m_ContextRecord->AddChunk(scope.Get()); GetResourceManager()->MarkResourceFrameReferenced(ProgramRes(GetCtx(), program), eFrameRef_Read); } }
void WrappedOpenGL::glLinkProgram(GLuint program) { m_Real.glLinkProgram(program); if(m_State >= WRITING) { GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), program)); RDCASSERT(record); { SCOPED_SERIALISE_CONTEXT(LINKPROGRAM); Serialise_glLinkProgram(program); record->AddChunk(scope.Get()); } } }
void WrappedOpenGL::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name) { m_Real.glBindFragDataLocation(program, color, name); if(m_State >= WRITING) { GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), program)); RDCASSERT(record); { SCOPED_SERIALISE_CONTEXT(BINDFRAGDATA_LOCATION); Serialise_glBindFragDataLocation(program, color, name); record->AddChunk(scope.Get()); } } }
void WrappedOpenGL::glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding) { m_Real.glShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding); if(m_State >= WRITING) { GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), program)); RDCASSERT(record); { SCOPED_SERIALISE_CONTEXT(STORAGE_BLOCKBIND); Serialise_glShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding); record->AddChunk(scope.Get()); } } }
void WrappedOpenGL::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode) { m_Real.glTransformFeedbackVaryings(program, count, varyings, bufferMode); if(m_State >= WRITING) { GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), program)); RDCASSERT(record); { SCOPED_SERIALISE_CONTEXT(FEEDBACK_VARYINGS); Serialise_glTransformFeedbackVaryings(program, count, varyings, bufferMode); record->AddChunk(scope.Get()); } } }
void WrappedOpenGL::glProgramParameteri(GLuint program, GLenum pname, GLint value) { m_Real.glProgramParameteri(program, pname, value); if(m_State >= WRITING) { GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), program)); RDCASSERT(record); { SCOPED_SERIALISE_CONTEXT(PROGRAMPARAMETER); Serialise_glProgramParameteri(program, pname, value); record->AddChunk(scope.Get()); } } }
bool WrappedOpenGL::Serialise_glAttachShader(GLuint program, GLuint shader) { SERIALISE_ELEMENT(ResourceId, progid, GetResourceManager()->GetID(ProgramRes(GetCtx(), program))); SERIALISE_ELEMENT(ResourceId, shadid, GetResourceManager()->GetID(ShaderRes(GetCtx(), shader))); if(m_State == READING) { ResourceId liveProgId = GetResourceManager()->GetLiveID(progid); ResourceId liveShadId = GetResourceManager()->GetLiveID(shadid); m_Programs[liveProgId].shaders.push_back(liveShadId); m_Real.glAttachShader(GetResourceManager()->GetLiveResource(progid).name, GetResourceManager()->GetLiveResource(shadid).name); } return true; }
void WrappedOpenGL::glDetachShader(GLuint program, GLuint shader) { m_Real.glDetachShader(program, shader); // check that shader still exists, it might have been deleted. If it has, it's not too important // that we detach the shader (only important if the program will attach it elsewhere). if(m_State >= WRITING && program != 0 && shader != 0 && GetResourceManager()->HasCurrentResource(ShaderRes(GetCtx(), shader))) { GLResourceRecord *progRecord = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), program)); RDCASSERT(progRecord); { SCOPED_SERIALISE_CONTEXT(DETACHSHADER); Serialise_glDetachShader(program, shader); progRecord->AddChunk(scope.Get()); } } }
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); GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramPipeRes(GetCtx(), pipeline)); RDCASSERT(record); record->AddChunk(scope.Get()); if(program) { GLResourceRecord *progrecord = GetResourceManager()->GetResourceRecord(ProgramRes(GetCtx(), program)); RDCASSERT(progrecord); record->AddParent(progrecord); } } }
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::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()); } } }
ResourceId GLReplay::RenderOverlay(ResourceId texid, TextureDisplayOverlay overlay, uint32_t frameID, uint32_t eventID) { WrappedOpenGL &gl = *m_pDriver; MakeCurrentReplayContext(&m_ReplayCtx); GLuint curProg = 0; gl.glGetIntegerv(eGL_CURRENT_PROGRAM, (GLint*)&curProg); GLuint curDrawFBO = 0; GLuint curReadFBO = 0; gl.glGetIntegerv(eGL_DRAW_FRAMEBUFFER_BINDING, (GLint*)&curDrawFBO); gl.glGetIntegerv(eGL_DRAW_FRAMEBUFFER_BINDING, (GLint*)&curReadFBO); auto &progDetails = m_pDriver->m_Programs[m_pDriver->GetResourceManager()->GetID(ProgramRes(curProg))]; if(progDetails.colOutProg == 0) { progDetails.colOutProg = gl.glCreateProgram(); GLuint shad = gl.glCreateShader(eGL_FRAGMENT_SHADER); const char *src = DebugData.genericfsSource.c_str(); gl.glShaderSource(shad, 1, &src, NULL); gl.glCompileShader(shad); gl.glAttachShader(progDetails.colOutProg, shad); gl.glDeleteShader(shad); for(size_t i=0; i < progDetails.shaders.size(); i++) { const auto &shadDetails = m_pDriver->m_Shaders[progDetails.shaders[i]]; if(shadDetails.type != eGL_FRAGMENT_SHADER) { shad = gl.glCreateShader(shadDetails.type); for(size_t s=0; s < shadDetails.sources.size(); s++) { src = shadDetails.sources[s].c_str(); gl.glShaderSource(shad, 1, &src, NULL); } gl.glCompileShader(shad); gl.glAttachShader(progDetails.colOutProg, shad); gl.glDeleteShader(shad); } } gl.glLinkProgram(progDetails.colOutProg); } auto &texDetails = m_pDriver->m_Textures[texid]; if(DebugData.overlayTexWidth != texDetails.width || DebugData.overlayTexHeight != texDetails.height) { if(DebugData.overlayFBO) { gl.glDeleteFramebuffers(1, &DebugData.overlayFBO); gl.glDeleteTextures(1, &DebugData.overlayTex); } gl.glGenFramebuffers(1, &DebugData.overlayFBO); gl.glBindFramebuffer(eGL_FRAMEBUFFER, DebugData.overlayFBO); GLuint curTex = 0; gl.glGetIntegerv(eGL_TEXTURE_BINDING_2D, (GLint*)&curTex); gl.glGenTextures(1, &DebugData.overlayTex); gl.glBindTexture(eGL_TEXTURE_2D, DebugData.overlayTex); DebugData.overlayTexWidth = texDetails.width; DebugData.overlayTexHeight = texDetails.height; gl.glTexStorage2D(eGL_TEXTURE_2D, 1, eGL_RGBA8, texDetails.width, texDetails.height); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MIN_FILTER, eGL_NEAREST); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_MAG_FILTER, eGL_NEAREST); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_WRAP_S, eGL_CLAMP_TO_EDGE); gl.glTexParameteri(eGL_TEXTURE_2D, eGL_TEXTURE_WRAP_T, eGL_CLAMP_TO_EDGE); gl.glFramebufferTexture(eGL_FRAMEBUFFER, eGL_COLOR_ATTACHMENT0, DebugData.overlayTex, 0); gl.glBindTexture(eGL_TEXTURE_2D, curTex); } gl.glBindFramebuffer(eGL_FRAMEBUFFER, DebugData.overlayFBO); if(overlay == eTexOverlay_NaN || overlay == eTexOverlay_Clipping) { // just need the basic texture float black[] = { 0.0f, 0.0f, 0.0f, 0.0f }; gl.glClearBufferfv(eGL_COLOR, 0, black); } else if(overlay == eTexOverlay_Drawcall) { gl.glUseProgram(progDetails.colOutProg); { // copy across uniforms GLint numUniforms = 0; gl.glGetProgramiv(curProg, eGL_ACTIVE_UNIFORMS, &numUniforms); for(GLint i=0; i < numUniforms; i++) { char uniName[1024] = {}; GLint uniSize = 0; GLenum uniType = eGL_UNKNOWN_ENUM; gl.glGetActiveUniform(curProg, i, 1024, NULL, &uniSize, &uniType, uniName); GLint origloc = gl.glGetUniformLocation(curProg, uniName); GLint newloc = gl.glGetUniformLocation(progDetails.colOutProg, uniName); double dv[16]; float *fv = (float *)dv; if(uniSize > 1) { RDCERR("Array elements beyond [0] not being copied to new program"); } if(origloc != -1 && newloc != -1) { if(uniType == eGL_FLOAT_MAT4) { gl.glGetUniformfv(curProg, origloc, fv); gl.glUniformMatrix4fv(newloc, 1, false, fv); } else if(uniType == eGL_FLOAT_VEC3) { gl.glGetUniformfv(curProg, origloc, fv); gl.glUniform3fv(newloc, 1, fv); } else if(uniType == eGL_FLOAT_VEC4) { gl.glGetUniformfv(curProg, origloc, fv); gl.glUniform4fv(newloc, 1, fv); } else { RDCERR("Uniform type '%s' not being copied to new program", ToStr::Get(uniType).c_str()); } } } } float black[] = { 0.0f, 0.0f, 0.0f, 0.5f }; gl.glClearBufferfv(eGL_COLOR, 0, black); GLint colLoc = gl.glGetUniformLocation(progDetails.colOutProg, "RENDERDOC_GenericFS_Color"); float colVal[] = { 0.8f, 0.1f, 0.8f, 1.0f }; gl.glUniform4fv(colLoc, 1, colVal); ReplayLog(frameID, 0, eventID, eReplay_OnlyDraw); gl.glUseProgram(curProg); } else if(overlay == eTexOverlay_Wireframe) { gl.glUseProgram(progDetails.colOutProg); { // copy across uniforms GLint numUniforms = 0; gl.glGetProgramiv(curProg, eGL_ACTIVE_UNIFORMS, &numUniforms); for(GLint i=0; i < numUniforms; i++) { char uniName[1024] = {}; GLint uniSize = 0; GLenum uniType = eGL_UNKNOWN_ENUM; gl.glGetActiveUniform(curProg, i, 1024, NULL, &uniSize, &uniType, uniName); GLint origloc = gl.glGetUniformLocation(curProg, uniName); GLint newloc = gl.glGetUniformLocation(progDetails.colOutProg, uniName); double dv[16]; float *fv = (float *)dv; if(uniSize > 1) { RDCERR("Array elements beyond [0] not being copied to new program"); } if(origloc != -1 && newloc != -1) { if(uniType == eGL_FLOAT_MAT4) { gl.glGetUniformfv(curProg, origloc, fv); gl.glUniformMatrix4fv(newloc, 1, false, fv); } else if(uniType == eGL_FLOAT_VEC3) { gl.glGetUniformfv(curProg, origloc, fv); gl.glUniform3fv(newloc, 1, fv); } else if(uniType == eGL_FLOAT_VEC4) { gl.glGetUniformfv(curProg, origloc, fv); gl.glUniform4fv(newloc, 1, fv); } else { RDCERR("Uniform type '%s' not being copied to new program", ToStr::Get(uniType).c_str()); } } } } float wireCol[] = { 200.0f/255.0f, 255.0f/255.0f, 0.0f/255.0f, 0.0f }; gl.glClearBufferfv(eGL_COLOR, 0, wireCol); GLint colLoc = gl.glGetUniformLocation(progDetails.colOutProg, "RENDERDOC_GenericFS_Color"); wireCol[3] = 1.0f; gl.glUniform4fv(colLoc, 1, wireCol); GLint depthTest = GL_FALSE; gl.glGetIntegerv(eGL_DEPTH_TEST, (GLint*)&depthTest); GLenum polyMode = eGL_FILL; gl.glGetIntegerv(eGL_POLYGON_MODE, (GLint*)&polyMode); gl.glDisable(eGL_DEPTH_TEST); gl.glPolygonMode(eGL_FRONT_AND_BACK, eGL_LINE); ReplayLog(frameID, 0, eventID, eReplay_OnlyDraw); if(depthTest) gl.glEnable(eGL_DEPTH_TEST); if(polyMode != eGL_LINE) gl.glPolygonMode(eGL_FRONT_AND_BACK, polyMode); gl.glUseProgram(curProg); } gl.glBindFramebuffer(eGL_DRAW_FRAMEBUFFER, curDrawFBO); gl.glBindFramebuffer(eGL_READ_FRAMEBUFFER, curReadFBO); return m_pDriver->GetResourceManager()->GetID(TextureRes(DebugData.overlayTex)); }
void GLRenderState::Serialise(LogState state, void *ctx, WrappedOpenGL *gl) { GLResourceManager *rm = gl->GetResourceManager(); // TODO check GL_MAX_* m_pSerialiser->Serialise<eEnabled_Count>("GL_ENABLED", Enabled); for(size_t i=0; i < ARRAY_COUNT(Tex2D); i++) { ResourceId ID = ResourceId(); if(state >= WRITING) ID = rm->GetID(TextureRes(ctx, Tex2D[i])); m_pSerialiser->Serialise("GL_TEXTURE_BINDING_2D", ID); if(state < WRITING && ID != ResourceId()) Tex2D[i] = rm->GetLiveResource(ID).name; } for(size_t i=0; i < ARRAY_COUNT(Samplers); i++) { ResourceId ID = ResourceId(); if(state >= WRITING) ID = rm->GetID(SamplerRes(ctx, Samplers[i])); m_pSerialiser->Serialise("GL_SAMPLER_BINDING", ID); if(state < WRITING && ID != ResourceId()) Samplers[i] = rm->GetLiveResource(ID).name; } m_pSerialiser->Serialise("GL_ACTIVE_TEXTURE", ActiveTexture); { ResourceId ID = ResourceId(); if(state >= WRITING) ID = rm->GetID(VertexArrayRes(ctx, VAO)); m_pSerialiser->Serialise("GL_VERTEX_ARRAY_BINDING", ID); if(state < WRITING && ID != ResourceId()) VAO = rm->GetLiveResource(ID).name; if(VAO == 0) VAO = gl->GetFakeVAO(); } { ResourceId ID = ResourceId(); if(state >= WRITING) ID = rm->GetID(FeedbackRes(ctx, FeedbackObj)); m_pSerialiser->Serialise("GL_TRANSFORM_FEEDBACK_BINDING", ID); if(state < WRITING && ID != ResourceId()) FeedbackObj = rm->GetLiveResource(ID).name; } for(size_t i=0; i < ARRAY_COUNT(GenericVertexAttribs); i++) { m_pSerialiser->Serialise<4>("GL_CURRENT_VERTEX_ATTRIB", &GenericVertexAttribs[i].x); } 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); m_pSerialiser->Serialise("GL_PRIMITIVE_RESTART_INDEX", PrimitiveRestartIndex); m_pSerialiser->Serialise("GL_CLIP_ORIGIN", ClipOrigin); m_pSerialiser->Serialise("GL_CLIP_DEPTH_MODE", ClipDepth); m_pSerialiser->Serialise("GL_PROVOKING_VERTEX", ProvokingVertex); for(size_t i=0; i < ARRAY_COUNT(BufferBindings); i++) { ResourceId ID = ResourceId(); if(state >= WRITING) ID = rm->GetID(BufferRes(ctx, BufferBindings[i])); m_pSerialiser->Serialise("GL_BUFFER_BINDING", ID); if(state < WRITING && ID != ResourceId()) BufferBindings[i] = rm->GetLiveResource(ID).name; } { ResourceId ID = ResourceId(); if(state >= WRITING) ID = rm->GetID(ProgramRes(ctx, Program)); m_pSerialiser->Serialise("GL_CURRENT_PROGRAM", ID); if(state < WRITING && ID != ResourceId()) Program = rm->GetLiveResource(ID).name; } { ResourceId ID = ResourceId(); if(state >= WRITING) ID = rm->GetID(ProgramPipeRes(ctx, Pipeline)); m_pSerialiser->Serialise("GL_PROGRAM_PIPELINE_BINDING", ID); if(state < WRITING && ID != ResourceId()) Pipeline = rm->GetLiveResource(ID).name; } for(size_t s=0; s < ARRAY_COUNT(Subroutines); s++) { m_pSerialiser->Serialise("GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS", Subroutines[s].numSubroutines); m_pSerialiser->Serialise<128>("GL_SUBROUTINE_UNIFORMS", Subroutines[s].Values); } { ResourceId ID = ResourceId(); if(state >= WRITING) ID = rm->GetID(FramebufferRes(ctx, DrawFBO)); m_pSerialiser->Serialise("GL_DRAW_FRAMEBUFFER_BINDING", ID); if(state < WRITING && ID != ResourceId()) DrawFBO = rm->GetLiveResource(ID).name; if(DrawFBO == 0) DrawFBO = gl->GetFakeBBFBO(); } { ResourceId ID = ResourceId(); if(state >= WRITING) ID = rm->GetID(FramebufferRes(ctx, ReadFBO)); m_pSerialiser->Serialise("GL_READ_FRAMEBUFFER_BINDING", ID); if(state < WRITING && ID != ResourceId()) ReadFBO = rm->GetLiveResource(ID).name; if(ReadFBO == 0) ReadFBO = gl->GetFakeBBFBO(); } struct { IdxRangeBuffer *bufs; int count; } idxBufs[] = { { AtomicCounter, ARRAY_COUNT(AtomicCounter), }, { ShaderStorage, ARRAY_COUNT(ShaderStorage), }, { TransformFeedback, ARRAY_COUNT(TransformFeedback), }, { UniformBinding, ARRAY_COUNT(UniformBinding), }, }; for(size_t b=0; b < ARRAY_COUNT(idxBufs); b++) { for(int i=0; i < idxBufs[b].count; i++) { ResourceId ID = ResourceId(); if(state >= WRITING) ID = rm->GetID(BufferRes(ctx, idxBufs[b].bufs[i].name)); m_pSerialiser->Serialise("BUFFER_BINDING", ID); if(state < WRITING && ID != ResourceId()) idxBufs[b].bufs[i].name = rm->GetLiveResource(ID).name; m_pSerialiser->Serialise("BUFFER_START", idxBufs[b].bufs[i].start); m_pSerialiser->Serialise("BUFFER_SIZE", idxBufs[b].bufs[i].size); } } for(size_t i=0; i < ARRAY_COUNT(Blends); i++) { m_pSerialiser->Serialise("GL_BLEND_EQUATION_RGB", Blends[i].EquationRGB); m_pSerialiser->Serialise("GL_BLEND_EQUATION_ALPHA", Blends[i].EquationAlpha); m_pSerialiser->Serialise("GL_BLEND_SRC_RGB", Blends[i].SourceRGB); m_pSerialiser->Serialise("GL_BLEND_SRC_ALPHA", Blends[i].SourceAlpha); m_pSerialiser->Serialise("GL_BLEND_DST_RGB", Blends[i].DestinationRGB); m_pSerialiser->Serialise("GL_BLEND_DST_ALPHA", Blends[i].DestinationAlpha); m_pSerialiser->Serialise("GL_BLEND", Blends[i].Enabled); } m_pSerialiser->Serialise<4>("GL_BLEND_COLOR", BlendColor); for(size_t i=0; i < ARRAY_COUNT(Viewports); i++) { m_pSerialiser->Serialise("GL_VIEWPORT.x", Viewports[i].x); m_pSerialiser->Serialise("GL_VIEWPORT.y", Viewports[i].y); m_pSerialiser->Serialise("GL_VIEWPORT.w", Viewports[i].width); m_pSerialiser->Serialise("GL_VIEWPORT.h", Viewports[i].height); } for(size_t i=0; i < ARRAY_COUNT(Scissors); i++) { m_pSerialiser->Serialise("GL_SCISSOR.x", Scissors[i].x); m_pSerialiser->Serialise("GL_SCISSOR.y", Scissors[i].y); m_pSerialiser->Serialise("GL_SCISSOR.w", Scissors[i].width); m_pSerialiser->Serialise("GL_SCISSOR.h", Scissors[i].height); m_pSerialiser->Serialise("GL_SCISSOR.enabled", Scissors[i].enabled); } m_pSerialiser->Serialise<8>("GL_DRAW_BUFFERS", DrawBuffers); m_pSerialiser->Serialise("GL_READ_BUFFER", ReadBuffer); m_pSerialiser->Serialise("GL_FRAGMENT_SHADER_DERIVATIVE_HINT", Hints.Derivatives); m_pSerialiser->Serialise("GL_LINE_SMOOTH_HINT", Hints.LineSmooth); m_pSerialiser->Serialise("GL_POLYGON_SMOOTH_HINT", Hints.PolySmooth); m_pSerialiser->Serialise("GL_TEXTURE_COMPRESSION_HINT", Hints.TexCompression); m_pSerialiser->Serialise("GL_DEPTH_WRITEMASK", DepthWriteMask); m_pSerialiser->Serialise("GL_DEPTH_CLEAR_VALUE", DepthClearValue); m_pSerialiser->Serialise("GL_DEPTH_FUNC", DepthFunc); for(size_t i=0; i < ARRAY_COUNT(DepthRanges); i++) { m_pSerialiser->Serialise("GL_DEPTH_RANGE.near", DepthRanges[i].nearZ); m_pSerialiser->Serialise("GL_DEPTH_RANGE.far", DepthRanges[i].farZ); } { m_pSerialiser->Serialise("GL_DEPTH_BOUNDS_EXT.near", DepthBounds.nearZ); m_pSerialiser->Serialise("GL_DEPTH_BOUNDS_EXT.far", DepthBounds.farZ); } { m_pSerialiser->Serialise("GL_STENCIL_FUNC", StencilFront.func); m_pSerialiser->Serialise("GL_STENCIL_BACK_FUNC", StencilBack.func); m_pSerialiser->Serialise("GL_STENCIL_REF", StencilFront.ref); m_pSerialiser->Serialise("GL_STENCIL_BACK_REF", StencilBack.ref); m_pSerialiser->Serialise("GL_STENCIL_VALUE_MASK", StencilFront.valuemask); m_pSerialiser->Serialise("GL_STENCIL_BACK_VALUE_MASK", StencilBack.valuemask); m_pSerialiser->Serialise("GL_STENCIL_WRITEMASK", StencilFront.writemask); m_pSerialiser->Serialise("GL_STENCIL_BACK_WRITEMASK", StencilBack.writemask); m_pSerialiser->Serialise("GL_STENCIL_FAIL", StencilFront.stencilFail); m_pSerialiser->Serialise("GL_STENCIL_BACK_FAIL", StencilBack.stencilFail); m_pSerialiser->Serialise("GL_STENCIL_PASS_DEPTH_FAIL", StencilFront.depthFail); m_pSerialiser->Serialise("GL_STENCIL_BACK_PASS_DEPTH_FAIL", StencilBack.depthFail); m_pSerialiser->Serialise("GL_STENCIL_PASS_DEPTH_PASS", StencilFront.pass); 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); m_pSerialiser->Serialise<2>("GL_SAMPLE_MASK_VALUE", &SampleMask[0]); m_pSerialiser->Serialise("GL_SAMPLE_COVERAGE_VALUE", SampleCoverage); m_pSerialiser->Serialise("GL_SAMPLE_COVERAGE_INVERT", SampleCoverageInvert); m_pSerialiser->Serialise("GL_MIN_SAMPLE_SHADING", MinSampleShading); m_pSerialiser->Serialise("GL_RASTER_SAMPLES_EXT", RasterSamples); m_pSerialiser->Serialise("GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT", RasterFixed); m_pSerialiser->Serialise("GL_LOGIC_OP_MODE", LogicOp); m_pSerialiser->Serialise<4>("GL_COLOR_CLEAR_VALUE", &ColorClearValue.red); { m_pSerialiser->Serialise("GL_PATCH_VERTICES", PatchParams.numVerts); m_pSerialiser->Serialise<2>("GL_PATCH_DEFAULT_INNER_LEVEL", &PatchParams.defaultInnerLevel[0]); m_pSerialiser->Serialise<4>("GL_PATCH_DEFAULT_OUTER_LEVEL", &PatchParams.defaultOuterLevel[0]); } m_pSerialiser->Serialise("GL_POLYGON_MODE", PolygonMode); m_pSerialiser->Serialise("GL_POLYGON_OFFSET_FACTOR", PolygonOffset[0]); m_pSerialiser->Serialise("GL_POLYGON_OFFSET_UNITS", PolygonOffset[1]); m_pSerialiser->Serialise("GL_POLYGON_OFFSET_CLAMP_EXT", PolygonOffset[2]); m_pSerialiser->Serialise("GL_FRONT_FACE", FrontFace); m_pSerialiser->Serialise("GL_CULL_FACE_MODE", CullFace); }
void GLReplay::SavePipelineState() { GLPipelineState &pipe = m_CurPipelineState; WrappedOpenGL &gl = *m_pDriver; GLResourceManager *rm = m_pDriver->GetResourceManager(); MakeCurrentReplayContext(&m_ReplayCtx); // Index buffer pipe.m_VtxIn.ibuffer.Offset = m_pDriver->m_LastIndexOffset; pipe.m_VtxIn.ibuffer.Format = ResourceFormat(); pipe.m_VtxIn.ibuffer.Format.special = false; pipe.m_VtxIn.ibuffer.Format.compCount = 1; pipe.m_VtxIn.ibuffer.Format.compType = eCompType_UInt; switch(m_pDriver->m_LastIndexSize) { default: break; case eGL_UNSIGNED_BYTE: pipe.m_VtxIn.ibuffer.Format.compByteWidth = 1; pipe.m_VtxIn.ibuffer.Format.strname = L"GL_UNSIGNED_BYTE"; break; case eGL_UNSIGNED_SHORT: pipe.m_VtxIn.ibuffer.Format.compByteWidth = 2; pipe.m_VtxIn.ibuffer.Format.strname = L"GL_UNSIGNED_SHORT"; break; case eGL_UNSIGNED_INT: pipe.m_VtxIn.ibuffer.Format.compByteWidth = 4; pipe.m_VtxIn.ibuffer.Format.strname = L"GL_UNSIGNED_INT"; break; } GLint curIdxBuf = 0; gl.glGetIntegerv(eGL_ELEMENT_ARRAY_BUFFER_BINDING, &curIdxBuf); pipe.m_VtxIn.ibuffer.Buffer = rm->GetOriginalID(rm->GetID(BufferRes(curIdxBuf))); // Vertex buffers and attributes GLint numVBufferBindings = 16; gl.glGetIntegerv(eGL_MAX_VERTEX_ATTRIB_BINDINGS, &numVBufferBindings); GLint numVAttribBindings = 16; gl.glGetIntegerv(eGL_MAX_VERTEX_ATTRIBS, &numVAttribBindings); create_array_uninit(pipe.m_VtxIn.vbuffers, numVBufferBindings); create_array_uninit(pipe.m_VtxIn.attributes, numVAttribBindings); for(GLuint i=0; i < (GLuint)numVBufferBindings; i++) { GLint vb = 0; gl.glGetIntegeri_v(eGL_VERTEX_BINDING_BUFFER, i, &vb); pipe.m_VtxIn.vbuffers[i].Buffer = rm->GetOriginalID(rm->GetID(BufferRes(vb))); gl.glGetIntegeri_v(eGL_VERTEX_BINDING_STRIDE, i, (GLint *)&pipe.m_VtxIn.vbuffers[i].Stride); gl.glGetIntegeri_v(eGL_VERTEX_BINDING_OFFSET, i, (GLint *)&pipe.m_VtxIn.vbuffers[i].Offset); gl.glGetIntegeri_v(eGL_VERTEX_BINDING_DIVISOR, i, (GLint *)&pipe.m_VtxIn.vbuffers[i].Divisor); pipe.m_VtxIn.vbuffers[i].PerInstance = (pipe.m_VtxIn.vbuffers[i].Divisor != 0); } for(GLuint i=0; i < (GLuint)numVAttribBindings; i++) { gl.glGetVertexAttribiv(i, eGL_VERTEX_ATTRIB_ARRAY_ENABLED, (GLint *)&pipe.m_VtxIn.attributes[i].Enabled); gl.glGetVertexAttribiv(i, eGL_VERTEX_ATTRIB_BINDING, (GLint *)&pipe.m_VtxIn.attributes[i].BufferSlot); gl.glGetVertexAttribiv(i, eGL_VERTEX_ATTRIB_RELATIVE_OFFSET, (GLint*)&pipe.m_VtxIn.attributes[i].RelativeOffset); GLenum type = eGL_FLOAT; GLint normalized = 0; gl.glGetVertexAttribiv(i, eGL_VERTEX_ATTRIB_ARRAY_TYPE, (GLint *)&type); gl.glGetVertexAttribiv(i, eGL_VERTEX_ATTRIB_ARRAY_NORMALIZED, &normalized); ResourceFormat fmt; fmt.special = false; fmt.compCount = 4; gl.glGetVertexAttribiv(i, eGL_VERTEX_ATTRIB_ARRAY_SIZE, (GLint *)&fmt.compCount); switch(type) { default: case eGL_BYTE: fmt.compByteWidth = 1; fmt.compType = normalized ? eCompType_SInt : eCompType_SNorm; fmt.strname = StringFormat::WFmt(L"GL_BYTE%d", fmt.compCount) + (normalized ? L"" : L"_SNORM"); break; case eGL_UNSIGNED_BYTE: fmt.compByteWidth = 1; fmt.compType = normalized ? eCompType_UInt : eCompType_UNorm; fmt.strname = StringFormat::WFmt(L"GL_UNSIGNED_BYTE%d", fmt.compCount) + (normalized ? L"" : L"_UNORM"); break; case eGL_SHORT: fmt.compByteWidth = 2; fmt.compType = normalized ? eCompType_SInt : eCompType_SNorm; fmt.strname = StringFormat::WFmt(L"GL_SHORT%d", fmt.compCount) + (normalized ? L"" : L"_SNORM"); break; case eGL_UNSIGNED_SHORT: fmt.compByteWidth = 2; fmt.compType = normalized ? eCompType_UInt : eCompType_UNorm; fmt.strname = StringFormat::WFmt(L"GL_UNSIGNED_SHORT%d", fmt.compCount) + (normalized ? L"" : L"_UNORM"); break; case eGL_INT: fmt.compByteWidth = 4; fmt.compType = normalized ? eCompType_SInt : eCompType_SNorm; fmt.strname = StringFormat::WFmt(L"GL_INT%d", fmt.compCount) + (normalized ? L"" : L"_SNORM"); break; case eGL_UNSIGNED_INT: fmt.compByteWidth = 4; fmt.compType = normalized ? eCompType_UInt : eCompType_UNorm; fmt.strname = StringFormat::WFmt(L"GL_UNSIGNED_INT%d", fmt.compCount) + (normalized ? L"" : L"_UNORM"); break; case eGL_FLOAT: fmt.compByteWidth = 4; fmt.compType = eCompType_Float; fmt.strname = StringFormat::WFmt(L"GL_FLOAT%d", fmt.compCount); break; case eGL_DOUBLE: fmt.compByteWidth = 8; fmt.compType = eCompType_Double; fmt.strname = StringFormat::WFmt(L"GL_DOUBLE%d", fmt.compCount); break; case eGL_HALF_FLOAT: fmt.compByteWidth = 2; fmt.compType = eCompType_Float; fmt.strname = StringFormat::WFmt(L"GL_HALF_FLOAT%d", fmt.compCount); break; case eGL_INT_2_10_10_10_REV: fmt.special = true; fmt.specialFormat = eSpecial_R10G10B10A2; fmt.compCount = 4; fmt.compType = eCompType_UInt; fmt.strname = L"GL_INT_2_10_10_10_REV"; break; case eGL_UNSIGNED_INT_2_10_10_10_REV: fmt.special = true; fmt.specialFormat = eSpecial_R10G10B10A2; fmt.compCount = 4; fmt.compType = eCompType_SInt; fmt.strname = L"eGL_UNSIGNED_INT_2_10_10_10_REV"; break; case eGL_UNSIGNED_INT_10F_11F_11F_REV: fmt.special = true; fmt.specialFormat = eSpecial_R11G11B10; fmt.compCount = 3; fmt.compType = eCompType_SInt; fmt.strname = L"eGL_UNSIGNED_INT_10F_11F_11F_REV"; break; } pipe.m_VtxIn.attributes[i].Format = fmt; } switch(m_pDriver->m_LastDrawMode) { default: pipe.m_VtxIn.Topology = eTopology_Unknown; break; case GL_POINTS: pipe.m_VtxIn.Topology = eTopology_PointList; break; case GL_LINE_STRIP: pipe.m_VtxIn.Topology = eTopology_LineStrip; break; case GL_LINE_LOOP: pipe.m_VtxIn.Topology = eTopology_LineLoop; break; case GL_LINES: pipe.m_VtxIn.Topology = eTopology_LineList; break; case GL_LINE_STRIP_ADJACENCY: pipe.m_VtxIn.Topology = eTopology_LineStrip_Adj; break; case GL_LINES_ADJACENCY: pipe.m_VtxIn.Topology = eTopology_LineList_Adj; break; case GL_TRIANGLE_STRIP: pipe.m_VtxIn.Topology = eTopology_TriangleStrip; break; case GL_TRIANGLE_FAN: pipe.m_VtxIn.Topology = eTopology_TriangleFan; break; case GL_TRIANGLES: pipe.m_VtxIn.Topology = eTopology_TriangleList; break; case GL_TRIANGLE_STRIP_ADJACENCY: pipe.m_VtxIn.Topology = eTopology_TriangleStrip_Adj; break; case GL_TRIANGLES_ADJACENCY: pipe.m_VtxIn.Topology = eTopology_TriangleList_Adj; break; case GL_PATCHES: { GLint patchCount = 3; gl.glGetIntegerv(eGL_PATCH_VERTICES, &patchCount); pipe.m_VtxIn.Topology = PrimitiveTopology(eTopology_PatchList_1CPs+patchCount); break; } } // Shader stages GLuint curProg = 0; gl.glGetIntegerv(eGL_CURRENT_PROGRAM, (GLint*)&curProg); auto &progDetails = m_pDriver->m_Programs[rm->GetID(ProgramRes(curProg))]; RDCASSERT(progDetails.shaders.size()); for(size_t i=0; i < progDetails.shaders.size(); i++) { if(m_pDriver->m_Shaders[ progDetails.shaders[i] ].type == eGL_VERTEX_SHADER) pipe.m_VS.Shader = rm->GetOriginalID(progDetails.shaders[i]); else if(m_pDriver->m_Shaders[ progDetails.shaders[i] ].type == eGL_FRAGMENT_SHADER) pipe.m_FS.Shader = rm->GetOriginalID(progDetails.shaders[i]); } pipe.m_VS.stage = eShaderStage_Vertex; pipe.m_TCS.stage = eShaderStage_Tess_Control; pipe.m_TES.stage = eShaderStage_Tess_Eval; pipe.m_GS.stage = eShaderStage_Geometry; pipe.m_FS.stage = eShaderStage_Fragment; pipe.m_CS.stage = eShaderStage_Compute; // Textures GLint numTexUnits = 8; gl.glGetIntegerv(eGL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &numTexUnits); create_array_uninit(pipe.Textures, numTexUnits); GLenum activeTexture = eGL_TEXTURE0; gl.glGetIntegerv(eGL_ACTIVE_TEXTURE, (GLint*)&activeTexture); // GL is ass-backwards in its handling of texture units. When a shader is active // the types in the glsl samplers inform which targets are used from which texture units // // So texture unit 5 can have a 2D bound (texture 52) and a Cube bound (texture 77). // * if a uniform sampler2D has value 5 then the 2D texture is used, and we sample from 52 // * if a uniform samplerCube has value 5 then the Cube texture is used, and we sample from 77 // It's illegal for both a sampler2D and samplerCube to both have the same value (or any two // different types). It makes it all rather pointless and needlessly complex. // // What we have to do then, is consider the program, look at the values of the uniforms, and // then get the appropriate current binding based on the uniform type. We can warn/alert the // user if we hit the illegal case of two uniforms with different types but the same value // // Handling is different if no shaders are active, but we don't consider that case. // prefetch uniform values in GetShader() ShaderReflection *refls[6]; for(size_t s=0; s < progDetails.shaders.size(); s++) refls[s] = GetShader(progDetails.shaders[s]); for(GLint unit=0; unit < numTexUnits; unit++) { GLenum binding = eGL_UNKNOWN_ENUM; GLenum target = eGL_UNKNOWN_ENUM; for(size_t s=0; s < progDetails.shaders.size(); s++) { if(refls[s] == NULL) continue; for(int32_t r=0; r < refls[s]->Resources.count; r++) { // bindPoint is the uniform value for this sampler if(refls[s]->Resources[r].bindPoint == (uint32_t)unit) { GLenum t = eGL_UNKNOWN_ENUM; switch(refls[s]->Resources[r].resType) { case eResType_None: t = eGL_UNKNOWN_ENUM; break; case eResType_Buffer: t = eGL_TEXTURE_BINDING_BUFFER; break; case eResType_Texture1D: t = eGL_TEXTURE_BINDING_1D; target = eGL_TEXTURE_1D; break; case eResType_Texture1DArray: t = eGL_TEXTURE_BINDING_1D_ARRAY; target = eGL_TEXTURE_1D_ARRAY; break; case eResType_Texture2D: t = eGL_TEXTURE_BINDING_2D; target = eGL_TEXTURE_2D; break; case eResType_Texture2DArray: t = eGL_TEXTURE_BINDING_2D_ARRAY; target = eGL_TEXTURE_2D_ARRAY; break; case eResType_Texture2DMS: t = eGL_TEXTURE_BINDING_2D_MULTISAMPLE; target = eGL_TEXTURE_2D_MULTISAMPLE; break; case eResType_Texture2DMSArray: t = eGL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY; target = eGL_TEXTURE_2D_MULTISAMPLE_ARRAY; break; case eResType_Texture3D: t = eGL_TEXTURE_BINDING_3D; target = eGL_TEXTURE_3D; break; case eResType_TextureCube: t = eGL_TEXTURE_BINDING_CUBE_MAP; target = eGL_TEXTURE_CUBE_MAP; break; case eResType_TextureCubeArray: t = eGL_TEXTURE_BINDING_CUBE_MAP_ARRAY; target = eGL_TEXTURE_CUBE_MAP_ARRAY; break; } if(binding == eGL_UNKNOWN_ENUM) { binding = t; } else if(binding == t) { // two uniforms with the same type pointing to the same slot is fine binding = t; } else if(binding != t) { RDCWARN("Two uniforms pointing to texture unit %d with types %s and %s", unit, ToStr::Get(binding).c_str(), ToStr::Get(t).c_str()); } } } } if(binding != eGL_UNKNOWN_ENUM) { gl.glActiveTexture(GLenum(eGL_TEXTURE0+unit)); GLuint tex; gl.glGetIntegerv(binding, (GLint *)&tex); // very bespoke/specific GLint firstSlice = 0; gl.glGetTexParameteriv(target, eGL_TEXTURE_VIEW_MIN_LEVEL, &firstSlice); pipe.Textures[unit].Resource = rm->GetOriginalID(rm->GetID(TextureRes(tex))); pipe.Textures[unit].FirstSlice = (uint32_t)firstSlice; } else { // what should we do in this case? there could be something bound just not used, // it'd be nice to return that } } gl.glActiveTexture(activeTexture); GLuint curFBO = 0; gl.glGetIntegerv(eGL_DRAW_FRAMEBUFFER_BINDING, (GLint*)&curFBO); GLint numCols = 8; gl.glGetIntegerv(eGL_MAX_COLOR_ATTACHMENTS, &numCols); GLuint curCol[32] = { 0 }; GLuint curDepth = 0; GLuint curStencil = 0; RDCASSERT(numCols <= 32); // we should never bind the true default framebuffer - if the app did, we will have our fake bound RDCASSERT(curFBO != 0); { for(GLint i=0; i < numCols; i++) gl.glGetFramebufferAttachmentParameteriv(eGL_DRAW_FRAMEBUFFER, GLenum(eGL_COLOR_ATTACHMENT0+i), eGL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, (GLint*)&curCol[i]); gl.glGetFramebufferAttachmentParameteriv(eGL_DRAW_FRAMEBUFFER, eGL_DEPTH_ATTACHMENT, eGL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, (GLint*)&curDepth); gl.glGetFramebufferAttachmentParameteriv(eGL_DRAW_FRAMEBUFFER, eGL_STENCIL_ATTACHMENT, eGL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, (GLint*)&curStencil); } pipe.m_FB.FBO = rm->GetOriginalID(rm->GetID(FramebufferRes(curFBO))); create_array_uninit(pipe.m_FB.Color, numCols); for(GLint i=0; i < numCols; i++) pipe.m_FB.Color[i] = rm->GetOriginalID(rm->GetID(TextureRes(curCol[i]))); pipe.m_FB.Depth = rm->GetOriginalID(rm->GetID(TextureRes(curDepth))); pipe.m_FB.Stencil = rm->GetOriginalID(rm->GetID(TextureRes(curStencil))); }