From 5f2d78e7a4b4e0a77ba670a4458859978fd3f6d2 Mon Sep 17 00:00:00 2001 From: baldurk Date: Sat, 31 May 2014 15:57:27 +0100 Subject: [PATCH] Fill in some functions that were implemented but not serialised --- renderdoc/driver/gl/gl_common.h | 4 + renderdoc/driver/gl/gl_context_driver.cpp | 92 ++------ renderdoc/driver/gl/gl_device_driver.cpp | 249 +++++++++++++++++++++- renderdoc/driver/gl/gl_driver.cpp | 37 +++- renderdoc/driver/gl/gl_driver.h | 2 + 5 files changed, 294 insertions(+), 90 deletions(-) diff --git a/renderdoc/driver/gl/gl_common.h b/renderdoc/driver/gl/gl_common.h index 3c519c57e..9bbc111a4 100644 --- a/renderdoc/driver/gl/gl_common.h +++ b/renderdoc/driver/gl/gl_common.h @@ -127,6 +127,7 @@ enum GLChunkType POLYGON_MODE, POLYGON_OFFSET, CULL_FACE, + HINT, ENABLE, DISABLE, ENABLEI, @@ -157,9 +158,12 @@ enum GLChunkType GEN_FRAMEBUFFERS, FRAMEBUFFER_TEX, + READ_BUFFER, BIND_FRAMEBUFFER, BLIT_FRAMEBUFFER, + GEN_SAMPLERS, + SAMPLER_PARAMETERI, BIND_SAMPLER, GEN_BUFFER, diff --git a/renderdoc/driver/gl/gl_context_driver.cpp b/renderdoc/driver/gl/gl_context_driver.cpp index a05392867..f712d625d 100644 --- a/renderdoc/driver/gl/gl_context_driver.cpp +++ b/renderdoc/driver/gl/gl_context_driver.cpp @@ -536,11 +536,30 @@ void WrappedOpenGL::glCullFace(GLenum mode) } } +bool WrappedOpenGL::Serialise_glHint(GLenum target, GLenum mode) +{ + SERIALISE_ELEMENT(GLenum, t, target); + SERIALISE_ELEMENT(GLenum, m, mode); + + if(m_State <= EXECUTING) + { + m_Real.glHint(t, m); + } + + return true; +} + void WrappedOpenGL::glHint(GLenum target, GLenum mode) { m_Real.glHint(target, mode); - RDCUNIMPLEMENTED(); + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(HINT); + Serialise_glHint(target, mode); + + m_ContextRecord->AddChunk(scope.Get()); + } } bool WrappedOpenGL::Serialise_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) @@ -788,77 +807,6 @@ void WrappedOpenGL::glPolygonOffset(GLfloat factor, GLfloat units) } } -bool WrappedOpenGL::Serialise_glBindFramebuffer(GLenum target, GLuint framebuffer) -{ - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(ResourceId, Id, GetResourceManager()->GetID(FramebufferRes(framebuffer))); - - if(m_State <= EXECUTING) - { - if(Id == ResourceId()) - { - m_Real.glBindFramebuffer(Target, m_FakeBB_FBO); - } - else - { - GLResource res = GetResourceManager()->GetLiveResource(Id); - m_Real.glBindFramebuffer(Target, res.name); - } - } - - return true; -} - -void WrappedOpenGL::glBindFramebuffer(GLenum target, GLuint framebuffer) -{ - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(BIND_FRAMEBUFFER); - Serialise_glBindFramebuffer(target, framebuffer); - - m_ContextRecord->AddChunk(scope.Get()); - } - - if(framebuffer == 0 && (m_State == READING || m_State == EXECUTING)) - framebuffer = m_FakeBB_FBO; - - m_Real.glBindFramebuffer(target, framebuffer); -} - -bool WrappedOpenGL::Serialise_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) -{ - SERIALISE_ELEMENT(int32_t, sX0, srcX0); - SERIALISE_ELEMENT(int32_t, sY0, srcY0); - SERIALISE_ELEMENT(int32_t, sX1, srcX1); - SERIALISE_ELEMENT(int32_t, sY1, srcY1); - SERIALISE_ELEMENT(int32_t, dX0, dstX0); - SERIALISE_ELEMENT(int32_t, dY0, dstY0); - SERIALISE_ELEMENT(int32_t, dX1, dstX1); - SERIALISE_ELEMENT(int32_t, dY1, dstY1); - SERIALISE_ELEMENT(uint32_t, msk, mask); - SERIALISE_ELEMENT(GLenum, flt, filter); - - if(m_State <= EXECUTING) - { - m_Real.glBlitFramebuffer(sX0, sY0, sX1, sY1, dX0, dY0, dX1, dY1, msk, flt); - } - - return true; -} - -void WrappedOpenGL::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) -{ - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(BLIT_FRAMEBUFFER); - Serialise_glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); - - m_ContextRecord->AddChunk(scope.Get()); - } - - m_Real.glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); -} - #pragma endregion #pragma region Debugging annotation diff --git a/renderdoc/driver/gl/gl_device_driver.cpp b/renderdoc/driver/gl/gl_device_driver.cpp index bcef2b14c..103d0e16e 100644 --- a/renderdoc/driver/gl/gl_device_driver.cpp +++ b/renderdoc/driver/gl/gl_device_driver.cpp @@ -278,7 +278,7 @@ bool WrappedOpenGL::Serialise_glTexParameteri(GLenum target, GLenum pname, GLint SERIALISE_ELEMENT(GLenum, PName, pname); SERIALISE_ELEMENT(int32_t, Param, param); - if(m_State == READING) + if(m_State < WRITING) { glTexParameteri(Target, PName, Param); } @@ -297,10 +297,31 @@ void WrappedOpenGL::glTexParameteri(GLenum target, GLenum pname, GLint param) SCOPED_SERIALISE_CONTEXT(TEXPARAMETERI); Serialise_glTexParameteri(target, pname, param); - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + if(m_State == WRITING_IDLE) + m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + else + m_ContextRecord->AddChunk(scope.Get()); } } +bool WrappedOpenGL::Serialise_glGenSamplers(GLsizei n, GLuint* samplers) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(*samplers))); + + if(m_State == READING) + { + GLuint real = 0; + m_Real.glGenSamplers(1, &real); + + GLResource res = SamplerRes(real); + + ResourceId live = m_ResourceManager->RegisterResource(res); + GetResourceManager()->AddLiveResource(id, res); + } + + return true; +} + void WrappedOpenGL::glGenSamplers(GLsizei count, GLuint *samplers) { m_Real.glGenSamplers(count, samplers); @@ -312,7 +333,19 @@ void WrappedOpenGL::glGenSamplers(GLsizei count, GLuint *samplers) if(m_State >= WRITING) { - RDCUNIMPLEMENTED(); + Chunk *chunk = NULL; + + { + SCOPED_SERIALISE_CONTEXT(GEN_SAMPLERS); + Serialise_glGenSamplers(1, samplers+i); + + chunk = scope.Get(); + } + + GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id); + RDCASSERT(record); + + record->AddChunk(chunk); } else { @@ -348,13 +381,34 @@ void WrappedOpenGL::glBindSampler(GLuint unit, GLuint sampler) } } +bool WrappedOpenGL::Serialise_glSamplerParameteri(GLuint sampler, GLenum pname, GLint param) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(sampler))); + SERIALISE_ELEMENT(GLenum, PName, pname); + SERIALISE_ELEMENT(int32_t, Param, param); + + if(m_State < WRITING) + { + GLResource res = GetResourceManager()->GetLiveResource(id); + glSamplerParameteri(res.name, pname, param); + } + + return true; +} + void WrappedOpenGL::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param) { m_Real.glSamplerParameteri(sampler, pname, param); if(m_State >= WRITING) { - RDCUNIMPLEMENTED(); + SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERI); + Serialise_glSamplerParameteri(sampler, pname, param); + + if(m_State == WRITING_IDLE) + GetResourceManager()->GetResourceRecord(SamplerRes(sampler))->AddChunk(scope.Get()); + else + m_ContextRecord->AddChunk(scope.Get()); } } @@ -363,7 +417,7 @@ bool WrappedOpenGL::Serialise_glPixelStorei(GLenum pname, GLint param) SERIALISE_ELEMENT(GLenum, PName, pname); SERIALISE_ELEMENT(int32_t, Param, param); - if(m_State == READING) + if(m_State < WRITING) m_Real.glPixelStorei(PName, Param); return true; @@ -390,6 +444,8 @@ void WrappedOpenGL::glPixelStoref(GLenum pname, GLfloat param) void WrappedOpenGL::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels) { m_Real.glTexImage1D(target, level, internalformat, width, border, format, type, pixels); + + RDCUNIMPLEMENTED(); } void WrappedOpenGL::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels) @@ -434,6 +490,24 @@ void WrappedOpenGL::glActiveTexture(GLenum texture) #pragma region Framebuffers +bool WrappedOpenGL::Serialise_glGenFramebuffers(GLsizei n, GLuint* framebuffers) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(FramebufferRes(*framebuffers))); + + if(m_State == READING) + { + GLuint real = 0; + m_Real.glGenFramebuffers(1, &real); + + GLResource res = FramebufferRes(real); + + ResourceId live = m_ResourceManager->RegisterResource(res); + GetResourceManager()->AddLiveResource(id, res); + } + + return true; +} + void WrappedOpenGL::glGenFramebuffers(GLsizei n, GLuint *framebuffers) { m_Real.glGenFramebuffers(n, framebuffers); @@ -445,7 +519,19 @@ void WrappedOpenGL::glGenFramebuffers(GLsizei n, GLuint *framebuffers) if(m_State >= WRITING) { - RDCUNIMPLEMENTED(); + Chunk *chunk = NULL; + + { + SCOPED_SERIALISE_CONTEXT(GEN_FRAMEBUFFERS); + Serialise_glGenFramebuffers(1, framebuffers+i); + + chunk = scope.Get(); + } + + GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id); + RDCASSERT(record); + + record->AddChunk(chunk); } else { @@ -454,20 +540,163 @@ void WrappedOpenGL::glGenFramebuffers(GLsizei n, GLuint *framebuffers) } } +bool WrappedOpenGL::Serialise_glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(GLenum, Attach, attachment); + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(texture))); + SERIALISE_ELEMENT(int32_t, Level, level); + + if(m_State < WRITING) + { + GLResource res = GetResourceManager()->GetLiveResource(id); + glFramebufferTexture(Target, Attach, res.name, Level); + } + + return true; +} + void WrappedOpenGL::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level) { m_Real.glFramebufferTexture(target, attachment, texture, level); if(m_State >= WRITING) - RDCUNIMPLEMENTED(); + { + SCOPED_SERIALISE_CONTEXT(FRAMEBUFFER_TEX); + Serialise_glFramebufferTexture(target, attachment, texture, level); + + if(m_State == WRITING_IDLE) + { + if(target == eGL_DRAW_FRAMEBUFFER || target == eGL_FRAMEBUFFER) + { + if(m_DrawFramebufferRecord) + m_DeviceRecord->AddChunk(scope.Get()); + else + m_DrawFramebufferRecord->AddChunk(scope.Get()); + } + else + { + if(m_ReadFramebufferRecord) + m_DeviceRecord->AddChunk(scope.Get()); + else + m_ReadFramebufferRecord->AddChunk(scope.Get()); + } + } + else + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glReadBuffer(GLenum mode) +{ + SERIALISE_ELEMENT(GLenum, m, mode); + + if(m_State < WRITING) + m_Real.glReadBuffer(m); + + return true; +} + +void WrappedOpenGL::glReadBuffer(GLenum mode) +{ + m_Real.glReadBuffer(mode); + + if(m_State >= WRITING) + { + SCOPED_SERIALISE_CONTEXT(READ_BUFFER); + Serialise_glReadBuffer(mode); + + if(m_State == WRITING_IDLE) + { + if(m_ReadFramebufferRecord) + m_ReadFramebufferRecord->AddChunk(scope.Get()); + else + m_DeviceRecord->AddChunk(scope.Get()); + } + else + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glBindFramebuffer(GLenum target, GLuint framebuffer) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(ResourceId, Id, GetResourceManager()->GetID(FramebufferRes(framebuffer))); + + if(m_State <= EXECUTING) + { + if(Id == ResourceId()) + { + m_Real.glBindFramebuffer(Target, m_FakeBB_FBO); + } + else + { + GLResource res = GetResourceManager()->GetLiveResource(Id); + m_Real.glBindFramebuffer(Target, res.name); + } + } + + return true; +} + +void WrappedOpenGL::glBindFramebuffer(GLenum target, GLuint framebuffer) +{ + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(BIND_FRAMEBUFFER); + Serialise_glBindFramebuffer(target, framebuffer); + + m_ContextRecord->AddChunk(scope.Get()); + } + + if(framebuffer == 0 && m_State < WRITING) + framebuffer = m_FakeBB_FBO; + + if(target == eGL_DRAW_FRAMEBUFFER || target == eGL_FRAMEBUFFER) + m_DrawFramebufferRecord = GetResourceManager()->GetResourceRecord(FramebufferRes(framebuffer)); + else + m_ReadFramebufferRecord = GetResourceManager()->GetResourceRecord(FramebufferRes(framebuffer)); + + m_Real.glBindFramebuffer(target, framebuffer); +} + +bool WrappedOpenGL::Serialise_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) +{ + SERIALISE_ELEMENT(int32_t, sX0, srcX0); + SERIALISE_ELEMENT(int32_t, sY0, srcY0); + SERIALISE_ELEMENT(int32_t, sX1, srcX1); + SERIALISE_ELEMENT(int32_t, sY1, srcY1); + SERIALISE_ELEMENT(int32_t, dX0, dstX0); + SERIALISE_ELEMENT(int32_t, dY0, dstY0); + SERIALISE_ELEMENT(int32_t, dX1, dstX1); + SERIALISE_ELEMENT(int32_t, dY1, dstY1); + SERIALISE_ELEMENT(uint32_t, msk, mask); + SERIALISE_ELEMENT(GLenum, flt, filter); + + if(m_State <= EXECUTING) + { + m_Real.glBlitFramebuffer(sX0, sY0, sX1, sY1, dX0, dY0, dX1, dY1, msk, flt); + } + + return true; +} + +void WrappedOpenGL::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) +{ + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(BLIT_FRAMEBUFFER); + Serialise_glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); + + m_ContextRecord->AddChunk(scope.Get()); + } + + m_Real.glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); } void WrappedOpenGL::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers) { m_Real.glDeleteFramebuffers(n, framebuffers); - - if(m_State >= WRITING) - RDCUNIMPLEMENTED(); for(GLsizei i=0; i < n; i++) GetResourceManager()->UnregisterResource(FramebufferRes(framebuffers[i])); diff --git a/renderdoc/driver/gl/gl_driver.cpp b/renderdoc/driver/gl/gl_driver.cpp index c8763b307..2085dbf9d 100644 --- a/renderdoc/driver/gl/gl_driver.cpp +++ b/renderdoc/driver/gl/gl_driver.cpp @@ -84,6 +84,7 @@ const char *GLChunkNames[] = "glPolygonMode", "glPolygonOffset", "glCullFace", + "glHint", "glEnable", "glDisable", "glEnablei", @@ -114,9 +115,12 @@ const char *GLChunkNames[] = "glGenFramebuffers", "glFramebufferTexture", + "glReadBuffer", "glBindFramebuffer", "glBlitFramebuffer", + "glGenSamplers", + "glSamplerParameteri", "glBindSampler", "glGenBuffers", @@ -224,6 +228,10 @@ WrappedOpenGL::WrappedOpenGL(const wchar_t *logfile, const GLHookSet &funcs) m_CurDrawcallID = 1; RDCEraseEl(m_TextureRecord); + RDCEraseEl(m_BufferRecord); + m_VertexArrayRecord = NULL; + m_DrawFramebufferRecord = NULL; + m_ReadFramebufferRecord = NULL; m_TextureUnit = 0; m_LastIndexSize = eGL_UNKNOWN_ENUM; @@ -973,17 +981,32 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) Serialise_glRotatef(0, 0, 0, 0); break; // - + + case GEN_FRAMEBUFFERS: + Serialise_glGenFramebuffers(0, NULL); + break; case BIND_FRAMEBUFFER: Serialise_glBindFramebuffer(eGL_UNKNOWN_ENUM, 0); break; + case READ_BUFFER: + Serialise_glReadBuffer(eGL_UNKNOWN_ENUM); + break; + case FRAMEBUFFER_TEX: + Serialise_glFramebufferTexture(eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, 0, 0); + break; case BLIT_FRAMEBUFFER: Serialise_glBlitFramebuffer(0, 0, 0, 0, 0, 0, 0, 0, 0, eGL_UNKNOWN_ENUM); break; - + + case GEN_SAMPLERS: + Serialise_glGenSamplers(0, NULL); + break; case BIND_SAMPLER: Serialise_glBindSampler(0, 0); break; + case SAMPLER_PARAMETERI: + Serialise_glSamplerParameteri(0, eGL_UNKNOWN_ENUM, 0); + break; case CLEAR_COLOR: Serialise_glClearColor(0, 0, 0, 0); @@ -1018,6 +1041,9 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) case DISABLE: Serialise_glDisable(eGL_UNKNOWN_ENUM); break; + case HINT: + Serialise_glHint(eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM); + break; case ENABLE: Serialise_glEnable(eGL_UNKNOWN_ENUM); break; @@ -1450,7 +1476,7 @@ void WrappedOpenGL::ReplayLog(uint32_t frameID, uint32_t startEventID, uint32_t } } -#pragma region Get functions +#pragma region Read-only functions GLenum WrappedOpenGL::glGetError() { @@ -1670,9 +1696,4 @@ void WrappedOpenGL::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height m_Real.glReadPixels(x, y, width, height, format, type, pixels); } -void WrappedOpenGL::glReadBuffer(GLenum mode) -{ - m_Real.glReadBuffer(mode); -} - #pragma endregion diff --git a/renderdoc/driver/gl/gl_driver.h b/renderdoc/driver/gl/gl_driver.h index 35fe43915..3af7ede4a 100644 --- a/renderdoc/driver/gl/gl_driver.h +++ b/renderdoc/driver/gl/gl_driver.h @@ -102,6 +102,8 @@ class WrappedOpenGL GLResourceRecord *m_TextureRecord[128]; GLResourceRecord *m_BufferRecord[16]; GLResourceRecord *m_VertexArrayRecord; + GLResourceRecord *m_DrawFramebufferRecord; + GLResourceRecord *m_ReadFramebufferRecord; GLint m_TextureUnit; size_t BufferIdx(GLenum buf);