/*!
* \brief initialize the local ubik_dbase
*
* We replay the logs and then read the resulting file to figure out what version we've really got.
*/
int
urecovery_Initialize(register struct ubik_dbase *adbase)
{
register afs_int32 code;
code = ReplayLog(adbase);
if (code)
return code;
code = InitializeDB(adbase);
return code;
}
/*!
* \brief initialize the local ubik_dbase
*
* We replay the logs and then read the resulting file to figure out what version we've really got.
*/
int
urecovery_Initialize(struct ubik_dbase *adbase)
{
afs_int32 code;
DBHOLD(adbase);
code = ReplayLog(adbase);
if (code)
goto done;
code = InitializeDB(adbase);
done:
DBRELE(adbase);
return code;
}
void GLReplay::RenderMesh(int frameID, vector<int> eventID, MeshDisplay cfg)
{
WrappedOpenGL &gl = *m_pDriver;
MakeCurrentReplayContext(m_DebugCtx);
GLuint curFBO = 0;
gl.glGetIntegerv(eGL_FRAMEBUFFER_BINDING, (GLint*)&curFBO);
OutputWindow *outw = NULL;
for(auto it = m_OutputWindows.begin(); it != m_OutputWindows.end(); ++it)
{
if(it->second.BlitData.windowFBO == curFBO)
{
outw = &it->second;
break;
}
}
if(!outw) return;
const auto &attr = m_CurPipelineState.m_VtxIn.attributes[0];
const auto &vb = m_CurPipelineState.m_VtxIn.vbuffers[attr.BufferSlot];
if(vb.Buffer == ResourceId())
return;
MakeCurrentReplayContext(&m_ReplayCtx);
GLint viewport[4];
gl.glGetIntegerv(eGL_VIEWPORT, viewport);
gl.glGetIntegerv(eGL_FRAMEBUFFER_BINDING, (GLint*)&curFBO);
if(outw->BlitData.replayFBO == 0)
{
gl.glGenFramebuffers(1, &outw->BlitData.replayFBO);
gl.glBindFramebuffer(eGL_FRAMEBUFFER, outw->BlitData.replayFBO);
gl.glFramebufferTexture(eGL_FRAMEBUFFER, eGL_COLOR_ATTACHMENT0, outw->BlitData.backbuffer, 0);
}
else
{
gl.glBindFramebuffer(eGL_FRAMEBUFFER, outw->BlitData.replayFBO);
}
gl.glViewport(0, 0, (GLsizei)DebugData.outWidth, (GLsizei)DebugData.outHeight);
GLuint curProg = 0;
gl.glGetIntegerv(eGL_CURRENT_PROGRAM, (GLint*)&curProg);
gl.glUseProgram(DebugData.meshProg);
float wireCol[] = { 0.0f, 0.0f, 0.0f, 1.0f };
GLint colLoc = gl.glGetUniformLocation(DebugData.meshProg, "RENDERDOC_GenericFS_Color");
gl.glUniform4fv(colLoc, 1, wireCol);
Matrix4f projMat = Matrix4f::Perspective(90.0f, 0.1f, 100000.0f, DebugData.outWidth/DebugData.outHeight);
Camera cam;
if(cfg.arcballCamera)
cam.Arcball(cfg.cameraPos.x, Vec3f(cfg.cameraRot.x, cfg.cameraRot.y, cfg.cameraRot.z));
else
cam.fpsLook(Vec3f(cfg.cameraPos.x, cfg.cameraPos.y, cfg.cameraPos.z), Vec3f(cfg.cameraRot.x, cfg.cameraRot.y, cfg.cameraRot.z));
Matrix4f camMat = cam.GetMatrix();
Matrix4f ModelViewProj = projMat.Mul(camMat);
GLint mvpLoc = gl.glGetUniformLocation(DebugData.meshProg, "ModelViewProj");
gl.glUniformMatrix4fv(mvpLoc, 1, GL_FALSE, ModelViewProj.Data());
GLuint curVAO = 0;
gl.glGetIntegerv(eGL_VERTEX_ARRAY_BINDING, (GLint*)&curVAO);
GLuint curArr = 0;
gl.glGetIntegerv(eGL_ARRAY_BUFFER_BINDING, (GLint*)&curArr);
gl.glBindVertexArray(DebugData.meshVAO);
// TODO: we should probably use glBindVertexBuffer, glVertexAttribFormat, glVertexAttribBinding.
// For now just assume things about the format and vbuffer.
RDCASSERT(attr.Format.compType == eCompType_Float && attr.Format.compByteWidth == 4);
gl.glBindBuffer(eGL_ARRAY_BUFFER, m_pDriver->GetResourceManager()->GetLiveResource(vb.Buffer).name);
gl.glVertexAttribPointer(0, attr.Format.compCount, eGL_FLOAT, GL_FALSE, 0, (void *)intptr_t(vb.Offset + attr.RelativeOffset));
gl.glEnableVertexAttribArray(0);
{
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[0], eReplay_OnlyDraw);
if(depthTest)
gl.glEnable(eGL_DEPTH_TEST);
if(polyMode != eGL_LINE)
gl.glPolygonMode(eGL_FRONT_AND_BACK, polyMode);
}
gl.glBindVertexArray(curVAO);
gl.glBindBuffer(eGL_ARRAY_BUFFER, curArr);
gl.glUseProgram(curProg);
gl.glViewport(viewport[0], viewport[1], (GLsizei)viewport[2], (GLsizei)viewport[3]);
gl.glBindFramebuffer(eGL_FRAMEBUFFER, curFBO);
}
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));
}
