From 770938d804bd334a5e75a7f082a0b53b531400f5 Mon Sep 17 00:00:00 2001 From: baldurk Date: Fri, 27 Oct 2017 17:40:03 +0100 Subject: [PATCH] Update GL sampler functions to new serialisation --- .../driver/gl/wrappers/gl_sampler_funcs.cpp | 319 +++++++++--------- 1 file changed, 160 insertions(+), 159 deletions(-) diff --git a/renderdoc/driver/gl/wrappers/gl_sampler_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_sampler_funcs.cpp index c08bbadd0..9adb614cd 100644 --- a/renderdoc/driver/gl/wrappers/gl_sampler_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_sampler_funcs.cpp @@ -27,11 +27,17 @@ #include "common/common.h" #include "strings/string_utils.h" -bool WrappedOpenGL::Serialise_glGenSamplers(GLsizei n, GLuint *samplers) +static constexpr uint32_t numParams(GLenum pname) { - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), *samplers))); + return pname == eGL_TEXTURE_BORDER_COLOR ? 4U : 1U; +} - if(m_State == READING) +template +bool WrappedOpenGL::Serialise_glGenSamplers(SerialiserType &ser, GLsizei n, GLuint *samplers) +{ + SERIALISE_ELEMENT_LOCAL(sampler, GetResourceManager()->GetID(SamplerRes(GetCtx(), *samplers))); + + if(IsReplayingAndReading()) { GLuint real = 0; m_Real.glGenSamplers(1, &real); @@ -41,7 +47,7 @@ bool WrappedOpenGL::Serialise_glGenSamplers(GLsizei n, GLuint *samplers) GLResource res = SamplerRes(GetCtx(), real); ResourceId live = m_ResourceManager->RegisterResource(res); - GetResourceManager()->AddLiveResource(id, res); + GetResourceManager()->AddLiveResource(sampler, res); } return true; @@ -56,13 +62,14 @@ void WrappedOpenGL::glGenSamplers(GLsizei count, GLuint *samplers) GLResource res = SamplerRes(GetCtx(), samplers[i]); ResourceId id = GetResourceManager()->RegisterResource(res); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { Chunk *chunk = NULL; { - SCOPED_SERIALISE_CONTEXT(GEN_SAMPLERS); - Serialise_glGenSamplers(1, samplers + i); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glGenSamplers(ser, 1, samplers + i); chunk = scope.Get(); } @@ -79,11 +86,12 @@ void WrappedOpenGL::glGenSamplers(GLsizei count, GLuint *samplers) } } -bool WrappedOpenGL::Serialise_glCreateSamplers(GLsizei n, GLuint *samplers) +template +bool WrappedOpenGL::Serialise_glCreateSamplers(SerialiserType &ser, GLsizei n, GLuint *samplers) { - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), *samplers))); + SERIALISE_ELEMENT_LOCAL(sampler, GetResourceManager()->GetID(SamplerRes(GetCtx(), *samplers))); - if(m_State == READING) + if(IsReplayingAndReading()) { GLuint real = 0; m_Real.glCreateSamplers(1, &real); @@ -91,7 +99,7 @@ bool WrappedOpenGL::Serialise_glCreateSamplers(GLsizei n, GLuint *samplers) GLResource res = SamplerRes(GetCtx(), real); ResourceId live = m_ResourceManager->RegisterResource(res); - GetResourceManager()->AddLiveResource(id, res); + GetResourceManager()->AddLiveResource(sampler, res); } return true; @@ -106,13 +114,14 @@ void WrappedOpenGL::glCreateSamplers(GLsizei count, GLuint *samplers) GLResource res = SamplerRes(GetCtx(), samplers[i]); ResourceId id = GetResourceManager()->RegisterResource(res); - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { Chunk *chunk = NULL; { - SCOPED_SERIALISE_CONTEXT(CREATE_SAMPLERS); - Serialise_glCreateSamplers(1, samplers + i); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glCreateSamplers(ser, 1, samplers + i); chunk = scope.Get(); } @@ -129,25 +138,14 @@ void WrappedOpenGL::glCreateSamplers(GLsizei count, GLuint *samplers) } } -bool WrappedOpenGL::Serialise_glBindSampler(GLuint unit, GLuint sampler) +template +bool WrappedOpenGL::Serialise_glBindSampler(SerialiserType &ser, GLuint unit, GLuint samplerHandle) { - SERIALISE_ELEMENT(uint32_t, Unit, unit); - SERIALISE_ELEMENT(ResourceId, id, sampler - ? GetResourceManager()->GetID(SamplerRes(GetCtx(), sampler)) - : ResourceId()); + SERIALISE_ELEMENT(unit); + SERIALISE_ELEMENT_LOCAL(sampler, SamplerRes(GetCtx(), samplerHandle)); - if(m_State < WRITING) - { - if(id == ResourceId()) - { - m_Real.glBindSampler(Unit, 0); - } - else - { - GLResource res = GetResourceManager()->GetLiveResource(id); - m_Real.glBindSampler(Unit, res.name); - } - } + if(IsReplayingAndReading()) + m_Real.glBindSampler(unit, sampler.name); return true; } @@ -156,44 +154,48 @@ void WrappedOpenGL::glBindSampler(GLuint unit, GLuint sampler) { m_Real.glBindSampler(unit, sampler); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(BIND_SAMPLER); - Serialise_glBindSampler(unit, sampler); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glBindSampler(ser, unit, sampler); m_ContextRecord->AddChunk(scope.Get()); GetResourceManager()->MarkResourceFrameReferenced(SamplerRes(GetCtx(), sampler), eFrameRef_Read); } } -bool WrappedOpenGL::Serialise_glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers) +template +bool WrappedOpenGL::Serialise_glBindSamplers(SerialiserType &ser, GLuint first, GLsizei count, + const GLuint *samplerHandles) { - SERIALISE_ELEMENT(uint32_t, First, first); - SERIALISE_ELEMENT(int32_t, Count, count); + SERIALISE_ELEMENT(first); + SERIALISE_ELEMENT(count); - GLuint *samps = NULL; - if(m_State <= EXECUTING) - samps = new GLuint[Count]; + // can't serialise arrays of GL handles since they're not wrapped or typed :(. + GLResource *samplers = NULL; - for(int32_t i = 0; i < Count; i++) + if(ser.IsWriting()) { - SERIALISE_ELEMENT(ResourceId, id, - samplers && samplers[i] - ? GetResourceManager()->GetID(SamplerRes(GetCtx(), samplers[i])) - : ResourceId()); - - if(m_State <= EXECUTING) - { - if(id != ResourceId()) - samps[i] = GetResourceManager()->GetLiveResource(id).name; - else - samps[i] = 0; - } + samplers = new GLResource[count]; + for(int32_t i = 0; i < count; i++) + samplers[i] = SamplerRes(GetCtx(), samplerHandles[i]); } - if(m_State <= EXECUTING) + uint32_t numSamps = count; + + SERIALISE_ELEMENT_ARRAY(samplers, numSamps); + + if(ser.IsWriting()) + SAFE_DELETE_ARRAY(samplers); + + if(IsReplayingAndReading()) { - m_Real.glBindSamplers(First, Count, samps); + GLuint *samps = new GLuint[count]; + for(int32_t i = 0; i < count; i++) + samps[i] = samplers[i].name; + + m_Real.glBindSamplers(first, count, samps); delete[] samps; } @@ -205,10 +207,11 @@ void WrappedOpenGL::glBindSamplers(GLuint first, GLsizei count, const GLuint *sa { m_Real.glBindSamplers(first, count, samplers); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(BIND_SAMPLERS); - Serialise_glBindSamplers(first, count, samplers); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glBindSamplers(ser, first, count, samplers); m_ContextRecord->AddChunk(scope.Get()); for(GLsizei i = 0; i < count; i++) @@ -218,36 +221,29 @@ void WrappedOpenGL::glBindSamplers(GLuint first, GLsizei count, const GLuint *sa } } -bool WrappedOpenGL::Serialise_glSamplerParameteri(GLuint sampler, GLenum pname, GLint param) +template +bool WrappedOpenGL::Serialise_glSamplerParameteri(SerialiserType &ser, GLuint samplerHandle, + GLenum pname, GLint param) { - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), sampler))); - SERIALISE_ELEMENT(GLenum, PName, pname); - - int32_t ParamValue = 0; + SERIALISE_ELEMENT_LOCAL(sampler, SamplerRes(GetCtx(), samplerHandle)); + SERIALISE_ELEMENT(pname); RDCCOMPILE_ASSERT(sizeof(int32_t) == sizeof(GLenum), "int32_t isn't the same size as GLenum - aliased serialising will break"); // special case a few parameters to serialise their value as an enum, not an int - if(PName == GL_TEXTURE_WRAP_S || PName == GL_TEXTURE_WRAP_T || PName == GL_TEXTURE_WRAP_R || - PName == GL_TEXTURE_MIN_FILTER || PName == GL_TEXTURE_MAG_FILTER || - PName == GL_TEXTURE_COMPARE_MODE || PName == GL_TEXTURE_COMPARE_FUNC) + if(pname == GL_TEXTURE_WRAP_S || pname == GL_TEXTURE_WRAP_T || pname == GL_TEXTURE_WRAP_R || + pname == GL_TEXTURE_MIN_FILTER || pname == GL_TEXTURE_MAG_FILTER || + pname == GL_TEXTURE_COMPARE_MODE || pname == GL_TEXTURE_COMPARE_FUNC) { - SERIALISE_ELEMENT(GLenum, Param, (GLenum)param); - - ParamValue = (int32_t)Param; + SERIALISE_ELEMENT_TYPED(GLenum, param); } else { - SERIALISE_ELEMENT(int32_t, Param, param); - - ParamValue = Param; + SERIALISE_ELEMENT(param); } - if(m_State < WRITING) - { - GLResource res = GetResourceManager()->GetLiveResource(id); - m_Real.glSamplerParameteri(res.name, PName, ParamValue); - } + if(IsReplayingAndReading()) + m_Real.glSamplerParameteri(sampler.name, pname, param); return true; } @@ -260,12 +256,13 @@ void WrappedOpenGL::glSamplerParameteri(GLuint sampler, GLenum pname, GLint para if(param == eGL_CLAMP) param = eGL_CLAMP_TO_EDGE; - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERI); - Serialise_glSamplerParameteri(sampler, pname, param); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glSamplerParameteri(ser, sampler, pname, param); - if(m_State == WRITING_IDLE) + if(IsBackgroundCapturing(m_State)) { GetResourceManager()->GetResourceRecord(SamplerRes(GetCtx(), sampler))->AddChunk(scope.Get()); } @@ -278,17 +275,16 @@ void WrappedOpenGL::glSamplerParameteri(GLuint sampler, GLenum pname, GLint para } } -bool WrappedOpenGL::Serialise_glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) +template +bool WrappedOpenGL::Serialise_glSamplerParameterf(SerialiserType &ser, GLuint samplerHandle, + GLenum pname, GLfloat param) { - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), sampler))); - SERIALISE_ELEMENT(GLenum, PName, pname); - SERIALISE_ELEMENT(float, Param, param); + SERIALISE_ELEMENT_LOCAL(sampler, SamplerRes(GetCtx(), samplerHandle)); + SERIALISE_ELEMENT(pname); + SERIALISE_ELEMENT(param); - if(m_State < WRITING) - { - GLResource res = GetResourceManager()->GetLiveResource(id); - m_Real.glSamplerParameterf(res.name, PName, Param); - } + if(IsReplayingAndReading()) + m_Real.glSamplerParameterf(sampler.name, pname, param); return true; } @@ -301,12 +297,13 @@ void WrappedOpenGL::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat pa if(param == (float)eGL_CLAMP) param = (float)eGL_CLAMP_TO_EDGE; - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERF); - Serialise_glSamplerParameterf(sampler, pname, param); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glSamplerParameterf(ser, sampler, pname, param); - if(m_State == WRITING_IDLE) + if(IsBackgroundCapturing(m_State)) { GetResourceManager()->GetResourceRecord(SamplerRes(GetCtx(), sampler))->AddChunk(scope.Get()); } @@ -319,20 +316,16 @@ void WrappedOpenGL::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat pa } } -bool WrappedOpenGL::Serialise_glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *params) +template +bool WrappedOpenGL::Serialise_glSamplerParameteriv(SerialiserType &ser, GLuint samplerHandle, + GLenum pname, const GLint *params) { - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), sampler))); - SERIALISE_ELEMENT(GLenum, PName, pname); - const size_t nParams = (PName == eGL_TEXTURE_BORDER_COLOR ? 4U : 1U); - SERIALISE_ELEMENT_ARR(int32_t, Params, params, nParams); + SERIALISE_ELEMENT_LOCAL(sampler, SamplerRes(GetCtx(), samplerHandle)); + SERIALISE_ELEMENT(pname); + SERIALISE_ELEMENT_ARRAY(params, FIXED_COUNT(numParams(pname))); - if(m_State < WRITING) - { - GLResource res = GetResourceManager()->GetLiveResource(id); - m_Real.glSamplerParameteriv(res.name, PName, Params); - } - - delete[] Params; + if(IsReplayingAndReading()) + m_Real.glSamplerParameteriv(sampler.name, pname, params); return true; } @@ -346,12 +339,13 @@ void WrappedOpenGL::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLi if(*params == eGL_CLAMP) params = clamptoedge; - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERIV); - Serialise_glSamplerParameteriv(sampler, pname, params); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glSamplerParameteriv(ser, sampler, pname, params); - if(m_State == WRITING_IDLE) + if(IsBackgroundCapturing(m_State)) { GetResourceManager()->GetResourceRecord(SamplerRes(GetCtx(), sampler))->AddChunk(scope.Get()); } @@ -364,20 +358,16 @@ void WrappedOpenGL::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLi } } -bool WrappedOpenGL::Serialise_glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *params) +template +bool WrappedOpenGL::Serialise_glSamplerParameterfv(SerialiserType &ser, GLuint samplerHandle, + GLenum pname, const GLfloat *params) { - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), sampler))); - SERIALISE_ELEMENT(GLenum, PName, pname); - const size_t nParams = (PName == eGL_TEXTURE_BORDER_COLOR ? 4U : 1U); - SERIALISE_ELEMENT_ARR(float, Params, params, nParams); + SERIALISE_ELEMENT_LOCAL(sampler, SamplerRes(GetCtx(), samplerHandle)); + SERIALISE_ELEMENT(pname); + SERIALISE_ELEMENT_ARRAY(params, FIXED_COUNT(numParams(pname))); - if(m_State < WRITING) - { - GLResource res = GetResourceManager()->GetLiveResource(id); - m_Real.glSamplerParameterfv(res.name, PName, Params); - } - - delete[] Params; + if(IsReplayingAndReading()) + m_Real.glSamplerParameterfv(sampler.name, pname, params); return true; } @@ -391,12 +381,13 @@ void WrappedOpenGL::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLf if(*params == (float)eGL_CLAMP) params = clamptoedge; - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERFV); - Serialise_glSamplerParameterfv(sampler, pname, params); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glSamplerParameterfv(ser, sampler, pname, params); - if(m_State == WRITING_IDLE) + if(IsBackgroundCapturing(m_State)) { GetResourceManager()->GetResourceRecord(SamplerRes(GetCtx(), sampler))->AddChunk(scope.Get()); } @@ -409,20 +400,16 @@ void WrappedOpenGL::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLf } } -bool WrappedOpenGL::Serialise_glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *params) +template +bool WrappedOpenGL::Serialise_glSamplerParameterIiv(SerialiserType &ser, GLuint samplerHandle, + GLenum pname, const GLint *params) { - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), sampler))); - SERIALISE_ELEMENT(GLenum, PName, pname); - const size_t nParams = (PName == eGL_TEXTURE_BORDER_COLOR ? 4U : 1U); - SERIALISE_ELEMENT_ARR(int32_t, Params, params, nParams); + SERIALISE_ELEMENT_LOCAL(sampler, SamplerRes(GetCtx(), samplerHandle)); + SERIALISE_ELEMENT(pname); + SERIALISE_ELEMENT_ARRAY(params, FIXED_COUNT(numParams(pname))); - if(m_State < WRITING) - { - GLResource res = GetResourceManager()->GetLiveResource(id); - m_Real.glSamplerParameterIiv(res.name, PName, Params); - } - - delete[] Params; + if(IsReplayingAndReading()) + m_Real.glSamplerParameterIiv(sampler.name, pname, params); return true; } @@ -436,12 +423,13 @@ void WrappedOpenGL::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GL if(*params == eGL_CLAMP) params = clamptoedge; - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERIIV); - Serialise_glSamplerParameterIiv(sampler, pname, params); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glSamplerParameterIiv(ser, sampler, pname, params); - if(m_State == WRITING_IDLE) + if(IsBackgroundCapturing(m_State)) { GetResourceManager()->GetResourceRecord(SamplerRes(GetCtx(), sampler))->AddChunk(scope.Get()); } @@ -454,21 +442,16 @@ void WrappedOpenGL::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GL } } -bool WrappedOpenGL::Serialise_glSamplerParameterIuiv(GLuint sampler, GLenum pname, - const GLuint *params) +template +bool WrappedOpenGL::Serialise_glSamplerParameterIuiv(SerialiserType &ser, GLuint samplerHandle, + GLenum pname, const GLuint *params) { - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), sampler))); - SERIALISE_ELEMENT(GLenum, PName, pname); - const size_t nParams = (PName == eGL_TEXTURE_BORDER_COLOR ? 4U : 1U); - SERIALISE_ELEMENT_ARR(uint32_t, Params, params, nParams); + SERIALISE_ELEMENT_LOCAL(sampler, SamplerRes(GetCtx(), samplerHandle)); + SERIALISE_ELEMENT(pname); + SERIALISE_ELEMENT_ARRAY(params, FIXED_COUNT(numParams(pname))); - if(m_State < WRITING) - { - GLResource res = GetResourceManager()->GetLiveResource(id); - m_Real.glSamplerParameterIuiv(res.name, PName, Params); - } - - delete[] Params; + if(IsReplayingAndReading()) + m_Real.glSamplerParameterIuiv(sampler.name, pname, params); return true; } @@ -482,12 +465,13 @@ void WrappedOpenGL::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const G if(*params == eGL_CLAMP) params = clamptoedge; - if(m_State >= WRITING) + if(IsCaptureMode(m_State)) { - SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERIUIV); - Serialise_glSamplerParameterIuiv(sampler, pname, params); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glSamplerParameterIuiv(ser, sampler, pname, params); - if(m_State == WRITING_IDLE) + if(IsBackgroundCapturing(m_State)) { GetResourceManager()->GetResourceRecord(SamplerRes(GetCtx(), sampler))->AddChunk(scope.Get()); } @@ -515,3 +499,20 @@ void WrappedOpenGL::glDeleteSamplers(GLsizei n, const GLuint *ids) m_Real.glDeleteSamplers(n, ids); } + +INSTANTIATE_FUNCTION_SERIALISED(void, glGenSamplers, GLsizei n, GLuint *samplers); +INSTANTIATE_FUNCTION_SERIALISED(void, glCreateSamplers, GLsizei n, GLuint *samplers); +INSTANTIATE_FUNCTION_SERIALISED(void, glBindSampler, GLuint unit, GLuint sampler); +INSTANTIATE_FUNCTION_SERIALISED(void, glBindSamplers, GLuint first, GLsizei count, + const GLuint *samplers); +INSTANTIATE_FUNCTION_SERIALISED(void, glSamplerParameteri, GLuint sampler, GLenum pname, GLint param); +INSTANTIATE_FUNCTION_SERIALISED(void, glSamplerParameterf, GLuint sampler, GLenum pname, + GLfloat param); +INSTANTIATE_FUNCTION_SERIALISED(void, glSamplerParameteriv, GLuint sampler, GLenum pname, + const GLint *params); +INSTANTIATE_FUNCTION_SERIALISED(void, glSamplerParameterfv, GLuint sampler, GLenum pname, + const GLfloat *params); +INSTANTIATE_FUNCTION_SERIALISED(void, glSamplerParameterIiv, GLuint sampler, GLenum pname, + const GLint *params); +INSTANTIATE_FUNCTION_SERIALISED(void, glSamplerParameterIuiv, GLuint sampler, GLenum pname, + const GLuint *params);