From 62f28f751c325b6d68766f6e6d41997e0cfb628d Mon Sep 17 00:00:00 2001 From: baldurk Date: Tue, 11 Nov 2014 17:55:26 +0000 Subject: [PATCH] Implement some multi-binding functions. --- renderdoc/driver/gl/gl_common.h | 9 +- renderdoc/driver/gl/gl_driver.cpp | 32 ++- renderdoc/driver/gl/gl_driver.h | 8 + renderdoc/driver/gl/gl_hookset.h | 6 + renderdoc/driver/gl/gl_hookset_defs.h | 12 ++ .../driver/gl/wrappers/gl_buffer_funcs.cpp | 190 +++++++++++++++++- .../driver/gl/wrappers/gl_sampler_funcs.cpp | 44 ++++ .../driver/gl/wrappers/gl_texture_funcs.cpp | 116 +++++++++++ 8 files changed, 406 insertions(+), 11 deletions(-) diff --git a/renderdoc/driver/gl/gl_common.h b/renderdoc/driver/gl/gl_common.h index f0f87af89..2c116ebfe 100644 --- a/renderdoc/driver/gl/gl_common.h +++ b/renderdoc/driver/gl/gl_common.h @@ -90,7 +90,9 @@ enum GLChunkType GEN_TEXTURE, BIND_TEXTURE, + BIND_TEXTURES, BIND_IMAGE_TEXTURE, + BIND_IMAGE_TEXTURES, ACTIVE_TEXTURE, TEXSTORAGE1D, TEXSTORAGE2D, @@ -208,8 +210,8 @@ enum GLChunkType VIEWPORT_ARRAY, SCISSOR, SCISSOR_ARRAY, - BINDVERTEXARRAY, - BINDVERTEXBUFFER, + BIND_VERTEXBUFFER, + BIND_VERTEXBUFFERS, VERTEXBINDINGDIVISOR, DISPATCH_COMPUTE, DISPATCH_COMPUTE_INDIRECT, @@ -254,11 +256,14 @@ enum GLChunkType SAMPLER_PARAMETERIIV, SAMPLER_PARAMETERIUIV, BIND_SAMPLER, + BIND_SAMPLERS, GEN_BUFFER, BIND_BUFFER, BIND_BUFFER_BASE, BIND_BUFFER_RANGE, + BIND_BUFFERS_BASE, + BIND_BUFFERS_RANGE, BUFFERSTORAGE, BUFFERDATA, BUFFERSUBDATA, diff --git a/renderdoc/driver/gl/gl_driver.cpp b/renderdoc/driver/gl/gl_driver.cpp index 8479685b4..e1c1186bf 100644 --- a/renderdoc/driver/gl/gl_driver.cpp +++ b/renderdoc/driver/gl/gl_driver.cpp @@ -43,7 +43,9 @@ const char *GLChunkNames[] = "glGenTextures", "glBindTexture", + "glBindTextures", "glBindImageTexture", + "glBindImageTextures", "glActiveTexture", "glTexStorage1D", "glTexStorage2D", @@ -115,6 +117,8 @@ const char *GLChunkNames[] = "glClearBufferfi", "glClearBufferData", "glClearBufferSubData", + "glClearTexImage", + "glClearTexSubImage", "glPolygonMode", "glPolygonOffset", "glCullFace", @@ -159,8 +163,8 @@ const char *GLChunkNames[] = "glViewportArrayv", "glScissor", "glScissorArrayv", - "glBindVertexArray", "glBindVertexBuffer", + "glBindVertexBuffers", "glVertexBindingDivisor", "glDispatchCompute", "glDispatchComputeIndirect", @@ -205,11 +209,14 @@ const char *GLChunkNames[] = "glSamplerParameterIiv", "glSamplerParameterIuiv", "glBindSampler", + "glBindSamplers", "glGenBuffers", "glBindBuffer", "glBindBufferBase", "glBindBufferRange", + "glBindBuffersBase", + "glBindBuffersRange", "glBufferStorage", "glBufferData", "glBufferSubData", @@ -1534,9 +1541,15 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) case BIND_TEXTURE: Serialise_glBindTexture(eGL_NONE, 0); break; + case BIND_TEXTURES: + Serialise_glBindTextures(0, 0, NULL); + break; case BIND_IMAGE_TEXTURE: Serialise_glBindImageTexture(0, 0, 0, 0, 0, eGL_NONE, eGL_NONE); break; + case BIND_IMAGE_TEXTURES: + Serialise_glBindImageTextures(0, 0, NULL); + break; case TEXSTORAGE1D: Serialise_glTextureStorage1DEXT(0, eGL_NONE, 0, eGL_NONE, 0); break; @@ -1871,12 +1884,12 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) case SCISSOR_ARRAY: Serialise_glScissorArrayv(0, 0, 0); break; - case BINDVERTEXARRAY: - Serialise_glBindVertexArray(0); - break; - case BINDVERTEXBUFFER: + case BIND_VERTEXBUFFER: Serialise_glBindVertexBuffer(0, 0, 0, 0); break; + case BIND_VERTEXBUFFERS: + Serialise_glBindVertexBuffers(0, 0, NULL, NULL, NULL); + break; case VERTEXBINDINGDIVISOR: Serialise_glVertexBindingDivisor(0, 0); break; @@ -2003,6 +2016,9 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) case BIND_SAMPLER: Serialise_glBindSampler(0, 0); break; + case BIND_SAMPLERS: + Serialise_glBindSamplers(0, 0, NULL); + break; case GEN_BUFFER: Serialise_glGenBuffers(0, NULL); @@ -2016,6 +2032,12 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) case BIND_BUFFER_RANGE: Serialise_glBindBufferRange(eGL_NONE, 0, 0, 0, 0); break; + case BIND_BUFFERS_BASE: + Serialise_glBindBuffersBase(eGL_NONE, 0, 0, NULL); + break; + case BIND_BUFFERS_RANGE: + Serialise_glBindBuffersRange(eGL_NONE, 0, 0, NULL, NULL, NULL); + break; case BUFFERSTORAGE: Serialise_glNamedBufferStorageEXT(0, 0, NULL, 0); break; diff --git a/renderdoc/driver/gl/gl_driver.h b/renderdoc/driver/gl/gl_driver.h index 87c48e410..09ca27c5a 100644 --- a/renderdoc/driver/gl/gl_driver.h +++ b/renderdoc/driver/gl/gl_driver.h @@ -329,7 +329,9 @@ class WrappedOpenGL void Present(void *windowHandle); IMPLEMENT_FUNCTION_SERIALISED(void, glBindTexture(GLenum target, GLuint texture)); + IMPLEMENT_FUNCTION_SERIALISED(void, glBindTextures(GLuint first, GLsizei count, const GLuint *textures)); IMPLEMENT_FUNCTION_SERIALISED(void, glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)); + IMPLEMENT_FUNCTION_SERIALISED(void, glBindImageTextures(GLuint first, GLsizei count, const GLuint *textures)); IMPLEMENT_FUNCTION_SERIALISED(void, glBlendFunc(GLenum sfactor, GLenum dfactor)); IMPLEMENT_FUNCTION_SERIALISED(void, glBlendFunci(GLuint buf, GLenum sfactor, GLenum dfactor)); IMPLEMENT_FUNCTION_SERIALISED(void, glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)); @@ -394,6 +396,7 @@ class WrappedOpenGL IMPLEMENT_FUNCTION_SERIALISED(void, glTexParameteriv(GLenum target, GLenum pname, const GLint *params)); IMPLEMENT_FUNCTION_SERIALISED(void, glGenSamplers(GLsizei count, GLuint *samplers)); IMPLEMENT_FUNCTION_SERIALISED(void, glBindSampler(GLuint unit, GLuint sampler)); + IMPLEMENT_FUNCTION_SERIALISED(void, glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers)); IMPLEMENT_FUNCTION_SERIALISED(void, glDeleteSamplers(GLsizei n, const GLuint *ids)); IMPLEMENT_FUNCTION_SERIALISED(void, glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)); IMPLEMENT_FUNCTION_SERIALISED(void, glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)); @@ -509,6 +512,8 @@ class WrappedOpenGL IMPLEMENT_FUNCTION_SERIALISED(void, glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)); 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, glBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint *buffers)); + IMPLEMENT_FUNCTION_SERIALISED(void, glBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes)); IMPLEMENT_FUNCTION_SERIALISED(void *, glMapBuffer(GLenum target, GLenum access)); IMPLEMENT_FUNCTION_SERIALISED(void *, glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)); IMPLEMENT_FUNCTION_SERIALISED(void, glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)); @@ -523,6 +528,8 @@ class WrappedOpenGL IMPLEMENT_FUNCTION_SERIALISED(void, glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)); IMPLEMENT_FUNCTION_SERIALISED(void, glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data)); IMPLEMENT_FUNCTION_SERIALISED(void, glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)); + IMPLEMENT_FUNCTION_SERIALISED(void, glClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void *data)); + IMPLEMENT_FUNCTION_SERIALISED(void, glClearTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data)); enum AttribType { @@ -630,6 +637,7 @@ class WrappedOpenGL IMPLEMENT_FUNCTION_SERIALISED(void, glGenVertexArrays(GLsizei n, GLuint *arrays)); IMPLEMENT_FUNCTION_SERIALISED(void, glBindVertexArray(GLuint array)); IMPLEMENT_FUNCTION_SERIALISED(void, glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)); + IMPLEMENT_FUNCTION_SERIALISED(void, glBindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)); IMPLEMENT_FUNCTION_SERIALISED(void, glVertexBindingDivisor(GLuint bindingindex, GLuint divisor)); IMPLEMENT_FUNCTION_SERIALISED(GLboolean, glIsEnabled(GLenum cap)); diff --git a/renderdoc/driver/gl/gl_hookset.h b/renderdoc/driver/gl/gl_hookset.h index 25e3d76fa..3db69f6d0 100644 --- a/renderdoc/driver/gl/gl_hookset.h +++ b/renderdoc/driver/gl/gl_hookset.h @@ -313,6 +313,8 @@ struct GLHookSet PFNGLCOPYBUFFERSUBDATAPROC glCopyBufferSubData; PFNGLBINDBUFFERBASEPROC glBindBufferBase; PFNGLBINDBUFFERRANGEPROC glBindBufferRange; + PFNGLBINDBUFFERSBASEPROC glBindBuffersBase; + PFNGLBINDBUFFERSRANGEPROC glBindBuffersRange; PFNGLMAPBUFFERPROC glMapBuffer; PFNGLMAPBUFFERRANGEPROC glMapBufferRange; PFNGLFLUSHMAPPEDBUFFERRANGEPROC glFlushMappedBufferRange; @@ -406,10 +408,14 @@ struct GLHookSet PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray; PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray; PFNGLBINDVERTEXBUFFERPROC glBindVertexBuffer; + PFNGLBINDVERTEXBUFFERSPROC glBindVertexBuffers; PFNGLVERTEXBINDINGDIVISORPROC glVertexBindingDivisor; PFNGLBINDIMAGETEXTUREPROC glBindImageTexture; + PFNGLBINDIMAGETEXTURESPROC glBindImageTextures; PFNGLGENSAMPLERSPROC glGenSamplers; PFNGLBINDSAMPLERPROC glBindSampler; + PFNGLBINDSAMPLERSPROC glBindSamplers; + PFNGLBINDTEXTURESPROC glBindTextures; PFNGLDELETESAMPLERSPROC glDeleteSamplers; PFNGLSAMPLERPARAMETERIPROC glSamplerParameteri; PFNGLSAMPLERPARAMETERFPROC glSamplerParameterf; diff --git a/renderdoc/driver/gl/gl_hookset_defs.h b/renderdoc/driver/gl/gl_hookset_defs.h index 76ac840bb..c279b55a0 100644 --- a/renderdoc/driver/gl/gl_hookset_defs.h +++ b/renderdoc/driver/gl/gl_hookset_defs.h @@ -332,6 +332,8 @@ HookExtension(PFNGLCOPYBUFFERSUBDATAPROC, glCopyBufferSubData); \ HookExtension(PFNGLBINDBUFFERBASEPROC, glBindBufferBase); \ HookExtension(PFNGLBINDBUFFERRANGEPROC, glBindBufferRange); \ + HookExtension(PFNGLBINDBUFFERSBASEPROC, glBindBuffersBase); \ + HookExtension(PFNGLBINDBUFFERSRANGEPROC, glBindBuffersRange); \ HookExtension(PFNGLMAPBUFFERPROC, glMapBuffer); \ HookExtension(PFNGLMAPBUFFERRANGEPROC, glMapBufferRange); \ HookExtension(PFNGLFLUSHMAPPEDBUFFERRANGEPROC, glFlushMappedBufferRange); \ @@ -425,10 +427,14 @@ HookExtension(PFNGLENABLEVERTEXATTRIBARRAYPROC, glEnableVertexAttribArray); \ HookExtension(PFNGLDISABLEVERTEXATTRIBARRAYPROC, glDisableVertexAttribArray); \ HookExtension(PFNGLBINDVERTEXBUFFERPROC, glBindVertexBuffer); \ + HookExtension(PFNGLBINDVERTEXBUFFERSPROC, glBindVertexBuffers); \ HookExtension(PFNGLVERTEXBINDINGDIVISORPROC, glVertexBindingDivisor); \ HookExtension(PFNGLBINDIMAGETEXTUREPROC, glBindImageTexture); \ + HookExtension(PFNGLBINDIMAGETEXTURESPROC, glBindImageTextures); \ HookExtension(PFNGLGENSAMPLERSPROC, glGenSamplers); \ HookExtension(PFNGLBINDSAMPLERPROC, glBindSampler); \ + HookExtension(PFNGLBINDSAMPLERSPROC, glBindSamplers); \ + HookExtension(PFNGLBINDTEXTURESPROC, glBindTextures); \ HookExtension(PFNGLDELETESAMPLERSPROC, glDeleteSamplers); \ HookExtension(PFNGLSAMPLERPARAMETERIPROC, glSamplerParameteri); \ HookExtension(PFNGLSAMPLERPARAMETERFPROC, glSamplerParameterf); \ @@ -961,6 +967,8 @@ HookWrapper5(void, glCopyBufferSubData, GLenum, readTarget, GLenum, writeTarget, GLintptr, readOffset, GLintptr, writeOffset, GLsizeiptr, size); \ HookWrapper3(void, glBindBufferBase, GLenum, target, GLuint, index, GLuint, buffer); \ HookWrapper5(void, glBindBufferRange, GLenum, target, GLuint, index, GLuint, buffer, GLintptr, offset, GLsizeiptr, size); \ + HookWrapper4(void, glBindBuffersBase, GLenum, target, GLuint, first, GLsizei, count, const GLuint *, buffers); \ + HookWrapper6(void, glBindBuffersRange, GLenum, target, GLuint, first, GLsizei, count, const GLuint *, buffers, const GLintptr *, offsets, const GLsizeiptr *, sizes); \ HookWrapper2(void *, glMapBuffer, GLenum, target, GLenum, access); \ HookWrapper4(void *, glMapBufferRange, GLenum, target, GLintptr, offset, GLsizeiptr, length, GLbitfield, access); \ HookWrapper3(void, glFlushMappedBufferRange, GLenum, target, GLintptr, offset, GLsizeiptr, length); \ @@ -1054,10 +1062,14 @@ HookWrapper1(void, glEnableVertexAttribArray, GLuint, index); \ HookWrapper1(void, glDisableVertexAttribArray, GLuint, index); \ HookWrapper4(void, glBindVertexBuffer, GLuint, bindingindex, GLuint, buffer, GLintptr, offset, GLsizei, stride); \ + HookWrapper5(void, glBindVertexBuffers, GLuint, first, GLsizei, count, const GLuint *, buffers, const GLintptr *, offsets, const GLsizei *, strides); \ HookWrapper2(void, glVertexBindingDivisor, GLuint, bindingindex, GLuint, divisor); \ HookWrapper7(void, glBindImageTexture, GLuint, unit, GLuint, texture, GLint, level, GLboolean, layered, GLint, layer, GLenum, access, GLenum, format); \ + HookWrapper3(void, glBindImageTextures, GLuint, first, GLsizei, count, const GLuint *, textures); \ HookWrapper2(void, glGenSamplers, GLsizei, count, GLuint *, samplers); \ HookWrapper2(void, glBindSampler, GLuint, unit, GLuint, sampler); \ + HookWrapper3(void, glBindSamplers, GLuint, first, GLsizei, count, const GLuint *, samplers); \ + HookWrapper3(void, glBindTextures, GLuint, first, GLsizei, count, const GLuint *, textures); \ HookWrapper2(void, glDeleteSamplers, GLsizei, count, const GLuint *, samplers); \ HookWrapper3(void, glSamplerParameteri, GLuint, sampler, GLenum, pname, GLint, param); \ HookWrapper3(void, glSamplerParameterf, GLuint, sampler, GLenum, pname, GLfloat, param); \ diff --git a/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp index d46a1efd8..24895a87e 100644 --- a/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp @@ -563,7 +563,7 @@ bool WrappedOpenGL::Serialise_glBindBufferBase(GLenum target, GLuint index, GLui void WrappedOpenGL::glBindBufferBase(GLenum target, GLuint index, GLuint buffer) { - if(m_State >= WRITING) + if(m_State >= WRITING && index == 0) { size_t idx = BufferIdx(target); @@ -610,7 +610,7 @@ bool WrappedOpenGL::Serialise_glBindBufferRange(GLenum target, GLuint index, GLu void WrappedOpenGL::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) { - if(m_State >= WRITING) + if(m_State >= WRITING && index == 0) { size_t idx = BufferIdx(target); @@ -631,6 +631,130 @@ void WrappedOpenGL::glBindBufferRange(GLenum target, GLuint index, GLuint buffer m_Real.glBindBufferRange(target, index, buffer, offset, size); } +bool WrappedOpenGL::Serialise_glBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint *buffers) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(uint32_t, First, first); + SERIALISE_ELEMENT(int32_t, Count, count); + + GLuint *bufs = NULL; + if(m_State <= EXECUTING) bufs = new GLuint[Count]; + + for(int32_t i=0; i < Count; i++) + { + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(BufferRes(GetCtx(), buffers[i]))); + + if(m_State <= EXECUTING) + { + if(id != ResourceId()) + bufs[i] = GetResourceManager()->GetLiveResource(id).name; + else + bufs[i] = 0; + } + } + + if(m_State <= EXECUTING) + { + m_Real.glBindBuffersBase(Target, First, Count, bufs); + + delete[] bufs; + } + + return true; +} + +void WrappedOpenGL::glBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint *buffers) +{ + m_Real.glBindBuffersBase(target, first, count, buffers); + + if(m_State >= WRITING && first == 0 && count > 0) + { + size_t idx = BufferIdx(target); + + if(buffers[0] == 0) + m_BufferRecord[idx] = NULL; + else + m_BufferRecord[idx] = GetResourceManager()->GetResourceRecord(BufferRes(GetCtx(), buffers[0])); + } + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(BIND_BUFFERS_BASE); + Serialise_glBindBuffersBase(target, first, count, buffers); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes) +{ + SERIALISE_ELEMENT(GLenum, Target, target); + SERIALISE_ELEMENT(uint32_t, First, first); + SERIALISE_ELEMENT(int32_t, Count, count); + + GLuint *bufs = NULL; + GLintptr *offs = NULL; + GLsizeiptr *sz = NULL; + + if(m_State <= EXECUTING) + { + bufs = new GLuint[Count]; + offs = new GLintptr[Count]; + sz = new GLsizeiptr[Count]; + } + + for(int32_t i=0; i < Count; i++) + { + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(BufferRes(GetCtx(), buffers[i]))); + SERIALISE_ELEMENT(uint64_t, offset, (uint64_t)offsets[i]); + SERIALISE_ELEMENT(uint64_t, size, (uint64_t)sizes[i]); + + if(m_State <= EXECUTING) + { + if(id != ResourceId()) + bufs[i] = GetResourceManager()->GetLiveResource(id).name; + else + bufs[i] = 0; + offs[i] = (GLintptr)offset; + sz[i] = (GLsizeiptr)sizes; + } + } + + if(m_State <= EXECUTING) + { + m_Real.glBindBuffersRange(Target, First, Count, bufs, offs, sz); + + delete[] bufs; + delete[] offs; + delete[] sz; + } + + return true; +} + +void WrappedOpenGL::glBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes) +{ + m_Real.glBindBuffersRange(target, first, count, buffers, offsets, sizes); + + if(m_State >= WRITING && first == 0 && count > 0) + { + size_t idx = BufferIdx(target); + + if(buffers[0] == 0) + m_BufferRecord[idx] = NULL; + else + m_BufferRecord[idx] = GetResourceManager()->GetResourceRecord(BufferRes(GetCtx(), buffers[0])); + } + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(BIND_BUFFERS_RANGE); + Serialise_glBindBuffersRange(target, first, count, buffers, offsets, sizes); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + #pragma endregion #pragma region Mapping @@ -1699,7 +1823,7 @@ void WrappedOpenGL::glBindVertexArray(GLuint array) if(m_State == WRITING_CAPFRAME) { - SCOPED_SERIALISE_CONTEXT(BINDVERTEXARRAY); + SCOPED_SERIALISE_CONTEXT(BIND_VERTEXARRAY); Serialise_glBindVertexArray(array); m_ContextRecord->AddChunk(scope.Get()); @@ -1731,13 +1855,71 @@ void WrappedOpenGL::glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLint if(m_State == WRITING_CAPFRAME) { - SCOPED_SERIALISE_CONTEXT(BINDVERTEXBUFFER); + SCOPED_SERIALISE_CONTEXT(BIND_VERTEXBUFFER); Serialise_glBindVertexBuffer(bindingindex, buffer, offset, stride); m_ContextRecord->AddChunk(scope.Get()); } } +bool WrappedOpenGL::Serialise_glBindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides) +{ + SERIALISE_ELEMENT(uint32_t, First, first); + SERIALISE_ELEMENT(int32_t, Count, count); + + GLuint *bufs = NULL; + GLintptr *offs = NULL; + GLsizei *str = NULL; + + if(m_State <= EXECUTING) + { + bufs = new GLuint[Count]; + offs = new GLintptr[Count]; + str = new GLsizei[Count]; + } + + for(int32_t i=0; i < Count; i++) + { + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(BufferRes(GetCtx(), buffers[i]))); + SERIALISE_ELEMENT(uint64_t, offset, (uint64_t)offsets[i]); + SERIALISE_ELEMENT(uint64_t, stride, (uint64_t)strides[i]); + + if(m_State <= EXECUTING) + { + if(id != ResourceId()) + bufs[i] = GetResourceManager()->GetLiveResource(id).name; + else + bufs[i] = 0; + offs[i] = (GLintptr)offset; + str[i] = (GLsizei)stride; + } + } + + if(m_State <= EXECUTING) + { + m_Real.glBindVertexBuffers(First, Count, bufs, offs, str); + + delete[] bufs; + delete[] offs; + delete[] str; + } + + return true; +} + +void WrappedOpenGL::glBindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides) +{ + m_Real.glBindVertexBuffers(first, count, buffers, offsets, strides); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(BIND_VERTEXBUFFERS); + Serialise_glBindVertexBuffers(first, count, buffers, offsets, strides); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + bool WrappedOpenGL::Serialise_glVertexBindingDivisor(GLuint bindingindex, GLuint divisor) { SERIALISE_ELEMENT(uint32_t, idx, bindingindex); diff --git a/renderdoc/driver/gl/wrappers/gl_sampler_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_sampler_funcs.cpp index b1e4aa7cc..949008717 100644 --- a/renderdoc/driver/gl/wrappers/gl_sampler_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_sampler_funcs.cpp @@ -110,6 +110,50 @@ void WrappedOpenGL::glBindSampler(GLuint unit, GLuint sampler) } } +bool WrappedOpenGL::Serialise_glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers) +{ + SERIALISE_ELEMENT(uint32_t, First, first); + SERIALISE_ELEMENT(int32_t, Count, count); + + GLuint *samps = NULL; + if(m_State <= EXECUTING) samps = new GLuint[Count]; + + for(int32_t i=0; i < Count; i++) + { + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), samplers[i]))); + + if(m_State <= EXECUTING) + { + if(id != ResourceId()) + samps[i] = GetResourceManager()->GetLiveResource(id).name; + else + samps[i] = 0; + } + } + + if(m_State <= EXECUTING) + { + m_Real.glBindSamplers(First, Count, samps); + + delete[] samps; + } + + return true; +} + +void WrappedOpenGL::glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers) +{ + m_Real.glBindSamplers(first, count, samplers); + + if(m_State >= WRITING) + { + SCOPED_SERIALISE_CONTEXT(BIND_SAMPLERS); + Serialise_glBindSamplers(first, count, samplers); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + bool WrappedOpenGL::Serialise_glSamplerParameteri(GLuint sampler, GLenum pname, GLint param) { SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(SamplerRes(GetCtx(), sampler))); diff --git a/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp index 4296439e1..238c0c28f 100644 --- a/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_texture_funcs.cpp @@ -176,6 +176,69 @@ void WrappedOpenGL::glBindTexture(GLenum target, GLuint texture) } } +bool WrappedOpenGL::Serialise_glBindTextures(GLuint first, GLsizei count, const GLuint *textures) +{ + SERIALISE_ELEMENT(uint32_t, First, first); + SERIALISE_ELEMENT(int32_t, Count, count); + + GLuint *texs = NULL; + if(m_State <= EXECUTING) texs = new GLuint[Count]; + + for(int32_t i=0; i < Count; i++) + { + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(GetCtx(), textures[i]))); + + if(m_State <= EXECUTING) + { + if(id != ResourceId()) + { + texs[i] = GetResourceManager()->GetLiveResource(id).name; + if(m_State == READING) + m_Textures[GetResourceManager()->GetLiveID(id)].creationFlags |= eTextureCreate_SRV; + } + else + { + texs[i] = 0; + } + } + } + + if(m_State <= EXECUTING) + { + m_Real.glBindTextures(First, Count, texs); + + delete[] texs; + } + + return true; +} + +// glBindTextures doesn't provide a target, so can't be used to "init" a texture from glGenTextures +// which makes our lives a bit easier +void WrappedOpenGL::glBindTextures(GLuint first, GLsizei count, const GLuint *textures) +{ + m_Real.glBindTextures(first, count, textures); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(BIND_TEXTURES); + Serialise_glBindTextures(first, count, textures); + + m_ContextRecord->AddChunk(scope.Get()); + } + + if(m_State >= WRITING) + { + for(GLsizei i=0; i < count; i++) + { + if(textures[i] == 0) + m_TextureRecord[first + i] = 0; + else + m_TextureRecord[first + i] = GetResourceManager()->GetResourceRecord(TextureRes(GetCtx(), textures[i])); + } + } +} + bool WrappedOpenGL::Serialise_glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format) { SERIALISE_ELEMENT(uint32_t, Unit, unit); @@ -191,6 +254,9 @@ bool WrappedOpenGL::Serialise_glBindImageTexture(GLuint unit, GLuint texture, GL GLResource tex = GetResourceManager()->GetLiveResource(texid); m_Real.glBindImageTexture(Unit, tex.name, Level, Layered, Layer, Access, Format); + + if(m_State == READING) + m_Textures[GetResourceManager()->GetLiveID(texid)].creationFlags |= eTextureCreate_UAV; } return true; @@ -215,6 +281,56 @@ void WrappedOpenGL::glBindImageTexture(GLuint unit, GLuint texture, GLint level, } } +bool WrappedOpenGL::Serialise_glBindImageTextures(GLuint first, GLsizei count, const GLuint *textures) +{ + SERIALISE_ELEMENT(uint32_t, First, first); + SERIALISE_ELEMENT(int32_t, Count, count); + + GLuint *texs = NULL; + if(m_State <= EXECUTING) texs = new GLuint[Count]; + + for(int32_t i=0; i < Count; i++) + { + SERIALISE_ELEMENT(ResourceId, id, GetResourceManager()->GetID(TextureRes(GetCtx(), textures[i]))); + + if(m_State <= EXECUTING) + { + if(id != ResourceId()) + { + texs[i] = GetResourceManager()->GetLiveResource(id).name; + if(m_State == READING) + m_Textures[GetResourceManager()->GetLiveID(id)].creationFlags |= eTextureCreate_UAV; + } + else + { + texs[i] = 0; + } + } + } + + if(m_State <= EXECUTING) + { + m_Real.glBindImageTextures(First, Count, texs); + + delete[] texs; + } + + return true; +} + +void WrappedOpenGL::glBindImageTextures(GLuint first, GLsizei count, const GLuint *textures) +{ + m_Real.glBindImageTextures(first, count, textures); + + if(m_State >= WRITING) + { + SCOPED_SERIALISE_CONTEXT(BIND_IMAGE_TEXTURES); + Serialise_glBindImageTextures(first, count, textures); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + bool WrappedOpenGL::Serialise_glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers) { SERIALISE_ELEMENT(GLenum, Target, target);