diff --git a/renderdoc/Makefile b/renderdoc/Makefile index b5f36e499..2e1ea0d34 100644 --- a/renderdoc/Makefile +++ b/renderdoc/Makefile @@ -36,8 +36,6 @@ os/os_specific.o \ 3rdparty/jpeg-compressor/jpge.o \ 3rdparty/lz4/lz4.o \ driver/gl/gl_common.o \ -driver/gl/gl_context_driver.o \ -driver/gl/gl_device_driver.o \ driver/gl/gl_driver.o \ driver/gl/gl_manager.o \ driver/gl/gl_debug.o \ @@ -45,6 +43,16 @@ driver/gl/gl_replay.o \ driver/gl/gl_replay_linux.o \ driver/gl/gl_resources.o \ driver/gl/gl_renderstate.o \ +driver/gl/wrappers/gl_buffer_funcs.o \ +driver/gl/wrappers/gl_debug_funcs.o \ +driver/gl/wrappers/gl_draw_funcs.o \ +driver/gl/wrappers/gl_framebuffer_funcs.o \ +driver/gl/wrappers/gl_get_funcs.o \ +driver/gl/wrappers/gl_sampler_funcs.o \ +driver/gl/wrappers/gl_shader_funcs.o \ +driver/gl/wrappers/gl_state_funcs.o \ +driver/gl/wrappers/gl_texture_funcs.o \ +driver/gl/wrappers/gl_uniform_funcs.o \ os/linux/linux_callstack.o \ os/linux/linux_network.o \ os/linux/linux_process.o \ diff --git a/renderdoc/driver/gl/gl_common.h b/renderdoc/driver/gl/gl_common.h index 5269009a3..01a120ff0 100644 --- a/renderdoc/driver/gl/gl_common.h +++ b/renderdoc/driver/gl/gl_common.h @@ -115,27 +115,6 @@ enum GLChunkType USE_PROGRAMSTAGES, BIND_PROGRAMPIPE, - // legacy/immediate mode chunks - LIGHTFV, - MATERIALFV, - GENLISTS, - NEWLIST, - ENDLIST, - CALLLIST, - SHADEMODEL, - BEGIN, - END, - VERTEX3F, - NORMAL3F, - PUSHMATRIX, - POPMATRIX, - MATRIXMODE, - LOADIDENTITY, - FRUSTUM, - TRANSLATEF, - ROTATEF, - // - CLEAR_COLOR, CLEAR_DEPTH, CLEAR, diff --git a/renderdoc/driver/gl/gl_context_driver.cpp b/renderdoc/driver/gl/gl_context_driver.cpp deleted file mode 100644 index 386a06bab..000000000 --- a/renderdoc/driver/gl/gl_context_driver.cpp +++ /dev/null @@ -1,2532 +0,0 @@ -/****************************************************************************** - * The MIT License (MIT) - * - * Copyright (c) 2014 Crytek - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - * THE SOFTWARE. - ******************************************************************************/ - - -#include "common/common.h" -#include "common/string_utils.h" -#include "gl_driver.h" - -#pragma region State functions - -bool WrappedOpenGL::Serialise_glBlendFunc(GLenum sfactor, GLenum dfactor) -{ - SERIALISE_ELEMENT(GLenum, s, sfactor); - SERIALISE_ELEMENT(GLenum, d, dfactor); - - if(m_State <= EXECUTING) - { - m_Real.glBlendFunc(s, d); - } - - return true; -} - -void WrappedOpenGL::glBlendFunc(GLenum sfactor, GLenum dfactor) -{ - m_Real.glBlendFunc(sfactor, dfactor); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(BLEND_FUNC); - Serialise_glBlendFunc(sfactor, dfactor); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glBlendFunci(GLuint buf, GLenum src, GLenum dst) -{ - SERIALISE_ELEMENT(GLuint, b, buf); - SERIALISE_ELEMENT(GLenum, s, src); - SERIALISE_ELEMENT(GLenum, d, dst); - - if(m_State <= EXECUTING) - { - m_Real.glBlendFunci(b, s, d); - } - - return true; -} - -void WrappedOpenGL::glBlendFunci(GLuint buf, GLenum src, GLenum dst) -{ - m_Real.glBlendFunci(buf, src, dst); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(BLEND_FUNCI); - Serialise_glBlendFunci(buf, src, dst); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glBlendColor(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); - - if(m_State <= EXECUTING) - { - m_Real.glBlendColor(r, g, b, a); - } - - return true; -} - -void WrappedOpenGL::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) -{ - m_Real.glBlendColor(red, green, blue, alpha); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(BLEND_COLOR); - Serialise_glBlendColor(red, green, blue, alpha); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glBlendFuncSeparate(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); - - if(m_State <= EXECUTING) - { - m_Real.glBlendFuncSeparate(s1, d1, s2, d2); - } - - return true; -} - -void WrappedOpenGL::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) -{ - m_Real.glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(BLEND_FUNC_SEP); - Serialise_glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glBlendFuncSeparatei(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); - - if(m_State <= EXECUTING) - { - m_Real.glBlendFuncSeparatei(b, s1, d1, s2, d2); - } - - return true; -} - -void WrappedOpenGL::glBlendFuncSeparatei(GLuint buf, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) -{ - m_Real.glBlendFuncSeparatei(buf, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(BLEND_FUNC_SEPI); - Serialise_glBlendFuncSeparatei(buf, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) -{ - SERIALISE_ELEMENT(GLenum, m1, modeRGB); - SERIALISE_ELEMENT(GLenum, m2, modeAlpha); - - if(m_State <= EXECUTING) - { - m_Real.glBlendEquationSeparate(m1, m2); - } - - return true; -} - -void WrappedOpenGL::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) -{ - m_Real.glBlendEquationSeparate(modeRGB, modeAlpha); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(BLEND_EQ_SEP); - Serialise_glBlendEquationSeparate(modeRGB, modeAlpha); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha) -{ - SERIALISE_ELEMENT(uint32_t, b, buf); - SERIALISE_ELEMENT(GLenum, m1, modeRGB); - SERIALISE_ELEMENT(GLenum, m2, modeAlpha); - - if(m_State <= EXECUTING) - { - m_Real.glBlendEquationSeparatei(b, m1, m2); - } - - return true; -} - -void WrappedOpenGL::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha) -{ - m_Real.glBlendEquationSeparatei(buf, modeRGB, modeAlpha); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(BLEND_EQ_SEPI); - Serialise_glBlendEquationSeparatei(buf, modeRGB, modeAlpha); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glStencilFunc(GLenum func, GLint ref, GLuint mask) -{ - SERIALISE_ELEMENT(GLenum, f, func); - SERIALISE_ELEMENT(int32_t, Ref, ref); - SERIALISE_ELEMENT(uint32_t, Mask, mask); - - if(m_State <= EXECUTING) - { - m_Real.glStencilFunc(f, Ref, Mask); - } - - return true; -} - -void WrappedOpenGL::glStencilFunc(GLenum func, GLint ref, GLuint mask) -{ - m_Real.glStencilFunc(func, ref, mask); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(STENCIL_FUNC); - Serialise_glStencilFunc(func, ref, mask); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glStencilFuncSeparate(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); - - if(m_State <= EXECUTING) - { - m_Real.glStencilFuncSeparate(Face, f, Ref, Mask); - } - - return true; -} - -void WrappedOpenGL::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) -{ - m_Real.glStencilFuncSeparate(face, func, ref, mask); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(STENCIL_FUNC_SEP); - Serialise_glStencilFuncSeparate(face, func, ref, mask); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glStencilMask(GLuint mask) -{ - SERIALISE_ELEMENT(uint32_t, Mask, mask); - - if(m_State <= EXECUTING) - { - m_Real.glStencilMask(Mask); - } - - return true; -} - -void WrappedOpenGL::glStencilMask(GLuint mask) -{ - m_Real.glStencilMask(mask); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(STENCIL_MASK); - Serialise_glStencilMask(mask); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glStencilMaskSeparate(GLenum face, GLuint mask) -{ - SERIALISE_ELEMENT(GLenum, Face, face); - SERIALISE_ELEMENT(uint32_t, Mask, mask); - - if(m_State <= EXECUTING) - { - m_Real.glStencilMaskSeparate(Face, Mask); - } - - return true; -} - -void WrappedOpenGL::glStencilMaskSeparate(GLenum face, GLuint mask) -{ - m_Real.glStencilMaskSeparate(face, mask); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(STENCIL_MASK_SEP); - Serialise_glStencilMaskSeparate(face, mask); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) -{ - SERIALISE_ELEMENT(GLenum, f, fail); - SERIALISE_ELEMENT(GLenum, zf, zfail); - SERIALISE_ELEMENT(GLenum, p, zpass); - - if(m_State <= EXECUTING) - { - m_Real.glStencilOp(f, zf, p); - } - - return true; -} - -void WrappedOpenGL::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) -{ - m_Real.glStencilOp(fail, zfail, zpass); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(STENCIL_OP); - Serialise_glStencilOp(fail, zfail, zpass); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glStencilOpSeparate(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); - - if(m_State <= EXECUTING) - { - m_Real.glStencilOpSeparate(Face, sf, zf, p); - } - - return true; -} - -void WrappedOpenGL::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) -{ - m_Real.glStencilOpSeparate(face, sfail, dpfail, dppass); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(STENCIL_OP_SEP); - Serialise_glStencilOpSeparate(face, sfail, dpfail, dppass); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glClearColor(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); - - if(m_State <= EXECUTING) - { - m_Real.glClearColor(r, g, b, a); - } - - return true; -} - -void WrappedOpenGL::glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) -{ - m_Real.glClearColor(red, green, blue, alpha); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(CLEAR_COLOR); - Serialise_glClearColor(red, green, blue, alpha); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glClearDepth(GLclampd depth) -{ - SERIALISE_ELEMENT(double, d, depth); - - if(m_State <= EXECUTING) - { - m_Real.glClearDepth(d); - } - - return true; -} - -void WrappedOpenGL::glClearDepth(GLclampd depth) -{ - m_Real.glClearDepth(depth); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(CLEAR_DEPTH); - Serialise_glClearDepth(depth); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glDepthFunc(GLenum func) -{ - SERIALISE_ELEMENT(GLenum, f, func); - - if(m_State <= EXECUTING) - { - m_Real.glDepthFunc(f); - } - - return true; -} - -void WrappedOpenGL::glDepthFunc(GLenum func) -{ - m_Real.glDepthFunc(func); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(DEPTH_FUNC); - Serialise_glDepthFunc(func); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glDepthMask(GLboolean flag) -{ - SERIALISE_ELEMENT(uint8_t, f, flag); - - if(m_State <= EXECUTING) - { - m_Real.glDepthMask(f); - } - - return true; -} - -void WrappedOpenGL::glDepthMask(GLboolean flag) -{ - m_Real.glDepthMask(flag); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(DEPTH_MASK); - Serialise_glDepthMask(flag); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glDepthRange(GLdouble nearVal, GLdouble farVal) -{ - SERIALISE_ELEMENT(GLdouble, n, nearVal); - SERIALISE_ELEMENT(GLdouble, f, farVal); - - if(m_State <= EXECUTING) - m_Real.glDepthRange(n, f); - - return true; -} - -void WrappedOpenGL::glDepthRange(GLdouble nearVal, GLdouble farVal) -{ - m_Real.glDepthRange(nearVal, farVal); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(DEPTH_RANGE); - Serialise_glDepthRange(nearVal, farVal); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -void WrappedOpenGL::glDepthRangef(GLfloat nearVal, GLfloat farVal) -{ - glDepthRange(nearVal, farVal); -} - -bool WrappedOpenGL::Serialise_glDepthRangeArrayv(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); - - if(m_State <= EXECUTING) - { - m_Real.glDepthRangeArrayv(idx, cnt, ranges); - } - - delete[] ranges; - - return true; -} - -void WrappedOpenGL::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v) -{ - m_Real.glDepthRangeArrayv(first, count, v); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(DEPTH_RANGEARRAY); - Serialise_glDepthRangeArrayv(first, count, v); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glDepthBoundsEXT(GLclampd nearVal, GLclampd farVal) -{ - SERIALISE_ELEMENT(GLdouble, n, nearVal); - SERIALISE_ELEMENT(GLdouble, f, farVal); - - if(m_State <= EXECUTING) - { - m_Real.glDepthBoundsEXT(n, f); - } - - return true; -} - -void WrappedOpenGL::glDepthBoundsEXT(GLclampd nearVal, GLclampd farVal) -{ - m_Real.glDepthBoundsEXT(nearVal, farVal); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(DEPTH_BOUNDS); - Serialise_glDepthBoundsEXT(nearVal, farVal); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glDisable(GLenum cap) -{ - SERIALISE_ELEMENT(GLenum, c, cap); - - if(m_State <= EXECUTING) - { - m_Real.glDisable(c); - } - - return true; -} - -void WrappedOpenGL::glDisable(GLenum cap) -{ - m_Real.glDisable(cap); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(DISABLE); - Serialise_glDisable(cap); - - m_ContextRecord->AddChunk(scope.Get()); - } - // TODO replace this with glIsEnabled() for the relevant states - if(m_State == WRITING_IDLE) - { - SCOPED_SERIALISE_CONTEXT(DISABLE); - Serialise_glDisable(cap); - - m_DeviceRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glEnable(GLenum cap) -{ - SERIALISE_ELEMENT(GLenum, c, cap); - - if(m_State <= EXECUTING) - { - m_Real.glEnable(c); - } - - return true; -} - -void WrappedOpenGL::glEnable(GLenum cap) -{ - m_Real.glEnable(cap); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(ENABLE); - Serialise_glEnable(cap); - - m_ContextRecord->AddChunk(scope.Get()); - } - // TODO replace this with glIsEnabled() for the relevant states - if(m_State == WRITING_IDLE) - { - SCOPED_SERIALISE_CONTEXT(ENABLE); - Serialise_glEnable(cap); - - m_DeviceRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glDisablei(GLenum cap, GLuint index) -{ - SERIALISE_ELEMENT(GLenum, c, cap); - SERIALISE_ELEMENT(uint32_t, i, index); - - if(m_State <= EXECUTING) - { - m_Real.glDisablei(c, i); - } - - return true; -} - -void WrappedOpenGL::glDisablei(GLenum cap, GLuint index) -{ - m_Real.glDisablei(cap, index); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(DISABLEI); - Serialise_glDisablei(cap, index); - - m_ContextRecord->AddChunk(scope.Get()); - } - // TODO replace this with glIsEnabled() for the relevant states - if(m_State == WRITING_IDLE) - { - SCOPED_SERIALISE_CONTEXT(DISABLEI); - Serialise_glDisablei(cap, index); - - m_DeviceRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glEnablei(GLenum cap, GLuint index) -{ - SERIALISE_ELEMENT(GLenum, c, cap); - SERIALISE_ELEMENT(uint32_t, i, index); - - if(m_State <= EXECUTING) - { - m_Real.glEnablei(c, i); - } - - return true; -} - -void WrappedOpenGL::glEnablei(GLenum cap, GLuint index) -{ - m_Real.glEnablei(cap, index); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(ENABLEI); - Serialise_glEnablei(cap, index); - - m_ContextRecord->AddChunk(scope.Get()); - } - // TODO replace this with glIsEnabled() for the relevant states - if(m_State == WRITING_IDLE) - { - SCOPED_SERIALISE_CONTEXT(ENABLEI); - Serialise_glEnablei(cap, index); - - m_DeviceRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glFrontFace(GLenum mode) -{ - SERIALISE_ELEMENT(GLenum, m, mode); - - if(m_State <= EXECUTING) - { - m_Real.glFrontFace(m); - } - - return true; -} - -void WrappedOpenGL::glFrontFace(GLenum mode) -{ - m_Real.glFrontFace(mode); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(FRONT_FACE); - Serialise_glFrontFace(mode); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glCullFace(GLenum mode) -{ - SERIALISE_ELEMENT(GLenum, m, mode); - - if(m_State <= EXECUTING) - { - m_Real.glCullFace(m); - } - - return true; -} - -void WrappedOpenGL::glCullFace(GLenum mode) -{ - m_Real.glCullFace(mode); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(CULL_FACE); - Serialise_glCullFace(mode); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -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); - - 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) -{ - SERIALISE_ELEMENT(uint8_t, r, red); - SERIALISE_ELEMENT(uint8_t, g, green); - SERIALISE_ELEMENT(uint8_t, b, blue); - SERIALISE_ELEMENT(uint8_t, a, alpha); - - if(m_State <= EXECUTING) - { - m_Real.glColorMask(r, g, b, a); - } - - return true; -} - -void WrappedOpenGL::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) -{ - m_Real.glColorMask(red, green, blue, alpha); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(COLOR_MASK); - Serialise_glColorMask(red, green, blue, alpha); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glColorMaski(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); - - if(m_State <= EXECUTING) - { - m_Real.glColorMaski(buffer, r, g, b, a); - } - - return true; -} - -void WrappedOpenGL::glColorMaski(GLuint buf, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) -{ - m_Real.glColorMaski(buf, red, green, blue, alpha); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(COLOR_MASKI); - Serialise_glColorMaski(buf, red, green, blue, alpha); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glSampleMaski(GLuint maskNumber, GLbitfield mask) -{ - SERIALISE_ELEMENT(uint32_t, num, maskNumber); - SERIALISE_ELEMENT(uint32_t, Mask, mask); - - if(m_State <= EXECUTING) - { - m_Real.glSampleMaski(num, Mask); - } - - return true; -} - -void WrappedOpenGL::glSampleMaski(GLuint maskNumber, GLbitfield mask) -{ - m_Real.glSampleMaski(maskNumber, mask); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(SAMPLE_MASK); - Serialise_glSampleMaski(maskNumber, mask); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glPatchParameteri(GLenum pname, GLint value) -{ - SERIALISE_ELEMENT(GLenum, PName, pname); - SERIALISE_ELEMENT(int32_t, Value, value); - - if(m_State <= EXECUTING) - { - m_Real.glPatchParameteri(PName, Value); - } - - return true; -} - -void WrappedOpenGL::glPatchParameteri(GLenum pname, GLint value) -{ - m_Real.glPatchParameteri(pname, value); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(PATCH_PARAMI); - Serialise_glPatchParameteri(pname, value); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glPatchParameterfv(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); - - if(m_State <= EXECUTING) - { - m_Real.glPatchParameterfv(PName, Values); - } - - delete[] Values; - - return true; -} - -void WrappedOpenGL::glPatchParameterfv(GLenum pname, const GLfloat *values) -{ - m_Real.glPatchParameterfv(pname, values); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(PATCH_PARAMFV); - Serialise_glPatchParameterfv(pname, values); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glViewport(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); - - if(m_State <= EXECUTING) - { - m_Real.glViewport(X, Y, W, H); - } - - return true; -} - -void WrappedOpenGL::glViewport(GLint x, GLint y, GLsizei width, GLsizei height) -{ - m_Real.glViewport(x, y, width, height); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(VIEWPORT); - Serialise_glViewport(x, y, width, height); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glViewportArrayv(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); - - if(m_State <= EXECUTING) - { - m_Real.glViewportArrayv(idx, cnt, views); - } - - delete[] views; - - return true; -} - -void WrappedOpenGL::glViewportArrayv(GLuint index, GLuint count, const GLfloat *v) -{ - m_Real.glViewportArrayv(index, count, v); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(VIEWPORT_ARRAY); - Serialise_glViewportArrayv(index, count, v); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -void WrappedOpenGL::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) -{ - const float v[4] = { x, y, w, h }; - glViewportArrayv(index, 1, v); -} - -void WrappedOpenGL::glViewportIndexedfv(GLuint index, const GLfloat *v) -{ - glViewportArrayv(index, 1, v); -} - -bool WrappedOpenGL::Serialise_glScissor(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); - - if(m_State <= EXECUTING) - { - m_Real.glScissor(X, Y, W, H); - } - - return true; -} - -void WrappedOpenGL::glScissor(GLint x, GLint y, GLsizei width, GLsizei height) -{ - m_Real.glScissor(x, y, width, height); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(SCISSOR); - Serialise_glScissor(x, y, width, height); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glScissorArrayv(GLuint index, 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); - - if(m_State <= EXECUTING) - { - m_Real.glScissorArrayv(idx, cnt, scissors); - } - - delete[] scissors; - - return true; -} - -void WrappedOpenGL::glScissorArrayv(GLuint first, GLsizei count, const GLint *v) -{ - m_Real.glScissorArrayv(first, count, v); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(SCISSOR_ARRAY); - Serialise_glScissorArrayv(first, count, v); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -void WrappedOpenGL::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) -{ - const GLint v[4] = { left, bottom, width, height }; - glScissorArrayv(index, 1, v); -} - -void WrappedOpenGL::glScissorIndexedv(GLuint index, const GLint *v) -{ - glScissorArrayv(index, 1, v); -} - -bool WrappedOpenGL::Serialise_glPolygonMode(GLenum face, GLenum mode) -{ - SERIALISE_ELEMENT(GLenum, f, face); - SERIALISE_ELEMENT(GLenum, m, mode); - - if(m_State <= EXECUTING) - { - m_Real.glPolygonMode(f, m); - } - - return true; -} - -void WrappedOpenGL::glPolygonMode(GLenum face, GLenum mode) -{ - m_Real.glPolygonMode(face, mode); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(POLYGON_MODE); - Serialise_glPolygonMode(face, mode); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glPolygonOffset(GLfloat factor, GLfloat units) -{ - SERIALISE_ELEMENT(float, f, factor); - SERIALISE_ELEMENT(float, u, units); - - if(m_State <= EXECUTING) - { - m_Real.glPolygonOffset(f, u); - } - - return true; -} - -void WrappedOpenGL::glPolygonOffset(GLfloat factor, GLfloat units) -{ - m_Real.glPolygonOffset(factor, units); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(POLYGON_OFFSET); - Serialise_glPolygonOffset(factor, units); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -#pragma endregion - -#pragma region Debugging annotation - -void WrappedOpenGL::glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label) -{ - m_Real.glGetObjectLabel(identifier, name, bufSize, length, label); -} - -bool WrappedOpenGL::Serialise_glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label) -{ - ResourceId liveid; - - string Label; - if(m_State >= WRITING) - { - if(length == 0) - Label = ""; - else - Label = string(label, label + (length > 0 ? length : strlen(label))); - - switch(identifier) - { - case eGL_TEXTURE: - liveid = GetResourceManager()->GetID(TextureRes(name)); - break; - case eGL_BUFFER: - liveid = GetResourceManager()->GetID(BufferRes(name)); - break; - default: - RDCERR("Unhandled namespace in glObjectLabel"); - } - } - - SERIALISE_ELEMENT(GLenum, Identifier, identifier); - SERIALISE_ELEMENT(ResourceId, id, liveid); - SERIALISE_ELEMENT(uint32_t, Length, length); - SERIALISE_ELEMENT(bool, HasLabel, label != NULL); - - m_pSerialiser->SerialiseString("label", Label); - - if(m_State == READING) - { - GLResource res = GetResourceManager()->GetLiveResource(id); - m_Real.glObjectLabel(Identifier, res.name, Length, HasLabel ? Label.c_str() : NULL); - } - - return true; -} - -void WrappedOpenGL::glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label) -{ - m_Real.glObjectLabel(identifier, name, length, label); - - if(m_State >= WRITING) - { - SCOPED_SERIALISE_CONTEXT(OBJECT_LABEL); - Serialise_glObjectLabel(identifier, name, length, label); - - m_DeviceRecord->AddChunk(scope.Get()); - } -} - -#pragma endregion - -#pragma region Drawcalls - -bool WrappedOpenGL::Serialise_glDrawArrays(GLenum mode, GLint first, GLsizei count) -{ - SERIALISE_ELEMENT(GLenum, Mode, mode); - SERIALISE_ELEMENT(int32_t, First, first); - SERIALISE_ELEMENT(uint32_t, Count, count); - - if(m_State <= EXECUTING) - { - m_Real.glDrawArrays(Mode, First, Count); - } - - const string desc = m_pSerialiser->GetDebugStr(); - - if(m_State == READING) - { - AddEvent(DRAWARRAYS, desc); - string name = "glDrawArrays(" + - ToStr::Get(Mode) + ", " + - ToStr::Get(First) + ", " + - ToStr::Get(Count) + ", " + ")"; - - FetchDrawcall draw; - draw.name = widen(name); - draw.numIndices = Count; - draw.numInstances = 1; - draw.indexOffset = 0; - draw.vertexOffset = First; - draw.instanceOffset = 0; - - draw.flags |= eDraw_Drawcall; - - m_LastDrawMode = Mode; - - AddDrawcall(draw, true); - } - - return true; -} - -void WrappedOpenGL::glDrawArrays(GLenum mode, GLint first, GLsizei count) -{ - m_Real.glDrawArrays(mode, first, count); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(DRAWARRAYS); - Serialise_glDrawArrays(mode, first, count); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount) -{ - SERIALISE_ELEMENT(GLenum, Mode, mode); - SERIALISE_ELEMENT(int32_t, First, first); - SERIALISE_ELEMENT(uint32_t, Count, count); - SERIALISE_ELEMENT(uint32_t, InstanceCount, instancecount); - - if(m_State <= EXECUTING) - { - m_Real.glDrawArraysInstanced(Mode, First, Count, InstanceCount); - } - - const string desc = m_pSerialiser->GetDebugStr(); - - if(m_State == READING) - { - AddEvent(DRAWARRAYS_INSTANCED, desc); - string name = "glDrawArraysInstanced(" + - ToStr::Get(Mode) + ", " + - ToStr::Get(First) + ", " + - ToStr::Get(Count) + ", " + - ToStr::Get(InstanceCount) + ")"; - - FetchDrawcall draw; - draw.name = widen(name); - draw.numIndices = Count; - draw.numInstances = InstanceCount; - draw.indexOffset = 0; - draw.vertexOffset = First; - draw.instanceOffset = 0; - - draw.flags |= eDraw_Drawcall|eDraw_Instanced; - - m_LastDrawMode = Mode; - - AddDrawcall(draw, true); - } - - return true; -} - -void WrappedOpenGL::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount) -{ - m_Real.glDrawArraysInstanced(mode, first, count, instancecount); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(DRAWARRAYS_INSTANCED); - Serialise_glDrawArraysInstanced(mode, first, count, instancecount); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance) -{ - SERIALISE_ELEMENT(GLenum, Mode, mode); - SERIALISE_ELEMENT(int32_t, First, first); - SERIALISE_ELEMENT(uint32_t, Count, count); - SERIALISE_ELEMENT(uint32_t, InstanceCount, instancecount); - SERIALISE_ELEMENT(uint32_t, BaseInstance, baseinstance); - - if(m_State <= EXECUTING) - { - m_Real.glDrawArraysInstancedBaseInstance(Mode, First, Count, InstanceCount, BaseInstance); - } - - const string desc = m_pSerialiser->GetDebugStr(); - - if(m_State == READING) - { - AddEvent(DRAWARRAYS_INSTANCEDBASEINSTANCE, desc); - string name = "glDrawArraysInstancedBaseInstance(" + - ToStr::Get(Mode) + ", " + - ToStr::Get(First) + ", " + - ToStr::Get(Count) + ", " + - ToStr::Get(InstanceCount) + ", " + - ToStr::Get(BaseInstance) + ")"; - - FetchDrawcall draw; - draw.name = widen(name); - draw.numIndices = Count; - draw.numInstances = InstanceCount; - draw.indexOffset = 0; - draw.vertexOffset = First; - draw.instanceOffset = BaseInstance; - - draw.flags |= eDraw_Drawcall|eDraw_Instanced; - - m_LastDrawMode = Mode; - - AddDrawcall(draw, true); - } - - return true; -} - -void WrappedOpenGL::glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance) -{ - m_Real.glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(DRAWARRAYS_INSTANCEDBASEINSTANCE); - Serialise_glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices) -{ - SERIALISE_ELEMENT(GLenum, Mode, mode); - SERIALISE_ELEMENT(uint32_t, Count, count); - SERIALISE_ELEMENT(GLenum, Type, type); - SERIALISE_ELEMENT(uint64_t, IdxOffset, (uint64_t)indices); - - if(m_State <= EXECUTING) - { - m_Real.glDrawElements(Mode, Count, Type, (const void *)IdxOffset); - } - - const string desc = m_pSerialiser->GetDebugStr(); - - if(m_State == READING) - { - AddEvent(DRAWELEMENTS, desc); - string name = "glDrawElements(" + - ToStr::Get(Mode) + ", " + - ToStr::Get(Count) + ", " + - ToStr::Get(Type) + ", " + - ToStr::Get(IdxOffset) + ")"; - - FetchDrawcall draw; - draw.name = widen(name); - draw.numIndices = Count; - draw.numInstances = 1; - draw.indexOffset = (uint32_t)IdxOffset; - draw.vertexOffset = 0; - draw.instanceOffset = 0; - - draw.flags |= eDraw_Drawcall|eDraw_UseIBuffer; - - m_LastDrawMode = Mode; - m_LastIndexSize = Type; - m_LastIndexOffset = (GLuint)IdxOffset; - - AddDrawcall(draw, true); - } - - return true; -} - -void WrappedOpenGL::glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices) -{ - m_Real.glDrawElements(mode, count, type, indices); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(DRAWELEMENTS); - Serialise_glDrawElements(mode, count, type, indices); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices) -{ - SERIALISE_ELEMENT(GLenum, Mode, mode); - SERIALISE_ELEMENT(uint32_t, Start, start); - SERIALISE_ELEMENT(uint32_t, End, end); - SERIALISE_ELEMENT(uint32_t, Count, count); - SERIALISE_ELEMENT(GLenum, Type, type); - SERIALISE_ELEMENT(uint64_t, IdxOffset, (uint64_t)indices); - - if(m_State <= EXECUTING) - { - m_Real.glDrawRangeElements(Mode, Start, End, Count, Type, (const void *)IdxOffset); - } - - const string desc = m_pSerialiser->GetDebugStr(); - - if(m_State == READING) - { - AddEvent(DRAWELEMENTS, desc); - string name = "glDrawRangeElements(" + - ToStr::Get(Mode) + ", " + - ToStr::Get(Count) + ", " + - ToStr::Get(Type) + ", " + - ToStr::Get(IdxOffset) + ")"; - - FetchDrawcall draw; - draw.name = widen(name); - draw.numIndices = Count; - draw.numInstances = 1; - draw.indexOffset = (uint32_t)IdxOffset; - draw.vertexOffset = 0; - draw.instanceOffset = 0; - - draw.flags |= eDraw_Drawcall|eDraw_UseIBuffer; - - m_LastDrawMode = Mode; - m_LastIndexSize = Type; - m_LastIndexOffset = (GLuint)IdxOffset; - - AddDrawcall(draw, true); - } - - return true; -} - -void WrappedOpenGL::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices) -{ - m_Real.glDrawRangeElements(mode, start, end, count, type, indices); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(DRAWRANGEELEMENTS); - Serialise_glDrawRangeElements(mode, start, end, count, type, indices); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex) -{ - SERIALISE_ELEMENT(GLenum, Mode, mode); - SERIALISE_ELEMENT(uint32_t, Count, count); - SERIALISE_ELEMENT(GLenum, Type, type); - SERIALISE_ELEMENT(uint64_t, IdxOffset, (uint64_t)indices); - SERIALISE_ELEMENT(int32_t, BaseVtx, basevertex); - - if(m_State <= EXECUTING) - { - m_Real.glDrawElementsBaseVertex(Mode, Count, Type, (const void *)IdxOffset, BaseVtx); - } - - const string desc = m_pSerialiser->GetDebugStr(); - - if(m_State == READING) - { - AddEvent(DRAWELEMENTS_BASEVERTEX, desc); - string name = "glDrawElementsBaseVertex(" + - ToStr::Get(Mode) + ", " + - ToStr::Get(Count) + ", " + - ToStr::Get(Type) + ", " + - ToStr::Get(IdxOffset) + ", " + - ToStr::Get(BaseVtx) + ")"; - - FetchDrawcall draw; - draw.name = widen(name); - draw.numIndices = Count; - draw.numInstances = 1; - draw.indexOffset = (uint32_t)IdxOffset; - draw.vertexOffset = BaseVtx; - draw.instanceOffset = 0; - - draw.flags |= eDraw_Drawcall|eDraw_UseIBuffer; - - m_LastDrawMode = Mode; - m_LastIndexSize = Type; - m_LastIndexOffset = (GLuint)IdxOffset; - - AddDrawcall(draw, true); - } - - return true; -} - -void WrappedOpenGL::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex) -{ - m_Real.glDrawElementsBaseVertex(mode, count, type, indices, basevertex); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(DRAWELEMENTS_BASEVERTEX); - Serialise_glDrawElementsBaseVertex(mode, count, type, indices, basevertex); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount) -{ - SERIALISE_ELEMENT(GLenum, Mode, mode); - SERIALISE_ELEMENT(uint32_t, Count, count); - SERIALISE_ELEMENT(GLenum, Type, type); - SERIALISE_ELEMENT(uint64_t, IdxOffset, (uint64_t)indices); - SERIALISE_ELEMENT(uint32_t, InstCount, instancecount); - - if(m_State <= EXECUTING) - { - m_Real.glDrawElementsInstanced(Mode, Count, Type, (const void *)IdxOffset, InstCount); - } - - const string desc = m_pSerialiser->GetDebugStr(); - - if(m_State == READING) - { - AddEvent(DRAWELEMENTS_INSTANCED, desc); - string name = "glDrawElementsInstanced(" + - ToStr::Get(Mode) + ", " + - ToStr::Get(Count) + ", " + - ToStr::Get(Type) + ", " + - ToStr::Get(IdxOffset) + ", " + - ToStr::Get(InstCount) + ")"; - - FetchDrawcall draw; - draw.name = widen(name); - draw.numIndices = Count; - draw.numInstances = InstCount; - draw.indexOffset = (uint32_t)IdxOffset; - draw.vertexOffset = 0; - draw.instanceOffset = 0; - - draw.flags |= eDraw_Drawcall|eDraw_UseIBuffer; - - m_LastDrawMode = Mode; - m_LastIndexSize = Type; - m_LastIndexOffset = (GLuint)IdxOffset; - - AddDrawcall(draw, true); - } - - return true; -} - -void WrappedOpenGL::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount) -{ - m_Real.glDrawElementsInstanced(mode, count, type, indices, instancecount); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(DRAWELEMENTS_INSTANCED); - Serialise_glDrawElementsInstanced(mode, count, type, indices, instancecount); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance) -{ - SERIALISE_ELEMENT(GLenum, Mode, mode); - SERIALISE_ELEMENT(uint32_t, Count, count); - SERIALISE_ELEMENT(GLenum, Type, type); - SERIALISE_ELEMENT(uint64_t, IdxOffset, (uint64_t)indices); - SERIALISE_ELEMENT(uint32_t, InstCount, instancecount); - SERIALISE_ELEMENT(uint32_t, BaseInstance, baseinstance); - - if(m_State <= EXECUTING) - { - m_Real.glDrawElementsInstancedBaseInstance(Mode, Count, Type, (const void *)IdxOffset, InstCount, BaseInstance); - } - - const string desc = m_pSerialiser->GetDebugStr(); - - if(m_State == READING) - { - AddEvent(DRAWELEMENTS_INSTANCEDBASEINSTANCE, desc); - string name = "glDrawElementsInstancedBaseInstance(" + - ToStr::Get(Mode) + ", " + - ToStr::Get(Count) + ", " + - ToStr::Get(Type) + ", " + - ToStr::Get(IdxOffset) + ", " + - ToStr::Get(InstCount) + ", " + - ToStr::Get(BaseInstance) + ")"; - - FetchDrawcall draw; - draw.name = widen(name); - draw.numIndices = Count; - draw.numInstances = InstCount; - draw.indexOffset = (uint32_t)IdxOffset; - draw.vertexOffset = 0; - draw.instanceOffset = BaseInstance; - - draw.flags |= eDraw_Drawcall|eDraw_UseIBuffer; - - m_LastDrawMode = Mode; - m_LastIndexSize = Type; - m_LastIndexOffset = (GLuint)IdxOffset; - - AddDrawcall(draw, true); - } - - return true; -} - -void WrappedOpenGL::glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance) -{ - m_Real.glDrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(DRAWELEMENTS_INSTANCEDBASEINSTANCE); - Serialise_glDrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex) -{ - SERIALISE_ELEMENT(GLenum, Mode, mode); - SERIALISE_ELEMENT(uint32_t, Count, count); - SERIALISE_ELEMENT(GLenum, Type, type); - SERIALISE_ELEMENT(uint64_t, IdxOffset, (uint64_t)indices); - SERIALISE_ELEMENT(uint32_t, InstCount, instancecount); - SERIALISE_ELEMENT(int32_t, BaseVertex, basevertex); - - if(m_State <= EXECUTING) - { - m_Real.glDrawElementsInstancedBaseVertex(Mode, Count, Type, (const void *)IdxOffset, InstCount, BaseVertex); - } - - const string desc = m_pSerialiser->GetDebugStr(); - - if(m_State == READING) - { - AddEvent(DRAWELEMENTS_INSTANCEDBASEVERTEX, desc); - string name = "glDrawElementsInstancedBaseVertex(" + - ToStr::Get(Mode) + ", " + - ToStr::Get(Count) + ", " + - ToStr::Get(Type) + ", " + - ToStr::Get(IdxOffset) + ", " + - ToStr::Get(InstCount) + ", " + - ToStr::Get(BaseVertex) + ")"; - - FetchDrawcall draw; - draw.name = widen(name); - draw.numIndices = Count; - draw.numInstances = InstCount; - draw.indexOffset = (uint32_t)IdxOffset; - draw.vertexOffset = BaseVertex; - draw.instanceOffset = 0; - - draw.flags |= eDraw_Drawcall|eDraw_UseIBuffer; - - m_LastDrawMode = Mode; - m_LastIndexSize = Type; - m_LastIndexOffset = (GLuint)IdxOffset; - - AddDrawcall(draw, true); - } - - return true; -} - -void WrappedOpenGL::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex) -{ - m_Real.glDrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(DRAWELEMENTS_INSTANCEDBASEVERTEX); - Serialise_glDrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance) -{ - SERIALISE_ELEMENT(GLenum, Mode, mode); - SERIALISE_ELEMENT(uint32_t, Count, count); - SERIALISE_ELEMENT(GLenum, Type, type); - SERIALISE_ELEMENT(uint64_t, IdxOffset, (uint64_t)indices); - SERIALISE_ELEMENT(uint32_t, InstCount, instancecount); - SERIALISE_ELEMENT(int32_t, BaseVertex, basevertex); - SERIALISE_ELEMENT(uint32_t, BaseInstance, baseinstance); - - if(m_State <= EXECUTING) - { - m_Real.glDrawElementsInstancedBaseVertexBaseInstance(Mode, Count, Type, (const void *)IdxOffset, InstCount, BaseVertex, BaseInstance); - } - - const string desc = m_pSerialiser->GetDebugStr(); - - if(m_State == READING) - { - AddEvent(DRAWELEMENTS_INSTANCEDBASEVERTEXBASEINSTANCE, desc); - string name = "glDrawElementsInstancedBaseVertexBaseInstance(" + - ToStr::Get(Mode) + ", " + - ToStr::Get(Count) + ", " + - ToStr::Get(Type) + ", " + - ToStr::Get(IdxOffset) + ", " + - ToStr::Get(InstCount) + ", " + - ToStr::Get(BaseVertex) + ", " + - ToStr::Get(BaseInstance) + ")"; - - FetchDrawcall draw; - draw.name = widen(name); - draw.numIndices = Count; - draw.numInstances = InstCount; - draw.indexOffset = (uint32_t)IdxOffset; - draw.vertexOffset = BaseVertex; - draw.instanceOffset = BaseInstance; - - draw.flags |= eDraw_Drawcall|eDraw_UseIBuffer; - - m_LastDrawMode = Mode; - m_LastIndexSize = Type; - m_LastIndexOffset = (GLuint)IdxOffset; - - AddDrawcall(draw, true); - } - - return true; -} - -void WrappedOpenGL::glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance) -{ - m_Real.glDrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(DRAWELEMENTS_INSTANCEDBASEVERTEXBASEINSTANCE); - Serialise_glDrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value) -{ - SERIALISE_ELEMENT(GLenum, buf, buffer); - SERIALISE_ELEMENT(int32_t, draw, drawbuffer); - - if(buf != eGL_DEPTH) - { - Vec4f v; - if(value) v = *((Vec4f *)value); - - m_pSerialiser->Serialise<4>("value", (float *)&v.x); - - if(m_State <= EXECUTING) - m_Real.glClearBufferfv(buf, draw, &v.x); - } - else - { - SERIALISE_ELEMENT(float, val, *value); - - if(m_State <= EXECUTING) - m_Real.glClearBufferfv(buf, draw, &val); - } - - const string desc = m_pSerialiser->GetDebugStr(); - - if(m_State == READING) - { - AddEvent(CLEARBUFFERF, desc); - string name = "glClearBufferfv(" + - ToStr::Get(buf) + ", " + - ToStr::Get(draw) + ")"; - - FetchDrawcall draw; - draw.name = widen(name); - draw.flags |= eDraw_Clear; - - AddDrawcall(draw, true); - } - - - return true; -} - -void WrappedOpenGL::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value) -{ - m_Real.glClearBufferfv(buffer, drawbuffer, value); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(CLEARBUFFERF); - Serialise_glClearBufferfv(buffer, drawbuffer, value); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value) -{ - SERIALISE_ELEMENT(GLenum, buf, buffer); - SERIALISE_ELEMENT(int32_t, draw, drawbuffer); - - if(buf != eGL_STENCIL) - { - int32_t v[4]; - if(value) memcpy(v, value, sizeof(v)); - - m_pSerialiser->Serialise<4>("value", v); - - if(m_State <= EXECUTING) - m_Real.glClearBufferiv(buf, draw, v); - } - else - { - SERIALISE_ELEMENT(int32_t, val, *value); - - if(m_State <= EXECUTING) - m_Real.glClearBufferiv(buf, draw, &val); - } - - const string desc = m_pSerialiser->GetDebugStr(); - - if(m_State == READING) - { - AddEvent(CLEARBUFFERI, desc); - string name = "glClearBufferiv(" + - ToStr::Get(buf) + ", " + - ToStr::Get(draw) + ")"; - - FetchDrawcall draw; - draw.name = widen(name); - draw.flags |= eDraw_Clear; - - AddDrawcall(draw, true); - } - - - return true; -} - -void WrappedOpenGL::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value) -{ - m_Real.glClearBufferiv(buffer, drawbuffer, value); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(CLEARBUFFERI); - Serialise_glClearBufferiv(buffer, drawbuffer, value); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value) -{ - SERIALISE_ELEMENT(GLenum, buf, buffer); - SERIALISE_ELEMENT(int32_t, draw, drawbuffer); - - { - uint32_t v[4]; - if(value) memcpy(v, value, sizeof(v)); - - m_pSerialiser->Serialise<4>("value", v); - - if(m_State <= EXECUTING) - m_Real.glClearBufferuiv(buf, draw, v); - } - - const string desc = m_pSerialiser->GetDebugStr(); - - if(m_State == READING) - { - AddEvent(CLEARBUFFERUI, desc); - string name = "glClearBufferuiv(" + - ToStr::Get(buf) + ", " + - ToStr::Get(draw) + ")"; - - FetchDrawcall draw; - draw.name = widen(name); - draw.flags |= eDraw_Clear; - - AddDrawcall(draw, true); - } - - return true; -} - -void WrappedOpenGL::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value) -{ - m_Real.glClearBufferuiv(buffer, drawbuffer, value); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(CLEARBUFFERUI); - Serialise_glClearBufferuiv(buffer, drawbuffer, value); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) -{ - SERIALISE_ELEMENT(GLenum, buf, buffer); - SERIALISE_ELEMENT(int32_t, draw, drawbuffer); - SERIALISE_ELEMENT(float, d, depth); - SERIALISE_ELEMENT(int32_t, s, stencil); - - if(m_State <= EXECUTING) - m_Real.glClearBufferfi(buf, draw, d, s); - - const string desc = m_pSerialiser->GetDebugStr(); - - if(m_State == READING) - { - AddEvent(CLEARBUFFERFI, desc); - string name = "glClearBufferfi(" + - ToStr::Get(buf) + ", " + - ToStr::Get(draw) + ")"; - - FetchDrawcall draw; - draw.name = widen(name); - draw.flags |= eDraw_Clear; - - AddDrawcall(draw, true); - } - - return true; -} - -void WrappedOpenGL::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) -{ - m_Real.glClearBufferfi(buffer, drawbuffer, depth, stencil); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(CLEARBUFFERFI); - Serialise_glClearBufferfi(buffer, drawbuffer, depth, stencil); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glClear(GLbitfield mask) -{ - SERIALISE_ELEMENT(uint32_t, Mask, mask); - - if(m_State <= EXECUTING) - m_Real.glClear(Mask); - - const string desc = m_pSerialiser->GetDebugStr(); - - if(m_State == READING) - { - AddEvent(CLEARBUFFERF, desc); - string name = "glClear("; - if(Mask & GL_DEPTH_BUFFER_BIT) - name += "GL_DEPTH_BUFFER_BIT | "; - if(Mask & GL_COLOR_BUFFER_BIT) - name += "GL_COLOR_BUFFER_BIT | "; - if(Mask & GL_STENCIL_BUFFER_BIT) - name += "GL_STENCIL_BUFFER_BIT | "; - - if(Mask & (eGL_DEPTH_BUFFER_BIT|eGL_COLOR_BUFFER_BIT|eGL_STENCIL_BUFFER_BIT)) - { - name.pop_back(); // ' ' - name.pop_back(); // '|' - name.pop_back(); // ' ' - } - - name += ")"; - - FetchDrawcall draw; - draw.name = widen(name); - draw.flags |= eDraw_Clear; - - AddDrawcall(draw, true); - } - - return true; -} - -void WrappedOpenGL::glClear(GLbitfield mask) -{ - m_Real.glClear(mask); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(CLEAR); - Serialise_glClear(mask); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -#pragma endregion - -// most of this is just hacks to get glxgears working :) - -#pragma region Legacy/Immediate mode - -bool WrappedOpenGL::Serialise_glGenLists(GLsizei range) -{ - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(DisplayListRes((GLuint)range))); - - if(m_State == READING) - { - GLuint real = m_Real.glGenLists(1); - - GLResource res = DisplayListRes(real); - - ResourceId live = m_ResourceManager->RegisterResource(res); - GetResourceManager()->AddLiveResource(id, res); - } - - return true; -} - -GLuint WrappedOpenGL::glGenLists(GLsizei range) -{ - GLuint listret = m_Real.glGenLists(range); - - RDCASSERT(range == 1); // assumption from glxgears. - - for(GLsizei i=0; i < range; i++) - { - GLResource res = DisplayListRes(listret+i); - ResourceId id = GetResourceManager()->RegisterResource(res); - - if(m_State >= WRITING) - { - Chunk *chunk = NULL; - - { - SCOPED_SERIALISE_CONTEXT(GENLISTS); - Serialise_glGenLists((GLsizei)(listret+i)); - - chunk = scope.Get(); - } - - GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id); - RDCASSERT(record); - - record->AddChunk(chunk); - } - else - { - GetResourceManager()->AddLiveResource(id, res); - } - } - - return listret; -} - -bool WrappedOpenGL::Serialise_glLightfv(GLenum light, GLenum pname, const GLfloat *params) -{ - SERIALISE_ELEMENT(GLenum, Light, light); - SERIALISE_ELEMENT(GLenum, Name, pname); - - Vec4f v; - if(params) v = *((Vec4f *)params); - - m_pSerialiser->Serialise<4>("params", (float *)&v.x); - - if(m_State <= EXECUTING) - m_Real.glLightfv(Light, Name, &v.x); - - return true; -} - -void WrappedOpenGL::glLightfv(GLenum light, GLenum pname, const GLfloat *params) -{ - RDCASSERT(pname == (GLenum)0x1203 /*eGL_POSITION*/); // assumption from glxgears. - - m_Real.glLightfv(light, pname, params); - - { - SCOPED_SERIALISE_CONTEXT(LIGHTFV); - Serialise_glLightfv(light, pname, params); - - m_DeviceRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) -{ - SERIALISE_ELEMENT(GLenum, Face, face); - SERIALISE_ELEMENT(GLenum, Name, pname); - - Vec4f v; - if(params) v = *((Vec4f *)params); - - m_pSerialiser->Serialise<4>("params", (float *)&v.x); - - if(m_State <= EXECUTING) - m_Real.glMaterialfv(Face, Name, &v.x); - - return true; -} - -void WrappedOpenGL::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) -{ - RDCASSERT(pname == (GLenum)0x1602 /*eGL_AMBIENT_AND_DIFFUSE*/); // assumption from glxgears. - - m_Real.glMaterialfv(face, pname, params); - - if(m_State == WRITING_CAPFRAME || m_DisplayListRecord) - { - SCOPED_SERIALISE_CONTEXT(MATERIALFV); - Serialise_glMaterialfv(face, pname, params); - - if(m_DisplayListRecord) - m_DisplayListRecord->AddChunk(scope.Get()); - else - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glNewList(GLuint list, GLenum mode) -{ - SERIALISE_ELEMENT(ResourceId, Id, GetResourceManager()->GetID(DisplayListRes(list))); - SERIALISE_ELEMENT(GLenum, Mode, mode); - - if(m_State <= EXECUTING) - { - GLResource res = GetResourceManager()->GetLiveResource(Id); - m_Real.glNewList(res.name, Mode); - } - - return true; -} - -void WrappedOpenGL::glNewList(GLuint list, GLenum mode) -{ - m_Real.glNewList(list, mode); - - RDCASSERT(m_DisplayListRecord == NULL); - m_DisplayListRecord = m_ResourceManager->GetResourceRecord(DisplayListRes(list)); - { - SCOPED_SERIALISE_CONTEXT(NEWLIST); - Serialise_glNewList(list, mode); - - m_DisplayListRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glEndList() -{ - if(m_State <= EXECUTING) - m_Real.glEndList(); - - return true; -} - -void WrappedOpenGL::glEndList() -{ - m_Real.glEndList(); - - RDCASSERT(m_DisplayListRecord); - { - SCOPED_SERIALISE_CONTEXT(ENDLIST); - Serialise_glEndList(); - - m_DisplayListRecord->AddChunk(scope.Get()); - } - m_DisplayListRecord = NULL; -} - -bool WrappedOpenGL::Serialise_glCallList(GLuint list) -{ - SERIALISE_ELEMENT(ResourceId, Id, GetResourceManager()->GetID(DisplayListRes(list))); - - if(m_State <= EXECUTING) - { - GLResource res = GetResourceManager()->GetLiveResource(Id); - m_Real.glCallList(res.name); - } - - const string desc = m_pSerialiser->GetDebugStr(); - - if(m_State == READING) - { - GLResource res = GetResourceManager()->GetLiveResource(Id); - AddEvent(CALLLIST, desc); - string name = "glCallList(" + ToStr::Get(res.name) + ")"; - - FetchDrawcall draw; - draw.name = widen(name); - - draw.flags |= eDraw_CmdList; - - AddDrawcall(draw, true); - } - - return true; -} - -void WrappedOpenGL::glCallList(GLuint list) -{ - m_Real.glCallList(list); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(CALLLIST); - Serialise_glCallList(list); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glShadeModel(GLenum mode) -{ - SERIALISE_ELEMENT(GLenum, Mode, mode); - - if(m_State <= EXECUTING) - m_Real.glShadeModel(Mode); - - return true; -} - -void WrappedOpenGL::glShadeModel(GLenum mode) -{ - m_Real.glShadeModel(mode); - - if(m_State == WRITING_CAPFRAME || m_DisplayListRecord) - { - SCOPED_SERIALISE_CONTEXT(SHADEMODEL); - Serialise_glShadeModel(mode); - - if(m_DisplayListRecord) - m_DisplayListRecord->AddChunk(scope.Get()); - else - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glBegin(GLenum mode) -{ - SERIALISE_ELEMENT(GLenum, Mode, mode); - - if(m_State <= EXECUTING) - m_Real.glBegin(Mode); - - return true; -} - -void WrappedOpenGL::glBegin(GLenum mode) -{ - m_Real.glBegin(mode); - - if(m_State == WRITING_CAPFRAME || m_DisplayListRecord) - { - SCOPED_SERIALISE_CONTEXT(BEGIN); - Serialise_glBegin(mode); - - if(m_DisplayListRecord) - m_DisplayListRecord->AddChunk(scope.Get()); - else - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glEnd() -{ - if(m_State <= EXECUTING) - m_Real.glEnd(); - - return true; -} - -void WrappedOpenGL::glEnd() -{ - m_Real.glEnd(); - - if(m_State == WRITING_CAPFRAME || m_DisplayListRecord) - { - SCOPED_SERIALISE_CONTEXT(END); - Serialise_glEnd(); - - if(m_DisplayListRecord) - m_DisplayListRecord->AddChunk(scope.Get()); - else - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glVertex3f(GLfloat x, GLfloat y, GLfloat z) -{ - SERIALISE_ELEMENT(float, X, x); - SERIALISE_ELEMENT(float, Y, y); - SERIALISE_ELEMENT(float, Z, z); - - if(m_State <= EXECUTING) - m_Real.glVertex3f(X, Y, Z); - - return true; -} - -void WrappedOpenGL::glVertex3f(GLfloat x, GLfloat y, GLfloat z) -{ - m_Real.glVertex3f(x, y, z); - - if(m_State == WRITING_CAPFRAME || m_DisplayListRecord) - { - SCOPED_SERIALISE_CONTEXT(VERTEX3F); - Serialise_glVertex3f(x, y, z); - - if(m_DisplayListRecord) - m_DisplayListRecord->AddChunk(scope.Get()); - else - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) -{ - SERIALISE_ELEMENT(float, NX, nx); - SERIALISE_ELEMENT(float, NY, ny); - SERIALISE_ELEMENT(float, NZ, nz); - - if(m_State <= EXECUTING) - m_Real.glNormal3f(NX, NY, NZ); - - return true; -} - -void WrappedOpenGL::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) -{ - m_Real.glNormal3f(nx, ny, nz); - - if(m_State == WRITING_CAPFRAME || m_DisplayListRecord) - { - SCOPED_SERIALISE_CONTEXT(NORMAL3F); - Serialise_glNormal3f(nx, ny, nz); - - if(m_DisplayListRecord) - m_DisplayListRecord->AddChunk(scope.Get()); - else - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glPushMatrix() -{ - if(m_State <= EXECUTING) - m_Real.glPushMatrix(); - - return true; -} - -void WrappedOpenGL::glPushMatrix() -{ - m_Real.glPushMatrix(); - - { - SCOPED_SERIALISE_CONTEXT(PUSHMATRIX); - Serialise_glPushMatrix(); - - if(m_DisplayListRecord) - m_DisplayListRecord->AddChunk(scope.Get()); - else if(m_State == WRITING_CAPFRAME) - m_ContextRecord->AddChunk(scope.Get()); - else - m_DeviceRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glPopMatrix() -{ - if(m_State <= EXECUTING) - m_Real.glPopMatrix(); - - return true; -} - -void WrappedOpenGL::glPopMatrix() -{ - m_Real.glPopMatrix(); - - { - SCOPED_SERIALISE_CONTEXT(POPMATRIX); - Serialise_glPopMatrix(); - - if(m_DisplayListRecord) - m_DisplayListRecord->AddChunk(scope.Get()); - else if(m_State == WRITING_CAPFRAME) - m_ContextRecord->AddChunk(scope.Get()); - else - m_DeviceRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glMatrixMode(GLenum mode) -{ - SERIALISE_ELEMENT(GLenum, Mode, mode); - - if(m_State <= EXECUTING) - m_Real.glMatrixMode(Mode); - - return true; -} - -void WrappedOpenGL::glMatrixMode(GLenum mode) -{ - m_Real.glMatrixMode(mode); - - { - SCOPED_SERIALISE_CONTEXT(MATRIXMODE); - Serialise_glMatrixMode(mode); - - m_DeviceRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glLoadIdentity() -{ - if(m_State <= EXECUTING) - m_Real.glLoadIdentity(); - - return true; -} - -void WrappedOpenGL::glLoadIdentity() -{ - m_Real.glLoadIdentity(); - - { - SCOPED_SERIALISE_CONTEXT(LOADIDENTITY); - Serialise_glLoadIdentity(); - - if(m_DisplayListRecord) - m_DisplayListRecord->AddChunk(scope.Get()); - else if(m_State == WRITING_CAPFRAME) - m_ContextRecord->AddChunk(scope.Get()); - else - m_DeviceRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) -{ - SERIALISE_ELEMENT(double, L, left); - SERIALISE_ELEMENT(double, R, right); - SERIALISE_ELEMENT(double, B, bottom); - SERIALISE_ELEMENT(double, T, top); - SERIALISE_ELEMENT(double, N, zNear); - SERIALISE_ELEMENT(double, F, zFar); - - if(m_State <= EXECUTING) - m_Real.glFrustum(L, R, B, T, N, F); - - return true; -} - -void WrappedOpenGL::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) -{ - m_Real.glFrustum(left, right, bottom, top, zNear, zFar); - - { - SCOPED_SERIALISE_CONTEXT(FRUSTUM); - Serialise_glFrustum(left, right, bottom, top, zNear, zFar); - - m_DeviceRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glTranslatef(GLfloat x, GLfloat y, GLfloat z) -{ - SERIALISE_ELEMENT(float, X, x); - SERIALISE_ELEMENT(float, Y, y); - SERIALISE_ELEMENT(float, Z, z); - - if(m_State <= EXECUTING) - m_Real.glTranslatef(X, Y, Z); - - return true; -} - -void WrappedOpenGL::glTranslatef(GLfloat x, GLfloat y, GLfloat z) -{ - m_Real.glTranslatef(x, y, z); - - { - SCOPED_SERIALISE_CONTEXT(TRANSLATEF); - Serialise_glTranslatef(x, y, z); - - if(m_DisplayListRecord) - m_DisplayListRecord->AddChunk(scope.Get()); - else if(m_State == WRITING_CAPFRAME) - m_ContextRecord->AddChunk(scope.Get()); - else - m_DeviceRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) -{ - SERIALISE_ELEMENT(float, ang, angle); - SERIALISE_ELEMENT(float, X, x); - SERIALISE_ELEMENT(float, Y, y); - SERIALISE_ELEMENT(float, Z, z); - - if(m_State <= EXECUTING) - m_Real.glRotatef(ang, X, Y, Z); - - return true; -} - -void WrappedOpenGL::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) -{ - m_Real.glRotatef(angle, x, y, z); - - if(m_State == WRITING_CAPFRAME || m_DisplayListRecord) - { - SCOPED_SERIALISE_CONTEXT(ROTATEF); - Serialise_glRotatef(angle, x, y, z); - - if(m_DisplayListRecord) - m_DisplayListRecord->AddChunk(scope.Get()); - else - m_ContextRecord->AddChunk(scope.Get()); - } -} - -#pragma endregion - - diff --git a/renderdoc/driver/gl/gl_device_driver.cpp b/renderdoc/driver/gl/gl_device_driver.cpp deleted file mode 100644 index 5b7fab3b6..000000000 --- a/renderdoc/driver/gl/gl_device_driver.cpp +++ /dev/null @@ -1,3230 +0,0 @@ -/****************************************************************************** - * The MIT License (MIT) - * - * Copyright (c) 2014 Crytek - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - * THE SOFTWARE. - ******************************************************************************/ - - -#include "common/common.h" -#include "gl_driver.h" - -#pragma region Textures - -bool WrappedOpenGL::Serialise_glGenTextures(GLsizei n, GLuint* textures) -{ - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(*textures))); - - if(m_State == READING) - { - GLuint real = 0; - m_Real.glGenTextures(1, &real); - - GLResource res = TextureRes(real); - - ResourceId live = m_ResourceManager->RegisterResource(res); - GetResourceManager()->AddLiveResource(id, res); - - m_Textures[live].resource = res; - m_Textures[live].curType = eGL_UNKNOWN_ENUM; - } - - return true; -} - -void WrappedOpenGL::glGenTextures(GLsizei n, GLuint* textures) -{ - m_Real.glGenTextures(n, textures); - - for(GLsizei i=0; i < n; i++) - { - GLResource res = TextureRes(textures[i]); - ResourceId id = GetResourceManager()->RegisterResource(res); - - if(m_State >= WRITING) - { - Chunk *chunk = NULL; - - { - SCOPED_SERIALISE_CONTEXT(GEN_TEXTURE); - Serialise_glGenTextures(1, textures+i); - - chunk = scope.Get(); - } - - GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id); - RDCASSERT(record); - - record->AddChunk(chunk); - } - else - { - GetResourceManager()->AddLiveResource(id, res); - m_Textures[id].resource = res; - m_Textures[id].curType = eGL_UNKNOWN_ENUM; - } - } -} - -void WrappedOpenGL::glDeleteTextures(GLsizei n, const GLuint *textures) -{ - m_Real.glDeleteTextures(n, textures); - - for(GLsizei i=0; i < n; i++) - GetResourceManager()->UnregisterResource(TextureRes(textures[i])); -} - -bool WrappedOpenGL::Serialise_glBindTexture(GLenum target, GLuint texture) -{ - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(ResourceId, Id, GetResourceManager()->GetID(TextureRes(texture))); - - if(m_State == WRITING_IDLE) - { - m_TextureRecord[m_TextureUnit]->datatype = Target; - } - else if(m_State < WRITING) - { - if(Id == ResourceId()) - { - m_Real.glBindTexture(Target, 0); - } - else - { - GLResource res = GetResourceManager()->GetLiveResource(Id); - m_Real.glBindTexture(Target, res.name); - - m_Textures[GetResourceManager()->GetLiveID(Id)].curType = Target; - } - } - - return true; -} - -void WrappedOpenGL::glBindTexture(GLenum target, GLuint texture) -{ - m_Real.glBindTexture(target, texture); - - if(m_State == WRITING_CAPFRAME) - { - Chunk *chunk = NULL; - - { - SCOPED_SERIALISE_CONTEXT(BIND_TEXTURE); - Serialise_glBindTexture(target, texture); - - chunk = scope.Get(); - } - - m_ContextRecord->AddChunk(chunk); - } - else if(m_State < WRITING) - { - m_Textures[GetResourceManager()->GetID(TextureRes(texture))].curType = target; - } - - if(texture == 0) - { - m_TextureRecord[m_TextureUnit] = NULL; - return; - } - - if(m_State >= WRITING) - { - GLResourceRecord *r = m_TextureRecord[m_TextureUnit] = GetResourceManager()->GetResourceRecord(TextureRes(texture)); - - if(r->datatype) - { - // it's illegal to retype a texture - RDCASSERT(r->datatype == target); - } - else - { - Chunk *chunk = NULL; - - { - SCOPED_SERIALISE_CONTEXT(BIND_TEXTURE); - Serialise_glBindTexture(target, texture); - - chunk = scope.Get(); - } - - r->AddChunk(chunk); - } - } -} - -bool WrappedOpenGL::Serialise_glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) -{ - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(uint32_t, Levels, levels); - SERIALISE_ELEMENT(GLenum, Format, internalformat); - SERIALISE_ELEMENT(uint32_t, Width, width); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); - - if(m_State == READING) - { - ResourceId liveId = GetResourceManager()->GetLiveID(id); - m_Textures[liveId].width = Width; - m_Textures[liveId].height = 1; - m_Textures[liveId].depth = 1; - - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - m_Real.glTexStorage1D(Target, Levels, Format, Width); - } - - return true; -} - -void WrappedOpenGL::glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) -{ - m_Real.glTexStorage1D(target, levels, internalformat, width); - - if(m_State >= WRITING) - { - RDCASSERT(m_TextureRecord[m_TextureUnit]); - - SCOPED_SERIALISE_CONTEXT(TEXSTORAGE1D); - Serialise_glTexStorage1D(target, levels, internalformat, width); - - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) -{ - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(uint32_t, Levels, levels); - SERIALISE_ELEMENT(GLenum, Format, internalformat); - SERIALISE_ELEMENT(uint32_t, Width, width); - SERIALISE_ELEMENT(uint32_t, Height, height); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); - - if(m_State == READING) - { - ResourceId liveId = GetResourceManager()->GetLiveID(id); - m_Textures[liveId].width = Width; - m_Textures[liveId].height = Height; - m_Textures[liveId].depth = 1; - - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - m_Real.glTexStorage2D(Target, Levels, Format, Width, Height); - } - - return true; -} - -void WrappedOpenGL::glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) -{ - m_Real.glTexStorage2D(target, levels, internalformat, width, height); - - if(m_State >= WRITING) - { - RDCASSERT(m_TextureRecord[m_TextureUnit]); - - SCOPED_SERIALISE_CONTEXT(TEXSTORAGE2D); - Serialise_glTexStorage2D(target, levels, internalformat, width, height); - - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) -{ - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(uint32_t, Levels, levels); - SERIALISE_ELEMENT(GLenum, Format, internalformat); - SERIALISE_ELEMENT(uint32_t, Width, width); - SERIALISE_ELEMENT(uint32_t, Height, height); - SERIALISE_ELEMENT(uint32_t, Depth, depth); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); - - if(m_State == READING) - { - ResourceId liveId = GetResourceManager()->GetLiveID(id); - m_Textures[liveId].width = Width; - m_Textures[liveId].height = Height; - m_Textures[liveId].depth = Depth; - - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - m_Real.glTexStorage3D(Target, Levels, Format, Width, Height, Depth); - } - - return true; -} - -void WrappedOpenGL::glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) -{ - m_Real.glTexStorage3D(target, levels, internalformat, width, height, depth); - - if(m_State >= WRITING) - { - RDCASSERT(m_TextureRecord[m_TextureUnit]); - - SCOPED_SERIALISE_CONTEXT(TEXSTORAGE3D); - Serialise_glTexStorage3D(target, levels, internalformat, width, height, depth); - - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) -{ - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(int32_t, Level, level); - SERIALISE_ELEMENT(int32_t, xoff, xoffset); - SERIALISE_ELEMENT(uint32_t, Width, width); - SERIALISE_ELEMENT(GLenum, Format, format); - SERIALISE_ELEMENT(GLenum, Type, type); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); - - GLint align = 1; - m_Real.glGetIntegerv(eGL_UNPACK_ALIGNMENT, &align); - - size_t subimageSize = GetByteSize(Width, 1, 1, Format, Type, Level, align); - - SERIALISE_ELEMENT_BUF(byte *, buf, pixels, subimageSize); - - if(m_State == READING) - { - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - m_Real.glTexSubImage1D(Target, Level, xoff, Width, Format, Type, buf); - - delete[] buf; - } - - return true; -} - -void WrappedOpenGL::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) -{ - m_Real.glTexSubImage1D(target, level, xoffset, width, format, type, pixels); - - if(m_State >= WRITING) - { - RDCASSERT(m_TextureRecord[m_TextureUnit]); - - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE1D); - Serialise_glTexSubImage1D(target, level, xoffset, width, format, type, pixels); - - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) -{ - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(int32_t, Level, level); - SERIALISE_ELEMENT(int32_t, xoff, xoffset); - SERIALISE_ELEMENT(int32_t, yoff, yoffset); - SERIALISE_ELEMENT(uint32_t, Width, width); - SERIALISE_ELEMENT(uint32_t, Height, height); - SERIALISE_ELEMENT(GLenum, Format, format); - SERIALISE_ELEMENT(GLenum, Type, type); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); - - GLint align = 1; - m_Real.glGetIntegerv(eGL_UNPACK_ALIGNMENT, &align); - - size_t subimageSize = GetByteSize(Width, Height, 1, Format, Type, Level, align); - - SERIALISE_ELEMENT_BUF(byte *, buf, pixels, subimageSize); - - if(m_State == READING) - { - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - m_Real.glTexSubImage2D(Target, Level, xoff, yoff, Width, Height, Format, Type, buf); - - delete[] buf; - } - - return true; -} - -void WrappedOpenGL::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) -{ - m_Real.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); - - if(m_State >= WRITING) - { - RDCASSERT(m_TextureRecord[m_TextureUnit]); - - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE2D); - Serialise_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); - - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) -{ - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(int32_t, Level, level); - SERIALISE_ELEMENT(int32_t, xoff, xoffset); - SERIALISE_ELEMENT(int32_t, yoff, yoffset); - SERIALISE_ELEMENT(int32_t, zoff, zoffset); - SERIALISE_ELEMENT(uint32_t, Width, width); - SERIALISE_ELEMENT(uint32_t, Height, height); - SERIALISE_ELEMENT(uint32_t, Depth, depth); - SERIALISE_ELEMENT(GLenum, Format, format); - SERIALISE_ELEMENT(GLenum, Type, type); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); - - GLint align = 1; - m_Real.glGetIntegerv(eGL_UNPACK_ALIGNMENT, &align); - - size_t subimageSize = GetByteSize(Width, Height, Depth, Format, Type, Level, align); - - SERIALISE_ELEMENT_BUF(byte *, buf, pixels, subimageSize); - - if(m_State == READING) - { - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - m_Real.glTexSubImage3D(Target, Level, xoff, yoff, zoff, Width, Height, Depth, Format, Type, buf); - - delete[] buf; - } - - return true; -} - -void WrappedOpenGL::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) -{ - m_Real.glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); - - if(m_State >= WRITING) - { - RDCASSERT(m_TextureRecord[m_TextureUnit]); - - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE3D); - Serialise_glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); - - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *pixels) -{ - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(int32_t, Level, level); - SERIALISE_ELEMENT(int32_t, xoff, xoffset); - SERIALISE_ELEMENT(uint32_t, Width, width); - SERIALISE_ELEMENT(GLenum, fmt, format); - SERIALISE_ELEMENT(uint32_t, byteSize, imageSize); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); - - SERIALISE_ELEMENT_BUF(byte *, buf, pixels, byteSize); - - if(m_State == READING) - { - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - m_Real.glCompressedTexSubImage1D(Target, Level, xoff, Width, fmt, byteSize, buf); - - delete[] buf; - } - - return true; -} - -void WrappedOpenGL::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *pixels) -{ - m_Real.glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, pixels); - - if(m_State >= WRITING) - { - RDCASSERT(m_TextureRecord[m_TextureUnit]); - - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE1D_COMPRESSED); - Serialise_glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, pixels); - - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) -{ - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(int32_t, Level, level); - SERIALISE_ELEMENT(int32_t, xoff, xoffset); - SERIALISE_ELEMENT(int32_t, yoff, yoffset); - SERIALISE_ELEMENT(uint32_t, Width, width); - SERIALISE_ELEMENT(uint32_t, Height, height); - SERIALISE_ELEMENT(GLenum, fmt, format); - SERIALISE_ELEMENT(uint32_t, byteSize, imageSize); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); - - SERIALISE_ELEMENT_BUF(byte *, buf, pixels, byteSize); - - if(m_State == READING) - { - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - m_Real.glCompressedTexSubImage2D(Target, Level, xoff, yoff, Width, Height, fmt, byteSize, buf); - - delete[] buf; - } - - return true; -} - -void WrappedOpenGL::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) -{ - m_Real.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, pixels); - - if(m_State >= WRITING) - { - RDCASSERT(m_TextureRecord[m_TextureUnit]); - - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE2D_COMPRESSED); - Serialise_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, pixels); - - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) -{ - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(int32_t, Level, level); - SERIALISE_ELEMENT(int32_t, xoff, xoffset); - SERIALISE_ELEMENT(int32_t, yoff, yoffset); - SERIALISE_ELEMENT(int32_t, zoff, zoffset); - SERIALISE_ELEMENT(uint32_t, Width, width); - SERIALISE_ELEMENT(uint32_t, Height, height); - SERIALISE_ELEMENT(uint32_t, Depth, depth); - SERIALISE_ELEMENT(GLenum, fmt, format); - SERIALISE_ELEMENT(uint32_t, byteSize, imageSize); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); - - SERIALISE_ELEMENT_BUF(byte *, buf, pixels, byteSize); - - if(m_State == READING) - { - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - m_Real.glCompressedTexSubImage3D(Target, Level, xoff, yoff, zoff, Width, Height, Depth, fmt, byteSize, buf); - - delete[] buf; - } - - return true; -} - -void WrappedOpenGL::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) -{ - m_Real.glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); - - if(m_State >= WRITING) - { - RDCASSERT(m_TextureRecord[m_TextureUnit]); - - SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE3D_COMPRESSED); - Serialise_glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); - - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glGenerateMipmap(GLenum target) -{ - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); - - if(m_State == READING) - { - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - m_Real.glGenerateMipmap(Target); - } - - return true; -} - -void WrappedOpenGL::glGenerateMipmap(GLenum target) -{ - m_Real.glGenerateMipmap(target); - - RDCASSERT(m_TextureRecord[m_TextureUnit]); - { - SCOPED_SERIALISE_CONTEXT(GENERATE_MIPMAP); - Serialise_glGenerateMipmap(target); - - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glTexParameteri(GLenum target, GLenum pname, GLint param) -{ - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(GLenum, PName, pname); - SERIALISE_ELEMENT(int32_t, Param, param); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); - - if(m_State < WRITING) - { - if(m_State == READING) - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - glTexParameteri(Target, PName, Param); - } - - return true; -} - -void WrappedOpenGL::glTexParameteri(GLenum target, GLenum pname, GLint param) -{ - m_Real.glTexParameteri(target, pname, param); - - if(m_State >= WRITING) - { - RDCASSERT(m_TextureRecord[m_TextureUnit]); - - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERI); - Serialise_glTexParameteri(target, pname, param); - - if(m_State == WRITING_IDLE) - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); - else - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glTexParameteriv(GLenum target, GLenum pname, const GLint *params) -{ - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(GLenum, PName, pname); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); - const size_t nParams = (PName == eGL_TEXTURE_BORDER_COLOR ? 4U : 1U); - SERIALISE_ELEMENT_ARR(int32_t, Params, params, nParams); - - if(m_State < WRITING) - { - if(m_State == READING) - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - glTexParameteriv(Target, PName, Params); - } - - delete[] Params; - - return true; -} - -void WrappedOpenGL::glTexParameteriv(GLenum target, GLenum pname, const GLint *params) -{ - m_Real.glTexParameteriv(target, pname, params); - - if(m_State >= WRITING) - { - RDCASSERT(m_TextureRecord[m_TextureUnit]); - - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERIV); - Serialise_glTexParameteriv(target, pname, params); - - if(m_State == WRITING_IDLE) - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); - else - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glTexParameterf(GLenum target, GLenum pname, GLfloat param) -{ - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(GLenum, PName, pname); - SERIALISE_ELEMENT(float, Param, param); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); - - if(m_State < WRITING) - { - if(m_State == READING) - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - glTexParameterf(Target, PName, Param); - } - - return true; -} - -void WrappedOpenGL::glTexParameterf(GLenum target, GLenum pname, GLfloat param) -{ - m_Real.glTexParameterf(target, pname, param); - - if(m_State >= WRITING) - { - RDCASSERT(m_TextureRecord[m_TextureUnit]); - - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERF); - Serialise_glTexParameterf(target, pname, param); - - if(m_State == WRITING_IDLE) - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); - else - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) -{ - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(GLenum, PName, pname); - SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); - const size_t nParams = (PName == eGL_TEXTURE_BORDER_COLOR ? 4U : 1U); - SERIALISE_ELEMENT_ARR(float, Params, params, nParams); - - if(m_State < WRITING) - { - if(m_State == READING) - m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); - glTexParameterfv(Target, PName, Params); - } - - delete[] Params; - - return true; -} - -void WrappedOpenGL::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) -{ - m_Real.glTexParameterfv(target, pname, params); - - if(m_State >= WRITING) - { - RDCASSERT(m_TextureRecord[m_TextureUnit]); - - SCOPED_SERIALISE_CONTEXT(TEXPARAMETERFV); - Serialise_glTexParameterfv(target, pname, params); - - 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); - - for(GLsizei i=0; i < count; i++) - { - GLResource res = SamplerRes(samplers[i]); - ResourceId id = GetResourceManager()->RegisterResource(res); - - if(m_State >= WRITING) - { - 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 - { - GetResourceManager()->AddLiveResource(id, res); - } - } -} - -bool WrappedOpenGL::Serialise_glBindSampler(GLuint unit, GLuint sampler) -{ - SERIALISE_ELEMENT(uint32_t, Unit, unit); - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(sampler))); - - if(m_State < WRITING) - { - GLResource res = GetResourceManager()->GetLiveResource(id); - glBindSampler(Unit, res.name); - } - - return true; -} - -void WrappedOpenGL::glBindSampler(GLuint unit, GLuint sampler) -{ - m_Real.glBindSampler(unit, sampler); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(BIND_SAMPLER); - Serialise_glBindSampler(unit, sampler); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -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) - { - 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()); - } -} - -bool WrappedOpenGL::Serialise_glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) -{ - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(sampler))); - SERIALISE_ELEMENT(GLenum, PName, pname); - SERIALISE_ELEMENT(float, Param, param); - - if(m_State < WRITING) - { - GLResource res = GetResourceManager()->GetLiveResource(id); - glSamplerParameterf(res.name, PName, Param); - } - - return true; -} - -void WrappedOpenGL::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) -{ - m_Real.glSamplerParameterf(sampler, pname, param); - - if(m_State >= WRITING) - { - SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERF); - Serialise_glSamplerParameterf(sampler, pname, param); - - if(m_State == WRITING_IDLE) - GetResourceManager()->GetResourceRecord(SamplerRes(sampler))->AddChunk(scope.Get()); - else - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *params) -{ - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(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); - - if(m_State < WRITING) - { - GLResource res = GetResourceManager()->GetLiveResource(id); - glSamplerParameteriv(res.name, PName, Params); - } - - delete[] Params; - - return true; -} - -void WrappedOpenGL::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *params) -{ - m_Real.glSamplerParameteriv(sampler, pname, params); - - if(m_State >= WRITING) - { - SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERIV); - Serialise_glSamplerParameteriv(sampler, pname, params); - - if(m_State == WRITING_IDLE) - GetResourceManager()->GetResourceRecord(SamplerRes(sampler))->AddChunk(scope.Get()); - else - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *params) -{ - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(sampler))); - SERIALISE_ELEMENT(GLenum, PName, pname); - const size_t nParams = (PName == eGL_TEXTURE_BORDER_COLOR ? 4U : 1U); - SERIALISE_ELEMENT_ARR(float, Params, params, nParams); - - if(m_State < WRITING) - { - GLResource res = GetResourceManager()->GetLiveResource(id); - glSamplerParameterfv(res.name, PName, Params); - } - - delete[] Params; - - return true; -} - -void WrappedOpenGL::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *params) -{ - m_Real.glSamplerParameterfv(sampler, pname, params); - - if(m_State >= WRITING) - { - SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERFV); - Serialise_glSamplerParameterfv(sampler, pname, params); - - if(m_State == WRITING_IDLE) - GetResourceManager()->GetResourceRecord(SamplerRes(sampler))->AddChunk(scope.Get()); - else - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *params) -{ - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(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); - - if(m_State < WRITING) - { - GLResource res = GetResourceManager()->GetLiveResource(id); - glSamplerParameterIiv(res.name, PName, Params); - } - - delete[] Params; - - return true; -} - -void WrappedOpenGL::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *params) -{ - m_Real.glSamplerParameterIiv(sampler, pname, params); - - if(m_State >= WRITING) - { - SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERIIV); - Serialise_glSamplerParameterIiv(sampler, pname, params); - - if(m_State == WRITING_IDLE) - GetResourceManager()->GetResourceRecord(SamplerRes(sampler))->AddChunk(scope.Get()); - else - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *params) -{ - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(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); - - if(m_State < WRITING) - { - GLResource res = GetResourceManager()->GetLiveResource(id); - glSamplerParameterIuiv(res.name, PName, Params); - } - - delete[] Params; - - return true; -} - -void WrappedOpenGL::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *params) -{ - m_Real.glSamplerParameterIuiv(sampler, pname, params); - - if(m_State >= WRITING) - { - SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERIUIV); - Serialise_glSamplerParameterIuiv(sampler, pname, params); - - if(m_State == WRITING_IDLE) - GetResourceManager()->GetResourceRecord(SamplerRes(sampler))->AddChunk(scope.Get()); - else - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glPixelStorei(GLenum pname, GLint param) -{ - SERIALISE_ELEMENT(GLenum, PName, pname); - SERIALISE_ELEMENT(int32_t, Param, param); - - if(m_State < WRITING) - m_Real.glPixelStorei(PName, Param); - - return true; -} - -void WrappedOpenGL::glPixelStorei(GLenum pname, GLint param) -{ - m_Real.glPixelStorei(pname, param); - - RDCASSERT(m_TextureRecord[m_TextureUnit]); - { - SCOPED_SERIALISE_CONTEXT(PIXELSTORE); - Serialise_glPixelStorei(pname, param); - - m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); - } -} - -void WrappedOpenGL::glPixelStoref(GLenum pname, GLfloat param) -{ - glPixelStorei(pname, (GLint)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) -{ - m_Real.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); - - RDCUNIMPLEMENTED(); -} - -void WrappedOpenGL::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels) -{ - m_Real.glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels); - - RDCUNIMPLEMENTED(); -} - -void WrappedOpenGL::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *pixels) -{ - m_Real.glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, pixels); - - RDCUNIMPLEMENTED(); -} - -void WrappedOpenGL::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * pixels) -{ - m_Real.glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, pixels); - - RDCUNIMPLEMENTED(); -} - -void WrappedOpenGL::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * pixels) -{ - m_Real.glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, pixels); - - RDCUNIMPLEMENTED(); -} - -bool WrappedOpenGL::Serialise_glActiveTexture(GLenum texture) -{ - SERIALISE_ELEMENT(GLenum, Texture, texture); - - if(m_State < WRITING) - m_Real.glActiveTexture(Texture); - - return true; -} - -void WrappedOpenGL::glActiveTexture(GLenum texture) -{ - m_Real.glActiveTexture(texture); - - m_TextureUnit = texture-eGL_TEXTURE0; - - if(m_State == WRITING_CAPFRAME) - { - Chunk *chunk = NULL; - - { - SCOPED_SERIALISE_CONTEXT(ACTIVE_TEXTURE); - Serialise_glActiveTexture(texture); - - chunk = scope.Get(); - } - - m_ContextRecord->AddChunk(chunk); - } -} - -#pragma endregion - -#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); - - for(GLsizei i=0; i < n; i++) - { - GLResource res = FramebufferRes(framebuffers[i]); - ResourceId id = GetResourceManager()->RegisterResource(res); - - if(m_State >= WRITING) - { - 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 - { - GetResourceManager()->AddLiveResource(id, res); - } - } -} - -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); - - ResourceId curFrameBuffer; - - if(m_State == WRITING_IDLE) - { - if(target == eGL_DRAW_FRAMEBUFFER || target == eGL_FRAMEBUFFER) - { - if(m_DrawFramebufferRecord) - curFrameBuffer = m_DrawFramebufferRecord->GetResourceID(); - } - else - { - if(m_ReadFramebufferRecord) - curFrameBuffer = m_ReadFramebufferRecord->GetResourceID(); - } - } - - SERIALISE_ELEMENT(ResourceId, fbid, curFrameBuffer); - - if(m_State < WRITING) - { - if(m_State == READING) - { - if(fbid != ResourceId()) - { - GLResource res = GetResourceManager()->GetLiveResource(fbid); - m_Real.glBindFramebuffer(Target, res.name); - } - else - { - m_Real.glBindFramebuffer(Target, 0); - } - } - - 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) - { - 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_DrawFramebufferRecord->AddChunk(scope.Get()); - else - m_DeviceRecord->AddChunk(scope.Get()); - } - else - { - if(m_ReadFramebufferRecord) - m_ReadFramebufferRecord->AddChunk(scope.Get()); - else - m_DeviceRecord->AddChunk(scope.Get()); - } - } - else - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glReadBuffer(GLenum mode) -{ - SERIALISE_ELEMENT(GLenum, m, mode); - SERIALISE_ELEMENT(ResourceId, id, m_ReadFramebufferRecord ? m_ReadFramebufferRecord->GetResourceID() : ResourceId()); - - if(m_State < WRITING) - { - if(id != ResourceId()) - { - GLResource res = GetResourceManager()->GetLiveResource(id); - m_Real.glBindFramebuffer(eGL_READ_FRAMEBUFFER, res.name); - } - else - { - m_Real.glBindFramebuffer(eGL_READ_FRAMEBUFFER, 0); - } - - 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_glDrawBuffer(GLenum buf) -{ - SERIALISE_ELEMENT(GLenum, b, buf); - - if(m_State < WRITING) - { - m_Real.glDrawBuffer(b); - } - - return true; -} - -void WrappedOpenGL::glDrawBuffer(GLenum buf) -{ - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(DRAW_BUFFER); - Serialise_glDrawBuffer(buf); - - m_ContextRecord->AddChunk(scope.Get()); - } - - m_Real.glDrawBuffer(buf); -} - -bool WrappedOpenGL::Serialise_glDrawBuffers(GLsizei n, const GLenum *bufs) -{ - SERIALISE_ELEMENT(uint32_t, num, n); - SERIALISE_ELEMENT_ARR(GLenum, buffers, bufs, num); - - if(m_State < WRITING) - { - m_Real.glDrawBuffers(num, buffers); - } - - delete[] buffers; - - return true; -} - -void WrappedOpenGL::glDrawBuffers(GLsizei n, const GLenum *bufs) -{ - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(DRAW_BUFFERS); - Serialise_glDrawBuffers(n, bufs); - - m_ContextRecord->AddChunk(scope.Get()); - } - - m_Real.glDrawBuffers(n, bufs); -} - -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); - - for(GLsizei i=0; i < n; i++) - GetResourceManager()->UnregisterResource(FramebufferRes(framebuffers[i])); -} - -void WrappedOpenGL::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params) -{ - m_Real.glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); -} - -GLenum WrappedOpenGL::glCheckFramebufferStatus(GLenum target) -{ - return m_Real.glCheckFramebufferStatus(target); -} - -#pragma endregion - -#pragma region Shaders - -bool WrappedOpenGL::Serialise_glCreateShader(GLuint shader, GLenum type) -{ - SERIALISE_ELEMENT(GLenum, Type, type); - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ShaderRes(shader))); - - if(m_State == READING) - { - GLuint real = m_Real.glCreateShader(Type); - - GLResource res = ShaderRes(real); - - ResourceId liveId = GetResourceManager()->RegisterResource(res); - - m_Shaders[liveId].type = Type; - - if(m_State >= WRITING) - { - RDCUNIMPLEMENTED(); - } - else - { - GetResourceManager()->AddLiveResource(id, res); - } - } - - return true; -} - -GLuint WrappedOpenGL::glCreateShader(GLenum type) -{ - GLuint real = m_Real.glCreateShader(type); - - GLResource res = ShaderRes(real); - ResourceId id = GetResourceManager()->RegisterResource(res); - - if(m_State >= WRITING) - { - Chunk *chunk = NULL; - - { - SCOPED_SERIALISE_CONTEXT(CREATE_SHADER); - Serialise_glCreateShader(real, type); - - chunk = scope.Get(); - } - - GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id); - RDCASSERT(record); - - record->AddChunk(chunk); - } - else - { - GetResourceManager()->AddLiveResource(id, res); - } - - return real; -} - -bool WrappedOpenGL::Serialise_glShaderSource(GLuint shader, GLsizei count, const GLchar* const *source, const GLint *length) -{ - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ShaderRes(shader))); - SERIALISE_ELEMENT(uint32_t, Count, count); - - vector srcs; - - for(uint32_t i=0; i < Count; i++) - { - string s; - if(source) - s = length ? string(source[i], source[i] + length[i]) : string(source[i]); - - m_pSerialiser->SerialiseString("source", s); - - if(m_State == READING) - srcs.push_back(s); - } - - if(m_State == READING) - { - const char **strings = new const char*[srcs.size()]; - for(size_t i=0; i < srcs.size(); i++) - strings[i] = srcs[i].c_str(); - - ResourceId liveId = GetResourceManager()->GetLiveID(id); - - for(uint32_t i=0; i < Count; i++) - m_Shaders[liveId].sources.push_back(strings[i]); - - m_Real.glShaderSource(GetResourceManager()->GetLiveResource(id).name, Count, strings, NULL); - } - - return true; -} - -void WrappedOpenGL::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length) -{ - m_Real.glShaderSource(shader, count, string, length); - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ShaderRes(shader)); - RDCASSERT(record); - { - SCOPED_SERIALISE_CONTEXT(SHADERSOURCE); - Serialise_glShaderSource(shader, count, string, length); - - record->AddChunk(scope.Get()); - } - } -} - -bool WrappedOpenGL::Serialise_glCompileShader(GLuint shader) -{ - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ShaderRes(shader))); - - if(m_State == READING) - { - m_Real.glCompileShader(GetResourceManager()->GetLiveResource(id).name); - } - - return true; -} - -void WrappedOpenGL::glCompileShader(GLuint shader) -{ - m_Real.glCompileShader(shader); - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ShaderRes(shader)); - RDCASSERT(record); - { - SCOPED_SERIALISE_CONTEXT(COMPILESHADER); - Serialise_glCompileShader(shader); - - record->AddChunk(scope.Get()); - } - } -} - -void WrappedOpenGL::glReleaseShaderCompiler() -{ - m_Real.glReleaseShaderCompiler(); -} - -void WrappedOpenGL::glDeleteShader(GLuint shader) -{ - m_Real.glDeleteShader(shader); - - GetResourceManager()->UnregisterResource(ShaderRes(shader)); -} - -bool WrappedOpenGL::Serialise_glAttachShader(GLuint program, GLuint shader) -{ - SERIALISE_ELEMENT(ResourceId, progid, GetResourceManager()->GetID(ProgramRes(program))); - SERIALISE_ELEMENT(ResourceId, shadid, GetResourceManager()->GetID(ShaderRes(shader))); - - if(m_State == READING) - { - ResourceId liveProgId = GetResourceManager()->GetLiveID(progid); - ResourceId liveShadId = GetResourceManager()->GetLiveID(shadid); - - m_Programs[liveProgId].shaders.push_back(liveShadId); - - m_Real.glAttachShader(GetResourceManager()->GetLiveResource(progid).name, - GetResourceManager()->GetLiveResource(shadid).name); - } - - return true; -} - -void WrappedOpenGL::glAttachShader(GLuint program, GLuint shader) -{ - m_Real.glAttachShader(program, shader); - - if(m_State >= WRITING) - { - GLResourceRecord *progRecord = GetResourceManager()->GetResourceRecord(ProgramRes(program)); - GLResourceRecord *shadRecord = GetResourceManager()->GetResourceRecord(ShaderRes(shader)); - RDCASSERT(progRecord && shadRecord); - { - SCOPED_SERIALISE_CONTEXT(ATTACHSHADER); - Serialise_glAttachShader(program, shader); - - progRecord->AddParent(shadRecord); - progRecord->AddChunk(scope.Get()); - } - } -} - -bool WrappedOpenGL::Serialise_glDetachShader(GLuint program, GLuint shader) -{ - SERIALISE_ELEMENT(ResourceId, progid, GetResourceManager()->GetID(ProgramRes(program))); - SERIALISE_ELEMENT(ResourceId, shadid, GetResourceManager()->GetID(ShaderRes(shader))); - - if(m_State == READING) - { - ResourceId liveProgId = GetResourceManager()->GetLiveID(progid); - ResourceId liveShadId = GetResourceManager()->GetLiveID(shadid); - - if(!m_Programs[liveProgId].linked) - m_Programs[liveProgId].shaders.push_back(liveShadId); - - m_Real.glDetachShader(GetResourceManager()->GetLiveResource(progid).name, - GetResourceManager()->GetLiveResource(shadid).name); - } - - return true; -} - -void WrappedOpenGL::glDetachShader(GLuint program, GLuint shader) -{ - m_Real.glDetachShader(program, shader); - - if(m_State >= WRITING) - { - GLResourceRecord *progRecord = GetResourceManager()->GetResourceRecord(ProgramRes(program)); - RDCASSERT(progRecord); - { - SCOPED_SERIALISE_CONTEXT(DETACHSHADER); - Serialise_glDetachShader(program, shader); - - progRecord->AddChunk(scope.Get()); - } - } -} - -#pragma endregion - -#pragma region Programs - -bool WrappedOpenGL::Serialise_glCreateShaderProgramv(GLuint program, GLenum type, GLsizei count, const GLchar *const*strings) -{ - SERIALISE_ELEMENT(GLenum, Type, type); - SERIALISE_ELEMENT(int32_t, Count, count); - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(program))); - - vector src; - - for(int32_t i=0; i < Count; i++) - { - string s; - if(m_State >= WRITING) s = strings[i]; - m_pSerialiser->SerialiseString("Source", s); - if(m_State < WRITING) src.push_back(s); - } - - if(m_State == READING) - { - char **sources = new char*[Count]; - - for(int32_t i=0; i < Count; i++) - sources[i] = &src[i][0]; - - GLuint real = m_Real.glCreateShaderProgramv(Type, Count, sources); - - delete[] sources; - - GLResource res = ProgramRes(program); - - m_ResourceManager->RegisterResource(res); - GetResourceManager()->AddLiveResource(id, res); - } - - return true; -} - -GLuint WrappedOpenGL::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const*strings) -{ - GLuint real = m_Real.glCreateShaderProgramv(type, count, strings); - - GLResource res = ProgramRes(real); - ResourceId id = GetResourceManager()->RegisterResource(res); - - if(m_State >= WRITING) - { - Chunk *chunk = NULL; - - { - SCOPED_SERIALISE_CONTEXT(CREATE_SHADERPROGRAM); - Serialise_glCreateShaderProgramv(real, type, count, strings); - - chunk = scope.Get(); - } - - GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id); - RDCASSERT(record); - - record->AddChunk(chunk); - } - else - { - GetResourceManager()->AddLiveResource(id, res); - } - - return real; -} - -bool WrappedOpenGL::Serialise_glCreateProgram(GLuint program) -{ - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(program))); - - if(m_State == READING) - { - GLuint real = m_Real.glCreateProgram(); - - GLResource res = ProgramRes(real); - - m_ResourceManager->RegisterResource(res); - GetResourceManager()->AddLiveResource(id, res); - } - - return true; -} - -GLuint WrappedOpenGL::glCreateProgram() -{ - GLuint real = m_Real.glCreateProgram(); - - GLResource res = ProgramRes(real); - ResourceId id = GetResourceManager()->RegisterResource(res); - - if(m_State >= WRITING) - { - Chunk *chunk = NULL; - - { - SCOPED_SERIALISE_CONTEXT(CREATE_PROGRAM); - Serialise_glCreateProgram(real); - - chunk = scope.Get(); - } - - GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id); - RDCASSERT(record); - - record->AddChunk(chunk); - } - else - { - GetResourceManager()->AddLiveResource(id, res); - } - - return real; -} - -bool WrappedOpenGL::Serialise_glLinkProgram(GLuint program) -{ - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(program))); - - if(m_State == READING) - { - ResourceId progid = GetResourceManager()->GetLiveID(id); - - m_Programs[progid].linked = true; - - m_Real.glLinkProgram(GetResourceManager()->GetLiveResource(id).name); - } - - return true; -} - -void WrappedOpenGL::glLinkProgram(GLuint program) -{ - m_Real.glLinkProgram(program); - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program)); - RDCASSERT(record); - { - SCOPED_SERIALISE_CONTEXT(LINKPROGRAM); - Serialise_glLinkProgram(program); - - record->AddChunk(scope.Get()); - } - } -} - -bool WrappedOpenGL::Serialise_glProgramParameteri(GLuint program, GLenum pname, GLint value) -{ - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(program))); - SERIALISE_ELEMENT(GLenum, PName, pname); - SERIALISE_ELEMENT(int32_t, Value, value); - - if(m_State == READING) - { - m_Real.glProgramParameteri(GetResourceManager()->GetLiveResource(id).name, PName, Value); - } - - return true; -} - -void WrappedOpenGL::glProgramParameteri(GLuint program, GLenum pname, GLint value) -{ - m_Real.glProgramParameteri(program, pname, value); - - if(m_State >= WRITING) - { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program)); - RDCASSERT(record); - { - SCOPED_SERIALISE_CONTEXT(PROGRAMPARAMETER); - Serialise_glProgramParameteri(program, pname, value); - - record->AddChunk(scope.Get()); - } - } -} - -void WrappedOpenGL::glDeleteProgram(GLuint program) -{ - m_Real.glDeleteProgram(program); - - GetResourceManager()->UnregisterResource(ProgramRes(program)); -} - -bool WrappedOpenGL::Serialise_glUseProgram(GLuint program) -{ - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(program))); - - if(m_State <= EXECUTING) - { - m_Real.glUseProgram(GetResourceManager()->GetLiveResource(id).name); - } - - return true; -} - -void WrappedOpenGL::glUseProgram(GLuint program) -{ - m_Real.glUseProgram(program); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(USEPROGRAM); - Serialise_glUseProgram(program); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -void WrappedOpenGL::glValidateProgram(GLuint program) -{ - m_Real.glValidateProgram(program); -} - -void WrappedOpenGL::glValidateProgramPipeline(GLuint pipeline) -{ - m_Real.glValidateProgramPipeline(pipeline); -} - -#pragma endregion - -#pragma region Program Pipelines - -bool WrappedOpenGL::Serialise_glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program) -{ - SERIALISE_ELEMENT(ResourceId, pipe, GetResourceManager()->GetID(ProgramPipeRes(pipeline))); - SERIALISE_ELEMENT(uint32_t, Stages, stages); - SERIALISE_ELEMENT(ResourceId, prog, GetResourceManager()->GetID(ProgramRes(program))); - - if(m_State < WRITING) - { - m_Real.glUseProgramStages(GetResourceManager()->GetLiveResource(pipe).name, - stages, - GetResourceManager()->GetLiveResource(prog).name); - } - - return true; -} - -void WrappedOpenGL::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program) -{ - m_Real.glUseProgramStages(pipeline, stages, program); - - if(m_State > WRITING) - { - SCOPED_SERIALISE_CONTEXT(USE_PROGRAMSTAGES); - Serialise_glUseProgramStages(pipeline, stages, program); - - if(m_State == WRITING_CAPFRAME) - { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramPipeRes(pipeline)); - RDCASSERT(record); - record->AddChunk(scope.Get()); - - GLResourceRecord *progrecord = GetResourceManager()->GetResourceRecord(ProgramRes(program)); - record->AddParent(progrecord); - } - else - { - m_ContextRecord->AddChunk(scope.Get()); - } - } -} - -bool WrappedOpenGL::Serialise_glGenProgramPipelines(GLsizei n, GLuint* pipelines) -{ - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramPipeRes(*pipelines))); - - if(m_State == READING) - { - GLuint real = 0; - m_Real.glGenProgramPipelines(1, &real); - - GLResource res = ProgramPipeRes(real); - - ResourceId live = m_ResourceManager->RegisterResource(res); - GetResourceManager()->AddLiveResource(id, res); - } - - return true; -} - -void WrappedOpenGL::glGenProgramPipelines(GLsizei n, GLuint *pipelines) -{ - m_Real.glGenProgramPipelines(n, pipelines); - - for(GLsizei i=0; i < n; i++) - { - GLResource res = ProgramPipeRes(pipelines[i]); - ResourceId id = GetResourceManager()->RegisterResource(res); - - if(m_State >= WRITING) - { - Chunk *chunk = NULL; - - { - SCOPED_SERIALISE_CONTEXT(GEN_PROGRAMPIPE); - Serialise_glGenProgramPipelines(1, pipelines+i); - - chunk = scope.Get(); - } - - GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id); - RDCASSERT(record); - - record->AddChunk(chunk); - } - else - { - GetResourceManager()->AddLiveResource(id, res); - } - } -} - -bool WrappedOpenGL::Serialise_glBindProgramPipeline(GLuint pipeline) -{ - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramPipeRes(pipeline))); - - if(m_State <= EXECUTING) - { - m_Real.glBindProgramPipeline(GetResourceManager()->GetLiveResource(id).name); - } - - return true; -} - -void WrappedOpenGL::glBindProgramPipeline(GLuint pipeline) -{ - m_Real.glBindProgramPipeline(pipeline); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(BIND_PROGRAMPIPE); - Serialise_glBindProgramPipeline(pipeline); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -void WrappedOpenGL::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines) -{ - m_Real.glDeleteProgramPipelines(n, pipelines); - - for(GLsizei i=0; i < n; i++) - GetResourceManager()->UnregisterResource(ProgramPipeRes(pipelines[i])); -} - -#pragma endregion - -#pragma region Uniforms - -bool WrappedOpenGL::Serialise_glUniformMatrix(GLint location, GLsizei count, GLboolean transpose, const void *value, UniformType type) -{ - SERIALISE_ELEMENT(UniformType, Type, type); - SERIALISE_ELEMENT(int32_t, Loc, location); - SERIALISE_ELEMENT(uint32_t, Count, count); - SERIALISE_ELEMENT(uint8_t, Transpose, transpose); - - size_t elemsPerMat = 0; - - switch(Type) - { - case MAT4FV: elemsPerMat = 16; break; - default: - RDCERR("Unexpected uniform type to Serialise_glUniformMatrix: %d", Type); - } - - if(m_State >= WRITING) - { - m_pSerialiser->RawWriteBytes(value, sizeof(float)*elemsPerMat*Count); - } - else if(m_State <= EXECUTING) - { - value = m_pSerialiser->RawReadBytes(sizeof(float)*elemsPerMat*Count); - - switch(Type) - { - case MAT4FV: m_Real.glUniformMatrix4fv(Loc, Count, Transpose, (const GLfloat *)value); break; - default: - RDCERR("Unexpected uniform type to Serialise_glUniformMatrix: %d", Type); - } - } - - if(m_pSerialiser->GetDebugText()) - { - switch(Type) - { - case MAT4FV: - { - float *f = (float *)value; - if(Transpose) - { - m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[0], f[4], f[8], f[12]); - m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[1], f[5], f[9], f[13]); - m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[2], f[6], f[10], f[14]); - m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[3], f[7], f[11], f[15]); - } - else - { - m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[0], f[1], f[2], f[3]); - m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[4], f[5], f[6], f[7]); - m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[8], f[9], f[10], f[11]); - m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[12], f[13], f[14], f[15]); - } - break; - } - default: - RDCERR("Unexpected uniform type to Serialise_glUniformVector: %d", Type); - } - } - - return true; -} - -void WrappedOpenGL::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) -{ - m_Real.glUniformMatrix4fv(location, count, transpose, value); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(UNIFORM_MATRIX); - Serialise_glUniformMatrix(location, count, transpose, value, MAT4FV); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glUniformVector(GLint location, GLsizei count, const void *value, UniformType type) -{ - SERIALISE_ELEMENT(UniformType, Type, type); - SERIALISE_ELEMENT(int32_t, Loc, location); - SERIALISE_ELEMENT(uint32_t, Count, count); - - size_t elemsPerVec = 0; - - switch(Type) - { - case VEC1IV: - case VEC1UIV: - case VEC1FV: elemsPerVec = 1; break; - case VEC2FV: elemsPerVec = 2; break; - case VEC3FV: elemsPerVec = 3; break; - case VEC4FV: elemsPerVec = 4; break; - default: - RDCERR("Unexpected uniform type to Serialise_glUniformVector: %d", Type); - } - - if(m_State >= WRITING) - { - m_pSerialiser->RawWriteBytes(value, sizeof(float)*elemsPerVec*Count); - } - else if(m_State <= EXECUTING) - { - value = m_pSerialiser->RawReadBytes(sizeof(float)*elemsPerVec*Count); - - switch(Type) - { - case VEC1FV: m_Real.glUniform1fv(Loc, Count, (const GLfloat *)value); break; - case VEC1IV: m_Real.glUniform1iv(Loc, Count, (const GLint *)value); break; - case VEC1UIV: m_Real.glUniform1uiv(Loc, Count, (const GLuint *)value); break; - case VEC2FV: m_Real.glUniform2fv(Loc, Count, (const GLfloat *)value); break; - case VEC3FV: m_Real.glUniform3fv(Loc, Count, (const GLfloat *)value); break; - case VEC4FV: m_Real.glUniform4fv(Loc, Count, (const GLfloat *)value); break; - default: - RDCERR("Unexpected uniform type to Serialise_glUniformVector: %d", Type); - } - } - - if(m_pSerialiser->GetDebugText()) - { - switch(Type) - { - case VEC1FV: - { - float *f = (float *)value; - m_pSerialiser->DebugPrint("value: {%f}\n", f[0]); - break; - } - case VEC1IV: - { - int32_t *i = (int32_t *)value; - m_pSerialiser->DebugPrint("value: {%d}\n", i[0]); - break; - } - case VEC1UIV: - { - uint32_t *u = (uint32_t *)value; - m_pSerialiser->DebugPrint("value: {%u}\n", u[0]); - break; - } - case VEC2FV: - { - float *f = (float *)value; - m_pSerialiser->DebugPrint("value: {%f %f}\n", f[0], f[1]); - break; - } - case VEC3FV: - { - float *f = (float *)value; - m_pSerialiser->DebugPrint("value: {%f %f %f}\n", f[0], f[1], f[2]); - break; - } - case VEC4FV: - { - float *f = (float *)value; - m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[0], f[1], f[2], f[3]); - break; - } - default: - RDCERR("Unexpected uniform type to Serialise_glUniformVector: %d", Type); - } - } - - return true; -} - -void WrappedOpenGL::glUniform1f(GLint location, GLfloat value) -{ - m_Real.glUniform1f(location, value); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR); - Serialise_glUniformVector(location, 1, &value, VEC1FV); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -void WrappedOpenGL::glUniform1i(GLint location, GLint value) -{ - m_Real.glUniform1i(location, value); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR); - Serialise_glUniformVector(location, 1, &value, VEC1IV); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -void WrappedOpenGL::glUniform1ui(GLint location, GLuint value) -{ - m_Real.glUniform1ui(location, value); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR); - Serialise_glUniformVector(location, 1, &value, VEC1UIV); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -void WrappedOpenGL::glUniform1fv(GLint location, GLsizei count, const GLfloat *value) -{ - m_Real.glUniform1fv(location, count, value); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR); - Serialise_glUniformVector(location, count, value, VEC1FV); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -void WrappedOpenGL::glUniform1iv(GLint location, GLsizei count, const GLint *value) -{ - m_Real.glUniform1iv(location, count, value); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR); - Serialise_glUniformVector(location, count, value, VEC1IV); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -void WrappedOpenGL::glUniform1uiv(GLint location, GLsizei count, const GLuint *value) -{ - m_Real.glUniform1uiv(location, count, value); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR); - Serialise_glUniformVector(location, count, value, VEC1UIV); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -void WrappedOpenGL::glUniform2fv(GLint location, GLsizei count, const GLfloat *value) -{ - m_Real.glUniform2fv(location, count, value); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR); - Serialise_glUniformVector(location, count, value, VEC2FV); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -void WrappedOpenGL::glUniform3fv(GLint location, GLsizei count, const GLfloat *value) -{ - m_Real.glUniform3fv(location, count, value); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR); - Serialise_glUniformVector(location, count, value, VEC3FV); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -void WrappedOpenGL::glUniform4fv(GLint location, GLsizei count, const GLfloat *value) -{ - m_Real.glUniform4fv(location, count, value); - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR); - Serialise_glUniformVector(location, count, value, VEC4FV); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glProgramUniformVector(GLuint program, GLint location, GLsizei count, const void *value, UniformType type) -{ - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(program))); - SERIALISE_ELEMENT(UniformType, Type, type); - SERIALISE_ELEMENT(int32_t, Loc, location); - SERIALISE_ELEMENT(uint32_t, Count, count); - - size_t elemsPerVec = 0; - - switch(Type) - { - case VEC1IV: - case VEC1UIV: - case VEC1FV: elemsPerVec = 1; break; - case VEC2FV: elemsPerVec = 2; break; - case VEC3FV: elemsPerVec = 3; break; - case VEC4FV: elemsPerVec = 4; break; - default: - RDCERR("Unexpected uniform type to Serialise_glProgramUniformVector: %d", Type); - } - - if(m_State >= WRITING) - { - m_pSerialiser->RawWriteBytes(value, sizeof(float)*elemsPerVec*Count); - } - else if(m_State <= EXECUTING) - { - value = m_pSerialiser->RawReadBytes(sizeof(float)*elemsPerVec*Count); - - GLuint live = GetResourceManager()->GetLiveResource(id).name; - - switch(Type) - { - case VEC1IV: m_Real.glProgramUniform1iv(live, Loc, Count, (const GLint *)value); break; - case VEC1UIV: m_Real.glProgramUniform1uiv(live, Loc, Count, (const GLuint *)value); break; - case VEC1FV: m_Real.glProgramUniform1fv(live, Loc, Count, (const GLfloat *)value); break; - case VEC2FV: m_Real.glProgramUniform2fv(live, Loc, Count, (const GLfloat *)value); break; - case VEC3FV: m_Real.glProgramUniform3fv(live, Loc, Count, (const GLfloat *)value); break; - case VEC4FV: m_Real.glProgramUniform4fv(live, Loc, Count, (const GLfloat *)value); break; - default: - RDCERR("Unexpected uniform type to Serialise_glProgramUniformVector: %d", Type); - } - } - - if(m_pSerialiser->GetDebugText()) - { - switch(Type) - { - case VEC1FV: - { - float *f = (float *)value; - m_pSerialiser->DebugPrint("value: {%f}\n", f[0]); - break; - } - case VEC1IV: - { - int32_t *i = (int32_t *)value; - m_pSerialiser->DebugPrint("value: {%d}\n", i[0]); - break; - } - case VEC1UIV: - { - uint32_t *u = (uint32_t *)value; - m_pSerialiser->DebugPrint("value: {%u}\n", u[0]); - break; - } - case VEC2FV: - { - float *f = (float *)value; - m_pSerialiser->DebugPrint("value: {%f %f}\n", f[0], f[1]); - break; - } - case VEC3FV: - { - float *f = (float *)value; - m_pSerialiser->DebugPrint("value: {%f %f %f}\n", f[0], f[1], f[2]); - break; - } - case VEC4FV: - { - float *f = (float *)value; - m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[0], f[1], f[2], f[3]); - break; - } - default: - RDCERR("Unexpected uniform type to Serialise_glProgramUniformVector: %d", Type); - } - } - - return true; -} - -void WrappedOpenGL::glProgramUniform1i(GLuint program, GLint location, GLint v0) -{ - m_Real.glProgramUniform1i(program, location, v0); - - if(m_State > WRITING) - { - SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR); - Serialise_glProgramUniformVector(program, location, 1, &v0, VEC1IV); - - if(m_State == WRITING_CAPFRAME) - { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program)); - RDCASSERT(record); - record->AddChunk(scope.Get()); - } - else - { - m_ContextRecord->AddChunk(scope.Get()); - } - } -} - -void WrappedOpenGL::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value) -{ - m_Real.glProgramUniform1iv(program, location, count, value); - - if(m_State > WRITING) - { - SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR); - Serialise_glProgramUniformVector(program, location, count, value, VEC1IV); - - if(m_State == WRITING_CAPFRAME) - { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program)); - RDCASSERT(record); - record->AddChunk(scope.Get()); - } - else - { - m_ContextRecord->AddChunk(scope.Get()); - } - } -} - -void WrappedOpenGL::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value) -{ - m_Real.glProgramUniform1fv(program, location, count, value); - - if(m_State > WRITING) - { - SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR); - Serialise_glProgramUniformVector(program, location, count, value, VEC1FV); - - if(m_State == WRITING_CAPFRAME) - { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program)); - RDCASSERT(record); - record->AddChunk(scope.Get()); - } - else - { - m_ContextRecord->AddChunk(scope.Get()); - } - } -} - -void WrappedOpenGL::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value) -{ - m_Real.glProgramUniform1uiv(program, location, count, value); - - if(m_State > WRITING) - { - SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR); - Serialise_glProgramUniformVector(program, location, count, value, VEC1UIV); - - if(m_State == WRITING_CAPFRAME) - { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program)); - RDCASSERT(record); - record->AddChunk(scope.Get()); - } - else - { - m_ContextRecord->AddChunk(scope.Get()); - } - } -} - -void WrappedOpenGL::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value) -{ - m_Real.glProgramUniform2fv(program, location, count, value); - - if(m_State > WRITING) - { - SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR); - Serialise_glProgramUniformVector(program, location, count, value, VEC2FV); - - if(m_State == WRITING_CAPFRAME) - { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program)); - RDCASSERT(record); - record->AddChunk(scope.Get()); - } - else - { - m_ContextRecord->AddChunk(scope.Get()); - } - } -} - -void WrappedOpenGL::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value) -{ - m_Real.glProgramUniform3fv(program, location, count, value); - - if(m_State > WRITING) - { - SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR); - Serialise_glProgramUniformVector(program, location, count, value, VEC3FV); - - if(m_State == WRITING_CAPFRAME) - { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program)); - RDCASSERT(record); - record->AddChunk(scope.Get()); - } - else - { - m_ContextRecord->AddChunk(scope.Get()); - } - } -} - -void WrappedOpenGL::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value) -{ - m_Real.glProgramUniform4fv(program, location, count, value); - - if(m_State > WRITING) - { - SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR); - Serialise_glProgramUniformVector(program, location, count, value, VEC4FV); - - if(m_State == WRITING_CAPFRAME) - { - GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program)); - RDCASSERT(record); - record->AddChunk(scope.Get()); - } - else - { - m_ContextRecord->AddChunk(scope.Get()); - } - } -} - -#pragma endregion - -#pragma region Buffers - -bool WrappedOpenGL::Serialise_glGenBuffers(GLsizei n, GLuint* textures) -{ - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(BufferRes(*textures))); - - if(m_State == READING) - { - GLuint real = 0; - m_Real.glGenBuffers(1, &real); - - GLResource res = BufferRes(real); - - ResourceId live = m_ResourceManager->RegisterResource(res); - GetResourceManager()->AddLiveResource(id, res); - - m_Buffers[live].resource = res; - m_Buffers[live].curType = eGL_UNKNOWN_ENUM; - } - - return true; -} - -void WrappedOpenGL::glGenBuffers(GLsizei n, GLuint *buffers) -{ - m_Real.glGenBuffers(n, buffers); - - for(GLsizei i=0; i < n; i++) - { - GLResource res = BufferRes(buffers[i]); - ResourceId id = GetResourceManager()->RegisterResource(res); - - if(m_State >= WRITING) - { - Chunk *chunk = NULL; - - { - SCOPED_SERIALISE_CONTEXT(GEN_BUFFER); - Serialise_glGenBuffers(1, buffers+i); - - chunk = scope.Get(); - } - - GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id); - RDCASSERT(record); - - record->AddChunk(chunk); - } - else - { - GetResourceManager()->AddLiveResource(id, res); - } - } -} - -size_t WrappedOpenGL::BufferIdx(GLenum buf) -{ - switch(buf) - { - case eGL_ARRAY_BUFFER: return 0; - case eGL_ATOMIC_COUNTER_BUFFER: return 1; - case eGL_COPY_READ_BUFFER: return 2; - case eGL_COPY_WRITE_BUFFER: return 3; - case eGL_DRAW_INDIRECT_BUFFER: return 4; - case eGL_DISPATCH_INDIRECT_BUFFER: return 5; - case eGL_ELEMENT_ARRAY_BUFFER: return 6; - case eGL_PIXEL_PACK_BUFFER: return 7; - case eGL_PIXEL_UNPACK_BUFFER: return 8; - case eGL_QUERY_BUFFER: return 9; - case eGL_SHADER_STORAGE_BUFFER: return 10; - case eGL_TEXTURE_BUFFER: return 11; - case eGL_TRANSFORM_FEEDBACK_BUFFER: return 12; - case eGL_UNIFORM_BUFFER: return 13; - default: - RDCERR("Unexpected enum as buffer target: %hs", ToStr::Get(buf).c_str()); - } - - return 0; -} - -bool WrappedOpenGL::Serialise_glBindBuffer(GLenum target, GLuint buffer) -{ - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(ResourceId, Id, GetResourceManager()->GetID(BufferRes(buffer))); - - if(m_State >= WRITING) - { - size_t idx = BufferIdx(target); - - m_BufferRecord[idx]->datatype = Target; - } - else if(m_State < WRITING) - { - GLResource res = GetResourceManager()->GetLiveResource(Id); - m_Real.glBindBuffer(Target, res.name); - - m_Buffers[GetResourceManager()->GetLiveID(Id)].curType = Target; - } - - return true; -} - -void WrappedOpenGL::glBindBuffer(GLenum target, GLuint buffer) -{ - m_Real.glBindBuffer(target, buffer); - - if(m_State == WRITING_CAPFRAME) - { - Chunk *chunk = NULL; - - { - SCOPED_SERIALISE_CONTEXT(BIND_BUFFER); - Serialise_glBindBuffer(target, buffer); - - chunk = scope.Get(); - } - - m_ContextRecord->AddChunk(chunk); - } - - size_t idx = BufferIdx(target); - - if(buffer == 0) - { - m_BufferRecord[idx] = NULL; - return; - } - - if(m_State >= WRITING) - { - GLResourceRecord *r = m_BufferRecord[idx] = GetResourceManager()->GetResourceRecord(BufferRes(buffer)); - - // it's legal to re-type buffers, generate another BindBuffer chunk to rename - if(r->datatype != target) - { - Chunk *chunk = NULL; - - { - SCOPED_SERIALISE_CONTEXT(BIND_BUFFER); - Serialise_glBindBuffer(target, buffer); - - chunk = scope.Get(); - } - - r->AddChunk(chunk); - } - } -} - -bool WrappedOpenGL::Serialise_glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage) -{ - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(uint64_t, Bytesize, (uint64_t)size); - - byte *dummy = NULL; - - if(m_State >= WRITING && data == NULL) - { - dummy = new byte[size]; - data = dummy; - } - - SERIALISE_ELEMENT_BUF(byte *, bytes, data, (size_t)Bytesize); - - uint64_t offs = m_pSerialiser->GetOffset(); - - SERIALISE_ELEMENT(GLenum, Usage, usage); - SERIALISE_ELEMENT(ResourceId, id, m_BufferRecord[BufferIdx(target)]->GetResourceID()); - - if(m_State == READING) - { - GLResource res = GetResourceManager()->GetLiveResource(id); - m_Real.glBindBuffer(Target, res.name); - m_Real.glBufferData(Target, (GLsizeiptr)Bytesize, bytes, Usage); - - m_Buffers[GetResourceManager()->GetLiveID(id)].size = Bytesize; - - SAFE_DELETE_ARRAY(bytes); - } - else if(m_State >= WRITING) - { - m_BufferRecord[BufferIdx(target)]->SetDataOffset(offs - Bytesize); - } - - if(dummy) - delete[] dummy; - - return true; -} - -void WrappedOpenGL::glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage) -{ - m_Real.glBufferData(target, size, data, usage); - - size_t idx = BufferIdx(target); - - if(m_State >= WRITING) - { - RDCASSERT(m_BufferRecord[idx]); - - SCOPED_SERIALISE_CONTEXT(BUFFERDATA); - Serialise_glBufferData(target, size, data, usage); - - Chunk *chunk = scope.Get(); - - m_BufferRecord[idx]->AddChunk(chunk); - m_BufferRecord[idx]->SetDataPtr(chunk->GetData()); - m_BufferRecord[idx]->Length = (int32_t)size; - } -} - -bool WrappedOpenGL::Serialise_glBindBufferBase(GLenum target, GLuint index, GLuint buffer) -{ - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(uint32_t, Index, index); - SERIALISE_ELEMENT(ResourceId, id, m_BufferRecord[BufferIdx(target)]->GetResourceID()); - - if(m_State < WRITING) - { - GLResource res = GetResourceManager()->GetLiveResource(id); - m_Real.glBindBufferBase(Target, Index, res.name); - } - - return true; -} - -void WrappedOpenGL::glBindBufferBase(GLenum target, GLuint index, GLuint buffer) -{ - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(BIND_BUFFER_BASE); - Serialise_glBindBufferBase(target, index, buffer); - - m_ContextRecord->AddChunk(scope.Get()); - } - - m_Real.glBindBufferBase(target, index, buffer); -} - -bool WrappedOpenGL::Serialise_glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) -{ - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(uint32_t, Index, index); - SERIALISE_ELEMENT(ResourceId, id, m_BufferRecord[BufferIdx(target)]->GetResourceID()); - SERIALISE_ELEMENT(uint64_t, Offset, (uint64_t)offset); - SERIALISE_ELEMENT(uint64_t, Size, (uint64_t)size); - - if(m_State < WRITING) - { - GLResource res = GetResourceManager()->GetLiveResource(id); - m_Real.glBindBufferRange(Target, Index, res.name, (GLintptr)Offset, (GLsizeiptr)Size); - } - - return true; -} - -void WrappedOpenGL::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) -{ - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(BIND_BUFFER_RANGE); - Serialise_glBindBufferRange(target, index, buffer, offset, size); - - m_ContextRecord->AddChunk(scope.Get()); - } - - m_Real.glBindBufferRange(target, index, buffer, offset, size); -} - -void *WrappedOpenGL::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) -{ - if(m_State >= WRITING) - { - // haven't implemented non-invalidating write maps - if((access & (GL_MAP_INVALIDATE_BUFFER_BIT|GL_MAP_INVALIDATE_RANGE_BIT|GL_MAP_READ_BIT)) == 0) - RDCUNIMPLEMENTED(); - - // haven't implemented coherent/persistent bits - if((access & (GL_MAP_COHERENT_BIT|GL_MAP_PERSISTENT_BIT)) != 0) - RDCUNIMPLEMENTED(); - - m_BufferRecord[BufferIdx(target)]->Map.offset = offset; - m_BufferRecord[BufferIdx(target)]->Map.length = length; - m_BufferRecord[BufferIdx(target)]->Map.access = access; - - if((access & GL_MAP_READ_BIT) != 0) - { - byte *ptr = m_BufferRecord[BufferIdx(target)]->GetDataPtr(); - - if(ptr == NULL) - { - RDCWARN("Mapping buffer that hasn't been allocated"); - - m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Mapped_Read_Real; - return m_Real.glMapBufferRange(target, offset, length, access); - } - - ptr += offset; - - m_Real.glGetBufferSubData(target, offset, length, ptr); - - m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Mapped_Read; - - return ptr; - } - - byte *ptr = m_BufferRecord[BufferIdx(target)]->GetDataPtr(); - - if(ptr == NULL) - { - RDCWARN("Mapping buffer that hasn't been allocated"); - - ptr = (byte *)m_Real.glMapBufferRange(target, offset, length, access); - - m_BufferRecord[BufferIdx(target)]->Map.ptr = ptr; - m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Mapped_Write_Real; - } - else - { - if(m_State == WRITING_CAPFRAME) - { - ptr = new byte[length]; - - m_BufferRecord[BufferIdx(target)]->Map.ptr = ptr; - m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Mapped_Write_Alloc; - } - else - { - ptr += offset; - - m_BufferRecord[BufferIdx(target)]->Map.ptr = ptr; - m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Mapped_Write; - } - } - - return ptr; - } - - return m_Real.glMapBufferRange(target, offset, length, access); -} - -bool WrappedOpenGL::Serialise_glUnmapBuffer(GLenum target) -{ - GLResourceRecord *record = NULL; - - if(m_State >= WRITING) - record = m_BufferRecord[BufferIdx(target)]; - - SERIALISE_ELEMENT(GLenum, Target, target); - SERIALISE_ELEMENT(ResourceId, bufID, record->GetResourceID()); - SERIALISE_ELEMENT(uint64_t, offs, record->Map.offset); - SERIALISE_ELEMENT(uint64_t, len, record->Map.length); - - uint64_t bufBindStart = 0; - - if(m_State >= WRITING) - { - if(Target == eGL_ATOMIC_COUNTER_BUFFER) - m_Real.glGetInteger64i_v(eGL_ATOMIC_COUNTER_BUFFER_START, 0, (GLint64 *)&bufBindStart); - if(Target == eGL_SHADER_STORAGE_BUFFER) - m_Real.glGetInteger64i_v(eGL_SHADER_STORAGE_BUFFER_START, 0, (GLint64 *)&bufBindStart); - if(Target == eGL_TRANSFORM_FEEDBACK_BUFFER) - m_Real.glGetInteger64i_v(eGL_TRANSFORM_FEEDBACK_BUFFER_START, 0, (GLint64 *)&bufBindStart); - if(Target == eGL_UNIFORM_BUFFER) - m_Real.glGetInteger64i_v(eGL_UNIFORM_BUFFER_START, 0, (GLint64 *)&bufBindStart); - } - - SERIALISE_ELEMENT(uint64_t, bufOffs, bufBindStart); - - SERIALISE_ELEMENT_BUF(byte *, data, record->Map.ptr, (size_t)len); - - if(m_State < WRITING || - (m_State >= WRITING && - (record->Map.status == GLResourceRecord::Mapped_Write || record->Map.status == GLResourceRecord::Mapped_Write_Alloc) - ) - ) - { - GLuint oldBuf = 0; - GLuint64 oldBufBase = 0; - GLuint64 oldBufSize = 0; - - if(m_State == READING) - { - GLResource res = GetResourceManager()->GetLiveResource(bufID); - m_Real.glGetIntegeri_v(eGL_UNIFORM_BUFFER_BINDING, 0, (GLint *)&oldBuf); - m_Real.glGetInteger64i_v(eGL_UNIFORM_BUFFER_START, 0, (GLint64 *)&oldBufBase); - m_Real.glGetInteger64i_v(eGL_UNIFORM_BUFFER_SIZE, 0, (GLint64 *)&oldBufSize); - m_Real.glBindBufferRange(eGL_UNIFORM_BUFFER, 0, res.name, (GLintptr)bufOffs, (GLsizeiptr)len); - } - - void *ptr = m_Real.glMapBufferRange(Target, (GLintptr)offs, (GLsizeiptr)len, GL_MAP_WRITE_BIT); - memcpy(ptr, data, (size_t)len); - m_Real.glUnmapBuffer(Target); - - if(m_State == READING) - { - if(oldBufBase == 0 && oldBufSize == 0) - m_Real.glBindBufferBase(eGL_UNIFORM_BUFFER, 0, oldBuf); - else - m_Real.glBindBufferRange(eGL_UNIFORM_BUFFER, 0, oldBuf, (GLintptr)oldBufBase, (GLsizeiptr)oldBufSize); - } - } - - if(m_State < WRITING) - delete[] data; - - return true; -} - -GLboolean WrappedOpenGL::glUnmapBuffer(GLenum target) -{ - if(m_State >= WRITING) - { - RDCASSERT(m_BufferRecord[BufferIdx(target)]); - - auto status = m_BufferRecord[BufferIdx(target)]->Map.status; - - GLboolean ret = GL_TRUE; - - switch(status) - { - case GLResourceRecord::Unmapped: - RDCERR("Unmapped buffer being passed to glUnmapBuffer"); - break; - case GLResourceRecord::Mapped_Read: - // can ignore - break; - case GLResourceRecord::Mapped_Read_Real: - // need to do real unmap - ret = m_Real.glUnmapBuffer(target); - break; - case GLResourceRecord::Mapped_Write: - { - if(m_State == WRITING_CAPFRAME) - RDCWARN("Failed to cap frame - uncapped Map/Unmap"); - - SCOPED_SERIALISE_CONTEXT(UNMAP); - Serialise_glUnmapBuffer(target); - - if(m_State == WRITING_CAPFRAME) - m_ContextRecord->AddChunk(scope.Get()); - else - m_BufferRecord[BufferIdx(target)]->AddChunk(scope.Get()); - - break; - } - case GLResourceRecord::Mapped_Write_Alloc: - { - SCOPED_SERIALISE_CONTEXT(UNMAP); - Serialise_glUnmapBuffer(target); - - if(m_State == WRITING_CAPFRAME) - m_ContextRecord->AddChunk(scope.Get()); - - delete[] m_BufferRecord[BufferIdx(target)]->Map.ptr; - - break; - } - case GLResourceRecord::Mapped_Write_Real: - RDCWARN("Throwing away map contents as we don't have datastore allocated"); - RDCWARN("Could init chunk here using known data (although maybe it's only partial)"); - ret = m_Real.glUnmapBuffer(target); - break; - } - - m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Unmapped; - - return ret; - } - - return m_Real.glUnmapBuffer(target); -} - -bool WrappedOpenGL::Serialise_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) -{ - SERIALISE_ELEMENT(uint32_t, Index, index); - SERIALISE_ELEMENT(int32_t, Size, size); - SERIALISE_ELEMENT(GLenum, Type, type); - SERIALISE_ELEMENT(uint8_t, Norm, normalized); - SERIALISE_ELEMENT(uint32_t, Stride, stride); - SERIALISE_ELEMENT(uint64_t, Offset, (uint64_t)pointer); - SERIALISE_ELEMENT(ResourceId, id, m_VertexArrayRecord ? m_VertexArrayRecord->GetResourceID() : ResourceId()); - - if(m_State < WRITING) - { - if(id != ResourceId()) - { - GLResource res = GetResourceManager()->GetLiveResource(id); - m_Real.glBindVertexArray(res.name); - } - else - { - m_Real.glBindVertexArray(0); - } - - m_Real.glVertexAttribPointer(Index, Size, Type, Norm, Stride, (const void *)Offset); - } - - return true; -} - -void WrappedOpenGL::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) -{ - m_Real.glVertexAttribPointer(index, size, type, normalized, stride, pointer); - - GLResourceRecord *r = m_VertexArrayRecord ? m_VertexArrayRecord : m_DeviceRecord; - if(m_State >= WRITING) - { - RDCASSERT(r); - - SCOPED_SERIALISE_CONTEXT(VERTEXATTRIBPOINTER); - Serialise_glVertexAttribPointer(index, size, type, normalized, stride, pointer); - - r->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glEnableVertexAttribArray(GLuint index) -{ - SERIALISE_ELEMENT(uint32_t, Index, index); - SERIALISE_ELEMENT(ResourceId, id, m_VertexArrayRecord ? m_VertexArrayRecord->GetResourceID() : ResourceId()); - - if(m_State < WRITING) - { - if(id != ResourceId()) - { - GLResource res = GetResourceManager()->GetLiveResource(id); - m_Real.glBindVertexArray(res.name); - } - else - { - m_Real.glBindVertexArray(0); - } - - m_Real.glEnableVertexAttribArray(Index); - } - return true; -} - -void WrappedOpenGL::glEnableVertexAttribArray(GLuint index) -{ - m_Real.glEnableVertexAttribArray(index); - - GLResourceRecord *r = m_VertexArrayRecord ? m_VertexArrayRecord : m_DeviceRecord; - if(m_State >= WRITING) - { - RDCASSERT(r); - - SCOPED_SERIALISE_CONTEXT(ENABLEVERTEXATTRIBARRAY); - Serialise_glEnableVertexAttribArray(index); - - r->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glDisableVertexAttribArray(GLuint index) -{ - SERIALISE_ELEMENT(uint32_t, Index, index); - SERIALISE_ELEMENT(ResourceId, id, m_VertexArrayRecord ? m_VertexArrayRecord->GetResourceID() : ResourceId()); - - if(m_State < WRITING) - { - if(id != ResourceId()) - { - GLResource res = GetResourceManager()->GetLiveResource(id); - m_Real.glBindVertexArray(res.name); - } - else - { - m_Real.glBindVertexArray(0); - } - - m_Real.glDisableVertexAttribArray(Index); - } - return true; -} - -void WrappedOpenGL::glDisableVertexAttribArray(GLuint index) -{ - m_Real.glDisableVertexAttribArray(index); - - GLResourceRecord *r = m_VertexArrayRecord ? m_VertexArrayRecord : m_DeviceRecord; - RDCASSERT(r); - if(m_State >= WRITING) - { - SCOPED_SERIALISE_CONTEXT(DISABLEVERTEXATTRIBARRAY); - Serialise_glDisableVertexAttribArray(index); - - r->AddChunk(scope.Get()); - } -} - -bool WrappedOpenGL::Serialise_glGenVertexArrays(GLsizei n, GLuint* arrays) -{ - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(VertexArrayRes(*arrays))); - - if(m_State == READING) - { - GLuint real = 0; - m_Real.glGenVertexArrays(1, &real); - - GLResource res = VertexArrayRes(real); - - m_ResourceManager->RegisterResource(res); - GetResourceManager()->AddLiveResource(id, res); - } - - return true; -} - -void WrappedOpenGL::glGenVertexArrays(GLsizei n, GLuint *arrays) -{ - m_Real.glGenVertexArrays(n, arrays); - - for(GLsizei i=0; i < n; i++) - { - GLResource res = VertexArrayRes(arrays[i]); - ResourceId id = GetResourceManager()->RegisterResource(res); - - if(m_State >= WRITING) - { - Chunk *chunk = NULL; - - { - SCOPED_SERIALISE_CONTEXT(GEN_VERTEXARRAY); - Serialise_glGenVertexArrays(1, arrays+i); - - chunk = scope.Get(); - } - - GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id); - RDCASSERT(record); - - record->AddChunk(chunk); - } - else - { - GetResourceManager()->AddLiveResource(id, res); - } - } -} - -bool WrappedOpenGL::Serialise_glBindVertexArray(GLuint array) -{ - SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(VertexArrayRes(array))); - - if(m_State <= EXECUTING) - { - m_Real.glBindVertexArray(GetResourceManager()->GetLiveResource(id).name); - } - - return true; -} - -void WrappedOpenGL::glBindVertexArray(GLuint array) -{ - m_Real.glBindVertexArray(array); - - if(m_State >= WRITING) - { - if(array == 0) - { - m_VertexArrayRecord = NULL; - } - else - { - m_VertexArrayRecord = GetResourceManager()->GetResourceRecord(VertexArrayRes(array)); - } - } - - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(BINDVERTEXARRAY); - Serialise_glBindVertexArray(array); - - m_ContextRecord->AddChunk(scope.Get()); - } -} - -void WrappedOpenGL::glDeleteBuffers(GLsizei n, const GLuint *buffers) -{ - m_Real.glDeleteBuffers(n, buffers); - - for(GLsizei i=0; i < n; i++) - GetResourceManager()->UnregisterResource(BufferRes(buffers[i])); -} - -void WrappedOpenGL::glDeleteVertexArrays(GLsizei n, const GLuint *arrays) -{ - m_Real.glDeleteVertexArrays(n, arrays); - - for(GLsizei i=0; i < n; i++) - GetResourceManager()->UnregisterResource(VertexArrayRes(arrays[i])); -} - -#pragma endregion diff --git a/renderdoc/driver/gl/gl_driver.cpp b/renderdoc/driver/gl/gl_driver.cpp index b25ea58c8..93000255e 100644 --- a/renderdoc/driver/gl/gl_driver.cpp +++ b/renderdoc/driver/gl/gl_driver.cpp @@ -72,27 +72,6 @@ const char *GLChunkNames[] = "glUseProgramStages", "glBindProgramPipeline", - // legacy/immediate mode chunks - "glLightfv", - "glMaterialfv", - "glGenLists", - "glNewList", - "glEndList", - "glCallList", - "glShadeModel", - "glBegin", - "glEnd", - "glVertex3f", - "glNormal3f", - "glPushMatrix", - "glPopMatrix", - "glMatrixMode", - "glLoadIdentity", - "glFrustum", - "glTranslatef", - "glRotatef", - // - "glClearColor", "glClearDepth", "glClear", @@ -820,108 +799,6 @@ void WrappedOpenGL::DebugSnoop(GLenum source, GLenum type, GLuint id, GLenum sev m_RealDebugFunc(source, type, id, severity, length, message, m_RealDebugFuncParam); } -void WrappedOpenGL::glDebugMessageCallback(GLDEBUGPROC callback, const void *userParam) -{ - m_RealDebugFunc = callback; - m_RealDebugFuncParam = userParam; - - m_Real.glDebugMessageCallback(&DebugSnoopStatic, this); -} - -void WrappedOpenGL::glDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled) -{ - // we could exert control over debug messages here - m_Real.glDebugMessageControl(source, type, severity, count, ids, enabled); -} - -bool WrappedOpenGL::Serialise_glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf) -{ - wstring name = buf ? widen(string(buf, buf+length)) : L""; - - m_pSerialiser->Serialise("Name", name); - - if(m_State == READING) - { - FetchDrawcall draw; - draw.name = name; - draw.flags |= eDraw_SetMarker; - - AddDrawcall(draw, false); - } - - return true; -} - -void WrappedOpenGL::glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf) -{ - if(m_State == WRITING_CAPFRAME && type == eGL_DEBUG_TYPE_MARKER) - { - SCOPED_SERIALISE_CONTEXT(SET_MARKER); - Serialise_glDebugMessageInsert(source, type, id, severity, length, buf); - - m_ContextRecord->AddChunk(scope.Get()); - } - - m_Real.glDebugMessageInsert(source, type, id, severity, length, buf); -} - -bool WrappedOpenGL::Serialise_glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message) -{ - wstring name = message ? widen(string(message, message+length)) : L""; - - m_pSerialiser->Serialise("Name", name); - - if(m_State == READING) - { - FetchDrawcall draw; - draw.name = name; - draw.flags |= eDraw_PushMarker; - - AddDrawcall(draw, false); - } - - return true; -} - -void WrappedOpenGL::glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message) -{ - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(BEGIN_EVENT); - Serialise_glPushDebugGroup(source, id, length, message); - - m_ContextRecord->AddChunk(scope.Get()); - } - - m_Real.glPushDebugGroup(source, id, length, message); -} - -bool WrappedOpenGL::Serialise_glPopDebugGroup() -{ - if(m_State == READING && !m_CurEvents.empty()) - { - FetchDrawcall draw; - draw.name = L"API Calls"; - draw.flags |= eDraw_SetMarker; - - AddDrawcall(draw, true); - } - - return true; -} -void WrappedOpenGL::glPopDebugGroup() -{ - if(m_State == WRITING_CAPFRAME) - { - SCOPED_SERIALISE_CONTEXT(END_EVENT); - Serialise_glPopDebugGroup(); - - m_ContextRecord->AddChunk(scope.Get()); - } - - m_Real.glPopDebugGroup(); -} - void WrappedOpenGL::ReadLogInitialisation() { uint64_t lastFrame = 0; @@ -1121,63 +998,6 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) Serialise_glBindProgramPipeline(0); break; - // legacy/immediate mode chunks - case LIGHTFV: - Serialise_glLightfv(eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, NULL); - break; - case MATERIALFV: - Serialise_glMaterialfv(eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM, NULL); - break; - case GENLISTS: - Serialise_glGenLists(0); - break; - case NEWLIST: - Serialise_glNewList(0, eGL_UNKNOWN_ENUM); - break; - case ENDLIST: - Serialise_glEndList(); - break; - case CALLLIST: - Serialise_glCallList(0); - break; - case SHADEMODEL: - Serialise_glShadeModel(eGL_UNKNOWN_ENUM); - break; - case BEGIN: - Serialise_glBegin(eGL_UNKNOWN_ENUM); - break; - case END: - Serialise_glEnd(); - break; - case VERTEX3F: - Serialise_glVertex3f(0, 0, 0); - break; - case NORMAL3F: - Serialise_glNormal3f(0, 0, 0); - break; - case PUSHMATRIX: - Serialise_glPushMatrix(); - break; - case POPMATRIX: - Serialise_glPopMatrix(); - break; - case MATRIXMODE: - Serialise_glMatrixMode(eGL_UNKNOWN_ENUM); - break; - case LOADIDENTITY: - Serialise_glLoadIdentity(); - break; - case FRUSTUM: - Serialise_glFrustum(0, 0, 0, 0, 0, 0); - break; - case TRANSLATEF: - Serialise_glTranslatef(0, 0, 0); - break; - case ROTATEF: - Serialise_glRotatef(0, 0, 0, 0); - break; - // - case GEN_FRAMEBUFFERS: Serialise_glGenFramebuffers(0, NULL); break; @@ -1760,260 +1580,3 @@ void WrappedOpenGL::ReplayLog(uint32_t frameID, uint32_t startEventID, uint32_t RDCFATAL("Unexpected replay type"); } } - -#pragma region Read-only functions - -GLenum WrappedOpenGL::glGetError() -{ - return m_Real.glGetError(); -} - -void WrappedOpenGL::glFlush() -{ - m_Real.glFlush(); -} - -void WrappedOpenGL::glFinish() -{ - m_Real.glFinish(); -} - -GLboolean WrappedOpenGL::glIsEnabled(GLenum cap) -{ - return m_Real.glIsEnabled(cap); -} - -GLboolean WrappedOpenGL::glIsEnabledi(GLenum cap, GLuint index) -{ - return m_Real.glIsEnabledi(cap, index); -} - -void WrappedOpenGL::glGetFloatv(GLenum pname, GLfloat *params) -{ - m_Real.glGetFloatv(pname, params); -} - -void WrappedOpenGL::glGetDoublev(GLenum pname, GLdouble *params) -{ - m_Real.glGetDoublev(pname, params); -} - -void WrappedOpenGL::glGetIntegerv(GLenum pname, GLint *params) -{ - if(pname == GL_NUM_EXTENSIONS) - { - if(params) - *params = (GLint)glExts.size(); - return; - } - - m_Real.glGetIntegerv(pname, params); -} - -void WrappedOpenGL::glGetBooleanv(GLenum pname, GLboolean *data) -{ - m_Real.glGetBooleanv(pname, data); -} - -void WrappedOpenGL::glGetBooleani_v(GLenum pname, GLuint index, GLboolean *data) -{ - m_Real.glGetBooleani_v(pname, index, data); -} - -void WrappedOpenGL::glGetIntegeri_v(GLenum pname, GLuint index, GLint *data) -{ - m_Real.glGetIntegeri_v(pname, index, data); -} - -void WrappedOpenGL::glGetFloati_v(GLenum pname, GLuint index, GLfloat *data) -{ - m_Real.glGetFloati_v(pname, index, data); -} - -void WrappedOpenGL::glGetDoublei_v(GLenum pname, GLuint index, GLdouble *data) -{ - m_Real.glGetDoublei_v(pname, index, data); -} - -void WrappedOpenGL::glGetInteger64i_v(GLenum pname, GLuint index, GLint64 *data) -{ - m_Real.glGetInteger64i_v(pname, index, data); -} - -void WrappedOpenGL::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) -{ - m_Real.glGetTexLevelParameteriv(target, level, pname, params); -} - -void WrappedOpenGL::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) -{ - m_Real.glGetTexLevelParameterfv(target, level, pname, params); -} - -void WrappedOpenGL::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) -{ - m_Real.glGetTexParameterfv(target, pname, params); -} - -void WrappedOpenGL::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params) -{ - m_Real.glGetTexParameteriv(target, pname, params); -} - -void WrappedOpenGL::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels) -{ - m_Real.glGetTexImage(target, level, format, type, pixels); -} - -void WrappedOpenGL::glGetCompressedTexImage(GLenum target, GLint level, void *img) -{ - m_Real.glGetCompressedTexImage(target, level, img); -} - -void WrappedOpenGL::glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params) -{ - m_Real.glGetInternalformativ(target, internalformat, pname, bufSize, params); -} - -void WrappedOpenGL::glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params) -{ - m_Real.glGetInternalformati64v(target, internalformat, pname, bufSize, params); -} - -void WrappedOpenGL::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params) -{ - m_Real.glGetBufferParameteriv(target, pname, params); -} - -void WrappedOpenGL::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data) -{ - m_Real.glGetBufferSubData(target, offset, size, data); -} - -const GLubyte *WrappedOpenGL::glGetString(GLenum name) -{ - if(name == GL_EXTENSIONS) - { - return (const GLubyte *)glExtsString.c_str(); - } - return m_Real.glGetString(name); -} - -const GLubyte *WrappedOpenGL::glGetStringi(GLenum name, GLuint i) -{ - if(name == GL_EXTENSIONS) - { - if((size_t)i < glExts.size()) - return (const GLubyte *)glExts[i].c_str(); - - return (const GLubyte *)""; - } - return m_Real.glGetStringi(name, i); -} - -void WrappedOpenGL::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params) -{ - m_Real.glGetVertexAttribiv(index, pname, params); -} - -void WrappedOpenGL::glGetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer) -{ - m_Real.glGetVertexAttribPointerv(index, pname, pointer); -} - -void WrappedOpenGL::glGetShaderiv(GLuint shader, GLenum pname, GLint *params) -{ - m_Real.glGetShaderiv(shader, pname, params); -} - -void WrappedOpenGL::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog) -{ - m_Real.glGetShaderInfoLog(shader, bufSize, length, infoLog); -} - -void WrappedOpenGL::glGetProgramiv(GLuint program, GLenum pname, GLint *params) -{ - m_Real.glGetProgramiv(program, pname, params); -} - -void WrappedOpenGL::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog) -{ - m_Real.glGetProgramInfoLog(program, bufSize, length, infoLog); -} - -void WrappedOpenGL::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params) -{ - m_Real.glGetProgramPipelineiv(pipeline, pname, params); -} - -void WrappedOpenGL::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog) -{ - m_Real.glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog); -} - -void WrappedOpenGL::glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params) -{ - m_Real.glGetProgramInterfaceiv(program, programInterface, pname, params); -} - -void WrappedOpenGL::glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params) -{ - m_Real.glGetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params); -} - -void WrappedOpenGL::glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name) -{ - m_Real.glGetProgramResourceName(program, programInterface, index, bufSize, length, name); -} - -GLint WrappedOpenGL::glGetUniformLocation(GLuint program, const GLchar *name) -{ - return m_Real.glGetUniformLocation(program, name); -} - -void WrappedOpenGL::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices) -{ - m_Real.glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices); -} - -GLuint WrappedOpenGL::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName) -{ - return m_Real.glGetUniformBlockIndex(program, uniformBlockName); -} - -GLint WrappedOpenGL::glGetAttribLocation(GLuint program, const GLchar *name) -{ - return m_Real.glGetAttribLocation(program, name); -} - -void WrappedOpenGL::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) -{ - m_Real.glGetActiveUniform(program, index, bufSize, length, size, type, name); -} - -void WrappedOpenGL::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params) -{ - m_Real.glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); -} - -void WrappedOpenGL::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) -{ - m_Real.glGetActiveAttrib(program, index, bufSize, length, size, type, name); -} - -void WrappedOpenGL::glGetUniformfv(GLuint program, GLint location, GLfloat *params) -{ - m_Real.glGetUniformfv(program, location, params); -} - -void WrappedOpenGL::glGetUniformiv(GLuint program, GLint location, GLint *params) -{ - m_Real.glGetUniformiv(program, location, params); -} - -void WrappedOpenGL::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels) -{ - m_Real.glReadPixels(x, y, width, height, format, type, pixels); -} - -#pragma endregion diff --git a/renderdoc/driver/gl/gl_driver.h b/renderdoc/driver/gl/gl_driver.h index 918b810cb..c6f201c0e 100644 --- a/renderdoc/driver/gl/gl_driver.h +++ b/renderdoc/driver/gl/gl_driver.h @@ -246,27 +246,6 @@ class WrappedOpenGL void WindowSize(void *windowHandle, uint32_t w, uint32_t h); void Present(void *windowHandle); - // legacy/immediate mode - IMPLEMENT_FUNCTION_SERIALISED(void, glLightfv(GLenum light, GLenum pname, const GLfloat *params)); - IMPLEMENT_FUNCTION_SERIALISED(void, glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)); - IMPLEMENT_FUNCTION_SERIALISED(GLuint, glGenLists(GLsizei range)); - IMPLEMENT_FUNCTION_SERIALISED(void, glNewList(GLuint list, GLenum mode)); - IMPLEMENT_FUNCTION_SERIALISED(void, glEndList()); - IMPLEMENT_FUNCTION_SERIALISED(void, glCallList(GLuint list)); - IMPLEMENT_FUNCTION_SERIALISED(void, glShadeModel(GLenum mode)); - IMPLEMENT_FUNCTION_SERIALISED(void, glBegin(GLenum mode)); - IMPLEMENT_FUNCTION_SERIALISED(void, glEnd()); - IMPLEMENT_FUNCTION_SERIALISED(void, glVertex3f(GLfloat x, GLfloat y, GLfloat z)); - IMPLEMENT_FUNCTION_SERIALISED(void, glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)); - IMPLEMENT_FUNCTION_SERIALISED(void, glPushMatrix()); - IMPLEMENT_FUNCTION_SERIALISED(void, glPopMatrix()); - IMPLEMENT_FUNCTION_SERIALISED(void, glMatrixMode(GLenum mode)); - IMPLEMENT_FUNCTION_SERIALISED(void, glLoadIdentity()); - IMPLEMENT_FUNCTION_SERIALISED(void, glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)); - IMPLEMENT_FUNCTION_SERIALISED(void, glTranslatef(GLfloat x, GLfloat y, GLfloat z)); - IMPLEMENT_FUNCTION_SERIALISED(void, glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)); - // - IMPLEMENT_FUNCTION_SERIALISED(void, glBindTexture(GLenum target, GLuint texture)); IMPLEMENT_FUNCTION_SERIALISED(void, glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)); IMPLEMENT_FUNCTION_SERIALISED(void, glBlendFunc(GLenum sfactor, GLenum dfactor)); diff --git a/renderdoc/driver/gl/gl_hookset.h b/renderdoc/driver/gl/gl_hookset.h index d754cf03a..b63ccfc9c 100644 --- a/renderdoc/driver/gl/gl_hookset.h +++ b/renderdoc/driver/gl/gl_hookset.h @@ -26,7 +26,6 @@ #pragma once #include "gl_common.h" -#include "gl_legacy_procs.h" struct GLHookSet { @@ -83,25 +82,6 @@ struct GLHookSet PFNGLTEXPARAMETERIPROC glTexParameteri; PFNGLTEXPARAMETERIVPROC glTexParameteriv; PFNGLVIEWPORTPROC glViewport; - // legacy - PFNGLLIGHTFVPROC glLightfv; - PFNGLMATERIALFVPROC glMaterialfv; - PFNGLGENLISTSPROC glGenLists; - PFNGLNEWLISTPROC glNewList; - PFNGLENDLISTPROC glEndList; - PFNGLCALLLISTPROC glCallList; - PFNGLSHADEMODELPROC glShadeModel; - PFNGLBEGINPROC glBegin; - PFNGLENDPROC glEnd; - PFNGLVERTEX3FPROC glVertex3f; - PFNGLNORMAL3FPROC glNormal3f; - PFNGLPUSHMATRIXPROC glPushMatrix; - PFNGLPOPMATRIXPROC glPopMatrix; - PFNGLMATRIXMODEPROC glMatrixMode; - PFNGLLOADIDENTITYPROC glLoadIdentity; - PFNGLFRUSTUMPROC glFrustum; - PFNGLTRANSLATEFPROC glTranslatef; - PFNGLROTATEFPROC glRotatef; // -- // ++ gl diff --git a/renderdoc/driver/gl/gl_hookset_defs.h b/renderdoc/driver/gl/gl_hookset_defs.h index 0731a0a59..1f3ca5265 100644 --- a/renderdoc/driver/gl/gl_hookset_defs.h +++ b/renderdoc/driver/gl/gl_hookset_defs.h @@ -83,24 +83,6 @@ HookInit(glTexParameteri); \ HookInit(glTexParameteriv); \ HookInit(glViewport); \ - HookInit(glLightfv); \ - HookInit(glMaterialfv); \ - HookInit(glGenLists); \ - HookInit(glNewList); \ - HookInit(glEndList); \ - HookInit(glCallList); \ - HookInit(glShadeModel); \ - HookInit(glBegin); \ - HookInit(glEnd); \ - HookInit(glVertex3f); \ - HookInit(glNormal3f); \ - HookInit(glPushMatrix); \ - HookInit(glPopMatrix); \ - HookInit(glMatrixMode); \ - HookInit(glLoadIdentity); \ - HookInit(glFrustum); \ - HookInit(glTranslatef); \ - HookInit(glRotatef); \ @@ -323,24 +305,6 @@ HookExtension(PFNGLTEXPARAMETERIPROC, glTexParameteri); \ HookExtension(PFNGLTEXPARAMETERIVPROC, glTexParameteriv); \ HookExtension(PFNGLVIEWPORTPROC, glViewport); \ - HookExtension(PFNGLLIGHTFVPROC, glLightfv); \ - HookExtension(PFNGLMATERIALFVPROC, glMaterialfv); \ - HookExtension(PFNGLGENLISTSPROC, glGenLists); \ - HookExtension(PFNGLNEWLISTPROC, glNewList); \ - HookExtension(PFNGLENDLISTPROC, glEndList); \ - HookExtension(PFNGLCALLLISTPROC, glCallList); \ - HookExtension(PFNGLSHADEMODELPROC, glShadeModel); \ - HookExtension(PFNGLBEGINPROC, glBegin); \ - HookExtension(PFNGLENDPROC, glEnd); \ - HookExtension(PFNGLVERTEX3FPROC, glVertex3f); \ - HookExtension(PFNGLNORMAL3FPROC, glNormal3f); \ - HookExtension(PFNGLPUSHMATRIXPROC, glPushMatrix); \ - HookExtension(PFNGLPOPMATRIXPROC, glPopMatrix); \ - HookExtension(PFNGLMATRIXMODEPROC, glMatrixMode); \ - HookExtension(PFNGLLOADIDENTITYPROC, glLoadIdentity); \ - HookExtension(PFNGLFRUSTUMPROC, glFrustum); \ - HookExtension(PFNGLTRANSLATEFPROC, glTranslatef); \ - HookExtension(PFNGLROTATEFPROC, glRotatef); \ @@ -398,24 +362,6 @@ HookWrapper3(void, glTexParameteri, GLenum, target, GLenum, pname, GLint, param); \ HookWrapper3(void, glTexParameteriv, GLenum, target, GLenum, pname, const GLint *, params); \ HookWrapper4(void, glViewport, GLint, x, GLint, y, GLsizei, width, GLsizei, height); \ - HookWrapper3(void, glLightfv, GLenum, light, GLenum, pname, const GLfloat *, params); \ - HookWrapper3(void, glMaterialfv, GLenum, face, GLenum, pname, const GLfloat *, params); \ - HookWrapper1(GLuint, glGenLists, GLsizei, range); \ - HookWrapper2(void, glNewList, GLuint, list, GLenum, mode); \ - HookWrapper0(void, glEndList); \ - HookWrapper1(void, glCallList, GLuint, list); \ - HookWrapper1(void, glShadeModel, GLenum, mode); \ - HookWrapper1(void, glBegin, GLenum, mode); \ - HookWrapper0(void, glEnd); \ - HookWrapper3(void, glVertex3f, GLfloat, x, GLfloat, y, GLfloat, z); \ - HookWrapper3(void, glNormal3f, GLfloat, nx, GLfloat, ny, GLfloat, nz); \ - HookWrapper0(void, glPushMatrix); \ - HookWrapper0(void, glPopMatrix); \ - HookWrapper1(void, glMatrixMode, GLenum, mode); \ - HookWrapper0(void, glLoadIdentity); \ - HookWrapper6(void, glFrustum, GLdouble, left, GLdouble, right, GLdouble, bottom, GLdouble, top, GLdouble, zNear, GLdouble, zFar); \ - HookWrapper3(void, glTranslatef, GLfloat, x, GLfloat, y, GLfloat, z); \ - HookWrapper4(void, glRotatef, GLfloat, angle, GLfloat, x, GLfloat, y, GLfloat, z); \ diff --git a/renderdoc/driver/gl/gl_legacy_procs.h b/renderdoc/driver/gl/gl_legacy_procs.h deleted file mode 100644 index 9b9d62849..000000000 --- a/renderdoc/driver/gl/gl_legacy_procs.h +++ /dev/null @@ -1,46 +0,0 @@ -/****************************************************************************** - * The MIT License (MIT) - * - * Copyright (c) 2014 Crytek - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - * THE SOFTWARE. - ******************************************************************************/ - - -#pragma once - -typedef void (APIENTRYP PFNGLLIGHTFVPROC) (GLenum light, GLenum pname, const GLfloat *params); -typedef void (APIENTRYP PFNGLMATERIALFVPROC) (GLenum face, GLenum pname, const GLfloat *params); -typedef GLuint (APIENTRYP PFNGLGENLISTSPROC) (GLsizei range); -typedef void (APIENTRYP PFNGLNEWLISTPROC) (GLuint list, GLenum mode); -typedef void (APIENTRYP PFNGLENDLISTPROC) (void); -typedef void (APIENTRYP PFNGLCALLLISTPROC) (GLuint list); -typedef void (APIENTRYP PFNGLSHADEMODELPROC) (GLenum mode); -typedef void (APIENTRYP PFNGLBEGINPROC) (GLenum mode); -typedef void (APIENTRYP PFNGLENDPROC) (void); -typedef void (APIENTRYP PFNGLVERTEX3FPROC) (GLfloat x, GLfloat y, GLfloat z); -typedef void (APIENTRYP PFNGLNORMAL3FPROC) (GLfloat nx, GLfloat ny, GLfloat nz); -typedef void (APIENTRYP PFNGLPUSHMATRIXPROC) (void); -typedef void (APIENTRYP PFNGLPOPMATRIXPROC) (void); -typedef void (APIENTRYP PFNGLMATRIXMODEPROC) (GLenum mode); -typedef void (APIENTRYP PFNGLLOADIDENTITYPROC) (void); -typedef void (APIENTRYP PFNGLFRUSTUMPROC) (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); -typedef void (APIENTRYP PFNGLTRANSLATEFPROC) (GLfloat x, GLfloat y, GLfloat z); -typedef void (APIENTRYP PFNGLROTATEFPROC) (GLfloat angle, GLfloat x, GLfloat y, GLfloat z); - diff --git a/renderdoc/driver/gl/gl_resources.h b/renderdoc/driver/gl/gl_resources.h index 6edfedbff..edce6777f 100644 --- a/renderdoc/driver/gl/gl_resources.h +++ b/renderdoc/driver/gl/gl_resources.h @@ -43,7 +43,6 @@ enum GLNamespace eResShader, eResProgram, eResProgramPipe, - eResDisplayList, }; enum GLSpecialResource @@ -87,7 +86,6 @@ inline GLResource VertexArrayRes(GLuint i) { return GLResource(eResVertexArray, inline GLResource ShaderRes(GLuint i) { return GLResource(eResShader, i); } inline GLResource ProgramRes(GLuint i) { return GLResource(eResProgram, i); } inline GLResource ProgramPipeRes(GLuint i) { return GLResource(eResProgramPipe, i); } -inline GLResource DisplayListRes(GLuint i) { return GLResource(eResDisplayList, i); } struct GLResourceRecord : public ResourceRecord { diff --git a/renderdoc/driver/gl/hookset.pl b/renderdoc/driver/gl/hookset.pl index 3eeee2d6e..a22b66cac 100644 --- a/renderdoc/driver/gl/hookset.pl +++ b/renderdoc/driver/gl/hookset.pl @@ -45,7 +45,7 @@ while() my $name = $2; my $aliases = $4; - my $def = trim(`grep -h $typedef gl_legacy_procs.h official/*`); + my $def = trim(`grep -h $typedef official/*`); if($def =~ /^typedef (.*)\([A-Z *]* $typedef\) \((.*)\);/) { diff --git a/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp new file mode 100644 index 000000000..471aa03ac --- /dev/null +++ b/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp @@ -0,0 +1,721 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2014 Crytek + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "common/common.h" +#include "common/string_utils.h" +#include "../gl_driver.h" + + +bool WrappedOpenGL::Serialise_glGenBuffers(GLsizei n, GLuint* textures) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(BufferRes(*textures))); + + if(m_State == READING) + { + GLuint real = 0; + m_Real.glGenBuffers(1, &real); + + GLResource res = BufferRes(real); + + ResourceId live = m_ResourceManager->RegisterResource(res); + GetResourceManager()->AddLiveResource(id, res); + + m_Buffers[live].resource = res; + m_Buffers[live].curType = eGL_UNKNOWN_ENUM; + } + + return true; +} + +void WrappedOpenGL::glGenBuffers(GLsizei n, GLuint *buffers) +{ + m_Real.glGenBuffers(n, buffers); + + for(GLsizei i=0; i < n; i++) + { + GLResource res = BufferRes(buffers[i]); + ResourceId id = GetResourceManager()->RegisterResource(res); + + if(m_State >= WRITING) + { + Chunk *chunk = NULL; + + { + SCOPED_SERIALISE_CONTEXT(GEN_BUFFER); + Serialise_glGenBuffers(1, buffers+i); + + chunk = scope.Get(); + } + + GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id); + RDCASSERT(record); + + record->AddChunk(chunk); + } + else + { + GetResourceManager()->AddLiveResource(id, res); + } + } +} + +size_t WrappedOpenGL::BufferIdx(GLenum buf) +{ + switch(buf) + { + case eGL_ARRAY_BUFFER: return 0; + case eGL_ATOMIC_COUNTER_BUFFER: return 1; + case eGL_COPY_READ_BUFFER: return 2; + case eGL_COPY_WRITE_BUFFER: return 3; + case eGL_DRAW_INDIRECT_BUFFER: return 4; + case eGL_DISPATCH_INDIRECT_BUFFER: return 5; + case eGL_ELEMENT_ARRAY_BUFFER: return 6; + case eGL_PIXEL_PACK_BUFFER: return 7; + case eGL_PIXEL_UNPACK_BUFFER: return 8; + case eGL_QUERY_BUFFER: return 9; + case eGL_SHADER_STORAGE_BUFFER: return 10; + case eGL_TEXTURE_BUFFER: return 11; + case eGL_TRANSFORM_FEEDBACK_BUFFER: return 12; + case eGL_UNIFORM_BUFFER: return 13; + default: + RDCERR("Unexpected enum as buffer target: %hs", ToStr::Get(buf).c_str()); + } + + return 0; +} + +bool WrappedOpenGL::Serialise_glBindBuffer(GLenum target, GLuint buffer) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(ResourceId, Id, GetResourceManager()->GetID(BufferRes(buffer))); + + if(m_State >= WRITING) + { + size_t idx = BufferIdx(target); + + m_BufferRecord[idx]->datatype = Target; + } + else if(m_State < WRITING) + { + GLResource res = GetResourceManager()->GetLiveResource(Id); + m_Real.glBindBuffer(Target, res.name); + + m_Buffers[GetResourceManager()->GetLiveID(Id)].curType = Target; + } + + return true; +} + +void WrappedOpenGL::glBindBuffer(GLenum target, GLuint buffer) +{ + m_Real.glBindBuffer(target, buffer); + + if(m_State == WRITING_CAPFRAME) + { + Chunk *chunk = NULL; + + { + SCOPED_SERIALISE_CONTEXT(BIND_BUFFER); + Serialise_glBindBuffer(target, buffer); + + chunk = scope.Get(); + } + + m_ContextRecord->AddChunk(chunk); + } + + size_t idx = BufferIdx(target); + + if(buffer == 0) + { + m_BufferRecord[idx] = NULL; + return; + } + + if(m_State >= WRITING) + { + GLResourceRecord *r = m_BufferRecord[idx] = GetResourceManager()->GetResourceRecord(BufferRes(buffer)); + + // it's legal to re-type buffers, generate another BindBuffer chunk to rename + if(r->datatype != target) + { + Chunk *chunk = NULL; + + { + SCOPED_SERIALISE_CONTEXT(BIND_BUFFER); + Serialise_glBindBuffer(target, buffer); + + chunk = scope.Get(); + } + + r->AddChunk(chunk); + } + } +} + +bool WrappedOpenGL::Serialise_glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(uint64_t, Bytesize, (uint64_t)size); + + byte *dummy = NULL; + + if(m_State >= WRITING && data == NULL) + { + dummy = new byte[size]; + data = dummy; + } + + SERIALISE_ELEMENT_BUF(byte *, bytes, data, (size_t)Bytesize); + + uint64_t offs = m_pSerialiser->GetOffset(); + + SERIALISE_ELEMENT(GLenum, Usage, usage); + SERIALISE_ELEMENT(ResourceId, id, m_BufferRecord[BufferIdx(target)]->GetResourceID()); + + if(m_State == READING) + { + GLResource res = GetResourceManager()->GetLiveResource(id); + m_Real.glBindBuffer(Target, res.name); + m_Real.glBufferData(Target, (GLsizeiptr)Bytesize, bytes, Usage); + + m_Buffers[GetResourceManager()->GetLiveID(id)].size = Bytesize; + + SAFE_DELETE_ARRAY(bytes); + } + else if(m_State >= WRITING) + { + m_BufferRecord[BufferIdx(target)]->SetDataOffset(offs - Bytesize); + } + + if(dummy) + delete[] dummy; + + return true; +} + +void WrappedOpenGL::glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage) +{ + m_Real.glBufferData(target, size, data, usage); + + size_t idx = BufferIdx(target); + + if(m_State >= WRITING) + { + RDCASSERT(m_BufferRecord[idx]); + + SCOPED_SERIALISE_CONTEXT(BUFFERDATA); + Serialise_glBufferData(target, size, data, usage); + + Chunk *chunk = scope.Get(); + + m_BufferRecord[idx]->AddChunk(chunk); + m_BufferRecord[idx]->SetDataPtr(chunk->GetData()); + m_BufferRecord[idx]->Length = (int32_t)size; + } +} + +bool WrappedOpenGL::Serialise_glBindBufferBase(GLenum target, GLuint index, GLuint buffer) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(uint32_t, Index, index); + SERIALISE_ELEMENT(ResourceId, id, m_BufferRecord[BufferIdx(target)]->GetResourceID()); + + if(m_State < WRITING) + { + GLResource res = GetResourceManager()->GetLiveResource(id); + m_Real.glBindBufferBase(Target, Index, res.name); + } + + return true; +} + +void WrappedOpenGL::glBindBufferBase(GLenum target, GLuint index, GLuint buffer) +{ + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(BIND_BUFFER_BASE); + Serialise_glBindBufferBase(target, index, buffer); + + m_ContextRecord->AddChunk(scope.Get()); + } + + m_Real.glBindBufferBase(target, index, buffer); +} + +bool WrappedOpenGL::Serialise_glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(uint32_t, Index, index); + SERIALISE_ELEMENT(ResourceId, id, m_BufferRecord[BufferIdx(target)]->GetResourceID()); + SERIALISE_ELEMENT(uint64_t, Offset, (uint64_t)offset); + SERIALISE_ELEMENT(uint64_t, Size, (uint64_t)size); + + if(m_State < WRITING) + { + GLResource res = GetResourceManager()->GetLiveResource(id); + m_Real.glBindBufferRange(Target, Index, res.name, (GLintptr)Offset, (GLsizeiptr)Size); + } + + return true; +} + +void WrappedOpenGL::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(BIND_BUFFER_RANGE); + Serialise_glBindBufferRange(target, index, buffer, offset, size); + + m_ContextRecord->AddChunk(scope.Get()); + } + + m_Real.glBindBufferRange(target, index, buffer, offset, size); +} + +void *WrappedOpenGL::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) +{ + if(m_State >= WRITING) + { + // haven't implemented non-invalidating write maps + if((access & (GL_MAP_INVALIDATE_BUFFER_BIT|GL_MAP_INVALIDATE_RANGE_BIT|GL_MAP_READ_BIT)) == 0) + RDCUNIMPLEMENTED(); + + // haven't implemented coherent/persistent bits + if((access & (GL_MAP_COHERENT_BIT|GL_MAP_PERSISTENT_BIT)) != 0) + RDCUNIMPLEMENTED(); + + m_BufferRecord[BufferIdx(target)]->Map.offset = offset; + m_BufferRecord[BufferIdx(target)]->Map.length = length; + m_BufferRecord[BufferIdx(target)]->Map.access = access; + + if((access & GL_MAP_READ_BIT) != 0) + { + byte *ptr = m_BufferRecord[BufferIdx(target)]->GetDataPtr(); + + if(ptr == NULL) + { + RDCWARN("Mapping buffer that hasn't been allocated"); + + m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Mapped_Read_Real; + return m_Real.glMapBufferRange(target, offset, length, access); + } + + ptr += offset; + + m_Real.glGetBufferSubData(target, offset, length, ptr); + + m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Mapped_Read; + + return ptr; + } + + byte *ptr = m_BufferRecord[BufferIdx(target)]->GetDataPtr(); + + if(ptr == NULL) + { + RDCWARN("Mapping buffer that hasn't been allocated"); + + ptr = (byte *)m_Real.glMapBufferRange(target, offset, length, access); + + m_BufferRecord[BufferIdx(target)]->Map.ptr = ptr; + m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Mapped_Write_Real; + } + else + { + if(m_State == WRITING_CAPFRAME) + { + ptr = new byte[length]; + + m_BufferRecord[BufferIdx(target)]->Map.ptr = ptr; + m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Mapped_Write_Alloc; + } + else + { + ptr += offset; + + m_BufferRecord[BufferIdx(target)]->Map.ptr = ptr; + m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Mapped_Write; + } + } + + return ptr; + } + + return m_Real.glMapBufferRange(target, offset, length, access); +} + +bool WrappedOpenGL::Serialise_glUnmapBuffer(GLenum target) +{ + GLResourceRecord *record = NULL; + + if(m_State >= WRITING) + record = m_BufferRecord[BufferIdx(target)]; + + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(ResourceId, bufID, record->GetResourceID()); + SERIALISE_ELEMENT(uint64_t, offs, record->Map.offset); + SERIALISE_ELEMENT(uint64_t, len, record->Map.length); + + uint64_t bufBindStart = 0; + + if(m_State >= WRITING) + { + if(Target == eGL_ATOMIC_COUNTER_BUFFER) + m_Real.glGetInteger64i_v(eGL_ATOMIC_COUNTER_BUFFER_START, 0, (GLint64 *)&bufBindStart); + if(Target == eGL_SHADER_STORAGE_BUFFER) + m_Real.glGetInteger64i_v(eGL_SHADER_STORAGE_BUFFER_START, 0, (GLint64 *)&bufBindStart); + if(Target == eGL_TRANSFORM_FEEDBACK_BUFFER) + m_Real.glGetInteger64i_v(eGL_TRANSFORM_FEEDBACK_BUFFER_START, 0, (GLint64 *)&bufBindStart); + if(Target == eGL_UNIFORM_BUFFER) + m_Real.glGetInteger64i_v(eGL_UNIFORM_BUFFER_START, 0, (GLint64 *)&bufBindStart); + } + + SERIALISE_ELEMENT(uint64_t, bufOffs, bufBindStart); + + SERIALISE_ELEMENT_BUF(byte *, data, record->Map.ptr, (size_t)len); + + if(m_State < WRITING || + (m_State >= WRITING && + (record->Map.status == GLResourceRecord::Mapped_Write || record->Map.status == GLResourceRecord::Mapped_Write_Alloc) + ) + ) + { + GLuint oldBuf = 0; + GLuint64 oldBufBase = 0; + GLuint64 oldBufSize = 0; + + if(m_State == READING) + { + GLResource res = GetResourceManager()->GetLiveResource(bufID); + m_Real.glGetIntegeri_v(eGL_UNIFORM_BUFFER_BINDING, 0, (GLint *)&oldBuf); + m_Real.glGetInteger64i_v(eGL_UNIFORM_BUFFER_START, 0, (GLint64 *)&oldBufBase); + m_Real.glGetInteger64i_v(eGL_UNIFORM_BUFFER_SIZE, 0, (GLint64 *)&oldBufSize); + m_Real.glBindBufferRange(eGL_UNIFORM_BUFFER, 0, res.name, (GLintptr)bufOffs, (GLsizeiptr)len); + } + + void *ptr = m_Real.glMapBufferRange(Target, (GLintptr)offs, (GLsizeiptr)len, GL_MAP_WRITE_BIT); + memcpy(ptr, data, (size_t)len); + m_Real.glUnmapBuffer(Target); + + if(m_State == READING) + { + if(oldBufBase == 0 && oldBufSize == 0) + m_Real.glBindBufferBase(eGL_UNIFORM_BUFFER, 0, oldBuf); + else + m_Real.glBindBufferRange(eGL_UNIFORM_BUFFER, 0, oldBuf, (GLintptr)oldBufBase, (GLsizeiptr)oldBufSize); + } + } + + if(m_State < WRITING) + delete[] data; + + return true; +} + +GLboolean WrappedOpenGL::glUnmapBuffer(GLenum target) +{ + if(m_State >= WRITING) + { + RDCASSERT(m_BufferRecord[BufferIdx(target)]); + + auto status = m_BufferRecord[BufferIdx(target)]->Map.status; + + GLboolean ret = GL_TRUE; + + switch(status) + { + case GLResourceRecord::Unmapped: + RDCERR("Unmapped buffer being passed to glUnmapBuffer"); + break; + case GLResourceRecord::Mapped_Read: + // can ignore + break; + case GLResourceRecord::Mapped_Read_Real: + // need to do real unmap + ret = m_Real.glUnmapBuffer(target); + break; + case GLResourceRecord::Mapped_Write: + { + if(m_State == WRITING_CAPFRAME) + RDCWARN("Failed to cap frame - uncapped Map/Unmap"); + + SCOPED_SERIALISE_CONTEXT(UNMAP); + Serialise_glUnmapBuffer(target); + + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(scope.Get()); + else + m_BufferRecord[BufferIdx(target)]->AddChunk(scope.Get()); + + break; + } + case GLResourceRecord::Mapped_Write_Alloc: + { + SCOPED_SERIALISE_CONTEXT(UNMAP); + Serialise_glUnmapBuffer(target); + + if(m_State == WRITING_CAPFRAME) + m_ContextRecord->AddChunk(scope.Get()); + + delete[] m_BufferRecord[BufferIdx(target)]->Map.ptr; + + break; + } + case GLResourceRecord::Mapped_Write_Real: + RDCWARN("Throwing away map contents as we don't have datastore allocated"); + RDCWARN("Could init chunk here using known data (although maybe it's only partial)"); + ret = m_Real.glUnmapBuffer(target); + break; + } + + m_BufferRecord[BufferIdx(target)]->Map.status = GLResourceRecord::Unmapped; + + return ret; + } + + return m_Real.glUnmapBuffer(target); +} + +bool WrappedOpenGL::Serialise_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) +{ + SERIALISE_ELEMENT(uint32_t, Index, index); + SERIALISE_ELEMENT(int32_t, Size, size); + SERIALISE_ELEMENT(GLenum, Type, type); + SERIALISE_ELEMENT(uint8_t, Norm, normalized); + SERIALISE_ELEMENT(uint32_t, Stride, stride); + SERIALISE_ELEMENT(uint64_t, Offset, (uint64_t)pointer); + SERIALISE_ELEMENT(ResourceId, id, m_VertexArrayRecord ? m_VertexArrayRecord->GetResourceID() : ResourceId()); + + if(m_State < WRITING) + { + if(id != ResourceId()) + { + GLResource res = GetResourceManager()->GetLiveResource(id); + m_Real.glBindVertexArray(res.name); + } + else + { + m_Real.glBindVertexArray(0); + } + + m_Real.glVertexAttribPointer(Index, Size, Type, Norm, Stride, (const void *)Offset); + } + + return true; +} + +void WrappedOpenGL::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) +{ + m_Real.glVertexAttribPointer(index, size, type, normalized, stride, pointer); + + GLResourceRecord *r = m_VertexArrayRecord ? m_VertexArrayRecord : m_DeviceRecord; + if(m_State >= WRITING) + { + RDCASSERT(r); + + SCOPED_SERIALISE_CONTEXT(VERTEXATTRIBPOINTER); + Serialise_glVertexAttribPointer(index, size, type, normalized, stride, pointer); + + r->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glEnableVertexAttribArray(GLuint index) +{ + SERIALISE_ELEMENT(uint32_t, Index, index); + SERIALISE_ELEMENT(ResourceId, id, m_VertexArrayRecord ? m_VertexArrayRecord->GetResourceID() : ResourceId()); + + if(m_State < WRITING) + { + if(id != ResourceId()) + { + GLResource res = GetResourceManager()->GetLiveResource(id); + m_Real.glBindVertexArray(res.name); + } + else + { + m_Real.glBindVertexArray(0); + } + + m_Real.glEnableVertexAttribArray(Index); + } + return true; +} + +void WrappedOpenGL::glEnableVertexAttribArray(GLuint index) +{ + m_Real.glEnableVertexAttribArray(index); + + GLResourceRecord *r = m_VertexArrayRecord ? m_VertexArrayRecord : m_DeviceRecord; + if(m_State >= WRITING) + { + RDCASSERT(r); + + SCOPED_SERIALISE_CONTEXT(ENABLEVERTEXATTRIBARRAY); + Serialise_glEnableVertexAttribArray(index); + + r->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glDisableVertexAttribArray(GLuint index) +{ + SERIALISE_ELEMENT(uint32_t, Index, index); + SERIALISE_ELEMENT(ResourceId, id, m_VertexArrayRecord ? m_VertexArrayRecord->GetResourceID() : ResourceId()); + + if(m_State < WRITING) + { + if(id != ResourceId()) + { + GLResource res = GetResourceManager()->GetLiveResource(id); + m_Real.glBindVertexArray(res.name); + } + else + { + m_Real.glBindVertexArray(0); + } + + m_Real.glDisableVertexAttribArray(Index); + } + return true; +} + +void WrappedOpenGL::glDisableVertexAttribArray(GLuint index) +{ + m_Real.glDisableVertexAttribArray(index); + + GLResourceRecord *r = m_VertexArrayRecord ? m_VertexArrayRecord : m_DeviceRecord; + RDCASSERT(r); + if(m_State >= WRITING) + { + SCOPED_SERIALISE_CONTEXT(DISABLEVERTEXATTRIBARRAY); + Serialise_glDisableVertexAttribArray(index); + + r->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glGenVertexArrays(GLsizei n, GLuint* arrays) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(VertexArrayRes(*arrays))); + + if(m_State == READING) + { + GLuint real = 0; + m_Real.glGenVertexArrays(1, &real); + + GLResource res = VertexArrayRes(real); + + m_ResourceManager->RegisterResource(res); + GetResourceManager()->AddLiveResource(id, res); + } + + return true; +} + +void WrappedOpenGL::glGenVertexArrays(GLsizei n, GLuint *arrays) +{ + m_Real.glGenVertexArrays(n, arrays); + + for(GLsizei i=0; i < n; i++) + { + GLResource res = VertexArrayRes(arrays[i]); + ResourceId id = GetResourceManager()->RegisterResource(res); + + if(m_State >= WRITING) + { + Chunk *chunk = NULL; + + { + SCOPED_SERIALISE_CONTEXT(GEN_VERTEXARRAY); + Serialise_glGenVertexArrays(1, arrays+i); + + chunk = scope.Get(); + } + + GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id); + RDCASSERT(record); + + record->AddChunk(chunk); + } + else + { + GetResourceManager()->AddLiveResource(id, res); + } + } +} + +bool WrappedOpenGL::Serialise_glBindVertexArray(GLuint array) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(VertexArrayRes(array))); + + if(m_State <= EXECUTING) + { + m_Real.glBindVertexArray(GetResourceManager()->GetLiveResource(id).name); + } + + return true; +} + +void WrappedOpenGL::glBindVertexArray(GLuint array) +{ + m_Real.glBindVertexArray(array); + + if(m_State >= WRITING) + { + if(array == 0) + { + m_VertexArrayRecord = NULL; + } + else + { + m_VertexArrayRecord = GetResourceManager()->GetResourceRecord(VertexArrayRes(array)); + } + } + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(BINDVERTEXARRAY); + Serialise_glBindVertexArray(array); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +void WrappedOpenGL::glDeleteBuffers(GLsizei n, const GLuint *buffers) +{ + m_Real.glDeleteBuffers(n, buffers); + + for(GLsizei i=0; i < n; i++) + GetResourceManager()->UnregisterResource(BufferRes(buffers[i])); +} + +void WrappedOpenGL::glDeleteVertexArrays(GLsizei n, const GLuint *arrays) +{ + m_Real.glDeleteVertexArrays(n, arrays); + + for(GLsizei i=0; i < n; i++) + GetResourceManager()->UnregisterResource(VertexArrayRes(arrays[i])); +} diff --git a/renderdoc/driver/gl/wrappers/gl_debug_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_debug_funcs.cpp new file mode 100644 index 000000000..b3dea4c9b --- /dev/null +++ b/renderdoc/driver/gl/wrappers/gl_debug_funcs.cpp @@ -0,0 +1,190 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2014 Crytek + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "common/common.h" +#include "common/string_utils.h" +#include "../gl_driver.h" + + +void WrappedOpenGL::glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label) +{ + m_Real.glGetObjectLabel(identifier, name, bufSize, length, label); +} + +bool WrappedOpenGL::Serialise_glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label) +{ + ResourceId liveid; + + string Label; + if(m_State >= WRITING) + { + if(length == 0) + Label = ""; + else + Label = string(label, label + (length > 0 ? length : strlen(label))); + + switch(identifier) + { + case eGL_TEXTURE: + liveid = GetResourceManager()->GetID(TextureRes(name)); + break; + case eGL_BUFFER: + liveid = GetResourceManager()->GetID(BufferRes(name)); + break; + default: + RDCERR("Unhandled namespace in glObjectLabel"); + } + } + + SERIALISE_ELEMENT(GLenum, Identifier, identifier); + SERIALISE_ELEMENT(ResourceId, id, liveid); + SERIALISE_ELEMENT(uint32_t, Length, length); + SERIALISE_ELEMENT(bool, HasLabel, label != NULL); + + m_pSerialiser->SerialiseString("label", Label); + + if(m_State == READING) + { + GLResource res = GetResourceManager()->GetLiveResource(id); + m_Real.glObjectLabel(Identifier, res.name, Length, HasLabel ? Label.c_str() : NULL); + } + + return true; +} + +void WrappedOpenGL::glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label) +{ + m_Real.glObjectLabel(identifier, name, length, label); + + if(m_State >= WRITING) + { + SCOPED_SERIALISE_CONTEXT(OBJECT_LABEL); + Serialise_glObjectLabel(identifier, name, length, label); + + m_DeviceRecord->AddChunk(scope.Get()); + } +} + + +void WrappedOpenGL::glDebugMessageCallback(GLDEBUGPROC callback, const void *userParam) +{ + m_RealDebugFunc = callback; + m_RealDebugFuncParam = userParam; + + m_Real.glDebugMessageCallback(&DebugSnoopStatic, this); +} + +void WrappedOpenGL::glDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled) +{ + // we could exert control over debug messages here + m_Real.glDebugMessageControl(source, type, severity, count, ids, enabled); +} + +bool WrappedOpenGL::Serialise_glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf) +{ + wstring name = buf ? widen(string(buf, buf+length)) : L""; + + m_pSerialiser->Serialise("Name", name); + + if(m_State == READING) + { + FetchDrawcall draw; + draw.name = name; + draw.flags |= eDraw_SetMarker; + + AddDrawcall(draw, false); + } + + return true; +} + +void WrappedOpenGL::glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf) +{ + if(m_State == WRITING_CAPFRAME && type == eGL_DEBUG_TYPE_MARKER) + { + SCOPED_SERIALISE_CONTEXT(SET_MARKER); + Serialise_glDebugMessageInsert(source, type, id, severity, length, buf); + + m_ContextRecord->AddChunk(scope.Get()); + } + + m_Real.glDebugMessageInsert(source, type, id, severity, length, buf); +} + +bool WrappedOpenGL::Serialise_glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message) +{ + wstring name = message ? widen(string(message, message+length)) : L""; + + m_pSerialiser->Serialise("Name", name); + + if(m_State == READING) + { + FetchDrawcall draw; + draw.name = name; + draw.flags |= eDraw_PushMarker; + + AddDrawcall(draw, false); + } + + return true; +} + +void WrappedOpenGL::glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message) +{ + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(BEGIN_EVENT); + Serialise_glPushDebugGroup(source, id, length, message); + + m_ContextRecord->AddChunk(scope.Get()); + } + + m_Real.glPushDebugGroup(source, id, length, message); +} + +bool WrappedOpenGL::Serialise_glPopDebugGroup() +{ + if(m_State == READING && !m_CurEvents.empty()) + { + FetchDrawcall draw; + draw.name = L"API Calls"; + draw.flags |= eDraw_SetMarker; + + AddDrawcall(draw, true); + } + + return true; +} +void WrappedOpenGL::glPopDebugGroup() +{ + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(END_EVENT); + Serialise_glPopDebugGroup(); + + m_ContextRecord->AddChunk(scope.Get()); + } + + m_Real.glPopDebugGroup(); +} diff --git a/renderdoc/driver/gl/wrappers/gl_draw_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_draw_funcs.cpp new file mode 100644 index 000000000..8498f9045 --- /dev/null +++ b/renderdoc/driver/gl/wrappers/gl_draw_funcs.cpp @@ -0,0 +1,854 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2014 Crytek + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "common/common.h" +#include "common/string_utils.h" +#include "../gl_driver.h" + +bool WrappedOpenGL::Serialise_glDrawArrays(GLenum mode, GLint first, GLsizei count) +{ + SERIALISE_ELEMENT(GLenum, Mode, mode); + SERIALISE_ELEMENT(int32_t, First, first); + SERIALISE_ELEMENT(uint32_t, Count, count); + + if(m_State <= EXECUTING) + { + m_Real.glDrawArrays(Mode, First, Count); + } + + const string desc = m_pSerialiser->GetDebugStr(); + + if(m_State == READING) + { + AddEvent(DRAWARRAYS, desc); + string name = "glDrawArrays(" + + ToStr::Get(Mode) + ", " + + ToStr::Get(First) + ", " + + ToStr::Get(Count) + ", " + ")"; + + FetchDrawcall draw; + draw.name = widen(name); + draw.numIndices = Count; + draw.numInstances = 1; + draw.indexOffset = 0; + draw.vertexOffset = First; + draw.instanceOffset = 0; + + draw.flags |= eDraw_Drawcall; + + m_LastDrawMode = Mode; + + AddDrawcall(draw, true); + } + + return true; +} + +void WrappedOpenGL::glDrawArrays(GLenum mode, GLint first, GLsizei count) +{ + m_Real.glDrawArrays(mode, first, count); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DRAWARRAYS); + Serialise_glDrawArrays(mode, first, count); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount) +{ + SERIALISE_ELEMENT(GLenum, Mode, mode); + SERIALISE_ELEMENT(int32_t, First, first); + SERIALISE_ELEMENT(uint32_t, Count, count); + SERIALISE_ELEMENT(uint32_t, InstanceCount, instancecount); + + if(m_State <= EXECUTING) + { + m_Real.glDrawArraysInstanced(Mode, First, Count, InstanceCount); + } + + const string desc = m_pSerialiser->GetDebugStr(); + + if(m_State == READING) + { + AddEvent(DRAWARRAYS_INSTANCED, desc); + string name = "glDrawArraysInstanced(" + + ToStr::Get(Mode) + ", " + + ToStr::Get(First) + ", " + + ToStr::Get(Count) + ", " + + ToStr::Get(InstanceCount) + ")"; + + FetchDrawcall draw; + draw.name = widen(name); + draw.numIndices = Count; + draw.numInstances = InstanceCount; + draw.indexOffset = 0; + draw.vertexOffset = First; + draw.instanceOffset = 0; + + draw.flags |= eDraw_Drawcall|eDraw_Instanced; + + m_LastDrawMode = Mode; + + AddDrawcall(draw, true); + } + + return true; +} + +void WrappedOpenGL::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount) +{ + m_Real.glDrawArraysInstanced(mode, first, count, instancecount); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DRAWARRAYS_INSTANCED); + Serialise_glDrawArraysInstanced(mode, first, count, instancecount); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance) +{ + SERIALISE_ELEMENT(GLenum, Mode, mode); + SERIALISE_ELEMENT(int32_t, First, first); + SERIALISE_ELEMENT(uint32_t, Count, count); + SERIALISE_ELEMENT(uint32_t, InstanceCount, instancecount); + SERIALISE_ELEMENT(uint32_t, BaseInstance, baseinstance); + + if(m_State <= EXECUTING) + { + m_Real.glDrawArraysInstancedBaseInstance(Mode, First, Count, InstanceCount, BaseInstance); + } + + const string desc = m_pSerialiser->GetDebugStr(); + + if(m_State == READING) + { + AddEvent(DRAWARRAYS_INSTANCEDBASEINSTANCE, desc); + string name = "glDrawArraysInstancedBaseInstance(" + + ToStr::Get(Mode) + ", " + + ToStr::Get(First) + ", " + + ToStr::Get(Count) + ", " + + ToStr::Get(InstanceCount) + ", " + + ToStr::Get(BaseInstance) + ")"; + + FetchDrawcall draw; + draw.name = widen(name); + draw.numIndices = Count; + draw.numInstances = InstanceCount; + draw.indexOffset = 0; + draw.vertexOffset = First; + draw.instanceOffset = BaseInstance; + + draw.flags |= eDraw_Drawcall|eDraw_Instanced; + + m_LastDrawMode = Mode; + + AddDrawcall(draw, true); + } + + return true; +} + +void WrappedOpenGL::glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance) +{ + m_Real.glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DRAWARRAYS_INSTANCEDBASEINSTANCE); + Serialise_glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices) +{ + SERIALISE_ELEMENT(GLenum, Mode, mode); + SERIALISE_ELEMENT(uint32_t, Count, count); + SERIALISE_ELEMENT(GLenum, Type, type); + SERIALISE_ELEMENT(uint64_t, IdxOffset, (uint64_t)indices); + + if(m_State <= EXECUTING) + { + m_Real.glDrawElements(Mode, Count, Type, (const void *)IdxOffset); + } + + const string desc = m_pSerialiser->GetDebugStr(); + + if(m_State == READING) + { + AddEvent(DRAWELEMENTS, desc); + string name = "glDrawElements(" + + ToStr::Get(Mode) + ", " + + ToStr::Get(Count) + ", " + + ToStr::Get(Type) + ", " + + ToStr::Get(IdxOffset) + ")"; + + FetchDrawcall draw; + draw.name = widen(name); + draw.numIndices = Count; + draw.numInstances = 1; + draw.indexOffset = (uint32_t)IdxOffset; + draw.vertexOffset = 0; + draw.instanceOffset = 0; + + draw.flags |= eDraw_Drawcall|eDraw_UseIBuffer; + + m_LastDrawMode = Mode; + m_LastIndexSize = Type; + m_LastIndexOffset = (GLuint)IdxOffset; + + AddDrawcall(draw, true); + } + + return true; +} + +void WrappedOpenGL::glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices) +{ + m_Real.glDrawElements(mode, count, type, indices); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DRAWELEMENTS); + Serialise_glDrawElements(mode, count, type, indices); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices) +{ + SERIALISE_ELEMENT(GLenum, Mode, mode); + SERIALISE_ELEMENT(uint32_t, Start, start); + SERIALISE_ELEMENT(uint32_t, End, end); + SERIALISE_ELEMENT(uint32_t, Count, count); + SERIALISE_ELEMENT(GLenum, Type, type); + SERIALISE_ELEMENT(uint64_t, IdxOffset, (uint64_t)indices); + + if(m_State <= EXECUTING) + { + m_Real.glDrawRangeElements(Mode, Start, End, Count, Type, (const void *)IdxOffset); + } + + const string desc = m_pSerialiser->GetDebugStr(); + + if(m_State == READING) + { + AddEvent(DRAWELEMENTS, desc); + string name = "glDrawRangeElements(" + + ToStr::Get(Mode) + ", " + + ToStr::Get(Count) + ", " + + ToStr::Get(Type) + ", " + + ToStr::Get(IdxOffset) + ")"; + + FetchDrawcall draw; + draw.name = widen(name); + draw.numIndices = Count; + draw.numInstances = 1; + draw.indexOffset = (uint32_t)IdxOffset; + draw.vertexOffset = 0; + draw.instanceOffset = 0; + + draw.flags |= eDraw_Drawcall|eDraw_UseIBuffer; + + m_LastDrawMode = Mode; + m_LastIndexSize = Type; + m_LastIndexOffset = (GLuint)IdxOffset; + + AddDrawcall(draw, true); + } + + return true; +} + +void WrappedOpenGL::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices) +{ + m_Real.glDrawRangeElements(mode, start, end, count, type, indices); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DRAWRANGEELEMENTS); + Serialise_glDrawRangeElements(mode, start, end, count, type, indices); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex) +{ + SERIALISE_ELEMENT(GLenum, Mode, mode); + SERIALISE_ELEMENT(uint32_t, Count, count); + SERIALISE_ELEMENT(GLenum, Type, type); + SERIALISE_ELEMENT(uint64_t, IdxOffset, (uint64_t)indices); + SERIALISE_ELEMENT(int32_t, BaseVtx, basevertex); + + if(m_State <= EXECUTING) + { + m_Real.glDrawElementsBaseVertex(Mode, Count, Type, (const void *)IdxOffset, BaseVtx); + } + + const string desc = m_pSerialiser->GetDebugStr(); + + if(m_State == READING) + { + AddEvent(DRAWELEMENTS_BASEVERTEX, desc); + string name = "glDrawElementsBaseVertex(" + + ToStr::Get(Mode) + ", " + + ToStr::Get(Count) + ", " + + ToStr::Get(Type) + ", " + + ToStr::Get(IdxOffset) + ", " + + ToStr::Get(BaseVtx) + ")"; + + FetchDrawcall draw; + draw.name = widen(name); + draw.numIndices = Count; + draw.numInstances = 1; + draw.indexOffset = (uint32_t)IdxOffset; + draw.vertexOffset = BaseVtx; + draw.instanceOffset = 0; + + draw.flags |= eDraw_Drawcall|eDraw_UseIBuffer; + + m_LastDrawMode = Mode; + m_LastIndexSize = Type; + m_LastIndexOffset = (GLuint)IdxOffset; + + AddDrawcall(draw, true); + } + + return true; +} + +void WrappedOpenGL::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex) +{ + m_Real.glDrawElementsBaseVertex(mode, count, type, indices, basevertex); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DRAWELEMENTS_BASEVERTEX); + Serialise_glDrawElementsBaseVertex(mode, count, type, indices, basevertex); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount) +{ + SERIALISE_ELEMENT(GLenum, Mode, mode); + SERIALISE_ELEMENT(uint32_t, Count, count); + SERIALISE_ELEMENT(GLenum, Type, type); + SERIALISE_ELEMENT(uint64_t, IdxOffset, (uint64_t)indices); + SERIALISE_ELEMENT(uint32_t, InstCount, instancecount); + + if(m_State <= EXECUTING) + { + m_Real.glDrawElementsInstanced(Mode, Count, Type, (const void *)IdxOffset, InstCount); + } + + const string desc = m_pSerialiser->GetDebugStr(); + + if(m_State == READING) + { + AddEvent(DRAWELEMENTS_INSTANCED, desc); + string name = "glDrawElementsInstanced(" + + ToStr::Get(Mode) + ", " + + ToStr::Get(Count) + ", " + + ToStr::Get(Type) + ", " + + ToStr::Get(IdxOffset) + ", " + + ToStr::Get(InstCount) + ")"; + + FetchDrawcall draw; + draw.name = widen(name); + draw.numIndices = Count; + draw.numInstances = InstCount; + draw.indexOffset = (uint32_t)IdxOffset; + draw.vertexOffset = 0; + draw.instanceOffset = 0; + + draw.flags |= eDraw_Drawcall|eDraw_UseIBuffer; + + m_LastDrawMode = Mode; + m_LastIndexSize = Type; + m_LastIndexOffset = (GLuint)IdxOffset; + + AddDrawcall(draw, true); + } + + return true; +} + +void WrappedOpenGL::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount) +{ + m_Real.glDrawElementsInstanced(mode, count, type, indices, instancecount); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DRAWELEMENTS_INSTANCED); + Serialise_glDrawElementsInstanced(mode, count, type, indices, instancecount); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance) +{ + SERIALISE_ELEMENT(GLenum, Mode, mode); + SERIALISE_ELEMENT(uint32_t, Count, count); + SERIALISE_ELEMENT(GLenum, Type, type); + SERIALISE_ELEMENT(uint64_t, IdxOffset, (uint64_t)indices); + SERIALISE_ELEMENT(uint32_t, InstCount, instancecount); + SERIALISE_ELEMENT(uint32_t, BaseInstance, baseinstance); + + if(m_State <= EXECUTING) + { + m_Real.glDrawElementsInstancedBaseInstance(Mode, Count, Type, (const void *)IdxOffset, InstCount, BaseInstance); + } + + const string desc = m_pSerialiser->GetDebugStr(); + + if(m_State == READING) + { + AddEvent(DRAWELEMENTS_INSTANCEDBASEINSTANCE, desc); + string name = "glDrawElementsInstancedBaseInstance(" + + ToStr::Get(Mode) + ", " + + ToStr::Get(Count) + ", " + + ToStr::Get(Type) + ", " + + ToStr::Get(IdxOffset) + ", " + + ToStr::Get(InstCount) + ", " + + ToStr::Get(BaseInstance) + ")"; + + FetchDrawcall draw; + draw.name = widen(name); + draw.numIndices = Count; + draw.numInstances = InstCount; + draw.indexOffset = (uint32_t)IdxOffset; + draw.vertexOffset = 0; + draw.instanceOffset = BaseInstance; + + draw.flags |= eDraw_Drawcall|eDraw_UseIBuffer; + + m_LastDrawMode = Mode; + m_LastIndexSize = Type; + m_LastIndexOffset = (GLuint)IdxOffset; + + AddDrawcall(draw, true); + } + + return true; +} + +void WrappedOpenGL::glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance) +{ + m_Real.glDrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DRAWELEMENTS_INSTANCEDBASEINSTANCE); + Serialise_glDrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex) +{ + SERIALISE_ELEMENT(GLenum, Mode, mode); + SERIALISE_ELEMENT(uint32_t, Count, count); + SERIALISE_ELEMENT(GLenum, Type, type); + SERIALISE_ELEMENT(uint64_t, IdxOffset, (uint64_t)indices); + SERIALISE_ELEMENT(uint32_t, InstCount, instancecount); + SERIALISE_ELEMENT(int32_t, BaseVertex, basevertex); + + if(m_State <= EXECUTING) + { + m_Real.glDrawElementsInstancedBaseVertex(Mode, Count, Type, (const void *)IdxOffset, InstCount, BaseVertex); + } + + const string desc = m_pSerialiser->GetDebugStr(); + + if(m_State == READING) + { + AddEvent(DRAWELEMENTS_INSTANCEDBASEVERTEX, desc); + string name = "glDrawElementsInstancedBaseVertex(" + + ToStr::Get(Mode) + ", " + + ToStr::Get(Count) + ", " + + ToStr::Get(Type) + ", " + + ToStr::Get(IdxOffset) + ", " + + ToStr::Get(InstCount) + ", " + + ToStr::Get(BaseVertex) + ")"; + + FetchDrawcall draw; + draw.name = widen(name); + draw.numIndices = Count; + draw.numInstances = InstCount; + draw.indexOffset = (uint32_t)IdxOffset; + draw.vertexOffset = BaseVertex; + draw.instanceOffset = 0; + + draw.flags |= eDraw_Drawcall|eDraw_UseIBuffer; + + m_LastDrawMode = Mode; + m_LastIndexSize = Type; + m_LastIndexOffset = (GLuint)IdxOffset; + + AddDrawcall(draw, true); + } + + return true; +} + +void WrappedOpenGL::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex) +{ + m_Real.glDrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DRAWELEMENTS_INSTANCEDBASEVERTEX); + Serialise_glDrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance) +{ + SERIALISE_ELEMENT(GLenum, Mode, mode); + SERIALISE_ELEMENT(uint32_t, Count, count); + SERIALISE_ELEMENT(GLenum, Type, type); + SERIALISE_ELEMENT(uint64_t, IdxOffset, (uint64_t)indices); + SERIALISE_ELEMENT(uint32_t, InstCount, instancecount); + SERIALISE_ELEMENT(int32_t, BaseVertex, basevertex); + SERIALISE_ELEMENT(uint32_t, BaseInstance, baseinstance); + + if(m_State <= EXECUTING) + { + m_Real.glDrawElementsInstancedBaseVertexBaseInstance(Mode, Count, Type, (const void *)IdxOffset, InstCount, BaseVertex, BaseInstance); + } + + const string desc = m_pSerialiser->GetDebugStr(); + + if(m_State == READING) + { + AddEvent(DRAWELEMENTS_INSTANCEDBASEVERTEXBASEINSTANCE, desc); + string name = "glDrawElementsInstancedBaseVertexBaseInstance(" + + ToStr::Get(Mode) + ", " + + ToStr::Get(Count) + ", " + + ToStr::Get(Type) + ", " + + ToStr::Get(IdxOffset) + ", " + + ToStr::Get(InstCount) + ", " + + ToStr::Get(BaseVertex) + ", " + + ToStr::Get(BaseInstance) + ")"; + + FetchDrawcall draw; + draw.name = widen(name); + draw.numIndices = Count; + draw.numInstances = InstCount; + draw.indexOffset = (uint32_t)IdxOffset; + draw.vertexOffset = BaseVertex; + draw.instanceOffset = BaseInstance; + + draw.flags |= eDraw_Drawcall|eDraw_UseIBuffer; + + m_LastDrawMode = Mode; + m_LastIndexSize = Type; + m_LastIndexOffset = (GLuint)IdxOffset; + + AddDrawcall(draw, true); + } + + return true; +} + +void WrappedOpenGL::glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance) +{ + m_Real.glDrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DRAWELEMENTS_INSTANCEDBASEVERTEXBASEINSTANCE); + Serialise_glDrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value) +{ + SERIALISE_ELEMENT(GLenum, buf, buffer); + SERIALISE_ELEMENT(int32_t, draw, drawbuffer); + + if(buf != eGL_DEPTH) + { + Vec4f v; + if(value) v = *((Vec4f *)value); + + m_pSerialiser->Serialise<4>("value", (float *)&v.x); + + if(m_State <= EXECUTING) + m_Real.glClearBufferfv(buf, draw, &v.x); + } + else + { + SERIALISE_ELEMENT(float, val, *value); + + if(m_State <= EXECUTING) + m_Real.glClearBufferfv(buf, draw, &val); + } + + const string desc = m_pSerialiser->GetDebugStr(); + + if(m_State == READING) + { + AddEvent(CLEARBUFFERF, desc); + string name = "glClearBufferfv(" + + ToStr::Get(buf) + ", " + + ToStr::Get(draw) + ")"; + + FetchDrawcall draw; + draw.name = widen(name); + draw.flags |= eDraw_Clear; + + AddDrawcall(draw, true); + } + + + return true; +} + +void WrappedOpenGL::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value) +{ + m_Real.glClearBufferfv(buffer, drawbuffer, value); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(CLEARBUFFERF); + Serialise_glClearBufferfv(buffer, drawbuffer, value); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value) +{ + SERIALISE_ELEMENT(GLenum, buf, buffer); + SERIALISE_ELEMENT(int32_t, draw, drawbuffer); + + if(buf != eGL_STENCIL) + { + int32_t v[4]; + if(value) memcpy(v, value, sizeof(v)); + + m_pSerialiser->Serialise<4>("value", v); + + if(m_State <= EXECUTING) + m_Real.glClearBufferiv(buf, draw, v); + } + else + { + SERIALISE_ELEMENT(int32_t, val, *value); + + if(m_State <= EXECUTING) + m_Real.glClearBufferiv(buf, draw, &val); + } + + const string desc = m_pSerialiser->GetDebugStr(); + + if(m_State == READING) + { + AddEvent(CLEARBUFFERI, desc); + string name = "glClearBufferiv(" + + ToStr::Get(buf) + ", " + + ToStr::Get(draw) + ")"; + + FetchDrawcall draw; + draw.name = widen(name); + draw.flags |= eDraw_Clear; + + AddDrawcall(draw, true); + } + + + return true; +} + +void WrappedOpenGL::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value) +{ + m_Real.glClearBufferiv(buffer, drawbuffer, value); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(CLEARBUFFERI); + Serialise_glClearBufferiv(buffer, drawbuffer, value); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value) +{ + SERIALISE_ELEMENT(GLenum, buf, buffer); + SERIALISE_ELEMENT(int32_t, draw, drawbuffer); + + { + uint32_t v[4]; + if(value) memcpy(v, value, sizeof(v)); + + m_pSerialiser->Serialise<4>("value", v); + + if(m_State <= EXECUTING) + m_Real.glClearBufferuiv(buf, draw, v); + } + + const string desc = m_pSerialiser->GetDebugStr(); + + if(m_State == READING) + { + AddEvent(CLEARBUFFERUI, desc); + string name = "glClearBufferuiv(" + + ToStr::Get(buf) + ", " + + ToStr::Get(draw) + ")"; + + FetchDrawcall draw; + draw.name = widen(name); + draw.flags |= eDraw_Clear; + + AddDrawcall(draw, true); + } + + return true; +} + +void WrappedOpenGL::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value) +{ + m_Real.glClearBufferuiv(buffer, drawbuffer, value); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(CLEARBUFFERUI); + Serialise_glClearBufferuiv(buffer, drawbuffer, value); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) +{ + SERIALISE_ELEMENT(GLenum, buf, buffer); + SERIALISE_ELEMENT(int32_t, draw, drawbuffer); + SERIALISE_ELEMENT(float, d, depth); + SERIALISE_ELEMENT(int32_t, s, stencil); + + if(m_State <= EXECUTING) + m_Real.glClearBufferfi(buf, draw, d, s); + + const string desc = m_pSerialiser->GetDebugStr(); + + if(m_State == READING) + { + AddEvent(CLEARBUFFERFI, desc); + string name = "glClearBufferfi(" + + ToStr::Get(buf) + ", " + + ToStr::Get(draw) + ")"; + + FetchDrawcall draw; + draw.name = widen(name); + draw.flags |= eDraw_Clear; + + AddDrawcall(draw, true); + } + + return true; +} + +void WrappedOpenGL::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) +{ + m_Real.glClearBufferfi(buffer, drawbuffer, depth, stencil); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(CLEARBUFFERFI); + Serialise_glClearBufferfi(buffer, drawbuffer, depth, stencil); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glClear(GLbitfield mask) +{ + SERIALISE_ELEMENT(uint32_t, Mask, mask); + + if(m_State <= EXECUTING) + m_Real.glClear(Mask); + + const string desc = m_pSerialiser->GetDebugStr(); + + if(m_State == READING) + { + AddEvent(CLEARBUFFERF, desc); + string name = "glClear("; + if(Mask & GL_DEPTH_BUFFER_BIT) + name += "GL_DEPTH_BUFFER_BIT | "; + if(Mask & GL_COLOR_BUFFER_BIT) + name += "GL_COLOR_BUFFER_BIT | "; + if(Mask & GL_STENCIL_BUFFER_BIT) + name += "GL_STENCIL_BUFFER_BIT | "; + + if(Mask & (eGL_DEPTH_BUFFER_BIT|eGL_COLOR_BUFFER_BIT|eGL_STENCIL_BUFFER_BIT)) + { + name.pop_back(); // ' ' + name.pop_back(); // '|' + name.pop_back(); // ' ' + } + + name += ")"; + + FetchDrawcall draw; + draw.name = widen(name); + draw.flags |= eDraw_Clear; + + AddDrawcall(draw, true); + } + + return true; +} + +void WrappedOpenGL::glClear(GLbitfield mask) +{ + m_Real.glClear(mask); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(CLEAR); + Serialise_glClear(mask); + + m_ContextRecord->AddChunk(scope.Get()); + } +} diff --git a/renderdoc/driver/gl/wrappers/gl_framebuffer_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_framebuffer_funcs.cpp new file mode 100644 index 000000000..aecb756a3 --- /dev/null +++ b/renderdoc/driver/gl/wrappers/gl_framebuffer_funcs.cpp @@ -0,0 +1,346 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2014 Crytek + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "common/common.h" +#include "common/string_utils.h" +#include "../gl_driver.h" + +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); + + for(GLsizei i=0; i < n; i++) + { + GLResource res = FramebufferRes(framebuffers[i]); + ResourceId id = GetResourceManager()->RegisterResource(res); + + if(m_State >= WRITING) + { + 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 + { + GetResourceManager()->AddLiveResource(id, res); + } + } +} + +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); + + ResourceId curFrameBuffer; + + if(m_State == WRITING_IDLE) + { + if(target == eGL_DRAW_FRAMEBUFFER || target == eGL_FRAMEBUFFER) + { + if(m_DrawFramebufferRecord) + curFrameBuffer = m_DrawFramebufferRecord->GetResourceID(); + } + else + { + if(m_ReadFramebufferRecord) + curFrameBuffer = m_ReadFramebufferRecord->GetResourceID(); + } + } + + SERIALISE_ELEMENT(ResourceId, fbid, curFrameBuffer); + + if(m_State < WRITING) + { + if(m_State == READING) + { + if(fbid != ResourceId()) + { + GLResource res = GetResourceManager()->GetLiveResource(fbid); + m_Real.glBindFramebuffer(Target, res.name); + } + else + { + m_Real.glBindFramebuffer(Target, 0); + } + } + + 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) + { + 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_DrawFramebufferRecord->AddChunk(scope.Get()); + else + m_DeviceRecord->AddChunk(scope.Get()); + } + else + { + if(m_ReadFramebufferRecord) + m_ReadFramebufferRecord->AddChunk(scope.Get()); + else + m_DeviceRecord->AddChunk(scope.Get()); + } + } + else + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glReadBuffer(GLenum mode) +{ + SERIALISE_ELEMENT(GLenum, m, mode); + SERIALISE_ELEMENT(ResourceId, id, m_ReadFramebufferRecord ? m_ReadFramebufferRecord->GetResourceID() : ResourceId()); + + if(m_State < WRITING) + { + if(id != ResourceId()) + { + GLResource res = GetResourceManager()->GetLiveResource(id); + m_Real.glBindFramebuffer(eGL_READ_FRAMEBUFFER, res.name); + } + else + { + m_Real.glBindFramebuffer(eGL_READ_FRAMEBUFFER, 0); + } + + 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_glDrawBuffer(GLenum buf) +{ + SERIALISE_ELEMENT(GLenum, b, buf); + + if(m_State < WRITING) + { + m_Real.glDrawBuffer(b); + } + + return true; +} + +void WrappedOpenGL::glDrawBuffer(GLenum buf) +{ + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DRAW_BUFFER); + Serialise_glDrawBuffer(buf); + + m_ContextRecord->AddChunk(scope.Get()); + } + + m_Real.glDrawBuffer(buf); +} + +bool WrappedOpenGL::Serialise_glDrawBuffers(GLsizei n, const GLenum *bufs) +{ + SERIALISE_ELEMENT(uint32_t, num, n); + SERIALISE_ELEMENT_ARR(GLenum, buffers, bufs, num); + + if(m_State < WRITING) + { + m_Real.glDrawBuffers(num, buffers); + } + + delete[] buffers; + + return true; +} + +void WrappedOpenGL::glDrawBuffers(GLsizei n, const GLenum *bufs) +{ + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DRAW_BUFFERS); + Serialise_glDrawBuffers(n, bufs); + + m_ContextRecord->AddChunk(scope.Get()); + } + + m_Real.glDrawBuffers(n, bufs); +} + +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); + + for(GLsizei i=0; i < n; i++) + GetResourceManager()->UnregisterResource(FramebufferRes(framebuffers[i])); +} + +void WrappedOpenGL::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params) +{ + m_Real.glGetFramebufferAttachmentParameteriv(target, attachment, pname, params); +} + +GLenum WrappedOpenGL::glCheckFramebufferStatus(GLenum target) +{ + return m_Real.glCheckFramebufferStatus(target); +} diff --git a/renderdoc/driver/gl/wrappers/gl_get_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_get_funcs.cpp new file mode 100644 index 000000000..b05f5fc84 --- /dev/null +++ b/renderdoc/driver/gl/wrappers/gl_get_funcs.cpp @@ -0,0 +1,281 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2014 Crytek + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "common/common.h" +#include "common/string_utils.h" +#include "../gl_driver.h" + + +GLenum WrappedOpenGL::glGetError() +{ + return m_Real.glGetError(); +} + +void WrappedOpenGL::glFlush() +{ + m_Real.glFlush(); +} + +void WrappedOpenGL::glFinish() +{ + m_Real.glFinish(); +} + +GLboolean WrappedOpenGL::glIsEnabled(GLenum cap) +{ + return m_Real.glIsEnabled(cap); +} + +GLboolean WrappedOpenGL::glIsEnabledi(GLenum cap, GLuint index) +{ + return m_Real.glIsEnabledi(cap, index); +} + +void WrappedOpenGL::glGetFloatv(GLenum pname, GLfloat *params) +{ + m_Real.glGetFloatv(pname, params); +} + +void WrappedOpenGL::glGetDoublev(GLenum pname, GLdouble *params) +{ + m_Real.glGetDoublev(pname, params); +} + +void WrappedOpenGL::glGetIntegerv(GLenum pname, GLint *params) +{ + if(pname == GL_NUM_EXTENSIONS) + { + if(params) + *params = (GLint)glExts.size(); + return; + } + + m_Real.glGetIntegerv(pname, params); +} + +void WrappedOpenGL::glGetBooleanv(GLenum pname, GLboolean *data) +{ + m_Real.glGetBooleanv(pname, data); +} + +void WrappedOpenGL::glGetBooleani_v(GLenum pname, GLuint index, GLboolean *data) +{ + m_Real.glGetBooleani_v(pname, index, data); +} + +void WrappedOpenGL::glGetIntegeri_v(GLenum pname, GLuint index, GLint *data) +{ + m_Real.glGetIntegeri_v(pname, index, data); +} + +void WrappedOpenGL::glGetFloati_v(GLenum pname, GLuint index, GLfloat *data) +{ + m_Real.glGetFloati_v(pname, index, data); +} + +void WrappedOpenGL::glGetDoublei_v(GLenum pname, GLuint index, GLdouble *data) +{ + m_Real.glGetDoublei_v(pname, index, data); +} + +void WrappedOpenGL::glGetInteger64i_v(GLenum pname, GLuint index, GLint64 *data) +{ + m_Real.glGetInteger64i_v(pname, index, data); +} + +void WrappedOpenGL::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) +{ + m_Real.glGetTexLevelParameteriv(target, level, pname, params); +} + +void WrappedOpenGL::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) +{ + m_Real.glGetTexLevelParameterfv(target, level, pname, params); +} + +void WrappedOpenGL::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) +{ + m_Real.glGetTexParameterfv(target, pname, params); +} + +void WrappedOpenGL::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params) +{ + m_Real.glGetTexParameteriv(target, pname, params); +} + +void WrappedOpenGL::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels) +{ + m_Real.glGetTexImage(target, level, format, type, pixels); +} + +void WrappedOpenGL::glGetCompressedTexImage(GLenum target, GLint level, void *img) +{ + m_Real.glGetCompressedTexImage(target, level, img); +} + +void WrappedOpenGL::glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params) +{ + m_Real.glGetInternalformativ(target, internalformat, pname, bufSize, params); +} + +void WrappedOpenGL::glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params) +{ + m_Real.glGetInternalformati64v(target, internalformat, pname, bufSize, params); +} + +void WrappedOpenGL::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params) +{ + m_Real.glGetBufferParameteriv(target, pname, params); +} + +void WrappedOpenGL::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data) +{ + m_Real.glGetBufferSubData(target, offset, size, data); +} + +const GLubyte *WrappedOpenGL::glGetString(GLenum name) +{ + if(name == GL_EXTENSIONS) + { + return (const GLubyte *)glExtsString.c_str(); + } + return m_Real.glGetString(name); +} + +const GLubyte *WrappedOpenGL::glGetStringi(GLenum name, GLuint i) +{ + if(name == GL_EXTENSIONS) + { + if((size_t)i < glExts.size()) + return (const GLubyte *)glExts[i].c_str(); + + return (const GLubyte *)""; + } + return m_Real.glGetStringi(name, i); +} + +void WrappedOpenGL::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params) +{ + m_Real.glGetVertexAttribiv(index, pname, params); +} + +void WrappedOpenGL::glGetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer) +{ + m_Real.glGetVertexAttribPointerv(index, pname, pointer); +} + +void WrappedOpenGL::glGetShaderiv(GLuint shader, GLenum pname, GLint *params) +{ + m_Real.glGetShaderiv(shader, pname, params); +} + +void WrappedOpenGL::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog) +{ + m_Real.glGetShaderInfoLog(shader, bufSize, length, infoLog); +} + +void WrappedOpenGL::glGetProgramiv(GLuint program, GLenum pname, GLint *params) +{ + m_Real.glGetProgramiv(program, pname, params); +} + +void WrappedOpenGL::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog) +{ + m_Real.glGetProgramInfoLog(program, bufSize, length, infoLog); +} + +void WrappedOpenGL::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params) +{ + m_Real.glGetProgramPipelineiv(pipeline, pname, params); +} + +void WrappedOpenGL::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog) +{ + m_Real.glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog); +} + +void WrappedOpenGL::glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params) +{ + m_Real.glGetProgramInterfaceiv(program, programInterface, pname, params); +} + +void WrappedOpenGL::glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params) +{ + m_Real.glGetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params); +} + +void WrappedOpenGL::glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name) +{ + m_Real.glGetProgramResourceName(program, programInterface, index, bufSize, length, name); +} + +GLint WrappedOpenGL::glGetUniformLocation(GLuint program, const GLchar *name) +{ + return m_Real.glGetUniformLocation(program, name); +} + +void WrappedOpenGL::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices) +{ + m_Real.glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices); +} + +GLuint WrappedOpenGL::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName) +{ + return m_Real.glGetUniformBlockIndex(program, uniformBlockName); +} + +GLint WrappedOpenGL::glGetAttribLocation(GLuint program, const GLchar *name) +{ + return m_Real.glGetAttribLocation(program, name); +} + +void WrappedOpenGL::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) +{ + m_Real.glGetActiveUniform(program, index, bufSize, length, size, type, name); +} + +void WrappedOpenGL::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params) +{ + m_Real.glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); +} + +void WrappedOpenGL::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) +{ + m_Real.glGetActiveAttrib(program, index, bufSize, length, size, type, name); +} + +void WrappedOpenGL::glGetUniformfv(GLuint program, GLint location, GLfloat *params) +{ + m_Real.glGetUniformfv(program, location, params); +} + +void WrappedOpenGL::glGetUniformiv(GLuint program, GLint location, GLint *params) +{ + m_Real.glGetUniformiv(program, location, params); +} + +void WrappedOpenGL::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels) +{ + m_Real.glReadPixels(x, y, width, height, format, type, pixels); +} diff --git a/renderdoc/driver/gl/wrappers/gl_sampler_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_sampler_funcs.cpp new file mode 100644 index 000000000..4ca4345c0 --- /dev/null +++ b/renderdoc/driver/gl/wrappers/gl_sampler_funcs.cpp @@ -0,0 +1,302 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2014 Crytek + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "common/common.h" +#include "common/string_utils.h" +#include "../gl_driver.h" + +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); + + for(GLsizei i=0; i < count; i++) + { + GLResource res = SamplerRes(samplers[i]); + ResourceId id = GetResourceManager()->RegisterResource(res); + + if(m_State >= WRITING) + { + 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 + { + GetResourceManager()->AddLiveResource(id, res); + } + } +} + +bool WrappedOpenGL::Serialise_glBindSampler(GLuint unit, GLuint sampler) +{ + SERIALISE_ELEMENT(uint32_t, Unit, unit); + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(sampler))); + + if(m_State < WRITING) + { + GLResource res = GetResourceManager()->GetLiveResource(id); + glBindSampler(Unit, res.name); + } + + return true; +} + +void WrappedOpenGL::glBindSampler(GLuint unit, GLuint sampler) +{ + m_Real.glBindSampler(unit, sampler); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(BIND_SAMPLER); + Serialise_glBindSampler(unit, sampler); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +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) + { + 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()); + } +} + +bool WrappedOpenGL::Serialise_glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(sampler))); + SERIALISE_ELEMENT(GLenum, PName, pname); + SERIALISE_ELEMENT(float, Param, param); + + if(m_State < WRITING) + { + GLResource res = GetResourceManager()->GetLiveResource(id); + glSamplerParameterf(res.name, PName, Param); + } + + return true; +} + +void WrappedOpenGL::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) +{ + m_Real.glSamplerParameterf(sampler, pname, param); + + if(m_State >= WRITING) + { + SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERF); + Serialise_glSamplerParameterf(sampler, pname, param); + + if(m_State == WRITING_IDLE) + GetResourceManager()->GetResourceRecord(SamplerRes(sampler))->AddChunk(scope.Get()); + else + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *params) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(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); + + if(m_State < WRITING) + { + GLResource res = GetResourceManager()->GetLiveResource(id); + glSamplerParameteriv(res.name, PName, Params); + } + + delete[] Params; + + return true; +} + +void WrappedOpenGL::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *params) +{ + m_Real.glSamplerParameteriv(sampler, pname, params); + + if(m_State >= WRITING) + { + SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERIV); + Serialise_glSamplerParameteriv(sampler, pname, params); + + if(m_State == WRITING_IDLE) + GetResourceManager()->GetResourceRecord(SamplerRes(sampler))->AddChunk(scope.Get()); + else + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *params) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(sampler))); + SERIALISE_ELEMENT(GLenum, PName, pname); + const size_t nParams = (PName == eGL_TEXTURE_BORDER_COLOR ? 4U : 1U); + SERIALISE_ELEMENT_ARR(float, Params, params, nParams); + + if(m_State < WRITING) + { + GLResource res = GetResourceManager()->GetLiveResource(id); + glSamplerParameterfv(res.name, PName, Params); + } + + delete[] Params; + + return true; +} + +void WrappedOpenGL::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *params) +{ + m_Real.glSamplerParameterfv(sampler, pname, params); + + if(m_State >= WRITING) + { + SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERFV); + Serialise_glSamplerParameterfv(sampler, pname, params); + + if(m_State == WRITING_IDLE) + GetResourceManager()->GetResourceRecord(SamplerRes(sampler))->AddChunk(scope.Get()); + else + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *params) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(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); + + if(m_State < WRITING) + { + GLResource res = GetResourceManager()->GetLiveResource(id); + glSamplerParameterIiv(res.name, PName, Params); + } + + delete[] Params; + + return true; +} + +void WrappedOpenGL::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *params) +{ + m_Real.glSamplerParameterIiv(sampler, pname, params); + + if(m_State >= WRITING) + { + SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERIIV); + Serialise_glSamplerParameterIiv(sampler, pname, params); + + if(m_State == WRITING_IDLE) + GetResourceManager()->GetResourceRecord(SamplerRes(sampler))->AddChunk(scope.Get()); + else + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *params) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(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); + + if(m_State < WRITING) + { + GLResource res = GetResourceManager()->GetLiveResource(id); + glSamplerParameterIuiv(res.name, PName, Params); + } + + delete[] Params; + + return true; +} + +void WrappedOpenGL::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *params) +{ + m_Real.glSamplerParameterIuiv(sampler, pname, params); + + if(m_State >= WRITING) + { + SCOPED_SERIALISE_CONTEXT(SAMPLER_PARAMETERIUIV); + Serialise_glSamplerParameterIuiv(sampler, pname, params); + + if(m_State == WRITING_IDLE) + GetResourceManager()->GetResourceRecord(SamplerRes(sampler))->AddChunk(scope.Get()); + else + m_ContextRecord->AddChunk(scope.Get()); + } +} diff --git a/renderdoc/driver/gl/wrappers/gl_shader_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_shader_funcs.cpp new file mode 100644 index 000000000..09e9afd2f --- /dev/null +++ b/renderdoc/driver/gl/wrappers/gl_shader_funcs.cpp @@ -0,0 +1,613 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2014 Crytek + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "common/common.h" +#include "common/string_utils.h" +#include "../gl_driver.h" + + +#pragma region Shaders + +bool WrappedOpenGL::Serialise_glCreateShader(GLuint shader, GLenum type) +{ + SERIALISE_ELEMENT(GLenum, Type, type); + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ShaderRes(shader))); + + if(m_State == READING) + { + GLuint real = m_Real.glCreateShader(Type); + + GLResource res = ShaderRes(real); + + ResourceId liveId = GetResourceManager()->RegisterResource(res); + + m_Shaders[liveId].type = Type; + + if(m_State >= WRITING) + { + RDCUNIMPLEMENTED(); + } + else + { + GetResourceManager()->AddLiveResource(id, res); + } + } + + return true; +} + +GLuint WrappedOpenGL::glCreateShader(GLenum type) +{ + GLuint real = m_Real.glCreateShader(type); + + GLResource res = ShaderRes(real); + ResourceId id = GetResourceManager()->RegisterResource(res); + + if(m_State >= WRITING) + { + Chunk *chunk = NULL; + + { + SCOPED_SERIALISE_CONTEXT(CREATE_SHADER); + Serialise_glCreateShader(real, type); + + chunk = scope.Get(); + } + + GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id); + RDCASSERT(record); + + record->AddChunk(chunk); + } + else + { + GetResourceManager()->AddLiveResource(id, res); + } + + return real; +} + +bool WrappedOpenGL::Serialise_glShaderSource(GLuint shader, GLsizei count, const GLchar* const *source, const GLint *length) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ShaderRes(shader))); + SERIALISE_ELEMENT(uint32_t, Count, count); + + vector srcs; + + for(uint32_t i=0; i < Count; i++) + { + string s; + if(source) + s = length ? string(source[i], source[i] + length[i]) : string(source[i]); + + m_pSerialiser->SerialiseString("source", s); + + if(m_State == READING) + srcs.push_back(s); + } + + if(m_State == READING) + { + const char **strings = new const char*[srcs.size()]; + for(size_t i=0; i < srcs.size(); i++) + strings[i] = srcs[i].c_str(); + + ResourceId liveId = GetResourceManager()->GetLiveID(id); + + for(uint32_t i=0; i < Count; i++) + m_Shaders[liveId].sources.push_back(strings[i]); + + m_Real.glShaderSource(GetResourceManager()->GetLiveResource(id).name, Count, strings, NULL); + } + + return true; +} + +void WrappedOpenGL::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length) +{ + m_Real.glShaderSource(shader, count, string, length); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ShaderRes(shader)); + RDCASSERT(record); + { + SCOPED_SERIALISE_CONTEXT(SHADERSOURCE); + Serialise_glShaderSource(shader, count, string, length); + + record->AddChunk(scope.Get()); + } + } +} + +bool WrappedOpenGL::Serialise_glCompileShader(GLuint shader) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ShaderRes(shader))); + + if(m_State == READING) + { + m_Real.glCompileShader(GetResourceManager()->GetLiveResource(id).name); + } + + return true; +} + +void WrappedOpenGL::glCompileShader(GLuint shader) +{ + m_Real.glCompileShader(shader); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ShaderRes(shader)); + RDCASSERT(record); + { + SCOPED_SERIALISE_CONTEXT(COMPILESHADER); + Serialise_glCompileShader(shader); + + record->AddChunk(scope.Get()); + } + } +} + +void WrappedOpenGL::glReleaseShaderCompiler() +{ + m_Real.glReleaseShaderCompiler(); +} + +void WrappedOpenGL::glDeleteShader(GLuint shader) +{ + m_Real.glDeleteShader(shader); + + GetResourceManager()->UnregisterResource(ShaderRes(shader)); +} + +bool WrappedOpenGL::Serialise_glAttachShader(GLuint program, GLuint shader) +{ + SERIALISE_ELEMENT(ResourceId, progid, GetResourceManager()->GetID(ProgramRes(program))); + SERIALISE_ELEMENT(ResourceId, shadid, GetResourceManager()->GetID(ShaderRes(shader))); + + if(m_State == READING) + { + ResourceId liveProgId = GetResourceManager()->GetLiveID(progid); + ResourceId liveShadId = GetResourceManager()->GetLiveID(shadid); + + m_Programs[liveProgId].shaders.push_back(liveShadId); + + m_Real.glAttachShader(GetResourceManager()->GetLiveResource(progid).name, + GetResourceManager()->GetLiveResource(shadid).name); + } + + return true; +} + +void WrappedOpenGL::glAttachShader(GLuint program, GLuint shader) +{ + m_Real.glAttachShader(program, shader); + + if(m_State >= WRITING) + { + GLResourceRecord *progRecord = GetResourceManager()->GetResourceRecord(ProgramRes(program)); + GLResourceRecord *shadRecord = GetResourceManager()->GetResourceRecord(ShaderRes(shader)); + RDCASSERT(progRecord && shadRecord); + { + SCOPED_SERIALISE_CONTEXT(ATTACHSHADER); + Serialise_glAttachShader(program, shader); + + progRecord->AddParent(shadRecord); + progRecord->AddChunk(scope.Get()); + } + } +} + +bool WrappedOpenGL::Serialise_glDetachShader(GLuint program, GLuint shader) +{ + SERIALISE_ELEMENT(ResourceId, progid, GetResourceManager()->GetID(ProgramRes(program))); + SERIALISE_ELEMENT(ResourceId, shadid, GetResourceManager()->GetID(ShaderRes(shader))); + + if(m_State == READING) + { + ResourceId liveProgId = GetResourceManager()->GetLiveID(progid); + ResourceId liveShadId = GetResourceManager()->GetLiveID(shadid); + + if(!m_Programs[liveProgId].linked) + m_Programs[liveProgId].shaders.push_back(liveShadId); + + m_Real.glDetachShader(GetResourceManager()->GetLiveResource(progid).name, + GetResourceManager()->GetLiveResource(shadid).name); + } + + return true; +} + +void WrappedOpenGL::glDetachShader(GLuint program, GLuint shader) +{ + m_Real.glDetachShader(program, shader); + + if(m_State >= WRITING) + { + GLResourceRecord *progRecord = GetResourceManager()->GetResourceRecord(ProgramRes(program)); + RDCASSERT(progRecord); + { + SCOPED_SERIALISE_CONTEXT(DETACHSHADER); + Serialise_glDetachShader(program, shader); + + progRecord->AddChunk(scope.Get()); + } + } +} + +#pragma endregion + +#pragma region Programs + +bool WrappedOpenGL::Serialise_glCreateShaderProgramv(GLuint program, GLenum type, GLsizei count, const GLchar *const*strings) +{ + SERIALISE_ELEMENT(GLenum, Type, type); + SERIALISE_ELEMENT(int32_t, Count, count); + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(program))); + + vector src; + + for(int32_t i=0; i < Count; i++) + { + string s; + if(m_State >= WRITING) s = strings[i]; + m_pSerialiser->SerialiseString("Source", s); + if(m_State < WRITING) src.push_back(s); + } + + if(m_State == READING) + { + char **sources = new char*[Count]; + + for(int32_t i=0; i < Count; i++) + sources[i] = &src[i][0]; + + GLuint real = m_Real.glCreateShaderProgramv(Type, Count, sources); + + delete[] sources; + + GLResource res = ProgramRes(program); + + m_ResourceManager->RegisterResource(res); + GetResourceManager()->AddLiveResource(id, res); + } + + return true; +} + +GLuint WrappedOpenGL::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const*strings) +{ + GLuint real = m_Real.glCreateShaderProgramv(type, count, strings); + + GLResource res = ProgramRes(real); + ResourceId id = GetResourceManager()->RegisterResource(res); + + if(m_State >= WRITING) + { + Chunk *chunk = NULL; + + { + SCOPED_SERIALISE_CONTEXT(CREATE_SHADERPROGRAM); + Serialise_glCreateShaderProgramv(real, type, count, strings); + + chunk = scope.Get(); + } + + GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id); + RDCASSERT(record); + + record->AddChunk(chunk); + } + else + { + GetResourceManager()->AddLiveResource(id, res); + } + + return real; +} + +bool WrappedOpenGL::Serialise_glCreateProgram(GLuint program) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(program))); + + if(m_State == READING) + { + GLuint real = m_Real.glCreateProgram(); + + GLResource res = ProgramRes(real); + + m_ResourceManager->RegisterResource(res); + GetResourceManager()->AddLiveResource(id, res); + } + + return true; +} + +GLuint WrappedOpenGL::glCreateProgram() +{ + GLuint real = m_Real.glCreateProgram(); + + GLResource res = ProgramRes(real); + ResourceId id = GetResourceManager()->RegisterResource(res); + + if(m_State >= WRITING) + { + Chunk *chunk = NULL; + + { + SCOPED_SERIALISE_CONTEXT(CREATE_PROGRAM); + Serialise_glCreateProgram(real); + + chunk = scope.Get(); + } + + GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id); + RDCASSERT(record); + + record->AddChunk(chunk); + } + else + { + GetResourceManager()->AddLiveResource(id, res); + } + + return real; +} + +bool WrappedOpenGL::Serialise_glLinkProgram(GLuint program) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(program))); + + if(m_State == READING) + { + ResourceId progid = GetResourceManager()->GetLiveID(id); + + m_Programs[progid].linked = true; + + m_Real.glLinkProgram(GetResourceManager()->GetLiveResource(id).name); + } + + return true; +} + +void WrappedOpenGL::glLinkProgram(GLuint program) +{ + m_Real.glLinkProgram(program); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program)); + RDCASSERT(record); + { + SCOPED_SERIALISE_CONTEXT(LINKPROGRAM); + Serialise_glLinkProgram(program); + + record->AddChunk(scope.Get()); + } + } +} + +bool WrappedOpenGL::Serialise_glProgramParameteri(GLuint program, GLenum pname, GLint value) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(program))); + SERIALISE_ELEMENT(GLenum, PName, pname); + SERIALISE_ELEMENT(int32_t, Value, value); + + if(m_State == READING) + { + m_Real.glProgramParameteri(GetResourceManager()->GetLiveResource(id).name, PName, Value); + } + + return true; +} + +void WrappedOpenGL::glProgramParameteri(GLuint program, GLenum pname, GLint value) +{ + m_Real.glProgramParameteri(program, pname, value); + + if(m_State >= WRITING) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program)); + RDCASSERT(record); + { + SCOPED_SERIALISE_CONTEXT(PROGRAMPARAMETER); + Serialise_glProgramParameteri(program, pname, value); + + record->AddChunk(scope.Get()); + } + } +} + +void WrappedOpenGL::glDeleteProgram(GLuint program) +{ + m_Real.glDeleteProgram(program); + + GetResourceManager()->UnregisterResource(ProgramRes(program)); +} + +bool WrappedOpenGL::Serialise_glUseProgram(GLuint program) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(program))); + + if(m_State <= EXECUTING) + { + m_Real.glUseProgram(GetResourceManager()->GetLiveResource(id).name); + } + + return true; +} + +void WrappedOpenGL::glUseProgram(GLuint program) +{ + m_Real.glUseProgram(program); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(USEPROGRAM); + Serialise_glUseProgram(program); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +void WrappedOpenGL::glValidateProgram(GLuint program) +{ + m_Real.glValidateProgram(program); +} + +void WrappedOpenGL::glValidateProgramPipeline(GLuint pipeline) +{ + m_Real.glValidateProgramPipeline(pipeline); +} + +#pragma endregion + +#pragma region Program Pipelines + +bool WrappedOpenGL::Serialise_glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program) +{ + SERIALISE_ELEMENT(ResourceId, pipe, GetResourceManager()->GetID(ProgramPipeRes(pipeline))); + SERIALISE_ELEMENT(uint32_t, Stages, stages); + SERIALISE_ELEMENT(ResourceId, prog, GetResourceManager()->GetID(ProgramRes(program))); + + if(m_State < WRITING) + { + m_Real.glUseProgramStages(GetResourceManager()->GetLiveResource(pipe).name, + stages, + GetResourceManager()->GetLiveResource(prog).name); + } + + return true; +} + +void WrappedOpenGL::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program) +{ + m_Real.glUseProgramStages(pipeline, stages, program); + + if(m_State > WRITING) + { + SCOPED_SERIALISE_CONTEXT(USE_PROGRAMSTAGES); + Serialise_glUseProgramStages(pipeline, stages, program); + + if(m_State == WRITING_CAPFRAME) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramPipeRes(pipeline)); + RDCASSERT(record); + record->AddChunk(scope.Get()); + + GLResourceRecord *progrecord = GetResourceManager()->GetResourceRecord(ProgramRes(program)); + record->AddParent(progrecord); + } + else + { + m_ContextRecord->AddChunk(scope.Get()); + } + } +} + +bool WrappedOpenGL::Serialise_glGenProgramPipelines(GLsizei n, GLuint* pipelines) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramPipeRes(*pipelines))); + + if(m_State == READING) + { + GLuint real = 0; + m_Real.glGenProgramPipelines(1, &real); + + GLResource res = ProgramPipeRes(real); + + ResourceId live = m_ResourceManager->RegisterResource(res); + GetResourceManager()->AddLiveResource(id, res); + } + + return true; +} + +void WrappedOpenGL::glGenProgramPipelines(GLsizei n, GLuint *pipelines) +{ + m_Real.glGenProgramPipelines(n, pipelines); + + for(GLsizei i=0; i < n; i++) + { + GLResource res = ProgramPipeRes(pipelines[i]); + ResourceId id = GetResourceManager()->RegisterResource(res); + + if(m_State >= WRITING) + { + Chunk *chunk = NULL; + + { + SCOPED_SERIALISE_CONTEXT(GEN_PROGRAMPIPE); + Serialise_glGenProgramPipelines(1, pipelines+i); + + chunk = scope.Get(); + } + + GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id); + RDCASSERT(record); + + record->AddChunk(chunk); + } + else + { + GetResourceManager()->AddLiveResource(id, res); + } + } +} + +bool WrappedOpenGL::Serialise_glBindProgramPipeline(GLuint pipeline) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramPipeRes(pipeline))); + + if(m_State <= EXECUTING) + { + m_Real.glBindProgramPipeline(GetResourceManager()->GetLiveResource(id).name); + } + + return true; +} + +void WrappedOpenGL::glBindProgramPipeline(GLuint pipeline) +{ + m_Real.glBindProgramPipeline(pipeline); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(BIND_PROGRAMPIPE); + Serialise_glBindProgramPipeline(pipeline); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +void WrappedOpenGL::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines) +{ + m_Real.glDeleteProgramPipelines(n, pipelines); + + for(GLsizei i=0; i < n; i++) + GetResourceManager()->UnregisterResource(ProgramPipeRes(pipelines[i])); +} + +#pragma endregion diff --git a/renderdoc/driver/gl/wrappers/gl_state_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_state_funcs.cpp new file mode 100644 index 000000000..6bda7b81a --- /dev/null +++ b/renderdoc/driver/gl/wrappers/gl_state_funcs.cpp @@ -0,0 +1,1103 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2014 Crytek + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "common/common.h" +#include "common/string_utils.h" +#include "../gl_driver.h" + + +bool WrappedOpenGL::Serialise_glBlendFunc(GLenum sfactor, GLenum dfactor) +{ + SERIALISE_ELEMENT(GLenum, s, sfactor); + SERIALISE_ELEMENT(GLenum, d, dfactor); + + if(m_State <= EXECUTING) + { + m_Real.glBlendFunc(s, d); + } + + return true; +} + +void WrappedOpenGL::glBlendFunc(GLenum sfactor, GLenum dfactor) +{ + m_Real.glBlendFunc(sfactor, dfactor); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(BLEND_FUNC); + Serialise_glBlendFunc(sfactor, dfactor); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glBlendFunci(GLuint buf, GLenum src, GLenum dst) +{ + SERIALISE_ELEMENT(GLuint, b, buf); + SERIALISE_ELEMENT(GLenum, s, src); + SERIALISE_ELEMENT(GLenum, d, dst); + + if(m_State <= EXECUTING) + { + m_Real.glBlendFunci(b, s, d); + } + + return true; +} + +void WrappedOpenGL::glBlendFunci(GLuint buf, GLenum src, GLenum dst) +{ + m_Real.glBlendFunci(buf, src, dst); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(BLEND_FUNCI); + Serialise_glBlendFunci(buf, src, dst); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glBlendColor(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); + + if(m_State <= EXECUTING) + { + m_Real.glBlendColor(r, g, b, a); + } + + return true; +} + +void WrappedOpenGL::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + m_Real.glBlendColor(red, green, blue, alpha); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(BLEND_COLOR); + Serialise_glBlendColor(red, green, blue, alpha); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glBlendFuncSeparate(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); + + if(m_State <= EXECUTING) + { + m_Real.glBlendFuncSeparate(s1, d1, s2, d2); + } + + return true; +} + +void WrappedOpenGL::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + m_Real.glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(BLEND_FUNC_SEP); + Serialise_glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glBlendFuncSeparatei(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); + + if(m_State <= EXECUTING) + { + m_Real.glBlendFuncSeparatei(b, s1, d1, s2, d2); + } + + return true; +} + +void WrappedOpenGL::glBlendFuncSeparatei(GLuint buf, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) +{ + m_Real.glBlendFuncSeparatei(buf, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(BLEND_FUNC_SEPI); + Serialise_glBlendFuncSeparatei(buf, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) +{ + SERIALISE_ELEMENT(GLenum, m1, modeRGB); + SERIALISE_ELEMENT(GLenum, m2, modeAlpha); + + if(m_State <= EXECUTING) + { + m_Real.glBlendEquationSeparate(m1, m2); + } + + return true; +} + +void WrappedOpenGL::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) +{ + m_Real.glBlendEquationSeparate(modeRGB, modeAlpha); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(BLEND_EQ_SEP); + Serialise_glBlendEquationSeparate(modeRGB, modeAlpha); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha) +{ + SERIALISE_ELEMENT(uint32_t, b, buf); + SERIALISE_ELEMENT(GLenum, m1, modeRGB); + SERIALISE_ELEMENT(GLenum, m2, modeAlpha); + + if(m_State <= EXECUTING) + { + m_Real.glBlendEquationSeparatei(b, m1, m2); + } + + return true; +} + +void WrappedOpenGL::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha) +{ + m_Real.glBlendEquationSeparatei(buf, modeRGB, modeAlpha); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(BLEND_EQ_SEPI); + Serialise_glBlendEquationSeparatei(buf, modeRGB, modeAlpha); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glStencilFunc(GLenum func, GLint ref, GLuint mask) +{ + SERIALISE_ELEMENT(GLenum, f, func); + SERIALISE_ELEMENT(int32_t, Ref, ref); + SERIALISE_ELEMENT(uint32_t, Mask, mask); + + if(m_State <= EXECUTING) + { + m_Real.glStencilFunc(f, Ref, Mask); + } + + return true; +} + +void WrappedOpenGL::glStencilFunc(GLenum func, GLint ref, GLuint mask) +{ + m_Real.glStencilFunc(func, ref, mask); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(STENCIL_FUNC); + Serialise_glStencilFunc(func, ref, mask); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glStencilFuncSeparate(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); + + if(m_State <= EXECUTING) + { + m_Real.glStencilFuncSeparate(Face, f, Ref, Mask); + } + + return true; +} + +void WrappedOpenGL::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) +{ + m_Real.glStencilFuncSeparate(face, func, ref, mask); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(STENCIL_FUNC_SEP); + Serialise_glStencilFuncSeparate(face, func, ref, mask); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glStencilMask(GLuint mask) +{ + SERIALISE_ELEMENT(uint32_t, Mask, mask); + + if(m_State <= EXECUTING) + { + m_Real.glStencilMask(Mask); + } + + return true; +} + +void WrappedOpenGL::glStencilMask(GLuint mask) +{ + m_Real.glStencilMask(mask); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(STENCIL_MASK); + Serialise_glStencilMask(mask); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glStencilMaskSeparate(GLenum face, GLuint mask) +{ + SERIALISE_ELEMENT(GLenum, Face, face); + SERIALISE_ELEMENT(uint32_t, Mask, mask); + + if(m_State <= EXECUTING) + { + m_Real.glStencilMaskSeparate(Face, Mask); + } + + return true; +} + +void WrappedOpenGL::glStencilMaskSeparate(GLenum face, GLuint mask) +{ + m_Real.glStencilMaskSeparate(face, mask); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(STENCIL_MASK_SEP); + Serialise_glStencilMaskSeparate(face, mask); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) +{ + SERIALISE_ELEMENT(GLenum, f, fail); + SERIALISE_ELEMENT(GLenum, zf, zfail); + SERIALISE_ELEMENT(GLenum, p, zpass); + + if(m_State <= EXECUTING) + { + m_Real.glStencilOp(f, zf, p); + } + + return true; +} + +void WrappedOpenGL::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) +{ + m_Real.glStencilOp(fail, zfail, zpass); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(STENCIL_OP); + Serialise_glStencilOp(fail, zfail, zpass); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glStencilOpSeparate(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); + + if(m_State <= EXECUTING) + { + m_Real.glStencilOpSeparate(Face, sf, zf, p); + } + + return true; +} + +void WrappedOpenGL::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) +{ + m_Real.glStencilOpSeparate(face, sfail, dpfail, dppass); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(STENCIL_OP_SEP); + Serialise_glStencilOpSeparate(face, sfail, dpfail, dppass); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glClearColor(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); + + if(m_State <= EXECUTING) + { + m_Real.glClearColor(r, g, b, a); + } + + return true; +} + +void WrappedOpenGL::glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) +{ + m_Real.glClearColor(red, green, blue, alpha); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(CLEAR_COLOR); + Serialise_glClearColor(red, green, blue, alpha); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glClearDepth(GLclampd depth) +{ + SERIALISE_ELEMENT(double, d, depth); + + if(m_State <= EXECUTING) + { + m_Real.glClearDepth(d); + } + + return true; +} + +void WrappedOpenGL::glClearDepth(GLclampd depth) +{ + m_Real.glClearDepth(depth); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(CLEAR_DEPTH); + Serialise_glClearDepth(depth); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glDepthFunc(GLenum func) +{ + SERIALISE_ELEMENT(GLenum, f, func); + + if(m_State <= EXECUTING) + { + m_Real.glDepthFunc(f); + } + + return true; +} + +void WrappedOpenGL::glDepthFunc(GLenum func) +{ + m_Real.glDepthFunc(func); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DEPTH_FUNC); + Serialise_glDepthFunc(func); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glDepthMask(GLboolean flag) +{ + SERIALISE_ELEMENT(uint8_t, f, flag); + + if(m_State <= EXECUTING) + { + m_Real.glDepthMask(f); + } + + return true; +} + +void WrappedOpenGL::glDepthMask(GLboolean flag) +{ + m_Real.glDepthMask(flag); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DEPTH_MASK); + Serialise_glDepthMask(flag); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glDepthRange(GLdouble nearVal, GLdouble farVal) +{ + SERIALISE_ELEMENT(GLdouble, n, nearVal); + SERIALISE_ELEMENT(GLdouble, f, farVal); + + if(m_State <= EXECUTING) + m_Real.glDepthRange(n, f); + + return true; +} + +void WrappedOpenGL::glDepthRange(GLdouble nearVal, GLdouble farVal) +{ + m_Real.glDepthRange(nearVal, farVal); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DEPTH_RANGE); + Serialise_glDepthRange(nearVal, farVal); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +void WrappedOpenGL::glDepthRangef(GLfloat nearVal, GLfloat farVal) +{ + glDepthRange(nearVal, farVal); +} + +bool WrappedOpenGL::Serialise_glDepthRangeArrayv(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); + + if(m_State <= EXECUTING) + { + m_Real.glDepthRangeArrayv(idx, cnt, ranges); + } + + delete[] ranges; + + return true; +} + +void WrappedOpenGL::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v) +{ + m_Real.glDepthRangeArrayv(first, count, v); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DEPTH_RANGEARRAY); + Serialise_glDepthRangeArrayv(first, count, v); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glDepthBoundsEXT(GLclampd nearVal, GLclampd farVal) +{ + SERIALISE_ELEMENT(GLdouble, n, nearVal); + SERIALISE_ELEMENT(GLdouble, f, farVal); + + if(m_State <= EXECUTING) + { + m_Real.glDepthBoundsEXT(n, f); + } + + return true; +} + +void WrappedOpenGL::glDepthBoundsEXT(GLclampd nearVal, GLclampd farVal) +{ + m_Real.glDepthBoundsEXT(nearVal, farVal); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DEPTH_BOUNDS); + Serialise_glDepthBoundsEXT(nearVal, farVal); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glDisable(GLenum cap) +{ + SERIALISE_ELEMENT(GLenum, c, cap); + + if(m_State <= EXECUTING) + { + m_Real.glDisable(c); + } + + return true; +} + +void WrappedOpenGL::glDisable(GLenum cap) +{ + m_Real.glDisable(cap); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DISABLE); + Serialise_glDisable(cap); + + m_ContextRecord->AddChunk(scope.Get()); + } + // TODO replace this with glIsEnabled() for the relevant states + if(m_State == WRITING_IDLE) + { + SCOPED_SERIALISE_CONTEXT(DISABLE); + Serialise_glDisable(cap); + + m_DeviceRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glEnable(GLenum cap) +{ + SERIALISE_ELEMENT(GLenum, c, cap); + + if(m_State <= EXECUTING) + { + m_Real.glEnable(c); + } + + return true; +} + +void WrappedOpenGL::glEnable(GLenum cap) +{ + m_Real.glEnable(cap); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(ENABLE); + Serialise_glEnable(cap); + + m_ContextRecord->AddChunk(scope.Get()); + } + // TODO replace this with glIsEnabled() for the relevant states + if(m_State == WRITING_IDLE) + { + SCOPED_SERIALISE_CONTEXT(ENABLE); + Serialise_glEnable(cap); + + m_DeviceRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glDisablei(GLenum cap, GLuint index) +{ + SERIALISE_ELEMENT(GLenum, c, cap); + SERIALISE_ELEMENT(uint32_t, i, index); + + if(m_State <= EXECUTING) + { + m_Real.glDisablei(c, i); + } + + return true; +} + +void WrappedOpenGL::glDisablei(GLenum cap, GLuint index) +{ + m_Real.glDisablei(cap, index); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DISABLEI); + Serialise_glDisablei(cap, index); + + m_ContextRecord->AddChunk(scope.Get()); + } + // TODO replace this with glIsEnabled() for the relevant states + if(m_State == WRITING_IDLE) + { + SCOPED_SERIALISE_CONTEXT(DISABLEI); + Serialise_glDisablei(cap, index); + + m_DeviceRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glEnablei(GLenum cap, GLuint index) +{ + SERIALISE_ELEMENT(GLenum, c, cap); + SERIALISE_ELEMENT(uint32_t, i, index); + + if(m_State <= EXECUTING) + { + m_Real.glEnablei(c, i); + } + + return true; +} + +void WrappedOpenGL::glEnablei(GLenum cap, GLuint index) +{ + m_Real.glEnablei(cap, index); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(ENABLEI); + Serialise_glEnablei(cap, index); + + m_ContextRecord->AddChunk(scope.Get()); + } + // TODO replace this with glIsEnabled() for the relevant states + if(m_State == WRITING_IDLE) + { + SCOPED_SERIALISE_CONTEXT(ENABLEI); + Serialise_glEnablei(cap, index); + + m_DeviceRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glFrontFace(GLenum mode) +{ + SERIALISE_ELEMENT(GLenum, m, mode); + + if(m_State <= EXECUTING) + { + m_Real.glFrontFace(m); + } + + return true; +} + +void WrappedOpenGL::glFrontFace(GLenum mode) +{ + m_Real.glFrontFace(mode); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(FRONT_FACE); + Serialise_glFrontFace(mode); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glCullFace(GLenum mode) +{ + SERIALISE_ELEMENT(GLenum, m, mode); + + if(m_State <= EXECUTING) + { + m_Real.glCullFace(m); + } + + return true; +} + +void WrappedOpenGL::glCullFace(GLenum mode) +{ + m_Real.glCullFace(mode); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(CULL_FACE); + Serialise_glCullFace(mode); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +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); + + 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) +{ + SERIALISE_ELEMENT(uint8_t, r, red); + SERIALISE_ELEMENT(uint8_t, g, green); + SERIALISE_ELEMENT(uint8_t, b, blue); + SERIALISE_ELEMENT(uint8_t, a, alpha); + + if(m_State <= EXECUTING) + { + m_Real.glColorMask(r, g, b, a); + } + + return true; +} + +void WrappedOpenGL::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + m_Real.glColorMask(red, green, blue, alpha); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(COLOR_MASK); + Serialise_glColorMask(red, green, blue, alpha); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glColorMaski(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); + + if(m_State <= EXECUTING) + { + m_Real.glColorMaski(buffer, r, g, b, a); + } + + return true; +} + +void WrappedOpenGL::glColorMaski(GLuint buf, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + m_Real.glColorMaski(buf, red, green, blue, alpha); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(COLOR_MASKI); + Serialise_glColorMaski(buf, red, green, blue, alpha); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glSampleMaski(GLuint maskNumber, GLbitfield mask) +{ + SERIALISE_ELEMENT(uint32_t, num, maskNumber); + SERIALISE_ELEMENT(uint32_t, Mask, mask); + + if(m_State <= EXECUTING) + { + m_Real.glSampleMaski(num, Mask); + } + + return true; +} + +void WrappedOpenGL::glSampleMaski(GLuint maskNumber, GLbitfield mask) +{ + m_Real.glSampleMaski(maskNumber, mask); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(SAMPLE_MASK); + Serialise_glSampleMaski(maskNumber, mask); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glPatchParameteri(GLenum pname, GLint value) +{ + SERIALISE_ELEMENT(GLenum, PName, pname); + SERIALISE_ELEMENT(int32_t, Value, value); + + if(m_State <= EXECUTING) + { + m_Real.glPatchParameteri(PName, Value); + } + + return true; +} + +void WrappedOpenGL::glPatchParameteri(GLenum pname, GLint value) +{ + m_Real.glPatchParameteri(pname, value); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(PATCH_PARAMI); + Serialise_glPatchParameteri(pname, value); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glPatchParameterfv(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); + + if(m_State <= EXECUTING) + { + m_Real.glPatchParameterfv(PName, Values); + } + + delete[] Values; + + return true; +} + +void WrappedOpenGL::glPatchParameterfv(GLenum pname, const GLfloat *values) +{ + m_Real.glPatchParameterfv(pname, values); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(PATCH_PARAMFV); + Serialise_glPatchParameterfv(pname, values); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glViewport(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); + + if(m_State <= EXECUTING) + { + m_Real.glViewport(X, Y, W, H); + } + + return true; +} + +void WrappedOpenGL::glViewport(GLint x, GLint y, GLsizei width, GLsizei height) +{ + m_Real.glViewport(x, y, width, height); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(VIEWPORT); + Serialise_glViewport(x, y, width, height); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glViewportArrayv(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); + + if(m_State <= EXECUTING) + { + m_Real.glViewportArrayv(idx, cnt, views); + } + + delete[] views; + + return true; +} + +void WrappedOpenGL::glViewportArrayv(GLuint index, GLuint count, const GLfloat *v) +{ + m_Real.glViewportArrayv(index, count, v); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(VIEWPORT_ARRAY); + Serialise_glViewportArrayv(index, count, v); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +void WrappedOpenGL::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) +{ + const float v[4] = { x, y, w, h }; + glViewportArrayv(index, 1, v); +} + +void WrappedOpenGL::glViewportIndexedfv(GLuint index, const GLfloat *v) +{ + glViewportArrayv(index, 1, v); +} + +bool WrappedOpenGL::Serialise_glScissor(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); + + if(m_State <= EXECUTING) + { + m_Real.glScissor(X, Y, W, H); + } + + return true; +} + +void WrappedOpenGL::glScissor(GLint x, GLint y, GLsizei width, GLsizei height) +{ + m_Real.glScissor(x, y, width, height); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(SCISSOR); + Serialise_glScissor(x, y, width, height); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glScissorArrayv(GLuint index, 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); + + if(m_State <= EXECUTING) + { + m_Real.glScissorArrayv(idx, cnt, scissors); + } + + delete[] scissors; + + return true; +} + +void WrappedOpenGL::glScissorArrayv(GLuint first, GLsizei count, const GLint *v) +{ + m_Real.glScissorArrayv(first, count, v); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(SCISSOR_ARRAY); + Serialise_glScissorArrayv(first, count, v); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +void WrappedOpenGL::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) +{ + const GLint v[4] = { left, bottom, width, height }; + glScissorArrayv(index, 1, v); +} + +void WrappedOpenGL::glScissorIndexedv(GLuint index, const GLint *v) +{ + glScissorArrayv(index, 1, v); +} + +bool WrappedOpenGL::Serialise_glPolygonMode(GLenum face, GLenum mode) +{ + SERIALISE_ELEMENT(GLenum, f, face); + SERIALISE_ELEMENT(GLenum, m, mode); + + if(m_State <= EXECUTING) + { + m_Real.glPolygonMode(f, m); + } + + return true; +} + +void WrappedOpenGL::glPolygonMode(GLenum face, GLenum mode) +{ + m_Real.glPolygonMode(face, mode); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(POLYGON_MODE); + Serialise_glPolygonMode(face, mode); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glPolygonOffset(GLfloat factor, GLfloat units) +{ + SERIALISE_ELEMENT(float, f, factor); + SERIALISE_ELEMENT(float, u, units); + + if(m_State <= EXECUTING) + { + m_Real.glPolygonOffset(f, u); + } + + return true; +} + +void WrappedOpenGL::glPolygonOffset(GLfloat factor, GLfloat units) +{ + m_Real.glPolygonOffset(factor, units); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(POLYGON_OFFSET); + Serialise_glPolygonOffset(factor, units); + + m_ContextRecord->AddChunk(scope.Get()); + } +} diff --git a/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp new file mode 100644 index 000000000..e0fd965a9 --- /dev/null +++ b/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp @@ -0,0 +1,819 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2014 Crytek + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "common/common.h" +#include "common/string_utils.h" +#include "../gl_driver.h" + +bool WrappedOpenGL::Serialise_glGenTextures(GLsizei n, GLuint* textures) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(*textures))); + + if(m_State == READING) + { + GLuint real = 0; + m_Real.glGenTextures(1, &real); + + GLResource res = TextureRes(real); + + ResourceId live = m_ResourceManager->RegisterResource(res); + GetResourceManager()->AddLiveResource(id, res); + + m_Textures[live].resource = res; + m_Textures[live].curType = eGL_UNKNOWN_ENUM; + } + + return true; +} + +void WrappedOpenGL::glGenTextures(GLsizei n, GLuint* textures) +{ + m_Real.glGenTextures(n, textures); + + for(GLsizei i=0; i < n; i++) + { + GLResource res = TextureRes(textures[i]); + ResourceId id = GetResourceManager()->RegisterResource(res); + + if(m_State >= WRITING) + { + Chunk *chunk = NULL; + + { + SCOPED_SERIALISE_CONTEXT(GEN_TEXTURE); + Serialise_glGenTextures(1, textures+i); + + chunk = scope.Get(); + } + + GLResourceRecord *record = GetResourceManager()->AddResourceRecord(id); + RDCASSERT(record); + + record->AddChunk(chunk); + } + else + { + GetResourceManager()->AddLiveResource(id, res); + m_Textures[id].resource = res; + m_Textures[id].curType = eGL_UNKNOWN_ENUM; + } + } +} + +void WrappedOpenGL::glDeleteTextures(GLsizei n, const GLuint *textures) +{ + m_Real.glDeleteTextures(n, textures); + + for(GLsizei i=0; i < n; i++) + GetResourceManager()->UnregisterResource(TextureRes(textures[i])); +} + +bool WrappedOpenGL::Serialise_glBindTexture(GLenum target, GLuint texture) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(ResourceId, Id, GetResourceManager()->GetID(TextureRes(texture))); + + if(m_State == WRITING_IDLE) + { + m_TextureRecord[m_TextureUnit]->datatype = Target; + } + else if(m_State < WRITING) + { + if(Id == ResourceId()) + { + m_Real.glBindTexture(Target, 0); + } + else + { + GLResource res = GetResourceManager()->GetLiveResource(Id); + m_Real.glBindTexture(Target, res.name); + + m_Textures[GetResourceManager()->GetLiveID(Id)].curType = Target; + } + } + + return true; +} + +void WrappedOpenGL::glBindTexture(GLenum target, GLuint texture) +{ + m_Real.glBindTexture(target, texture); + + if(m_State == WRITING_CAPFRAME) + { + Chunk *chunk = NULL; + + { + SCOPED_SERIALISE_CONTEXT(BIND_TEXTURE); + Serialise_glBindTexture(target, texture); + + chunk = scope.Get(); + } + + m_ContextRecord->AddChunk(chunk); + } + else if(m_State < WRITING) + { + m_Textures[GetResourceManager()->GetID(TextureRes(texture))].curType = target; + } + + if(texture == 0) + { + m_TextureRecord[m_TextureUnit] = NULL; + return; + } + + if(m_State >= WRITING) + { + GLResourceRecord *r = m_TextureRecord[m_TextureUnit] = GetResourceManager()->GetResourceRecord(TextureRes(texture)); + + if(r->datatype) + { + // it's illegal to retype a texture + RDCASSERT(r->datatype == target); + } + else + { + Chunk *chunk = NULL; + + { + SCOPED_SERIALISE_CONTEXT(BIND_TEXTURE); + Serialise_glBindTexture(target, texture); + + chunk = scope.Get(); + } + + r->AddChunk(chunk); + } + } +} + + +bool WrappedOpenGL::Serialise_glGenerateMipmap(GLenum target) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + + if(m_State == READING) + { + m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); + m_Real.glGenerateMipmap(Target); + } + + return true; +} + +void WrappedOpenGL::glGenerateMipmap(GLenum target) +{ + m_Real.glGenerateMipmap(target); + + RDCASSERT(m_TextureRecord[m_TextureUnit]); + { + SCOPED_SERIALISE_CONTEXT(GENERATE_MIPMAP); + Serialise_glGenerateMipmap(target); + + m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glTexParameteri(GLenum target, GLenum pname, GLint param) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(GLenum, PName, pname); + SERIALISE_ELEMENT(int32_t, Param, param); + SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + + if(m_State < WRITING) + { + if(m_State == READING) + m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); + glTexParameteri(Target, PName, Param); + } + + return true; +} + +void WrappedOpenGL::glTexParameteri(GLenum target, GLenum pname, GLint param) +{ + m_Real.glTexParameteri(target, pname, param); + + if(m_State >= WRITING) + { + RDCASSERT(m_TextureRecord[m_TextureUnit]); + + SCOPED_SERIALISE_CONTEXT(TEXPARAMETERI); + Serialise_glTexParameteri(target, pname, param); + + if(m_State == WRITING_IDLE) + m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + else + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glTexParameteriv(GLenum target, GLenum pname, const GLint *params) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(GLenum, PName, pname); + SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + const size_t nParams = (PName == eGL_TEXTURE_BORDER_COLOR ? 4U : 1U); + SERIALISE_ELEMENT_ARR(int32_t, Params, params, nParams); + + if(m_State < WRITING) + { + if(m_State == READING) + m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); + glTexParameteriv(Target, PName, Params); + } + + delete[] Params; + + return true; +} + +void WrappedOpenGL::glTexParameteriv(GLenum target, GLenum pname, const GLint *params) +{ + m_Real.glTexParameteriv(target, pname, params); + + if(m_State >= WRITING) + { + RDCASSERT(m_TextureRecord[m_TextureUnit]); + + SCOPED_SERIALISE_CONTEXT(TEXPARAMETERIV); + Serialise_glTexParameteriv(target, pname, params); + + if(m_State == WRITING_IDLE) + m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + else + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glTexParameterf(GLenum target, GLenum pname, GLfloat param) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(GLenum, PName, pname); + SERIALISE_ELEMENT(float, Param, param); + SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + + if(m_State < WRITING) + { + if(m_State == READING) + m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); + glTexParameterf(Target, PName, Param); + } + + return true; +} + +void WrappedOpenGL::glTexParameterf(GLenum target, GLenum pname, GLfloat param) +{ + m_Real.glTexParameterf(target, pname, param); + + if(m_State >= WRITING) + { + RDCASSERT(m_TextureRecord[m_TextureUnit]); + + SCOPED_SERIALISE_CONTEXT(TEXPARAMETERF); + Serialise_glTexParameterf(target, pname, param); + + if(m_State == WRITING_IDLE) + m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + else + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(GLenum, PName, pname); + SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + const size_t nParams = (PName == eGL_TEXTURE_BORDER_COLOR ? 4U : 1U); + SERIALISE_ELEMENT_ARR(float, Params, params, nParams); + + if(m_State < WRITING) + { + if(m_State == READING) + m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); + glTexParameterfv(Target, PName, Params); + } + + delete[] Params; + + return true; +} + +void WrappedOpenGL::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) +{ + m_Real.glTexParameterfv(target, pname, params); + + if(m_State >= WRITING) + { + RDCASSERT(m_TextureRecord[m_TextureUnit]); + + SCOPED_SERIALISE_CONTEXT(TEXPARAMETERFV); + Serialise_glTexParameterfv(target, pname, params); + + if(m_State == WRITING_IDLE) + m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + else + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glPixelStorei(GLenum pname, GLint param) +{ + SERIALISE_ELEMENT(GLenum, PName, pname); + SERIALISE_ELEMENT(int32_t, Param, param); + + if(m_State < WRITING) + m_Real.glPixelStorei(PName, Param); + + return true; +} + +void WrappedOpenGL::glPixelStorei(GLenum pname, GLint param) +{ + m_Real.glPixelStorei(pname, param); + + RDCASSERT(m_TextureRecord[m_TextureUnit]); + { + SCOPED_SERIALISE_CONTEXT(PIXELSTORE); + Serialise_glPixelStorei(pname, param); + + m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + } +} + +void WrappedOpenGL::glPixelStoref(GLenum pname, GLfloat param) +{ + glPixelStorei(pname, (GLint)param); +} + +bool WrappedOpenGL::Serialise_glActiveTexture(GLenum texture) +{ + SERIALISE_ELEMENT(GLenum, Texture, texture); + + if(m_State < WRITING) + m_Real.glActiveTexture(Texture); + + return true; +} + +void WrappedOpenGL::glActiveTexture(GLenum texture) +{ + m_Real.glActiveTexture(texture); + + m_TextureUnit = texture-eGL_TEXTURE0; + + if(m_State == WRITING_CAPFRAME) + { + Chunk *chunk = NULL; + + { + SCOPED_SERIALISE_CONTEXT(ACTIVE_TEXTURE); + Serialise_glActiveTexture(texture); + + chunk = scope.Get(); + } + + m_ContextRecord->AddChunk(chunk); + } +} + +#pragma region Texture Storage/Upload + +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) +{ + m_Real.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); + + RDCUNIMPLEMENTED(); +} + +void WrappedOpenGL::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels) +{ + m_Real.glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels); + + RDCUNIMPLEMENTED(); +} + +void WrappedOpenGL::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *pixels) +{ + m_Real.glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, pixels); + + RDCUNIMPLEMENTED(); +} + +void WrappedOpenGL::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * pixels) +{ + m_Real.glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, pixels); + + RDCUNIMPLEMENTED(); +} + +void WrappedOpenGL::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * pixels) +{ + m_Real.glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, pixels); + + RDCUNIMPLEMENTED(); +} + +bool WrappedOpenGL::Serialise_glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(uint32_t, Levels, levels); + SERIALISE_ELEMENT(GLenum, Format, internalformat); + SERIALISE_ELEMENT(uint32_t, Width, width); + SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + + if(m_State == READING) + { + ResourceId liveId = GetResourceManager()->GetLiveID(id); + m_Textures[liveId].width = Width; + m_Textures[liveId].height = 1; + m_Textures[liveId].depth = 1; + + m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); + m_Real.glTexStorage1D(Target, Levels, Format, Width); + } + + return true; +} + +void WrappedOpenGL::glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) +{ + m_Real.glTexStorage1D(target, levels, internalformat, width); + + if(m_State >= WRITING) + { + RDCASSERT(m_TextureRecord[m_TextureUnit]); + + SCOPED_SERIALISE_CONTEXT(TEXSTORAGE1D); + Serialise_glTexStorage1D(target, levels, internalformat, width); + + m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(uint32_t, Levels, levels); + SERIALISE_ELEMENT(GLenum, Format, internalformat); + SERIALISE_ELEMENT(uint32_t, Width, width); + SERIALISE_ELEMENT(uint32_t, Height, height); + SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + + if(m_State == READING) + { + ResourceId liveId = GetResourceManager()->GetLiveID(id); + m_Textures[liveId].width = Width; + m_Textures[liveId].height = Height; + m_Textures[liveId].depth = 1; + + m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); + m_Real.glTexStorage2D(Target, Levels, Format, Width, Height); + } + + return true; +} + +void WrappedOpenGL::glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) +{ + m_Real.glTexStorage2D(target, levels, internalformat, width, height); + + if(m_State >= WRITING) + { + RDCASSERT(m_TextureRecord[m_TextureUnit]); + + SCOPED_SERIALISE_CONTEXT(TEXSTORAGE2D); + Serialise_glTexStorage2D(target, levels, internalformat, width, height); + + m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(uint32_t, Levels, levels); + SERIALISE_ELEMENT(GLenum, Format, internalformat); + SERIALISE_ELEMENT(uint32_t, Width, width); + SERIALISE_ELEMENT(uint32_t, Height, height); + SERIALISE_ELEMENT(uint32_t, Depth, depth); + SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + + if(m_State == READING) + { + ResourceId liveId = GetResourceManager()->GetLiveID(id); + m_Textures[liveId].width = Width; + m_Textures[liveId].height = Height; + m_Textures[liveId].depth = Depth; + + m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); + m_Real.glTexStorage3D(Target, Levels, Format, Width, Height, Depth); + } + + return true; +} + +void WrappedOpenGL::glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) +{ + m_Real.glTexStorage3D(target, levels, internalformat, width, height, depth); + + if(m_State >= WRITING) + { + RDCASSERT(m_TextureRecord[m_TextureUnit]); + + SCOPED_SERIALISE_CONTEXT(TEXSTORAGE3D); + Serialise_glTexStorage3D(target, levels, internalformat, width, height, depth); + + m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(int32_t, Level, level); + SERIALISE_ELEMENT(int32_t, xoff, xoffset); + SERIALISE_ELEMENT(uint32_t, Width, width); + SERIALISE_ELEMENT(GLenum, Format, format); + SERIALISE_ELEMENT(GLenum, Type, type); + SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + + GLint align = 1; + m_Real.glGetIntegerv(eGL_UNPACK_ALIGNMENT, &align); + + size_t subimageSize = GetByteSize(Width, 1, 1, Format, Type, Level, align); + + SERIALISE_ELEMENT_BUF(byte *, buf, pixels, subimageSize); + + if(m_State == READING) + { + m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); + m_Real.glTexSubImage1D(Target, Level, xoff, Width, Format, Type, buf); + + delete[] buf; + } + + return true; +} + +void WrappedOpenGL::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) +{ + m_Real.glTexSubImage1D(target, level, xoffset, width, format, type, pixels); + + if(m_State >= WRITING) + { + RDCASSERT(m_TextureRecord[m_TextureUnit]); + + SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE1D); + Serialise_glTexSubImage1D(target, level, xoffset, width, format, type, pixels); + + m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(int32_t, Level, level); + SERIALISE_ELEMENT(int32_t, xoff, xoffset); + SERIALISE_ELEMENT(int32_t, yoff, yoffset); + SERIALISE_ELEMENT(uint32_t, Width, width); + SERIALISE_ELEMENT(uint32_t, Height, height); + SERIALISE_ELEMENT(GLenum, Format, format); + SERIALISE_ELEMENT(GLenum, Type, type); + SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + + GLint align = 1; + m_Real.glGetIntegerv(eGL_UNPACK_ALIGNMENT, &align); + + size_t subimageSize = GetByteSize(Width, Height, 1, Format, Type, Level, align); + + SERIALISE_ELEMENT_BUF(byte *, buf, pixels, subimageSize); + + if(m_State == READING) + { + m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); + m_Real.glTexSubImage2D(Target, Level, xoff, yoff, Width, Height, Format, Type, buf); + + delete[] buf; + } + + return true; +} + +void WrappedOpenGL::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) +{ + m_Real.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); + + if(m_State >= WRITING) + { + RDCASSERT(m_TextureRecord[m_TextureUnit]); + + SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE2D); + Serialise_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); + + m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(int32_t, Level, level); + SERIALISE_ELEMENT(int32_t, xoff, xoffset); + SERIALISE_ELEMENT(int32_t, yoff, yoffset); + SERIALISE_ELEMENT(int32_t, zoff, zoffset); + SERIALISE_ELEMENT(uint32_t, Width, width); + SERIALISE_ELEMENT(uint32_t, Height, height); + SERIALISE_ELEMENT(uint32_t, Depth, depth); + SERIALISE_ELEMENT(GLenum, Format, format); + SERIALISE_ELEMENT(GLenum, Type, type); + SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + + GLint align = 1; + m_Real.glGetIntegerv(eGL_UNPACK_ALIGNMENT, &align); + + size_t subimageSize = GetByteSize(Width, Height, Depth, Format, Type, Level, align); + + SERIALISE_ELEMENT_BUF(byte *, buf, pixels, subimageSize); + + if(m_State == READING) + { + m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); + m_Real.glTexSubImage3D(Target, Level, xoff, yoff, zoff, Width, Height, Depth, Format, Type, buf); + + delete[] buf; + } + + return true; +} + +void WrappedOpenGL::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) +{ + m_Real.glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); + + if(m_State >= WRITING) + { + RDCASSERT(m_TextureRecord[m_TextureUnit]); + + SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE3D); + Serialise_glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); + + m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *pixels) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(int32_t, Level, level); + SERIALISE_ELEMENT(int32_t, xoff, xoffset); + SERIALISE_ELEMENT(uint32_t, Width, width); + SERIALISE_ELEMENT(GLenum, fmt, format); + SERIALISE_ELEMENT(uint32_t, byteSize, imageSize); + SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + + SERIALISE_ELEMENT_BUF(byte *, buf, pixels, byteSize); + + if(m_State == READING) + { + m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); + m_Real.glCompressedTexSubImage1D(Target, Level, xoff, Width, fmt, byteSize, buf); + + delete[] buf; + } + + return true; +} + +void WrappedOpenGL::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *pixels) +{ + m_Real.glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, pixels); + + if(m_State >= WRITING) + { + RDCASSERT(m_TextureRecord[m_TextureUnit]); + + SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE1D_COMPRESSED); + Serialise_glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, pixels); + + m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(int32_t, Level, level); + SERIALISE_ELEMENT(int32_t, xoff, xoffset); + SERIALISE_ELEMENT(int32_t, yoff, yoffset); + SERIALISE_ELEMENT(uint32_t, Width, width); + SERIALISE_ELEMENT(uint32_t, Height, height); + SERIALISE_ELEMENT(GLenum, fmt, format); + SERIALISE_ELEMENT(uint32_t, byteSize, imageSize); + SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + + SERIALISE_ELEMENT_BUF(byte *, buf, pixels, byteSize); + + if(m_State == READING) + { + m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); + m_Real.glCompressedTexSubImage2D(Target, Level, xoff, yoff, Width, Height, fmt, byteSize, buf); + + delete[] buf; + } + + return true; +} + +void WrappedOpenGL::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels) +{ + m_Real.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, pixels); + + if(m_State >= WRITING) + { + RDCASSERT(m_TextureRecord[m_TextureUnit]); + + SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE2D_COMPRESSED); + Serialise_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, pixels); + + m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(int32_t, Level, level); + SERIALISE_ELEMENT(int32_t, xoff, xoffset); + SERIALISE_ELEMENT(int32_t, yoff, yoffset); + SERIALISE_ELEMENT(int32_t, zoff, zoffset); + SERIALISE_ELEMENT(uint32_t, Width, width); + SERIALISE_ELEMENT(uint32_t, Height, height); + SERIALISE_ELEMENT(uint32_t, Depth, depth); + SERIALISE_ELEMENT(GLenum, fmt, format); + SERIALISE_ELEMENT(uint32_t, byteSize, imageSize); + SERIALISE_ELEMENT(ResourceId, id, m_TextureRecord[m_TextureUnit]->GetResourceID()); + + SERIALISE_ELEMENT_BUF(byte *, buf, pixels, byteSize); + + if(m_State == READING) + { + m_Real.glBindTexture(Target, GetResourceManager()->GetLiveResource(id).name); + m_Real.glCompressedTexSubImage3D(Target, Level, xoff, yoff, zoff, Width, Height, Depth, fmt, byteSize, buf); + + delete[] buf; + } + + return true; +} + +void WrappedOpenGL::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *pixels) +{ + m_Real.glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); + + if(m_State >= WRITING) + { + RDCASSERT(m_TextureRecord[m_TextureUnit]); + + SCOPED_SERIALISE_CONTEXT(TEXSUBIMAGE3D_COMPRESSED); + Serialise_glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, pixels); + + m_TextureRecord[m_TextureUnit]->AddChunk(scope.Get()); + } +} + +#pragma endregion diff --git a/renderdoc/driver/gl/wrappers/gl_uniform_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_uniform_funcs.cpp new file mode 100644 index 000000000..affc43ac1 --- /dev/null +++ b/renderdoc/driver/gl/wrappers/gl_uniform_funcs.cpp @@ -0,0 +1,555 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2014 Crytek + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "common/common.h" +#include "common/string_utils.h" +#include "../gl_driver.h" + +bool WrappedOpenGL::Serialise_glUniformMatrix(GLint location, GLsizei count, GLboolean transpose, const void *value, UniformType type) +{ + SERIALISE_ELEMENT(UniformType, Type, type); + SERIALISE_ELEMENT(int32_t, Loc, location); + SERIALISE_ELEMENT(uint32_t, Count, count); + SERIALISE_ELEMENT(uint8_t, Transpose, transpose); + + size_t elemsPerMat = 0; + + switch(Type) + { + case MAT4FV: elemsPerMat = 16; break; + default: + RDCERR("Unexpected uniform type to Serialise_glUniformMatrix: %d", Type); + } + + if(m_State >= WRITING) + { + m_pSerialiser->RawWriteBytes(value, sizeof(float)*elemsPerMat*Count); + } + else if(m_State <= EXECUTING) + { + value = m_pSerialiser->RawReadBytes(sizeof(float)*elemsPerMat*Count); + + switch(Type) + { + case MAT4FV: m_Real.glUniformMatrix4fv(Loc, Count, Transpose, (const GLfloat *)value); break; + default: + RDCERR("Unexpected uniform type to Serialise_glUniformMatrix: %d", Type); + } + } + + if(m_pSerialiser->GetDebugText()) + { + switch(Type) + { + case MAT4FV: + { + float *f = (float *)value; + if(Transpose) + { + m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[0], f[4], f[8], f[12]); + m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[1], f[5], f[9], f[13]); + m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[2], f[6], f[10], f[14]); + m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[3], f[7], f[11], f[15]); + } + else + { + m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[0], f[1], f[2], f[3]); + m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[4], f[5], f[6], f[7]); + m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[8], f[9], f[10], f[11]); + m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[12], f[13], f[14], f[15]); + } + break; + } + default: + RDCERR("Unexpected uniform type to Serialise_glUniformVector: %d", Type); + } + } + + return true; +} + +void WrappedOpenGL::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) +{ + m_Real.glUniformMatrix4fv(location, count, transpose, value); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(UNIFORM_MATRIX); + Serialise_glUniformMatrix(location, count, transpose, value, MAT4FV); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glUniformVector(GLint location, GLsizei count, const void *value, UniformType type) +{ + SERIALISE_ELEMENT(UniformType, Type, type); + SERIALISE_ELEMENT(int32_t, Loc, location); + SERIALISE_ELEMENT(uint32_t, Count, count); + + size_t elemsPerVec = 0; + + switch(Type) + { + case VEC1IV: + case VEC1UIV: + case VEC1FV: elemsPerVec = 1; break; + case VEC2FV: elemsPerVec = 2; break; + case VEC3FV: elemsPerVec = 3; break; + case VEC4FV: elemsPerVec = 4; break; + default: + RDCERR("Unexpected uniform type to Serialise_glUniformVector: %d", Type); + } + + if(m_State >= WRITING) + { + m_pSerialiser->RawWriteBytes(value, sizeof(float)*elemsPerVec*Count); + } + else if(m_State <= EXECUTING) + { + value = m_pSerialiser->RawReadBytes(sizeof(float)*elemsPerVec*Count); + + switch(Type) + { + case VEC1FV: m_Real.glUniform1fv(Loc, Count, (const GLfloat *)value); break; + case VEC1IV: m_Real.glUniform1iv(Loc, Count, (const GLint *)value); break; + case VEC1UIV: m_Real.glUniform1uiv(Loc, Count, (const GLuint *)value); break; + case VEC2FV: m_Real.glUniform2fv(Loc, Count, (const GLfloat *)value); break; + case VEC3FV: m_Real.glUniform3fv(Loc, Count, (const GLfloat *)value); break; + case VEC4FV: m_Real.glUniform4fv(Loc, Count, (const GLfloat *)value); break; + default: + RDCERR("Unexpected uniform type to Serialise_glUniformVector: %d", Type); + } + } + + if(m_pSerialiser->GetDebugText()) + { + switch(Type) + { + case VEC1FV: + { + float *f = (float *)value; + m_pSerialiser->DebugPrint("value: {%f}\n", f[0]); + break; + } + case VEC1IV: + { + int32_t *i = (int32_t *)value; + m_pSerialiser->DebugPrint("value: {%d}\n", i[0]); + break; + } + case VEC1UIV: + { + uint32_t *u = (uint32_t *)value; + m_pSerialiser->DebugPrint("value: {%u}\n", u[0]); + break; + } + case VEC2FV: + { + float *f = (float *)value; + m_pSerialiser->DebugPrint("value: {%f %f}\n", f[0], f[1]); + break; + } + case VEC3FV: + { + float *f = (float *)value; + m_pSerialiser->DebugPrint("value: {%f %f %f}\n", f[0], f[1], f[2]); + break; + } + case VEC4FV: + { + float *f = (float *)value; + m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[0], f[1], f[2], f[3]); + break; + } + default: + RDCERR("Unexpected uniform type to Serialise_glUniformVector: %d", Type); + } + } + + return true; +} + +void WrappedOpenGL::glUniform1f(GLint location, GLfloat value) +{ + m_Real.glUniform1f(location, value); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR); + Serialise_glUniformVector(location, 1, &value, VEC1FV); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +void WrappedOpenGL::glUniform1i(GLint location, GLint value) +{ + m_Real.glUniform1i(location, value); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR); + Serialise_glUniformVector(location, 1, &value, VEC1IV); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +void WrappedOpenGL::glUniform1ui(GLint location, GLuint value) +{ + m_Real.glUniform1ui(location, value); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR); + Serialise_glUniformVector(location, 1, &value, VEC1UIV); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +void WrappedOpenGL::glUniform1fv(GLint location, GLsizei count, const GLfloat *value) +{ + m_Real.glUniform1fv(location, count, value); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR); + Serialise_glUniformVector(location, count, value, VEC1FV); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +void WrappedOpenGL::glUniform1iv(GLint location, GLsizei count, const GLint *value) +{ + m_Real.glUniform1iv(location, count, value); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR); + Serialise_glUniformVector(location, count, value, VEC1IV); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +void WrappedOpenGL::glUniform1uiv(GLint location, GLsizei count, const GLuint *value) +{ + m_Real.glUniform1uiv(location, count, value); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR); + Serialise_glUniformVector(location, count, value, VEC1UIV); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +void WrappedOpenGL::glUniform2fv(GLint location, GLsizei count, const GLfloat *value) +{ + m_Real.glUniform2fv(location, count, value); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR); + Serialise_glUniformVector(location, count, value, VEC2FV); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +void WrappedOpenGL::glUniform3fv(GLint location, GLsizei count, const GLfloat *value) +{ + m_Real.glUniform3fv(location, count, value); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR); + Serialise_glUniformVector(location, count, value, VEC3FV); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +void WrappedOpenGL::glUniform4fv(GLint location, GLsizei count, const GLfloat *value) +{ + m_Real.glUniform4fv(location, count, value); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(UNIFORM_VECTOR); + Serialise_glUniformVector(location, count, value, VEC4FV); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glProgramUniformVector(GLuint program, GLint location, GLsizei count, const void *value, UniformType type) +{ + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(ProgramRes(program))); + SERIALISE_ELEMENT(UniformType, Type, type); + SERIALISE_ELEMENT(int32_t, Loc, location); + SERIALISE_ELEMENT(uint32_t, Count, count); + + size_t elemsPerVec = 0; + + switch(Type) + { + case VEC1IV: + case VEC1UIV: + case VEC1FV: elemsPerVec = 1; break; + case VEC2FV: elemsPerVec = 2; break; + case VEC3FV: elemsPerVec = 3; break; + case VEC4FV: elemsPerVec = 4; break; + default: + RDCERR("Unexpected uniform type to Serialise_glProgramUniformVector: %d", Type); + } + + if(m_State >= WRITING) + { + m_pSerialiser->RawWriteBytes(value, sizeof(float)*elemsPerVec*Count); + } + else if(m_State <= EXECUTING) + { + value = m_pSerialiser->RawReadBytes(sizeof(float)*elemsPerVec*Count); + + GLuint live = GetResourceManager()->GetLiveResource(id).name; + + switch(Type) + { + case VEC1IV: m_Real.glProgramUniform1iv(live, Loc, Count, (const GLint *)value); break; + case VEC1UIV: m_Real.glProgramUniform1uiv(live, Loc, Count, (const GLuint *)value); break; + case VEC1FV: m_Real.glProgramUniform1fv(live, Loc, Count, (const GLfloat *)value); break; + case VEC2FV: m_Real.glProgramUniform2fv(live, Loc, Count, (const GLfloat *)value); break; + case VEC3FV: m_Real.glProgramUniform3fv(live, Loc, Count, (const GLfloat *)value); break; + case VEC4FV: m_Real.glProgramUniform4fv(live, Loc, Count, (const GLfloat *)value); break; + default: + RDCERR("Unexpected uniform type to Serialise_glProgramUniformVector: %d", Type); + } + } + + if(m_pSerialiser->GetDebugText()) + { + switch(Type) + { + case VEC1FV: + { + float *f = (float *)value; + m_pSerialiser->DebugPrint("value: {%f}\n", f[0]); + break; + } + case VEC1IV: + { + int32_t *i = (int32_t *)value; + m_pSerialiser->DebugPrint("value: {%d}\n", i[0]); + break; + } + case VEC1UIV: + { + uint32_t *u = (uint32_t *)value; + m_pSerialiser->DebugPrint("value: {%u}\n", u[0]); + break; + } + case VEC2FV: + { + float *f = (float *)value; + m_pSerialiser->DebugPrint("value: {%f %f}\n", f[0], f[1]); + break; + } + case VEC3FV: + { + float *f = (float *)value; + m_pSerialiser->DebugPrint("value: {%f %f %f}\n", f[0], f[1], f[2]); + break; + } + case VEC4FV: + { + float *f = (float *)value; + m_pSerialiser->DebugPrint("value: {%f %f %f %f}\n", f[0], f[1], f[2], f[3]); + break; + } + default: + RDCERR("Unexpected uniform type to Serialise_glProgramUniformVector: %d", Type); + } + } + + return true; +} + +void WrappedOpenGL::glProgramUniform1i(GLuint program, GLint location, GLint v0) +{ + m_Real.glProgramUniform1i(program, location, v0); + + if(m_State > WRITING) + { + SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR); + Serialise_glProgramUniformVector(program, location, 1, &v0, VEC1IV); + + if(m_State == WRITING_CAPFRAME) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program)); + RDCASSERT(record); + record->AddChunk(scope.Get()); + } + else + { + m_ContextRecord->AddChunk(scope.Get()); + } + } +} + +void WrappedOpenGL::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value) +{ + m_Real.glProgramUniform1iv(program, location, count, value); + + if(m_State > WRITING) + { + SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR); + Serialise_glProgramUniformVector(program, location, count, value, VEC1IV); + + if(m_State == WRITING_CAPFRAME) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program)); + RDCASSERT(record); + record->AddChunk(scope.Get()); + } + else + { + m_ContextRecord->AddChunk(scope.Get()); + } + } +} + +void WrappedOpenGL::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value) +{ + m_Real.glProgramUniform1fv(program, location, count, value); + + if(m_State > WRITING) + { + SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR); + Serialise_glProgramUniformVector(program, location, count, value, VEC1FV); + + if(m_State == WRITING_CAPFRAME) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program)); + RDCASSERT(record); + record->AddChunk(scope.Get()); + } + else + { + m_ContextRecord->AddChunk(scope.Get()); + } + } +} + +void WrappedOpenGL::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value) +{ + m_Real.glProgramUniform1uiv(program, location, count, value); + + if(m_State > WRITING) + { + SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR); + Serialise_glProgramUniformVector(program, location, count, value, VEC1UIV); + + if(m_State == WRITING_CAPFRAME) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program)); + RDCASSERT(record); + record->AddChunk(scope.Get()); + } + else + { + m_ContextRecord->AddChunk(scope.Get()); + } + } +} + +void WrappedOpenGL::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value) +{ + m_Real.glProgramUniform2fv(program, location, count, value); + + if(m_State > WRITING) + { + SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR); + Serialise_glProgramUniformVector(program, location, count, value, VEC2FV); + + if(m_State == WRITING_CAPFRAME) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program)); + RDCASSERT(record); + record->AddChunk(scope.Get()); + } + else + { + m_ContextRecord->AddChunk(scope.Get()); + } + } +} + +void WrappedOpenGL::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value) +{ + m_Real.glProgramUniform3fv(program, location, count, value); + + if(m_State > WRITING) + { + SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR); + Serialise_glProgramUniformVector(program, location, count, value, VEC3FV); + + if(m_State == WRITING_CAPFRAME) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program)); + RDCASSERT(record); + record->AddChunk(scope.Get()); + } + else + { + m_ContextRecord->AddChunk(scope.Get()); + } + } +} + +void WrappedOpenGL::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value) +{ + m_Real.glProgramUniform4fv(program, location, count, value); + + if(m_State > WRITING) + { + SCOPED_SERIALISE_CONTEXT(PROGRAMUNIFORM_VECTOR); + Serialise_glProgramUniformVector(program, location, count, value, VEC4FV); + + if(m_State == WRITING_CAPFRAME) + { + GLResourceRecord *record = GetResourceManager()->GetResourceRecord(ProgramRes(program)); + RDCASSERT(record); + record->AddChunk(scope.Get()); + } + else + { + m_ContextRecord->AddChunk(scope.Get()); + } + } +} diff --git a/renderdoc/renderdoc.vcxproj b/renderdoc/renderdoc.vcxproj index c77bbf69a..5e7a668a1 100644 --- a/renderdoc/renderdoc.vcxproj +++ b/renderdoc/renderdoc.vcxproj @@ -260,7 +260,6 @@ - @@ -328,15 +327,23 @@ - - + + + + + + + + + + diff --git a/renderdoc/renderdoc.vcxproj.filters b/renderdoc/renderdoc.vcxproj.filters index f46e8cb98..e8eb58b5f 100644 --- a/renderdoc/renderdoc.vcxproj.filters +++ b/renderdoc/renderdoc.vcxproj.filters @@ -73,6 +73,9 @@ {889cc549-e49b-430b-9e9b-5a42e7c26b03} + + {5e7e0e62-aba4-4256-b0ec-a1a7fbcba715} + @@ -276,9 +279,6 @@ Drivers\OpenGL - - Drivers\OpenGL - Resources\hlsl @@ -422,12 +422,6 @@ Drivers\OpenGL - - Drivers\OpenGL - - - Drivers\OpenGL - Drivers\OpenGL @@ -479,6 +473,36 @@ Drivers\OpenGL + + Drivers\OpenGL\Function Wrappers + + + Drivers\OpenGL\Function Wrappers + + + Drivers\OpenGL\Function Wrappers + + + Drivers\OpenGL\Function Wrappers + + + Drivers\OpenGL\Function Wrappers + + + Drivers\OpenGL\Function Wrappers + + + Drivers\OpenGL\Function Wrappers + + + Drivers\OpenGL\Function Wrappers + + + Drivers\OpenGL\Function Wrappers + + + Drivers\OpenGL\Function Wrappers +