From 8cc5a6646522e19e59b1300579cd9974509adf96 Mon Sep 17 00:00:00 2001 From: baldurk Date: Fri, 27 Oct 2017 17:40:11 +0100 Subject: [PATCH] Update GL state-setting functions to new serialisation --- .../driver/gl/wrappers/gl_state_funcs.cpp | 1269 ++++++++++------- 1 file changed, 754 insertions(+), 515 deletions(-) diff --git a/renderdoc/driver/gl/wrappers/gl_state_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_state_funcs.cpp index 51172f799..ecfb89198 100644 --- a/renderdoc/driver/gl/wrappers/gl_state_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_state_funcs.cpp @@ -27,14 +27,15 @@ #include "common/common.h" #include "strings/string_utils.h" -bool WrappedOpenGL::Serialise_glBlendFunc(GLenum sfactor, GLenum dfactor) +template +bool WrappedOpenGL::Serialise_glBlendFunc(SerialiserType &ser, GLenum sfactor, GLenum dfactor) { - SERIALISE_ELEMENT(GLenum, s, sfactor); - SERIALISE_ELEMENT(GLenum, d, dfactor); + SERIALISE_ELEMENT(sfactor); + SERIALISE_ELEMENT(dfactor); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glBlendFunc(s, d); + m_Real.glBlendFunc(sfactor, dfactor); } return true; @@ -44,24 +45,26 @@ void WrappedOpenGL::glBlendFunc(GLenum sfactor, GLenum dfactor) { m_Real.glBlendFunc(sfactor, dfactor); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(BLEND_FUNC); - Serialise_glBlendFunc(sfactor, dfactor); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glBlendFunc(ser, sfactor, dfactor); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glBlendFunci(GLuint buf, GLenum src, GLenum dst) +template +bool WrappedOpenGL::Serialise_glBlendFunci(SerialiserType &ser, GLuint buf, GLenum src, GLenum dst) { - SERIALISE_ELEMENT(GLuint, b, buf); - SERIALISE_ELEMENT(GLenum, s, src); - SERIALISE_ELEMENT(GLenum, d, dst); + SERIALISE_ELEMENT(buf); + SERIALISE_ELEMENT(src); + SERIALISE_ELEMENT(dst); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glBlendFunci(b, s, d); + m_Real.glBlendFunci(buf, src, dst); } return true; @@ -71,25 +74,28 @@ void WrappedOpenGL::glBlendFunci(GLuint buf, GLenum src, GLenum dst) { m_Real.glBlendFunci(buf, src, dst); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(BLEND_FUNCI); - Serialise_glBlendFunci(buf, src, dst); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glBlendFunci(ser, buf, src, dst); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +template +bool WrappedOpenGL::Serialise_glBlendColor(SerialiserType &ser, GLfloat red, GLfloat green, + GLfloat blue, GLfloat alpha) { - SERIALISE_ELEMENT(float, r, red); - SERIALISE_ELEMENT(float, g, green); - SERIALISE_ELEMENT(float, b, blue); - SERIALISE_ELEMENT(float, a, alpha); + SERIALISE_ELEMENT(red); + SERIALISE_ELEMENT(green); + SERIALISE_ELEMENT(blue); + SERIALISE_ELEMENT(alpha); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glBlendColor(r, g, b, a); + m_Real.glBlendColor(red, green, blue, alpha); } return true; @@ -99,26 +105,29 @@ void WrappedOpenGL::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLflo { m_Real.glBlendColor(red, green, blue, alpha); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(BLEND_COLOR); - Serialise_glBlendColor(red, green, blue, alpha); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glBlendColor(ser, red, green, blue, alpha); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, - GLenum sfactorAlpha, GLenum dfactorAlpha) +template +bool WrappedOpenGL::Serialise_glBlendFuncSeparate(SerialiserType &ser, GLenum sfactorRGB, + GLenum dfactorRGB, GLenum sfactorAlpha, + GLenum dfactorAlpha) { - SERIALISE_ELEMENT(GLenum, s1, sfactorRGB); - SERIALISE_ELEMENT(GLenum, d1, dfactorRGB); - SERIALISE_ELEMENT(GLenum, s2, sfactorAlpha); - SERIALISE_ELEMENT(GLenum, d2, dfactorAlpha); + SERIALISE_ELEMENT(sfactorRGB); + SERIALISE_ELEMENT(dfactorRGB); + SERIALISE_ELEMENT(sfactorAlpha); + SERIALISE_ELEMENT(dfactorAlpha); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glBlendFuncSeparate(s1, d1, s2, d2); + m_Real.glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); } return true; @@ -129,27 +138,30 @@ void WrappedOpenGL::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GL { m_Real.glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(BLEND_FUNC_SEP); - Serialise_glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glBlendFuncSeparate(ser, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glBlendFuncSeparatei(GLuint buf, GLenum sfactorRGB, GLenum dfactorRGB, +template +bool WrappedOpenGL::Serialise_glBlendFuncSeparatei(SerialiserType &ser, GLuint buf, + GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) { - SERIALISE_ELEMENT(uint32_t, b, buf); - SERIALISE_ELEMENT(GLenum, s1, sfactorRGB); - SERIALISE_ELEMENT(GLenum, d1, dfactorRGB); - SERIALISE_ELEMENT(GLenum, s2, sfactorAlpha); - SERIALISE_ELEMENT(GLenum, d2, dfactorAlpha); + SERIALISE_ELEMENT(buf); + SERIALISE_ELEMENT(sfactorRGB); + SERIALISE_ELEMENT(dfactorRGB); + SERIALISE_ELEMENT(sfactorAlpha); + SERIALISE_ELEMENT(dfactorAlpha); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glBlendFuncSeparatei(b, s1, d1, s2, d2); + m_Real.glBlendFuncSeparatei(buf, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); } return true; @@ -160,22 +172,24 @@ void WrappedOpenGL::glBlendFuncSeparatei(GLuint buf, GLenum sfactorRGB, GLenum d { m_Real.glBlendFuncSeparatei(buf, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(BLEND_FUNC_SEPI); - Serialise_glBlendFuncSeparatei(buf, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glBlendFuncSeparatei(ser, buf, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glBlendEquation(GLenum mode) +template +bool WrappedOpenGL::Serialise_glBlendEquation(SerialiserType &ser, GLenum mode) { - SERIALISE_ELEMENT(GLenum, m, mode); + SERIALISE_ELEMENT(mode); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glBlendEquation(m); + m_Real.glBlendEquation(mode); } return true; @@ -185,23 +199,25 @@ void WrappedOpenGL::glBlendEquation(GLenum mode) { m_Real.glBlendEquation(mode); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(BLEND_EQ); - Serialise_glBlendEquation(mode); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glBlendEquation(ser, mode); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glBlendEquationi(GLuint buf, GLenum mode) +template +bool WrappedOpenGL::Serialise_glBlendEquationi(SerialiserType &ser, GLuint buf, GLenum mode) { - SERIALISE_ELEMENT(uint32_t, b, buf); - SERIALISE_ELEMENT(GLenum, m, mode); + SERIALISE_ELEMENT(buf); + SERIALISE_ELEMENT(mode); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glBlendEquationi(b, m); + m_Real.glBlendEquationi(buf, mode); } return true; @@ -211,23 +227,26 @@ void WrappedOpenGL::glBlendEquationi(GLuint buf, GLenum mode) { m_Real.glBlendEquationi(buf, mode); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(BLEND_EQI); - Serialise_glBlendEquationi(buf, mode); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glBlendEquationi(ser, buf, mode); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) +template +bool WrappedOpenGL::Serialise_glBlendEquationSeparate(SerialiserType &ser, GLenum modeRGB, + GLenum modeAlpha) { - SERIALISE_ELEMENT(GLenum, m1, modeRGB); - SERIALISE_ELEMENT(GLenum, m2, modeAlpha); + SERIALISE_ELEMENT(modeRGB); + SERIALISE_ELEMENT(modeAlpha); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glBlendEquationSeparate(m1, m2); + m_Real.glBlendEquationSeparate(modeRGB, modeAlpha); } return true; @@ -237,24 +256,27 @@ void WrappedOpenGL::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) { m_Real.glBlendEquationSeparate(modeRGB, modeAlpha); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(BLEND_EQ_SEP); - Serialise_glBlendEquationSeparate(modeRGB, modeAlpha); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glBlendEquationSeparate(ser, modeRGB, modeAlpha); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha) +template +bool WrappedOpenGL::Serialise_glBlendEquationSeparatei(SerialiserType &ser, GLuint buf, + GLenum modeRGB, GLenum modeAlpha) { - SERIALISE_ELEMENT(uint32_t, b, buf); - SERIALISE_ELEMENT(GLenum, m1, modeRGB); - SERIALISE_ELEMENT(GLenum, m2, modeAlpha); + SERIALISE_ELEMENT(buf); + SERIALISE_ELEMENT(modeRGB); + SERIALISE_ELEMENT(modeAlpha); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glBlendEquationSeparatei(b, m1, m2); + m_Real.glBlendEquationSeparatei(buf, modeRGB, modeAlpha); } return true; @@ -264,18 +286,20 @@ void WrappedOpenGL::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum { m_Real.glBlendEquationSeparatei(buf, modeRGB, modeAlpha); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(BLEND_EQ_SEPI); - Serialise_glBlendEquationSeparatei(buf, modeRGB, modeAlpha); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glBlendEquationSeparatei(ser, buf, modeRGB, modeAlpha); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glBlendBarrierKHR() +template +bool WrappedOpenGL::Serialise_glBlendBarrierKHR(SerialiserType &ser) { - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { if(IsGLES && m_Real.glBlendBarrier) m_Real.glBlendBarrier(); @@ -292,10 +316,11 @@ void WrappedOpenGL::glBlendBarrierKHR() m_Real.glBlendBarrierKHR(); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(BLEND_BARRIER); - Serialise_glBlendBarrierKHR(); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glBlendBarrierKHR(ser); m_ContextRecord->AddChunk(scope.Get()); } @@ -307,22 +332,24 @@ void WrappedOpenGL::glBlendBarrier() m_Real.glBlendBarrier(); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(BLEND_BARRIER); - Serialise_glBlendBarrierKHR(); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glBlendBarrierKHR(ser); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glLogicOp(GLenum opcode) +template +bool WrappedOpenGL::Serialise_glLogicOp(SerialiserType &ser, GLenum opcode) { - SERIALISE_ELEMENT(GLenum, Op, opcode); + SERIALISE_ELEMENT(opcode); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glLogicOp(Op); + m_Real.glLogicOp(opcode); } return true; @@ -332,24 +359,26 @@ void WrappedOpenGL::glLogicOp(GLenum opcode) { m_Real.glLogicOp(opcode); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(LOGIC_OP); - Serialise_glLogicOp(opcode); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glLogicOp(ser, opcode); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glStencilFunc(GLenum func, GLint ref, GLuint mask) +template +bool WrappedOpenGL::Serialise_glStencilFunc(SerialiserType &ser, GLenum func, GLint ref, GLuint mask) { - SERIALISE_ELEMENT(GLenum, f, func); - SERIALISE_ELEMENT(int32_t, Ref, ref); - SERIALISE_ELEMENT(uint32_t, Mask, mask); + SERIALISE_ELEMENT(func); + SERIALISE_ELEMENT(ref); + SERIALISE_ELEMENT(mask); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glStencilFunc(f, Ref, Mask); + m_Real.glStencilFunc(func, ref, mask); } return true; @@ -359,25 +388,28 @@ void WrappedOpenGL::glStencilFunc(GLenum func, GLint ref, GLuint mask) { m_Real.glStencilFunc(func, ref, mask); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(STENCIL_FUNC); - Serialise_glStencilFunc(func, ref, mask); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glStencilFunc(ser, func, ref, mask); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) +template +bool WrappedOpenGL::Serialise_glStencilFuncSeparate(SerialiserType &ser, GLenum face, GLenum func, + GLint ref, GLuint mask) { - SERIALISE_ELEMENT(GLenum, Face, face); - SERIALISE_ELEMENT(GLenum, f, func); - SERIALISE_ELEMENT(int32_t, Ref, ref); - SERIALISE_ELEMENT(uint32_t, Mask, mask); + SERIALISE_ELEMENT(face); + SERIALISE_ELEMENT(func); + SERIALISE_ELEMENT(ref); + SERIALISE_ELEMENT(mask); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glStencilFuncSeparate(Face, f, Ref, Mask); + m_Real.glStencilFuncSeparate(face, func, ref, mask); } return true; @@ -387,22 +419,24 @@ void WrappedOpenGL::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, G { m_Real.glStencilFuncSeparate(face, func, ref, mask); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(STENCIL_FUNC_SEP); - Serialise_glStencilFuncSeparate(face, func, ref, mask); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glStencilFuncSeparate(ser, face, func, ref, mask); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glStencilMask(GLuint mask) +template +bool WrappedOpenGL::Serialise_glStencilMask(SerialiserType &ser, GLuint mask) { - SERIALISE_ELEMENT(uint32_t, Mask, mask); + SERIALISE_ELEMENT(mask); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glStencilMask(Mask); + m_Real.glStencilMask(mask); } return true; @@ -412,23 +446,25 @@ void WrappedOpenGL::glStencilMask(GLuint mask) { m_Real.glStencilMask(mask); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(STENCIL_MASK); - Serialise_glStencilMask(mask); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glStencilMask(ser, mask); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glStencilMaskSeparate(GLenum face, GLuint mask) +template +bool WrappedOpenGL::Serialise_glStencilMaskSeparate(SerialiserType &ser, GLenum face, GLuint mask) { - SERIALISE_ELEMENT(GLenum, Face, face); - SERIALISE_ELEMENT(uint32_t, Mask, mask); + SERIALISE_ELEMENT(face); + SERIALISE_ELEMENT(mask); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glStencilMaskSeparate(Face, Mask); + m_Real.glStencilMaskSeparate(face, mask); } return true; @@ -438,24 +474,26 @@ void WrappedOpenGL::glStencilMaskSeparate(GLenum face, GLuint mask) { m_Real.glStencilMaskSeparate(face, mask); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(STENCIL_MASK_SEP); - Serialise_glStencilMaskSeparate(face, mask); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glStencilMaskSeparate(ser, face, mask); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) +template +bool WrappedOpenGL::Serialise_glStencilOp(SerialiserType &ser, GLenum fail, GLenum zfail, GLenum zpass) { - SERIALISE_ELEMENT(GLenum, f, fail); - SERIALISE_ELEMENT(GLenum, zf, zfail); - SERIALISE_ELEMENT(GLenum, p, zpass); + SERIALISE_ELEMENT(fail); + SERIALISE_ELEMENT(zfail); + SERIALISE_ELEMENT(zpass); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glStencilOp(f, zf, p); + m_Real.glStencilOp(fail, zfail, zpass); } return true; @@ -465,26 +503,28 @@ void WrappedOpenGL::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) { m_Real.glStencilOp(fail, zfail, zpass); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(STENCIL_OP); - Serialise_glStencilOp(fail, zfail, zpass); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glStencilOp(ser, fail, zfail, zpass); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, - GLenum dppass) +template +bool WrappedOpenGL::Serialise_glStencilOpSeparate(SerialiserType &ser, GLenum face, GLenum sfail, + GLenum dpfail, GLenum dppass) { - SERIALISE_ELEMENT(GLenum, Face, face); - SERIALISE_ELEMENT(GLenum, sf, sfail); - SERIALISE_ELEMENT(GLenum, zf, dpfail); - SERIALISE_ELEMENT(GLenum, p, dppass); + SERIALISE_ELEMENT(face); + SERIALISE_ELEMENT(sfail); + SERIALISE_ELEMENT(dpfail); + SERIALISE_ELEMENT(dppass); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glStencilOpSeparate(Face, sf, zf, p); + m_Real.glStencilOpSeparate(face, sfail, dpfail, dppass); } return true; @@ -494,25 +534,28 @@ void WrappedOpenGL::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail { m_Real.glStencilOpSeparate(face, sfail, dpfail, dppass); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(STENCIL_OP_SEP); - Serialise_glStencilOpSeparate(face, sfail, dpfail, dppass); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glStencilOpSeparate(ser, face, sfail, dpfail, dppass); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) +template +bool WrappedOpenGL::Serialise_glClearColor(SerialiserType &ser, GLclampf red, GLclampf green, + GLclampf blue, GLclampf alpha) { - SERIALISE_ELEMENT(float, r, red); - SERIALISE_ELEMENT(float, g, green); - SERIALISE_ELEMENT(float, b, blue); - SERIALISE_ELEMENT(float, a, alpha); + SERIALISE_ELEMENT(red); + SERIALISE_ELEMENT(green); + SERIALISE_ELEMENT(blue); + SERIALISE_ELEMENT(alpha); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glClearColor(r, g, b, a); + m_Real.glClearColor(red, green, blue, alpha); } return true; @@ -522,22 +565,24 @@ void WrappedOpenGL::glClearColor(GLclampf red, GLclampf green, GLclampf blue, GL { m_Real.glClearColor(red, green, blue, alpha); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(CLEAR_COLOR); - Serialise_glClearColor(red, green, blue, alpha); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glClearColor(ser, red, green, blue, alpha); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glClearStencil(GLint stencil) +template +bool WrappedOpenGL::Serialise_glClearStencil(SerialiserType &ser, GLint stencil) { - SERIALISE_ELEMENT(uint32_t, s, (uint32_t)stencil); + SERIALISE_ELEMENT_TYPED(int32_t, stencil); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glClearStencil((GLint)s); + m_Real.glClearStencil(stencil); } return true; @@ -547,25 +592,27 @@ void WrappedOpenGL::glClearStencil(GLint stencil) { m_Real.glClearStencil(stencil); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(CLEAR_STENCIL); - Serialise_glClearStencil(stencil); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glClearStencil(ser, stencil); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glClearDepth(GLdouble depth) +template +bool WrappedOpenGL::Serialise_glClearDepth(SerialiserType &ser, GLdouble depth) { - SERIALISE_ELEMENT(double, d, depth); + SERIALISE_ELEMENT(depth); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { if(IsGLES) - m_Real.glClearDepthf((float)d); + m_Real.glClearDepthf((float)depth); else - m_Real.glClearDepth(d); + m_Real.glClearDepth(depth); } return true; @@ -575,10 +622,11 @@ void WrappedOpenGL::glClearDepth(GLdouble depth) { m_Real.glClearDepth(depth); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(CLEAR_DEPTH); - Serialise_glClearDepth(depth); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glClearDepth(ser, depth); m_ContextRecord->AddChunk(scope.Get()); } @@ -588,22 +636,24 @@ void WrappedOpenGL::glClearDepthf(GLfloat depth) { m_Real.glClearDepthf(depth); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(CLEAR_DEPTH); - Serialise_glClearDepth(depth); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glClearDepth(ser, depth); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glDepthFunc(GLenum func) +template +bool WrappedOpenGL::Serialise_glDepthFunc(SerialiserType &ser, GLenum func) { - SERIALISE_ELEMENT(GLenum, f, func); + SERIALISE_ELEMENT(func); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glDepthFunc(f); + m_Real.glDepthFunc(func); } return true; @@ -613,22 +663,24 @@ void WrappedOpenGL::glDepthFunc(GLenum func) { m_Real.glDepthFunc(func); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(DEPTH_FUNC); - Serialise_glDepthFunc(func); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glDepthFunc(ser, func); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glDepthMask(GLboolean flag) +template +bool WrappedOpenGL::Serialise_glDepthMask(SerialiserType &ser, GLboolean flag) { - SERIALISE_ELEMENT(uint8_t, f, flag); + SERIALISE_ELEMENT_TYPED(bool, flag); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glDepthMask(f); + m_Real.glDepthMask(flag ? GL_TRUE : GL_FALSE); } return true; @@ -638,22 +690,24 @@ void WrappedOpenGL::glDepthMask(GLboolean flag) { m_Real.glDepthMask(flag); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(DEPTH_MASK); - Serialise_glDepthMask(flag); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glDepthMask(ser, flag); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glDepthRange(GLdouble nearVal, GLdouble farVal) +template +bool WrappedOpenGL::Serialise_glDepthRange(SerialiserType &ser, GLdouble nearVal, GLdouble farVal) { - SERIALISE_ELEMENT(GLdouble, n, nearVal); - SERIALISE_ELEMENT(GLdouble, f, farVal); + SERIALISE_ELEMENT(nearVal); + SERIALISE_ELEMENT(farVal); - if(m_State <= EXECUTING) - m_Real.glDepthRange(n, f); + if(IsReplayingAndReading()) + m_Real.glDepthRange(nearVal, farVal); return true; } @@ -662,22 +716,24 @@ void WrappedOpenGL::glDepthRange(GLdouble nearVal, GLdouble farVal) { m_Real.glDepthRange(nearVal, farVal); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(DEPTH_RANGE); - Serialise_glDepthRange(nearVal, farVal); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glDepthRange(ser, nearVal, farVal); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glDepthRangef(GLfloat nearVal, GLfloat farVal) +template +bool WrappedOpenGL::Serialise_glDepthRangef(SerialiserType &ser, GLfloat nearVal, GLfloat farVal) { - SERIALISE_ELEMENT(GLfloat, n, nearVal); - SERIALISE_ELEMENT(GLfloat, f, farVal); + SERIALISE_ELEMENT(nearVal); + SERIALISE_ELEMENT(farVal); - if(m_State <= EXECUTING) - m_Real.glDepthRangef(n, f); + if(IsReplayingAndReading()) + m_Real.glDepthRangef(nearVal, farVal); return true; } @@ -686,27 +742,30 @@ void WrappedOpenGL::glDepthRangef(GLfloat nearVal, GLfloat farVal) { m_Real.glDepthRangef(nearVal, farVal); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(DEPTH_RANGEF); - Serialise_glDepthRangef(nearVal, farVal); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glDepthRangef(ser, nearVal, farVal); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glDepthRangeIndexed(GLuint index, GLdouble nearVal, GLdouble farVal) +template +bool WrappedOpenGL::Serialise_glDepthRangeIndexed(SerialiserType &ser, GLuint index, + GLdouble nearVal, GLdouble farVal) { - SERIALISE_ELEMENT(GLuint, i, index); - SERIALISE_ELEMENT(GLdouble, n, nearVal); - SERIALISE_ELEMENT(GLdouble, f, farVal); + SERIALISE_ELEMENT(index); + SERIALISE_ELEMENT(nearVal); + SERIALISE_ELEMENT(farVal); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { if(IsGLES) - m_Real.glDepthRangeIndexedfOES(i, (GLfloat)n, (GLfloat)f); + m_Real.glDepthRangeIndexedfOES(index, (GLfloat)nearVal, (GLfloat)farVal); else - m_Real.glDepthRangeIndexed(i, n, f); + m_Real.glDepthRangeIndexed(index, nearVal, farVal); } return true; @@ -716,10 +775,11 @@ void WrappedOpenGL::glDepthRangeIndexed(GLuint index, GLdouble nearVal, GLdouble { m_Real.glDepthRangeIndexed(index, nearVal, farVal); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(DEPTH_RANGE_IDX); - Serialise_glDepthRangeIndexed(index, nearVal, farVal); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glDepthRangeIndexed(ser, index, nearVal, farVal); m_ContextRecord->AddChunk(scope.Get()); } @@ -729,41 +789,43 @@ void WrappedOpenGL::glDepthRangeIndexedfOES(GLuint index, GLfloat nearVal, GLflo { m_Real.glDepthRangeIndexedfOES(index, nearVal, farVal); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(DEPTH_RANGE_IDX); - Serialise_glDepthRangeIndexed(index, (GLdouble)nearVal, (GLdouble)farVal); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glDepthRangeIndexed(ser, index, (GLdouble)nearVal, (GLdouble)farVal); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v) +template +bool WrappedOpenGL::Serialise_glDepthRangeArrayv(SerialiserType &ser, GLuint first, GLsizei count, + const GLdouble *v) { - SERIALISE_ELEMENT(uint32_t, idx, first); - SERIALISE_ELEMENT(uint32_t, cnt, count); - SERIALISE_ELEMENT_ARR(GLdouble, ranges, v, cnt * 2); + SERIALISE_ELEMENT(first); + SERIALISE_ELEMENT(count); + uint32_t numValues = count * 2; + SERIALISE_ELEMENT_ARRAY(v, numValues); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { if(IsGLES) { - GLfloat *fv = new GLfloat[cnt * 2]; - for(uint32_t i = 0; i < cnt * 2; ++i) - fv[i] = (GLfloat)ranges[i]; + GLfloat *fv = new GLfloat[numValues]; + for(uint32_t i = 0; i < numValues; ++i) + fv[i] = (GLfloat)v[i]; - m_Real.glDepthRangeArrayfvOES(idx, cnt, fv); + m_Real.glDepthRangeArrayfvOES(first, count, fv); delete[] fv; } else { - m_Real.glDepthRangeArrayv(idx, cnt, ranges); + m_Real.glDepthRangeArrayv(first, count, v); } } - delete[] ranges; - return true; } @@ -771,10 +833,11 @@ void WrappedOpenGL::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdoub { m_Real.glDepthRangeArrayv(first, count, v); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(DEPTH_RANGEARRAY); - Serialise_glDepthRangeArrayv(first, count, v); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glDepthRangeArrayv(ser, first, count, v); m_ContextRecord->AddChunk(scope.Get()); } @@ -784,14 +847,15 @@ void WrappedOpenGL::glDepthRangeArrayfvOES(GLuint first, GLsizei count, const GL { m_Real.glDepthRangeArrayfvOES(first, count, v); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { GLdouble *dv = new GLdouble[count * 2]; for(GLsizei i = 0; i < count * 2; ++i) dv[i] = v[i]; - SCOPED_SERIALISE_CONTEXT(DEPTH_RANGEARRAY); - Serialise_glDepthRangeArrayv(first, count, dv); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glDepthRangeArrayv(ser, first, count, dv); delete[] dv; @@ -799,14 +863,15 @@ void WrappedOpenGL::glDepthRangeArrayfvOES(GLuint first, GLsizei count, const GL } } -bool WrappedOpenGL::Serialise_glDepthBoundsEXT(GLclampd nearVal, GLclampd farVal) +template +bool WrappedOpenGL::Serialise_glDepthBoundsEXT(SerialiserType &ser, GLclampd nearVal, GLclampd farVal) { - SERIALISE_ELEMENT(GLdouble, n, nearVal); - SERIALISE_ELEMENT(GLdouble, f, farVal); + SERIALISE_ELEMENT(nearVal); + SERIALISE_ELEMENT(farVal); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glDepthBoundsEXT(n, f); + m_Real.glDepthBoundsEXT(nearVal, farVal); } return true; @@ -816,23 +881,25 @@ void WrappedOpenGL::glDepthBoundsEXT(GLclampd nearVal, GLclampd farVal) { m_Real.glDepthBoundsEXT(nearVal, farVal); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(DEPTH_BOUNDS); - Serialise_glDepthBoundsEXT(nearVal, farVal); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glDepthBoundsEXT(ser, nearVal, farVal); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glClipControl(GLenum origin, GLenum depth) +template +bool WrappedOpenGL::Serialise_glClipControl(SerialiserType &ser, GLenum origin, GLenum depth) { - SERIALISE_ELEMENT(GLenum, o, origin); - SERIALISE_ELEMENT(GLenum, d, depth); + SERIALISE_ELEMENT(origin); + SERIALISE_ELEMENT(depth); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glClipControl(o, d); + m_Real.glClipControl(origin, depth); } return true; @@ -842,22 +909,24 @@ void WrappedOpenGL::glClipControl(GLenum origin, GLenum depth) { m_Real.glClipControl(origin, depth); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(CLIP_CONTROL); - Serialise_glClipControl(origin, depth); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glClipControl(ser, origin, depth); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glProvokingVertex(GLenum mode) +template +bool WrappedOpenGL::Serialise_glProvokingVertex(SerialiserType &ser, GLenum mode) { - SERIALISE_ELEMENT(GLenum, m, mode); + SERIALISE_ELEMENT(mode); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glProvokingVertex(m); + m_Real.glProvokingVertex(mode); } return true; @@ -867,22 +936,24 @@ void WrappedOpenGL::glProvokingVertex(GLenum mode) { m_Real.glProvokingVertex(mode); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(PROVOKING_VERTEX); - Serialise_glProvokingVertex(mode); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glProvokingVertex(ser, mode); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glPrimitiveRestartIndex(GLuint index) +template +bool WrappedOpenGL::Serialise_glPrimitiveRestartIndex(SerialiserType &ser, GLuint index) { - SERIALISE_ELEMENT(GLuint, i, index); + SERIALISE_ELEMENT(index); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glPrimitiveRestartIndex(i); + m_Real.glPrimitiveRestartIndex(index); } return true; @@ -892,22 +963,24 @@ void WrappedOpenGL::glPrimitiveRestartIndex(GLuint index) { m_Real.glPrimitiveRestartIndex(index); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(PRIMITIVE_RESTART); - Serialise_glPrimitiveRestartIndex(index); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glPrimitiveRestartIndex(ser, index); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glDisable(GLenum cap) +template +bool WrappedOpenGL::Serialise_glDisable(SerialiserType &ser, GLenum cap) { - SERIALISE_ELEMENT(GLenum, c, cap); + SERIALISE_ELEMENT(cap); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glDisable(c); + m_Real.glDisable(cap); } return true; @@ -917,7 +990,7 @@ void WrappedOpenGL::glDisable(GLenum cap) { m_Real.glDisable(cap); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { // Skip some compatibility caps purely for the sake of avoiding debug message spam. // We don't explicitly support compatibility, but where it's trivial we try and support it. @@ -930,20 +1003,22 @@ void WrappedOpenGL::glDisable(GLenum cap) if(cap == 0x0BC0) return; // GL_ALPHA_TEST - SCOPED_SERIALISE_CONTEXT(DISABLE); - Serialise_glDisable(cap); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glDisable(ser, cap); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glEnable(GLenum cap) +template +bool WrappedOpenGL::Serialise_glEnable(SerialiserType &ser, GLenum cap) { - SERIALISE_ELEMENT(GLenum, c, cap); + SERIALISE_ELEMENT(cap); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glEnable(c); + m_Real.glEnable(cap); } return true; @@ -953,23 +1028,25 @@ void WrappedOpenGL::glEnable(GLenum cap) { m_Real.glEnable(cap); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(ENABLE); - Serialise_glEnable(cap); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glEnable(ser, cap); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glDisablei(GLenum cap, GLuint index) +template +bool WrappedOpenGL::Serialise_glDisablei(SerialiserType &ser, GLenum cap, GLuint index) { - SERIALISE_ELEMENT(GLenum, c, cap); - SERIALISE_ELEMENT(uint32_t, i, index); + SERIALISE_ELEMENT(cap); + SERIALISE_ELEMENT(index); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glDisablei(c, i); + m_Real.glDisablei(cap, index); } return true; @@ -979,23 +1056,25 @@ void WrappedOpenGL::glDisablei(GLenum cap, GLuint index) { m_Real.glDisablei(cap, index); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(DISABLEI); - Serialise_glDisablei(cap, index); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glDisablei(ser, cap, index); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glEnablei(GLenum cap, GLuint index) +template +bool WrappedOpenGL::Serialise_glEnablei(SerialiserType &ser, GLenum cap, GLuint index) { - SERIALISE_ELEMENT(GLenum, c, cap); - SERIALISE_ELEMENT(uint32_t, i, index); + SERIALISE_ELEMENT(cap); + SERIALISE_ELEMENT(index); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glEnablei(c, i); + m_Real.glEnablei(cap, index); } return true; @@ -1005,22 +1084,24 @@ void WrappedOpenGL::glEnablei(GLenum cap, GLuint index) { m_Real.glEnablei(cap, index); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(ENABLEI); - Serialise_glEnablei(cap, index); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glEnablei(ser, cap, index); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glFrontFace(GLenum mode) +template +bool WrappedOpenGL::Serialise_glFrontFace(SerialiserType &ser, GLenum mode) { - SERIALISE_ELEMENT(GLenum, m, mode); + SERIALISE_ELEMENT(mode); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glFrontFace(m); + m_Real.glFrontFace(mode); } return true; @@ -1030,22 +1111,24 @@ void WrappedOpenGL::glFrontFace(GLenum mode) { m_Real.glFrontFace(mode); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(FRONT_FACE); - Serialise_glFrontFace(mode); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glFrontFace(ser, mode); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glCullFace(GLenum mode) +template +bool WrappedOpenGL::Serialise_glCullFace(SerialiserType &ser, GLenum mode) { - SERIALISE_ELEMENT(GLenum, m, mode); + SERIALISE_ELEMENT(mode); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glCullFace(m); + m_Real.glCullFace(mode); } return true; @@ -1055,23 +1138,25 @@ void WrappedOpenGL::glCullFace(GLenum mode) { m_Real.glCullFace(mode); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(CULL_FACE); - Serialise_glCullFace(mode); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glCullFace(ser, mode); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glHint(GLenum target, GLenum mode) +template +bool WrappedOpenGL::Serialise_glHint(SerialiserType &ser, GLenum target, GLenum mode) { - SERIALISE_ELEMENT(GLenum, t, target); - SERIALISE_ELEMENT(GLenum, m, mode); + SERIALISE_ELEMENT(target); + SERIALISE_ELEMENT(mode); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glHint(t, m); + m_Real.glHint(target, mode); } return true; @@ -1081,26 +1166,29 @@ void WrappedOpenGL::glHint(GLenum target, GLenum mode) { m_Real.glHint(target, mode); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(HINT); - Serialise_glHint(target, mode); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glHint(ser, target, mode); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glColorMask(GLboolean red, GLboolean green, GLboolean blue, - GLboolean alpha) +template +bool WrappedOpenGL::Serialise_glColorMask(SerialiserType &ser, GLboolean red, GLboolean green, + GLboolean blue, GLboolean alpha) { - SERIALISE_ELEMENT(uint8_t, r, red); - SERIALISE_ELEMENT(uint8_t, g, green); - SERIALISE_ELEMENT(uint8_t, b, blue); - SERIALISE_ELEMENT(uint8_t, a, alpha); + SERIALISE_ELEMENT_TYPED(bool, red); + SERIALISE_ELEMENT_TYPED(bool, green); + SERIALISE_ELEMENT_TYPED(bool, blue); + SERIALISE_ELEMENT_TYPED(bool, alpha); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glColorMask(r, g, b, a); + m_Real.glColorMask(red ? GL_TRUE : GL_FALSE, green ? GL_TRUE : GL_FALSE, + blue ? GL_TRUE : GL_FALSE, alpha ? GL_TRUE : GL_FALSE); } return true; @@ -1110,27 +1198,30 @@ void WrappedOpenGL::glColorMask(GLboolean red, GLboolean green, GLboolean blue, { m_Real.glColorMask(red, green, blue, alpha); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(COLOR_MASK); - Serialise_glColorMask(red, green, blue, alpha); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glColorMask(ser, red, green, blue, alpha); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glColorMaski(GLuint buf, GLboolean red, GLboolean green, - GLboolean blue, GLboolean alpha) +template +bool WrappedOpenGL::Serialise_glColorMaski(SerialiserType &ser, GLuint buf, GLboolean red, + GLboolean green, GLboolean blue, GLboolean alpha) { - SERIALISE_ELEMENT(uint32_t, buffer, buf); - SERIALISE_ELEMENT(uint8_t, r, red); - SERIALISE_ELEMENT(uint8_t, g, green); - SERIALISE_ELEMENT(uint8_t, b, blue); - SERIALISE_ELEMENT(uint8_t, a, alpha); + SERIALISE_ELEMENT(buf); + SERIALISE_ELEMENT_TYPED(bool, red); + SERIALISE_ELEMENT_TYPED(bool, green); + SERIALISE_ELEMENT_TYPED(bool, blue); + SERIALISE_ELEMENT_TYPED(bool, alpha); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glColorMaski(buffer, r, g, b, a); + m_Real.glColorMaski(buf, red ? GL_TRUE : GL_FALSE, green ? GL_TRUE : GL_FALSE, + blue ? GL_TRUE : GL_FALSE, alpha ? GL_TRUE : GL_FALSE); } return true; @@ -1141,23 +1232,25 @@ void WrappedOpenGL::glColorMaski(GLuint buf, GLboolean red, GLboolean green, GLb { m_Real.glColorMaski(buf, red, green, blue, alpha); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(COLOR_MASKI); - Serialise_glColorMaski(buf, red, green, blue, alpha); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glColorMaski(ser, buf, red, green, blue, alpha); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glSampleMaski(GLuint maskNumber, GLbitfield mask) +template +bool WrappedOpenGL::Serialise_glSampleMaski(SerialiserType &ser, GLuint maskNumber, GLbitfield mask) { - SERIALISE_ELEMENT(uint32_t, num, maskNumber); - SERIALISE_ELEMENT(uint32_t, Mask, mask); + SERIALISE_ELEMENT(maskNumber); + SERIALISE_ELEMENT(mask); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glSampleMaski(num, Mask); + m_Real.glSampleMaski(maskNumber, mask); } return true; @@ -1167,23 +1260,25 @@ void WrappedOpenGL::glSampleMaski(GLuint maskNumber, GLbitfield mask) { m_Real.glSampleMaski(maskNumber, mask); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(SAMPLE_MASK); - Serialise_glSampleMaski(maskNumber, mask); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glSampleMaski(ser, maskNumber, mask); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glSampleCoverage(GLfloat value, GLboolean invert) +template +bool WrappedOpenGL::Serialise_glSampleCoverage(SerialiserType &ser, GLfloat value, GLboolean invert) { - SERIALISE_ELEMENT(float, Value, value); - SERIALISE_ELEMENT(bool, Invert, invert != 0); + SERIALISE_ELEMENT(value); + SERIALISE_ELEMENT_TYPED(bool, invert); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glSampleCoverage(Value, Invert ? GL_TRUE : GL_FALSE); + m_Real.glSampleCoverage(value, invert ? GL_TRUE : GL_FALSE); } return true; @@ -1193,22 +1288,24 @@ void WrappedOpenGL::glSampleCoverage(GLfloat value, GLboolean invert) { m_Real.glSampleCoverage(value, invert); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(SAMPLE_COVERAGE); - Serialise_glSampleCoverage(value, invert); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glSampleCoverage(ser, value, invert); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glMinSampleShading(GLfloat value) +template +bool WrappedOpenGL::Serialise_glMinSampleShading(SerialiserType &ser, GLfloat value) { - SERIALISE_ELEMENT(float, Value, value); + SERIALISE_ELEMENT(value); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glMinSampleShading(Value); + m_Real.glMinSampleShading(value); } return true; @@ -1218,23 +1315,26 @@ void WrappedOpenGL::glMinSampleShading(GLfloat value) { m_Real.glMinSampleShading(value); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(MIN_SAMPLE_SHADING); - Serialise_glMinSampleShading(value); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glMinSampleShading(ser, value); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glRasterSamplesEXT(GLuint samples, GLboolean fixedsamplelocations) +template +bool WrappedOpenGL::Serialise_glRasterSamplesEXT(SerialiserType &ser, GLuint samples, + GLboolean fixedsamplelocations) { - SERIALISE_ELEMENT(uint32_t, s, samples); - SERIALISE_ELEMENT(bool, f, fixedsamplelocations != 0); + SERIALISE_ELEMENT(samples); + SERIALISE_ELEMENT_TYPED(bool, fixedsamplelocations); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glRasterSamplesEXT(s, f); + m_Real.glRasterSamplesEXT(samples, fixedsamplelocations ? GL_TRUE : GL_FALSE); } return true; @@ -1244,23 +1344,25 @@ void WrappedOpenGL::glRasterSamplesEXT(GLuint samples, GLboolean fixedsampleloca { m_Real.glRasterSamplesEXT(samples, fixedsamplelocations); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(RASTER_SAMPLES); - Serialise_glRasterSamplesEXT(samples, fixedsamplelocations); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glRasterSamplesEXT(ser, samples, fixedsamplelocations); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glPatchParameteri(GLenum pname, GLint value) +template +bool WrappedOpenGL::Serialise_glPatchParameteri(SerialiserType &ser, GLenum pname, GLint value) { - SERIALISE_ELEMENT(GLenum, PName, pname); - SERIALISE_ELEMENT(int32_t, Value, value); + SERIALISE_ELEMENT(pname); + SERIALISE_ELEMENT(value); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glPatchParameteri(PName, Value); + m_Real.glPatchParameteri(pname, value); } return true; @@ -1270,28 +1372,28 @@ void WrappedOpenGL::glPatchParameteri(GLenum pname, GLint value) { m_Real.glPatchParameteri(pname, value); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(PATCH_PARAMI); - Serialise_glPatchParameteri(pname, value); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glPatchParameteri(ser, pname, value); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glPatchParameterfv(GLenum pname, const GLfloat *values) +template +bool WrappedOpenGL::Serialise_glPatchParameterfv(SerialiserType &ser, GLenum pname, + const GLfloat *values) { - SERIALISE_ELEMENT(GLenum, PName, pname); - const size_t nParams = (PName == eGL_PATCH_DEFAULT_OUTER_LEVEL ? 4U : 2U); - SERIALISE_ELEMENT_ARR(float, Values, values, nParams); + SERIALISE_ELEMENT(pname); + SERIALISE_ELEMENT_ARRAY(values, FIXED_COUNT(pname == eGL_PATCH_DEFAULT_OUTER_LEVEL ? 4U : 2U)); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glPatchParameterfv(PName, Values); + m_Real.glPatchParameterfv(pname, values); } - delete[] Values; - return true; } @@ -1299,22 +1401,24 @@ void WrappedOpenGL::glPatchParameterfv(GLenum pname, const GLfloat *values) { m_Real.glPatchParameterfv(pname, values); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(PATCH_PARAMFV); - Serialise_glPatchParameterfv(pname, values); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glPatchParameterfv(ser, pname, values); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glLineWidth(GLfloat width) +template +bool WrappedOpenGL::Serialise_glLineWidth(SerialiserType &ser, GLfloat width) { - SERIALISE_ELEMENT(GLfloat, w, width); + SERIALISE_ELEMENT(width); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glLineWidth(w); + m_Real.glLineWidth(width); } return true; @@ -1324,22 +1428,24 @@ void WrappedOpenGL::glLineWidth(GLfloat width) { m_Real.glLineWidth(width); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(LINE_WIDTH); - Serialise_glLineWidth(width); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glLineWidth(ser, width); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glPointSize(GLfloat size) +template +bool WrappedOpenGL::Serialise_glPointSize(SerialiserType &ser, GLfloat size) { - SERIALISE_ELEMENT(GLfloat, s, size); + SERIALISE_ELEMENT(size); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glPointSize(s); + m_Real.glPointSize(size); } return true; @@ -1349,40 +1455,36 @@ void WrappedOpenGL::glPointSize(GLfloat size) { m_Real.glPointSize(size); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(POINT_SIZE); - Serialise_glPointSize(size); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glPointSize(ser, size); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glPointParameteri(GLenum pname, GLint param) +template +bool WrappedOpenGL::Serialise_glPointParameteri(SerialiserType &ser, GLenum pname, GLint param) { - SERIALISE_ELEMENT(GLenum, PName, pname); - - int32_t ParamValue = 0; + 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_POINT_SPRITE_COORD_ORIGIN) + if(pname == GL_POINT_SPRITE_COORD_ORIGIN) { - 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 <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glPointParameteri(PName, ParamValue); + m_Real.glPointParameteri(pname, param); } return true; @@ -1392,23 +1494,26 @@ void WrappedOpenGL::glPointParameteri(GLenum pname, GLint param) { m_Real.glPointParameteri(pname, param); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(POINT_PARAMI); - Serialise_glPointParameteri(pname, param); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glPointParameteri(ser, pname, param); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glPointParameteriv(GLenum pname, const GLint *params) +template +bool WrappedOpenGL::Serialise_glPointParameteriv(SerialiserType &ser, GLenum pname, + const GLint *params) { - SERIALISE_ELEMENT(GLenum, PName, pname); - SERIALISE_ELEMENT(int32_t, Param, *params); + SERIALISE_ELEMENT(pname); + SERIALISE_ELEMENT_LOCAL(Param, *params); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glPointParameteriv(PName, &Param); + m_Real.glPointParameteriv(pname, &Param); } return true; @@ -1418,23 +1523,25 @@ void WrappedOpenGL::glPointParameteriv(GLenum pname, const GLint *params) { m_Real.glPointParameteriv(pname, params); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(POINT_PARAMIV); - Serialise_glPointParameteriv(pname, params); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glPointParameteriv(ser, pname, params); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glPointParameterf(GLenum pname, GLfloat param) +template +bool WrappedOpenGL::Serialise_glPointParameterf(SerialiserType &ser, GLenum pname, GLfloat param) { - SERIALISE_ELEMENT(GLenum, PName, pname); - SERIALISE_ELEMENT(float, Param, param); + SERIALISE_ELEMENT(pname); + SERIALISE_ELEMENT(param); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glPointParameterf(PName, Param); + m_Real.glPointParameterf(pname, param); } return true; @@ -1444,23 +1551,26 @@ void WrappedOpenGL::glPointParameterf(GLenum pname, GLfloat param) { m_Real.glPointParameterf(pname, param); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(POINT_PARAMF); - Serialise_glPointParameterf(pname, param); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glPointParameterf(ser, pname, param); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glPointParameterfv(GLenum pname, const GLfloat *params) +template +bool WrappedOpenGL::Serialise_glPointParameterfv(SerialiserType &ser, GLenum pname, + const GLfloat *params) { - SERIALISE_ELEMENT(GLenum, PName, pname); - SERIALISE_ELEMENT(float, Param, *params); + SERIALISE_ELEMENT(pname); + SERIALISE_ELEMENT_LOCAL(Param, *params); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glPointParameterfv(PName, &Param); + m_Real.glPointParameterfv(pname, &Param); } return true; @@ -1470,25 +1580,28 @@ void WrappedOpenGL::glPointParameterfv(GLenum pname, const GLfloat *params) { m_Real.glPointParameterfv(pname, params); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(POINT_PARAMFV); - Serialise_glPointParameterfv(pname, params); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glPointParameterfv(ser, pname, params); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glViewport(GLint x, GLint y, GLsizei width, GLsizei height) +template +bool WrappedOpenGL::Serialise_glViewport(SerialiserType &ser, GLint x, GLint y, GLsizei width, + GLsizei height) { - SERIALISE_ELEMENT(int32_t, X, x); - SERIALISE_ELEMENT(int32_t, Y, y); - SERIALISE_ELEMENT(uint32_t, W, width); - SERIALISE_ELEMENT(uint32_t, H, height); + SERIALISE_ELEMENT(x); + SERIALISE_ELEMENT(y); + SERIALISE_ELEMENT(width); + SERIALISE_ELEMENT(height); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glViewport(X, Y, W, H); + m_Real.glViewport(x, y, width, height); } return true; @@ -1498,28 +1611,30 @@ void WrappedOpenGL::glViewport(GLint x, GLint y, GLsizei width, GLsizei height) { m_Real.glViewport(x, y, width, height); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(VIEWPORT); - Serialise_glViewport(x, y, width, height); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glViewport(ser, x, y, width, height); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glViewportArrayv(GLuint index, GLuint count, const GLfloat *v) +template +bool WrappedOpenGL::Serialise_glViewportArrayv(SerialiserType &ser, GLuint index, GLuint count, + const GLfloat *v) { - SERIALISE_ELEMENT(uint32_t, idx, index); - SERIALISE_ELEMENT(uint32_t, cnt, count); - SERIALISE_ELEMENT_ARR(GLfloat, views, v, cnt * 4); + SERIALISE_ELEMENT(index); + SERIALISE_ELEMENT(count); + uint32_t numValues = count * 4; + SERIALISE_ELEMENT_ARRAY(v, numValues); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glViewportArrayv(idx, cnt, views); + m_Real.glViewportArrayv(index, count, v); } - delete[] views; - return true; } @@ -1527,10 +1642,11 @@ void WrappedOpenGL::glViewportArrayv(GLuint index, GLuint count, const GLfloat * { m_Real.glViewportArrayv(index, count, v); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(VIEWPORT_ARRAY); - Serialise_glViewportArrayv(index, count, v); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glViewportArrayv(ser, index, count, v); m_ContextRecord->AddChunk(scope.Get()); } @@ -1547,16 +1663,18 @@ void WrappedOpenGL::glViewportIndexedfv(GLuint index, const GLfloat *v) glViewportArrayv(index, 1, v); } -bool WrappedOpenGL::Serialise_glScissor(GLint x, GLint y, GLsizei width, GLsizei height) +template +bool WrappedOpenGL::Serialise_glScissor(SerialiserType &ser, GLint x, GLint y, GLsizei width, + GLsizei height) { - SERIALISE_ELEMENT(int32_t, X, x); - SERIALISE_ELEMENT(int32_t, Y, y); - SERIALISE_ELEMENT(uint32_t, W, width); - SERIALISE_ELEMENT(uint32_t, H, height); + SERIALISE_ELEMENT(x); + SERIALISE_ELEMENT(y); + SERIALISE_ELEMENT(width); + SERIALISE_ELEMENT(height); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glScissor(X, Y, W, H); + m_Real.glScissor(x, y, width, height); } return true; @@ -1566,28 +1684,30 @@ void WrappedOpenGL::glScissor(GLint x, GLint y, GLsizei width, GLsizei height) { m_Real.glScissor(x, y, width, height); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(SCISSOR); - Serialise_glScissor(x, y, width, height); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glScissor(ser, x, y, width, height); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glScissorArrayv(GLuint index, GLsizei count, const GLint *v) +template +bool WrappedOpenGL::Serialise_glScissorArrayv(SerialiserType &ser, GLuint first, GLsizei count, + const GLint *v) { - SERIALISE_ELEMENT(uint32_t, idx, index); - SERIALISE_ELEMENT(uint32_t, cnt, count); - SERIALISE_ELEMENT_ARR(GLint, scissors, v, cnt * 4); + SERIALISE_ELEMENT(first); + SERIALISE_ELEMENT(count); + uint32_t numValues = count * 4; + SERIALISE_ELEMENT_ARRAY(v, numValues); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glScissorArrayv(idx, cnt, scissors); + m_Real.glScissorArrayv(first, count, v); } - delete[] scissors; - return true; } @@ -1595,10 +1715,11 @@ void WrappedOpenGL::glScissorArrayv(GLuint first, GLsizei count, const GLint *v) { m_Real.glScissorArrayv(first, count, v); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(SCISSOR_ARRAY); - Serialise_glScissorArrayv(first, count, v); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glScissorArrayv(ser, first, count, v); m_ContextRecord->AddChunk(scope.Get()); } @@ -1616,14 +1737,15 @@ void WrappedOpenGL::glScissorIndexedv(GLuint index, const GLint *v) glScissorArrayv(index, 1, v); } -bool WrappedOpenGL::Serialise_glPolygonMode(GLenum face, GLenum mode) +template +bool WrappedOpenGL::Serialise_glPolygonMode(SerialiserType &ser, GLenum face, GLenum mode) { - SERIALISE_ELEMENT(GLenum, f, face); - SERIALISE_ELEMENT(GLenum, m, mode); + SERIALISE_ELEMENT(face); + SERIALISE_ELEMENT(mode); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glPolygonMode(f, m); + m_Real.glPolygonMode(face, mode); } return true; @@ -1633,23 +1755,25 @@ void WrappedOpenGL::glPolygonMode(GLenum face, GLenum mode) { m_Real.glPolygonMode(face, mode); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(POLYGON_MODE); - Serialise_glPolygonMode(face, mode); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glPolygonMode(ser, face, mode); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glPolygonOffset(GLfloat factor, GLfloat units) +template +bool WrappedOpenGL::Serialise_glPolygonOffset(SerialiserType &ser, GLfloat factor, GLfloat units) { - SERIALISE_ELEMENT(float, f, factor); - SERIALISE_ELEMENT(float, u, units); + SERIALISE_ELEMENT(factor); + SERIALISE_ELEMENT(units); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glPolygonOffset(f, u); + m_Real.glPolygonOffset(factor, units); } return true; @@ -1659,24 +1783,27 @@ void WrappedOpenGL::glPolygonOffset(GLfloat factor, GLfloat units) { m_Real.glPolygonOffset(factor, units); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(POLYGON_OFFSET); - Serialise_glPolygonOffset(factor, units); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glPolygonOffset(ser, factor, units); m_ContextRecord->AddChunk(scope.Get()); } } -bool WrappedOpenGL::Serialise_glPolygonOffsetClampEXT(GLfloat factor, GLfloat units, GLfloat clamp) +template +bool WrappedOpenGL::Serialise_glPolygonOffsetClampEXT(SerialiserType &ser, GLfloat factor, + GLfloat units, GLfloat clamp) { - SERIALISE_ELEMENT(float, f, factor); - SERIALISE_ELEMENT(float, u, units); - SERIALISE_ELEMENT(float, c, clamp); + SERIALISE_ELEMENT(factor); + SERIALISE_ELEMENT(units); + SERIALISE_ELEMENT(clamp); - if(m_State <= EXECUTING) + if(IsReplayingAndReading()) { - m_Real.glPolygonOffsetClampEXT(f, u, c); + m_Real.glPolygonOffsetClampEXT(factor, units, clamp); } return true; @@ -1686,11 +1813,123 @@ void WrappedOpenGL::glPolygonOffsetClampEXT(GLfloat factor, GLfloat units, GLflo { m_Real.glPolygonOffsetClampEXT(factor, units, clamp); - if(m_State == WRITING_CAPFRAME) + if(IsActiveCapturing(m_State)) { - SCOPED_SERIALISE_CONTEXT(POLYGON_OFFSET_CLAMP); - Serialise_glPolygonOffsetClampEXT(factor, units, clamp); + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glPolygonOffsetClampEXT(ser, factor, units, clamp); m_ContextRecord->AddChunk(scope.Get()); } } + +template +bool WrappedOpenGL::Serialise_glPrimitiveBoundingBox(SerialiserType &ser, GLfloat minX, GLfloat minY, + GLfloat minZ, GLfloat minW, GLfloat maxX, + GLfloat maxY, GLfloat maxZ, GLfloat maxW) +{ + SERIALISE_ELEMENT(minX); + SERIALISE_ELEMENT(minY); + SERIALISE_ELEMENT(minZ); + SERIALISE_ELEMENT(minW); + SERIALISE_ELEMENT(maxX); + SERIALISE_ELEMENT(maxY); + SERIALISE_ELEMENT(maxZ); + SERIALISE_ELEMENT(maxW); + + if(IsReplayingAndReading()) + { + m_Real.glPrimitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW); + } + + return true; +} + +void WrappedOpenGL::glPrimitiveBoundingBox(GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, + GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW) +{ + m_Real.glPrimitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW); + + if(IsActiveCapturing(m_State)) + { + USE_SCRATCH_SERIALISER(); + SCOPED_SERIALISE_CHUNK(gl_CurChunk); + Serialise_glPrimitiveBoundingBox(ser, minX, minY, minZ, minW, maxX, maxY, maxZ, maxW); + m_ContextRecord->AddChunk(scope.Get()); + } +} + +INSTANTIATE_FUNCTION_SERIALISED(void, glBlendFunc, GLenum sfactor, GLenum dfactor); +INSTANTIATE_FUNCTION_SERIALISED(void, glBlendFunci, GLuint buf, GLenum src, GLenum dst); +INSTANTIATE_FUNCTION_SERIALISED(void, glBlendColor, GLfloat red, GLfloat green, GLfloat blue, + GLfloat alpha); +INSTANTIATE_FUNCTION_SERIALISED(void, glBlendFuncSeparate, GLenum sfactorRGB, GLenum dfactorRGB, + GLenum sfactorAlpha, GLenum dfactorAlpha); +INSTANTIATE_FUNCTION_SERIALISED(void, glBlendFuncSeparatei, GLuint buf, GLenum sfactorRGB, + GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +INSTANTIATE_FUNCTION_SERIALISED(void, glBlendEquation, GLenum mode); +INSTANTIATE_FUNCTION_SERIALISED(void, glBlendEquationi, GLuint buf, GLenum mode); +INSTANTIATE_FUNCTION_SERIALISED(void, glBlendEquationSeparate, GLenum modeRGB, GLenum modeAlpha); +INSTANTIATE_FUNCTION_SERIALISED(void, glBlendEquationSeparatei, GLuint buf, GLenum modeRGB, + GLenum modeAlpha); +INSTANTIATE_FUNCTION_SERIALISED(void, glBlendBarrierKHR); +INSTANTIATE_FUNCTION_SERIALISED(void, glLogicOp, GLenum opcode); +INSTANTIATE_FUNCTION_SERIALISED(void, glStencilFunc, GLenum func, GLint ref, GLuint mask); +INSTANTIATE_FUNCTION_SERIALISED(void, glStencilFuncSeparate, GLenum face, GLenum func, GLint ref, + GLuint mask); +INSTANTIATE_FUNCTION_SERIALISED(void, glStencilMask, GLuint mask); +INSTANTIATE_FUNCTION_SERIALISED(void, glStencilMaskSeparate, GLenum face, GLuint mask); +INSTANTIATE_FUNCTION_SERIALISED(void, glStencilOp, GLenum fail, GLenum zfail, GLenum zpass); +INSTANTIATE_FUNCTION_SERIALISED(void, glStencilOpSeparate, GLenum face, GLenum sfail, GLenum dpfail, + GLenum dppass); +INSTANTIATE_FUNCTION_SERIALISED(void, glClearColor, GLclampf red, GLclampf green, GLclampf blue, + GLclampf alpha); +INSTANTIATE_FUNCTION_SERIALISED(void, glClearStencil, GLint stencil); +INSTANTIATE_FUNCTION_SERIALISED(void, glClearDepth, GLdouble depth); +INSTANTIATE_FUNCTION_SERIALISED(void, glDepthFunc, GLenum func); +INSTANTIATE_FUNCTION_SERIALISED(void, glDepthMask, GLboolean flag); +INSTANTIATE_FUNCTION_SERIALISED(void, glDepthRange, GLdouble nearVal, GLdouble farVal); +INSTANTIATE_FUNCTION_SERIALISED(void, glDepthRangef, GLfloat nearVal, GLfloat farVal); +INSTANTIATE_FUNCTION_SERIALISED(void, glDepthRangeIndexed, GLuint index, GLdouble nearVal, + GLdouble farVal); +INSTANTIATE_FUNCTION_SERIALISED(void, glDepthRangeArrayv, GLuint first, GLsizei count, + const GLdouble *v); +INSTANTIATE_FUNCTION_SERIALISED(void, glDepthBoundsEXT, GLclampd nearVal, GLclampd farVal); +INSTANTIATE_FUNCTION_SERIALISED(void, glClipControl, GLenum origin, GLenum depth); +INSTANTIATE_FUNCTION_SERIALISED(void, glProvokingVertex, GLenum mode); +INSTANTIATE_FUNCTION_SERIALISED(void, glPrimitiveRestartIndex, GLuint index); +INSTANTIATE_FUNCTION_SERIALISED(void, glDisable, GLenum cap); +INSTANTIATE_FUNCTION_SERIALISED(void, glEnable, GLenum cap); +INSTANTIATE_FUNCTION_SERIALISED(void, glDisablei, GLenum cap, GLuint index); +INSTANTIATE_FUNCTION_SERIALISED(void, glEnablei, GLenum cap, GLuint index); +INSTANTIATE_FUNCTION_SERIALISED(void, glFrontFace, GLenum mode); +INSTANTIATE_FUNCTION_SERIALISED(void, glCullFace, GLenum mode); +INSTANTIATE_FUNCTION_SERIALISED(void, glHint, GLenum target, GLenum mode); +INSTANTIATE_FUNCTION_SERIALISED(void, glColorMask, GLboolean red, GLboolean green, GLboolean blue, + GLboolean alpha); +INSTANTIATE_FUNCTION_SERIALISED(void, glColorMaski, GLuint buf, GLboolean red, GLboolean green, + GLboolean blue, GLboolean alpha); +INSTANTIATE_FUNCTION_SERIALISED(void, glSampleMaski, GLuint maskNumber, GLbitfield mask); +INSTANTIATE_FUNCTION_SERIALISED(void, glSampleCoverage, GLfloat value, GLboolean invert); +INSTANTIATE_FUNCTION_SERIALISED(void, glMinSampleShading, GLfloat value); +INSTANTIATE_FUNCTION_SERIALISED(void, glRasterSamplesEXT, GLuint samples, + GLboolean fixedsamplelocations); +INSTANTIATE_FUNCTION_SERIALISED(void, glPatchParameteri, GLenum pname, GLint value); +INSTANTIATE_FUNCTION_SERIALISED(void, glPatchParameterfv, GLenum pname, const GLfloat *values); +INSTANTIATE_FUNCTION_SERIALISED(void, glLineWidth, GLfloat width); +INSTANTIATE_FUNCTION_SERIALISED(void, glPointSize, GLfloat size); +INSTANTIATE_FUNCTION_SERIALISED(void, glPointParameteri, GLenum pname, GLint param); +INSTANTIATE_FUNCTION_SERIALISED(void, glPointParameteriv, GLenum pname, const GLint *params); +INSTANTIATE_FUNCTION_SERIALISED(void, glPointParameterf, GLenum pname, GLfloat param); +INSTANTIATE_FUNCTION_SERIALISED(void, glPointParameterfv, GLenum pname, const GLfloat *params); +INSTANTIATE_FUNCTION_SERIALISED(void, glViewport, GLint x, GLint y, GLsizei width, GLsizei height); +INSTANTIATE_FUNCTION_SERIALISED(void, glViewportArrayv, GLuint index, GLuint count, const GLfloat *v); +INSTANTIATE_FUNCTION_SERIALISED(void, glScissor, GLint x, GLint y, GLsizei width, GLsizei height); +INSTANTIATE_FUNCTION_SERIALISED(void, glScissorArrayv, GLuint first, GLsizei count, const GLint *v); +INSTANTIATE_FUNCTION_SERIALISED(void, glPolygonMode, GLenum face, GLenum mode); +INSTANTIATE_FUNCTION_SERIALISED(void, glPolygonOffset, GLfloat factor, GLfloat units); +INSTANTIATE_FUNCTION_SERIALISED(void, glPolygonOffsetClampEXT, GLfloat factor, GLfloat units, + GLfloat clamp); +INSTANTIATE_FUNCTION_SERIALISED(void, glPrimitiveBoundingBox, GLfloat minX, GLfloat minY, + GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, + GLfloat maxZ, GLfloat maxW);