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)));
}
