From 5d7f296deb60b07f158224d9d4eea00200042a4b Mon Sep 17 00:00:00 2001 From: baldurk Date: Sun, 25 May 2014 17:57:31 +0100 Subject: [PATCH] Add GLRenderState class to track GL state vector * Use it to serialise in/out initial state at the start of each captured frame. * Serialise active texture and buffer bindings (indexed and non-indexed). --- renderdoc/driver/d3d11/d3d11_renderstate.h | 1 - renderdoc/driver/gl/gl_device_driver.cpp | 28 +++- renderdoc/driver/gl/gl_driver.cpp | 37 ++--- renderdoc/driver/gl/gl_driver.h | 3 + renderdoc/driver/gl/gl_hookset.h | 2 + renderdoc/driver/gl/gl_hookset_defs.h | 4 + renderdoc/driver/gl/gl_renderstate.cpp | 168 +++++++++++++++++++++ renderdoc/driver/gl/gl_renderstate.h | 57 +++++++ renderdoc/renderdoc.vcxproj | 2 + renderdoc/renderdoc.vcxproj.filters | 6 + 10 files changed, 275 insertions(+), 33 deletions(-) create mode 100644 renderdoc/driver/gl/gl_renderstate.cpp create mode 100644 renderdoc/driver/gl/gl_renderstate.h diff --git a/renderdoc/driver/d3d11/d3d11_renderstate.h b/renderdoc/driver/d3d11/d3d11_renderstate.h index f076c5ef1..710f33566 100644 --- a/renderdoc/driver/d3d11/d3d11_renderstate.h +++ b/renderdoc/driver/d3d11/d3d11_renderstate.h @@ -419,7 +419,6 @@ struct D3D11RenderState void SetSerialiser(Serialiser *ser) { m_pSerialiser = ser; } void Serialise(LogState state, WrappedID3D11Device *device); - ID3D11Resource *GetSerialised(ID3D11Resource *res) const; void SetImmediatePipeline(WrappedID3D11Device *device) { m_ImmediatePipeline = true; m_pDevice = device; } diff --git a/renderdoc/driver/gl/gl_device_driver.cpp b/renderdoc/driver/gl/gl_device_driver.cpp index 0a18d4580..25b6435b1 100644 --- a/renderdoc/driver/gl/gl_device_driver.cpp +++ b/renderdoc/driver/gl/gl_device_driver.cpp @@ -984,10 +984,20 @@ size_t WrappedOpenGL::BufferIdx(GLenum buf) { switch(buf) { - case eGL_ARRAY_BUFFER: return 0; - case eGL_ELEMENT_ARRAY_BUFFER: return 1; - case eGL_UNIFORM_BUFFER: return 2; - case eGL_COPY_READ_BUFFER: return 3; + 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()); } @@ -1113,6 +1123,16 @@ void WrappedOpenGL::glBindBufferBase(GLenum target, GLuint index, GLuint buffer) m_Real.glBindBufferBase(target, index, buffer); } +void WrappedOpenGL::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + if(m_State >= WRITING) + { + RDCUNIMPLEMENTED(); + } + + m_Real.glBindBufferRange(target, index, buffer, offset, size); +} + void *WrappedOpenGL::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) { if(m_State >= WRITING) diff --git a/renderdoc/driver/gl/gl_driver.cpp b/renderdoc/driver/gl/gl_driver.cpp index 7d7d66a98..59709ac39 100644 --- a/renderdoc/driver/gl/gl_driver.cpp +++ b/renderdoc/driver/gl/gl_driver.cpp @@ -688,43 +688,19 @@ void WrappedOpenGL::AttemptCapture() bool WrappedOpenGL::Serialise_BeginCaptureFrame(bool applyInitialState) { - // TODO check GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS bound - // TODO fetch bindings for other types than 2D - ResourceId textures2D[128]; + GLRenderState state(&m_Real, m_pSerialiser); if(m_State >= WRITING) { - for(int i=0; i < ARRAY_COUNT(textures2D); i++) - { - GLint binding = 0; - - m_Real.glActiveTexture(GLenum(eGL_TEXTURE0 + i)); - m_Real.glGetIntegerv(eGL_TEXTURE_BINDING_2D, &binding); - - if(binding == 0) - textures2D[i] = ResourceId(); - else - textures2D[i] = GetResourceManager()->GetID(TextureRes(binding)); - } + state.FetchState(); } - m_pSerialiser->Serialise<128>("textures", textures2D); + state.Serialise(m_State, GetResourceManager()); if(m_State <= EXECUTING && applyInitialState) { m_DoStateVerify = false; - { - - for(int i=0; i < ARRAY_COUNT(textures2D); i++) - { - m_Real.glActiveTexture(GLenum(eGL_TEXTURE0 + i)); - if(textures2D[i] == ResourceId()) - m_Real.glBindTexture(eGL_TEXTURE_2D, 0); - else - m_Real.glBindTexture(eGL_TEXTURE_2D, GetResourceManager()->GetLiveResource(textures2D[i]).name); - } - - } + state.ApplyState(); m_DoStateVerify = true; } @@ -1376,6 +1352,11 @@ void WrappedOpenGL::glGetIntegeri_v(GLenum pname, GLuint index, GLint *data) m_Real.glGetIntegeri_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); diff --git a/renderdoc/driver/gl/gl_driver.h b/renderdoc/driver/gl/gl_driver.h index b7b8473cf..f9412efca 100644 --- a/renderdoc/driver/gl/gl_driver.h +++ b/renderdoc/driver/gl/gl_driver.h @@ -36,6 +36,7 @@ #include "gl_hookset.h" #include "gl_resources.h" #include "gl_manager.h" +#include "gl_renderstate.h" #include "gl_replay.h" #include @@ -275,6 +276,7 @@ class WrappedOpenGL IMPLEMENT_FUNCTION_SERIALISED(void, glGetFloatv(GLenum pname, GLfloat *params)); IMPLEMENT_FUNCTION_SERIALISED(void, glGetIntegerv(GLenum pname, GLint *params)); IMPLEMENT_FUNCTION_SERIALISED(void, glGetIntegeri_v(GLenum target, GLuint index, GLint *data)); + IMPLEMENT_FUNCTION_SERIALISED(void, glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)); IMPLEMENT_FUNCTION_SERIALISED(const GLubyte *, glGetStringi(GLenum name, GLuint i)); IMPLEMENT_FUNCTION_SERIALISED(const GLubyte *, glGetString(GLenum name)); IMPLEMENT_FUNCTION_SERIALISED(void, glGenTextures(GLsizei n, GLuint* textures)); @@ -339,6 +341,7 @@ class WrappedOpenGL IMPLEMENT_FUNCTION_SERIALISED(void, glBindBuffer(GLenum target, GLuint buffer)); IMPLEMENT_FUNCTION_SERIALISED(void, glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage)); IMPLEMENT_FUNCTION_SERIALISED(void, glBindBufferBase(GLenum target, GLuint index, GLuint buffer)); + IMPLEMENT_FUNCTION_SERIALISED(void, glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)); IMPLEMENT_FUNCTION_SERIALISED(void *, glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)); IMPLEMENT_FUNCTION_SERIALISED(GLboolean, glUnmapBuffer(GLenum target)); diff --git a/renderdoc/driver/gl/gl_hookset.h b/renderdoc/driver/gl/gl_hookset.h index 3c30d36ca..8f1c8762c 100644 --- a/renderdoc/driver/gl/gl_hookset.h +++ b/renderdoc/driver/gl/gl_hookset.h @@ -91,6 +91,7 @@ struct GLHookSet PFNGLGETBUFFERPARAMETERIVPROC glGetBufferParameteriv; PFNGLGETSTRINGIPROC glGetStringi; PFNGLGETINTEGERI_VPROC glGetIntegeri_v; + PFNGLGETINTEGER64I_VPROC glGetInteger64i_v; PFNGLCREATESHADERPROC glCreateShader; PFNGLDELETESHADERPROC glDeleteShader; PFNGLSHADERSOURCEPROC glShaderSource; @@ -119,6 +120,7 @@ struct GLHookSet PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glGetFramebufferAttachmentParameteriv; PFNGLBUFFERDATAPROC glBufferData; PFNGLBINDBUFFERBASEPROC glBindBufferBase; + PFNGLBINDBUFFERRANGEPROC glBindBufferRange; PFNGLMAPBUFFERRANGEPROC glMapBufferRange; PFNGLUNMAPBUFFERPROC glUnmapBuffer; PFNGLDELETEBUFFERSPROC glDeleteBuffers; diff --git a/renderdoc/driver/gl/gl_hookset_defs.h b/renderdoc/driver/gl/gl_hookset_defs.h index a738f6c10..1f975cc34 100644 --- a/renderdoc/driver/gl/gl_hookset_defs.h +++ b/renderdoc/driver/gl/gl_hookset_defs.h @@ -102,6 +102,7 @@ HookExtension(PFNGLGETBUFFERPARAMETERIVPROC, glGetBufferParameteriv); \ HookExtension(PFNGLGETSTRINGIPROC, glGetStringi); \ HookExtension(PFNGLGETINTEGERI_VPROC, glGetIntegeri_v); \ + HookExtension(PFNGLGETINTEGER64I_VPROC, glGetInteger64i_v); \ HookExtension(PFNGLCREATESHADERPROC, glCreateShader); \ HookExtension(PFNGLDELETESHADERPROC, glDeleteShader); \ HookExtension(PFNGLSHADERSOURCEPROC, glShaderSource); \ @@ -131,6 +132,7 @@ HookExtension(PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC, glGetFramebufferAttachmentParameteriv); \ HookExtension(PFNGLBUFFERDATAPROC, glBufferData); \ HookExtension(PFNGLBINDBUFFERBASEPROC, glBindBufferBase); \ + HookExtension(PFNGLBINDBUFFERRANGEPROC, glBindBufferRange); \ HookExtension(PFNGLMAPBUFFERRANGEPROC, glMapBufferRange); \ HookExtension(PFNGLUNMAPBUFFERPROC, glUnmapBuffer); \ HookExtension(PFNGLDELETEBUFFERSPROC, glDeleteBuffers); \ @@ -277,6 +279,7 @@ HookWrapper3(void, glGetBufferParameteriv, GLenum, target, GLenum, pname, GLint *, params); \ HookWrapper2(const GLubyte *, glGetStringi, GLenum, name, GLuint, index); \ HookWrapper3(void, glGetIntegeri_v, GLenum, target, GLuint, index, GLint *, data); \ + HookWrapper3(void, glGetInteger64i_v, GLenum, target, GLuint, index, GLint64 *, data); \ HookWrapper1(GLuint, glCreateShader, GLenum, type); \ HookWrapper1(void, glDeleteShader, GLuint, shader); \ HookWrapper4(void, glShaderSource, GLuint, shader, GLsizei, count, const GLchar *const*, string, const GLint *, length); \ @@ -305,6 +308,7 @@ HookWrapper4(void, glGetFramebufferAttachmentParameteriv, GLenum, target, GLenum, attachment, GLenum, pname, GLint *, params); \ HookWrapper4(void, glBufferData, GLenum, target, GLsizeiptr, size, const void *, data, GLenum, usage); \ HookWrapper3(void, glBindBufferBase, GLenum, target, GLuint, index, GLuint, buffer); \ + HookWrapper5(void, glBindBufferRange, GLenum, target, GLuint, index, GLuint, buffer, GLintptr, offset, GLsizeiptr, size); \ HookWrapper4(void *, glMapBufferRange, GLenum, target, GLintptr, offset, GLsizeiptr, length, GLbitfield, access); \ HookWrapper1(GLboolean, glUnmapBuffer, GLenum, target); \ HookWrapper2(void, glDeleteBuffers, GLsizei, n, const GLuint *, buffers); \ diff --git a/renderdoc/driver/gl/gl_renderstate.cpp b/renderdoc/driver/gl/gl_renderstate.cpp new file mode 100644 index 000000000..9f2ae43aa --- /dev/null +++ b/renderdoc/driver/gl/gl_renderstate.cpp @@ -0,0 +1,168 @@ +/****************************************************************************** + * 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 "gl_renderstate.h" + +GLRenderState::GLRenderState(const GLHookSet *funcs, Serialiser *ser) + : m_Real(funcs) + , m_pSerialiser(ser) +{ + Clear(); +} + +GLRenderState::~GLRenderState() +{ +} + +void GLRenderState::FetchState() +{ + // TODO check GL_MAX_* + + m_Real->glGetIntegerv(eGL_ACTIVE_TEXTURE, (GLint *)&ActiveTexture); + + // TODO fetch bindings for other types than 2D + for(int i=0; i < ARRAY_COUNT(Tex2D); i++) + { + m_Real->glActiveTexture(GLenum(eGL_TEXTURE0 + i)); + m_Real->glGetIntegerv(eGL_TEXTURE_BINDING_2D, (GLint*)&Tex2D[i]); + } + + m_Real->glActiveTexture(ActiveTexture); + + m_Real->glGetIntegerv(eGL_ARRAY_BUFFER_BINDING, (GLint*)&BufferBindings[0]); + m_Real->glGetIntegerv(eGL_COPY_READ_BUFFER_BINDING, (GLint*)&BufferBindings[1]); + m_Real->glGetIntegerv(eGL_COPY_WRITE_BUFFER_BINDING, (GLint*)&BufferBindings[2]); + m_Real->glGetIntegerv(eGL_DRAW_INDIRECT_BUFFER_BINDING, (GLint*)&BufferBindings[3]); + m_Real->glGetIntegerv(eGL_DISPATCH_INDIRECT_BUFFER_BINDING, (GLint*)&BufferBindings[4]); + m_Real->glGetIntegerv(eGL_ELEMENT_ARRAY_BUFFER_BINDING, (GLint*)&BufferBindings[5]); + m_Real->glGetIntegerv(eGL_PIXEL_PACK_BUFFER_BINDING, (GLint*)&BufferBindings[6]); + m_Real->glGetIntegerv(eGL_PIXEL_UNPACK_BUFFER_BINDING, (GLint*)&BufferBindings[7]); + m_Real->glGetIntegerv(eGL_QUERY_BUFFER_BINDING, (GLint*)&BufferBindings[8]); + m_Real->glGetIntegerv(eGL_TEXTURE_BUFFER_BINDING, (GLint*)&BufferBindings[9]); + + struct { IdxRangeBuffer *bufs; int count; GLenum binding; GLenum start; GLenum size; } idxBufs[] = + { + { AtomicCounter, ARRAY_COUNT(AtomicCounter), eGL_ATOMIC_COUNTER_BUFFER_BINDING, }, + { ShaderStorage, ARRAY_COUNT(ShaderStorage), eGL_SHADER_STORAGE_BUFFER_BINDING, }, + { TransformFeedback, ARRAY_COUNT(TransformFeedback), eGL_TRANSFORM_FEEDBACK_BUFFER_BINDING, }, + { UniformBinding, ARRAY_COUNT(UniformBinding), eGL_UNIFORM_BUFFER_BINDING, }, + }; + + for(int b=0; b < ARRAY_COUNT(idxBufs); b++) + { + for(int i=0; i < idxBufs[b].count; i++) + { + m_Real->glGetIntegeri_v(idxBufs[b].binding, i, (GLint*)&idxBufs[b].bufs[i].name); + m_Real->glGetInteger64i_v(idxBufs[b].start, i, (GLint64*)&idxBufs[b].bufs[i].start); + m_Real->glGetInteger64i_v(idxBufs[b].size, i, (GLint64*)&idxBufs[b].bufs[i].size); + } + } +} + +void GLRenderState::ApplyState() +{ + for(int i=0; i < ARRAY_COUNT(Tex2D); i++) + { + m_Real->glActiveTexture(GLenum(eGL_TEXTURE0 + i)); + m_Real->glBindTexture(eGL_TEXTURE_2D, Tex2D[i]); + } + + m_Real->glActiveTexture(ActiveTexture); + + m_Real->glBindBuffer(eGL_ARRAY_BUFFER, BufferBindings[0]); + m_Real->glBindBuffer(eGL_COPY_READ_BUFFER, BufferBindings[1]); + m_Real->glBindBuffer(eGL_COPY_WRITE_BUFFER, BufferBindings[2]); + m_Real->glBindBuffer(eGL_DRAW_INDIRECT_BUFFER, BufferBindings[3]); + m_Real->glBindBuffer(eGL_DISPATCH_INDIRECT_BUFFER, BufferBindings[4]); + m_Real->glBindBuffer(eGL_ELEMENT_ARRAY_BUFFER, BufferBindings[5]); + m_Real->glBindBuffer(eGL_PIXEL_PACK_BUFFER, BufferBindings[6]); + m_Real->glBindBuffer(eGL_PIXEL_UNPACK_BUFFER, BufferBindings[7]); + m_Real->glBindBuffer(eGL_QUERY_BUFFER, BufferBindings[8]); + m_Real->glBindBuffer(eGL_TEXTURE_BUFFER, BufferBindings[9]); + + struct { IdxRangeBuffer *bufs; int count; GLenum binding; } idxBufs[] = + { + { AtomicCounter, ARRAY_COUNT(AtomicCounter), eGL_ATOMIC_COUNTER_BUFFER, }, + { ShaderStorage, ARRAY_COUNT(ShaderStorage), eGL_SHADER_STORAGE_BUFFER, }, + { TransformFeedback, ARRAY_COUNT(TransformFeedback), eGL_TRANSFORM_FEEDBACK_BUFFER, }, + { UniformBinding, ARRAY_COUNT(UniformBinding), eGL_UNIFORM_BUFFER, }, + }; + + for(int b=0; b < ARRAY_COUNT(idxBufs); b++) + for(int i=0; i < idxBufs[b].count; i++) + m_Real->glBindBufferRange(idxBufs[b].binding, i, idxBufs[b].bufs[i].name, (GLintptr)idxBufs[b].bufs[i].start, (GLsizeiptr)idxBufs[b].bufs[i].size); +} + +void GLRenderState::Clear() +{ + RDCEraseEl(Tex2D); + RDCEraseEl(ActiveTexture); + RDCEraseEl(BufferBindings); + RDCEraseEl(AtomicCounter); + RDCEraseEl(ShaderStorage); + RDCEraseEl(TransformFeedback); + RDCEraseEl(UniformBinding); +} + +void GLRenderState::Serialise(LogState state, GLResourceManager *rm) +{ + // TODO check GL_MAX_* + + { + ResourceId IDs[128]; + m_pSerialiser->Serialise<128>("GL_TEXTURE_BINDING_2D", IDs); + } + + m_pSerialiser->Serialise("GL_ACTIVE_TEXTURE", ActiveTexture); + + for(int i=0; i < ARRAY_COUNT(BufferBindings); i++) + { + ResourceId ID = ResourceId(); + if(state >= WRITING) ID = rm->GetID(BufferRes(BufferBindings[i])); + m_pSerialiser->Serialise("GL_BUFFER_BINDING", ID); + if(state < WRITING) BufferBindings[i] = rm->GetLiveResource(ID).name; + } + + struct { IdxRangeBuffer *bufs; int count; } idxBufs[] = + { + { AtomicCounter, ARRAY_COUNT(AtomicCounter), }, + { ShaderStorage, ARRAY_COUNT(ShaderStorage), }, + { TransformFeedback, ARRAY_COUNT(TransformFeedback), }, + { UniformBinding, ARRAY_COUNT(UniformBinding), }, + }; + + for(int b=0; b < ARRAY_COUNT(idxBufs); b++) + { + for(int i=0; i < idxBufs[b].count; i++) + { + ResourceId ID = ResourceId(); + if(state >= WRITING) ID = rm->GetID(BufferRes(idxBufs[b].bufs[i].name)); + m_pSerialiser->Serialise("BUFFER_BINDING", ID); + if(state < WRITING) idxBufs[b].bufs[i].name = rm->GetLiveResource(ID).name; + + m_pSerialiser->Serialise("BUFFER_START", idxBufs[b].bufs[i].start); + m_pSerialiser->Serialise("BUFFER_SIZE", idxBufs[b].bufs[i].size); + } + } +} diff --git a/renderdoc/driver/gl/gl_renderstate.h b/renderdoc/driver/gl/gl_renderstate.h new file mode 100644 index 000000000..66205326f --- /dev/null +++ b/renderdoc/driver/gl/gl_renderstate.h @@ -0,0 +1,57 @@ +/****************************************************************************** + * 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 + +#include "gl_common.h" +#include "gl_hookset.h" +#include "gl_manager.h" + +struct GLRenderState +{ + GLRenderState(const GLHookSet *funcs, Serialiser *ser); + ~GLRenderState(); + + void FetchState(); + void ApplyState(); + void Clear(); + + // + uint32_t Tex2D[128]; + GLenum ActiveTexture; + uint32_t BufferBindings[10]; + struct IdxRangeBuffer + { + uint32_t name; + uint64_t start; + uint64_t size; + } AtomicCounter[8], ShaderStorage[8], TransformFeedback[8], UniformBinding[128]; + // + + void Serialise(LogState state, GLResourceManager *rm); +private: + Serialiser *m_pSerialiser; + const GLHookSet *m_Real; +}; \ No newline at end of file diff --git a/renderdoc/renderdoc.vcxproj b/renderdoc/renderdoc.vcxproj index 3bb48c07f..c77bbf69a 100644 --- a/renderdoc/renderdoc.vcxproj +++ b/renderdoc/renderdoc.vcxproj @@ -262,6 +262,7 @@ + @@ -332,6 +333,7 @@ + diff --git a/renderdoc/renderdoc.vcxproj.filters b/renderdoc/renderdoc.vcxproj.filters index 7e588a5c5..f46e8cb98 100644 --- a/renderdoc/renderdoc.vcxproj.filters +++ b/renderdoc/renderdoc.vcxproj.filters @@ -285,6 +285,9 @@ Replay\external interface + + Drivers\OpenGL + @@ -473,6 +476,9 @@ Drivers\OpenGL + + Drivers\OpenGL +