diff --git a/renderdoc/driver/gl/gl_common.h b/renderdoc/driver/gl/gl_common.h index e457af65c..3c519c57e 100644 --- a/renderdoc/driver/gl/gl_common.h +++ b/renderdoc/driver/gl/gl_common.h @@ -124,11 +124,16 @@ enum GLChunkType CLEARBUFFERI, CLEARBUFFERUI, CLEARBUFFERFI, + POLYGON_MODE, + POLYGON_OFFSET, CULL_FACE, ENABLE, DISABLE, + ENABLEI, + DISABLEI, FRONT_FACE, BLEND_FUNC, + BLEND_FUNCI, BLEND_COLOR, BLEND_FUNC_SEP, BLEND_FUNC_SEPI, @@ -137,8 +142,12 @@ enum GLChunkType COLOR_MASK, COLOR_MASKI, DEPTH_FUNC, + DEPTH_MASK, + DEPTH_RANGEARRAY, VIEWPORT, VIEWPORT_ARRAY, + SCISSOR, + SCISSOR_ARRAY, USEPROGRAM, BINDVERTEXARRAY, UNIFORM_MATRIX, @@ -162,6 +171,7 @@ enum GLChunkType BIND_VERTEXARRAY, VERTEXATTRIBPOINTER, ENABLEVERTEXATTRIBARRAY, + DISABLEVERTEXATTRIBARRAY, DELETE_VERTEXARRAY, DELETE_BUFFER, diff --git a/renderdoc/driver/gl/gl_context_driver.cpp b/renderdoc/driver/gl/gl_context_driver.cpp index b7f75ea60..a05392867 100644 --- a/renderdoc/driver/gl/gl_context_driver.cpp +++ b/renderdoc/driver/gl/gl_context_driver.cpp @@ -55,6 +55,33 @@ void WrappedOpenGL::glBlendFunc(GLenum sfactor, GLenum dfactor) } } +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) + { + 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); @@ -271,6 +298,60 @@ void WrappedOpenGL::glDepthFunc(GLenum func) } } +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_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_glDisable(GLenum cap) { SERIALISE_ELEMENT(GLenum, c, cap); @@ -294,6 +375,7 @@ void WrappedOpenGL::glDisable(GLenum cap) m_ContextRecord->AddChunk(scope.Get()); } + // TODO replace this with glIsEnabled() for the relevant states if(m_State == WRITING_IDLE) { SCOPED_SERIALISE_CONTEXT(DISABLE); @@ -336,6 +418,74 @@ void WrappedOpenGL::glEnable(GLenum cap) } } +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); @@ -454,8 +604,8 @@ bool WrappedOpenGL::Serialise_glViewport(GLint x, GLint y, GLsizei width, GLsize { SERIALISE_ELEMENT(int32_t, X, x); SERIALISE_ELEMENT(int32_t, Y, y); - SERIALISE_ELEMENT(int32_t, W, width); - SERIALISE_ELEMENT(int32_t, H, height); + SERIALISE_ELEMENT(uint32_t, W, width); + SERIALISE_ELEMENT(uint32_t, H, height); if(m_State <= EXECUTING) { @@ -518,9 +668,124 @@ 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()); + } } bool WrappedOpenGL::Serialise_glBindFramebuffer(GLenum target, GLuint framebuffer) diff --git a/renderdoc/driver/gl/gl_device_driver.cpp b/renderdoc/driver/gl/gl_device_driver.cpp index 2380b4aea..bcef2b14c 100644 --- a/renderdoc/driver/gl/gl_device_driver.cpp +++ b/renderdoc/driver/gl/gl_device_driver.cpp @@ -1282,6 +1282,32 @@ void WrappedOpenGL::glEnableVertexAttribArray(GLuint index) } } +bool WrappedOpenGL::Serialise_glDisableVertexAttribArray(GLuint index) +{ + SERIALISE_ELEMENT(uint32_t, Index, index); + + if(m_State < WRITING) + { + 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))); diff --git a/renderdoc/driver/gl/gl_driver.cpp b/renderdoc/driver/gl/gl_driver.cpp index 599e73eef..c8763b307 100644 --- a/renderdoc/driver/gl/gl_driver.cpp +++ b/renderdoc/driver/gl/gl_driver.cpp @@ -81,11 +81,16 @@ const char *GLChunkNames[] = "glClearBufferiv", "glClearBufferuiv", "glClearBufferfi", + "glPolygonMode", + "glPolygonOffset", "glCullFace", "glEnable", "glDisable", + "glEnablei", + "glDisablei", "glFrontFace", "glBlendFunc", + "glBlendFunci", "glBlendColor", "glBlendFuncSeparate", "glBlendFuncSeparatei", @@ -94,8 +99,12 @@ const char *GLChunkNames[] = "glColorMask", "glColorMaski", "glDepthFunc", + "glDepthMask", + "glDepthRangeArrayv", "glViewport", "glViewportArrayv", + "glScissor", + "glScissorArrayv", "glUseProgram", "glBindVertexArray", "glUniformMatrix*", @@ -119,6 +128,7 @@ const char *GLChunkNames[] = "glBindVertexArray", "glVertexAttribPointer", "glEnableVertexAttribArray", + "glDisableVertexAttribArray", "glDeleteVertexArray", "glDeleteBuffer", @@ -987,6 +997,12 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) case CULL_FACE: Serialise_glCullFace(eGL_UNKNOWN_ENUM); break; + case POLYGON_MODE: + glPolygonMode(eGL_UNKNOWN_ENUM, eGL_UNKNOWN_ENUM); + break; + case POLYGON_OFFSET: + glPolygonOffset(0, 0); + break; case CLEARBUFFERF: Serialise_glClearBufferfv(eGL_UNKNOWN_ENUM, 0, NULL); break; @@ -1005,6 +1021,12 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) case ENABLE: Serialise_glEnable(eGL_UNKNOWN_ENUM); break; + case DISABLEI: + Serialise_glDisablei(eGL_UNKNOWN_ENUM, 0); + break; + case ENABLEI: + Serialise_glEnablei(eGL_UNKNOWN_ENUM, 0); + break; case FRONT_FACE: Serialise_glFrontFace(eGL_UNKNOWN_ENUM); break; @@ -1035,12 +1057,24 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) case DEPTH_FUNC: Serialise_glDepthFunc(eGL_UNKNOWN_ENUM); break; + case DEPTH_MASK: + Serialise_glDepthMask(0); + break; + case DEPTH_RANGEARRAY: + Serialise_glDepthRangeArrayv(0, 0, NULL); + break; case VIEWPORT: Serialise_glViewport(0, 0, 0, 0); break; case VIEWPORT_ARRAY: Serialise_glViewportArrayv(0, 0, 0); break; + case SCISSOR: + Serialise_glScissor(0, 0, 0, 0); + break; + case SCISSOR_ARRAY: + Serialise_glScissorArrayv(0, 0, 0); + break; case USEPROGRAM: Serialise_glUseProgram(0); break; @@ -1084,6 +1118,9 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) case ENABLEVERTEXATTRIBARRAY: Serialise_glEnableVertexAttribArray(0); break; + case DISABLEVERTEXATTRIBARRAY: + Serialise_glDisableVertexAttribArray(0); + break; case DELETE_VERTEXARRAY: case DELETE_BUFFER: @@ -1420,6 +1457,16 @@ GLenum WrappedOpenGL::glGetError() return m_Real.glGetError(); } +void WrappedOpenGL::glFlush() +{ + m_Real.glFlush(); +} + +void WrappedOpenGL::glFinish() +{ + m_Real.glFinish(); +} + void WrappedOpenGL::glGetFloatv(GLenum pname, GLfloat *params) { m_Real.glGetFloatv(pname, params); diff --git a/renderdoc/driver/gl/gl_driver.h b/renderdoc/driver/gl/gl_driver.h index 7aad08e04..35fe43915 100644 --- a/renderdoc/driver/gl/gl_driver.h +++ b/renderdoc/driver/gl/gl_driver.h @@ -265,7 +265,9 @@ class WrappedOpenGL // 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)); + IMPLEMENT_FUNCTION_SERIALISED(void, glBlendFunci(GLuint buf, GLenum sfactor, GLenum dfactor)); IMPLEMENT_FUNCTION_SERIALISED(void, glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)); IMPLEMENT_FUNCTION_SERIALISED(void, glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)); IMPLEMENT_FUNCTION_SERIALISED(void, glBlendFuncSeparatei(GLuint buf, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)); @@ -278,10 +280,16 @@ class WrappedOpenGL IMPLEMENT_FUNCTION_SERIALISED(void, glClearDepth(GLclampd depth)); IMPLEMENT_FUNCTION_SERIALISED(void, glCullFace(GLenum cap)); IMPLEMENT_FUNCTION_SERIALISED(void, glDepthFunc(GLenum func)); + IMPLEMENT_FUNCTION_SERIALISED(void, glDepthMask(GLboolean flag)); + IMPLEMENT_FUNCTION_SERIALISED(void, glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)); IMPLEMENT_FUNCTION_SERIALISED(void, glDisable(GLenum cap)); IMPLEMENT_FUNCTION_SERIALISED(void, glEnable(GLenum cap)); + IMPLEMENT_FUNCTION_SERIALISED(void, glDisablei(GLenum cap, GLuint index)); + IMPLEMENT_FUNCTION_SERIALISED(void, glEnablei(GLenum cap, GLuint index)); IMPLEMENT_FUNCTION_SERIALISED(void, glFrontFace(GLenum cap)); IMPLEMENT_FUNCTION_SERIALISED(GLenum, glGetError()); + IMPLEMENT_FUNCTION_SERIALISED(void, glFinish()); + IMPLEMENT_FUNCTION_SERIALISED(void, glFlush()); IMPLEMENT_FUNCTION_SERIALISED(void, glGetFloatv(GLenum pname, GLfloat *params)); IMPLEMENT_FUNCTION_SERIALISED(void, glGetIntegerv(GLenum pname, GLint *params)); IMPLEMENT_FUNCTION_SERIALISED(void, glGetBooleanv(GLenum pname, GLboolean *data)); @@ -297,6 +305,7 @@ class WrappedOpenGL IMPLEMENT_FUNCTION_SERIALISED(void, glPixelStorei(GLenum pname, GLint param)); IMPLEMENT_FUNCTION_SERIALISED(void, glPixelStoref(GLenum pname, GLfloat param)); IMPLEMENT_FUNCTION_SERIALISED(void, glPolygonMode(GLenum face, GLenum mode)); + IMPLEMENT_FUNCTION_SERIALISED(void, glPolygonOffset(GLfloat factor, GLfloat units)); IMPLEMENT_FUNCTION_SERIALISED(void, glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)); IMPLEMENT_FUNCTION_SERIALISED(void, glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels)); IMPLEMENT_FUNCTION_SERIALISED(void, glTexParameteri(GLenum target, GLenum pname, GLint param)); @@ -307,6 +316,10 @@ class WrappedOpenGL IMPLEMENT_FUNCTION_SERIALISED(void, glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)); IMPLEMENT_FUNCTION_SERIALISED(void, glViewportIndexedfv(GLuint index, const GLfloat *v)); IMPLEMENT_FUNCTION_SERIALISED(void, glViewportArrayv(GLuint first, GLuint count, const GLfloat *v)); + IMPLEMENT_FUNCTION_SERIALISED(void, glScissor(GLint x, GLint y, GLsizei width, GLsizei height)); + IMPLEMENT_FUNCTION_SERIALISED(void, glScissorArrayv(GLuint first, GLsizei count, const GLint *v)); + IMPLEMENT_FUNCTION_SERIALISED(void, glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)); + IMPLEMENT_FUNCTION_SERIALISED(void, glScissorIndexedv(GLuint index, const GLint *v)); IMPLEMENT_FUNCTION_SERIALISED(void, glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels)); IMPLEMENT_FUNCTION_SERIALISED(void, glReadBuffer(GLenum mode)); IMPLEMENT_FUNCTION_SERIALISED(void, glGenFramebuffers(GLsizei n, GLuint *framebuffers)); @@ -370,6 +383,7 @@ class WrappedOpenGL IMPLEMENT_FUNCTION_SERIALISED(void, glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)); IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer)); IMPLEMENT_FUNCTION_SERIALISED(void, glEnableVertexAttribArray(GLuint index)); + IMPLEMENT_FUNCTION_SERIALISED(void, glDisableVertexAttribArray(GLuint index)); IMPLEMENT_FUNCTION_SERIALISED(void, glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)); IMPLEMENT_FUNCTION_SERIALISED(void, glGetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer)); IMPLEMENT_FUNCTION_SERIALISED(void, glGenVertexArrays(GLsizei n, GLuint *arrays)); diff --git a/renderdoc/driver/gl/gl_hookset.h b/renderdoc/driver/gl/gl_hookset.h index a228f185a..8b183c4b8 100644 --- a/renderdoc/driver/gl/gl_hookset.h +++ b/renderdoc/driver/gl/gl_hookset.h @@ -43,6 +43,8 @@ struct GLHookSet PFNGLDISABLEPROC glDisable; PFNGLDRAWARRAYSPROC glDrawArrays; PFNGLENABLEPROC glEnable; + PFNGLFLUSHPROC glFlush; + PFNGLFINISHPROC glFinish; PFNGLFRONTFACEPROC glFrontFace; PFNGLGENTEXTURESPROC glGenTextures; PFNGLDELETETEXTURESPROC glDeleteTextures; @@ -60,8 +62,10 @@ struct GLHookSet PFNGLPIXELSTOREIPROC glPixelStorei; PFNGLPIXELSTOREFPROC glPixelStoref; PFNGLPOLYGONMODEPROC glPolygonMode; + PFNGLPOLYGONOFFSETPROC glPolygonOffset; PFNGLREADPIXELSPROC glReadPixels; PFNGLREADBUFFERPROC glReadBuffer; + PFNGLSCISSORPROC glScissor; PFNGLTEXIMAGE1DPROC glTexImage1D; PFNGLTEXIMAGE2DPROC glTexImage2D; PFNGLTEXPARAMETERIPROC glTexParameteri; @@ -101,11 +105,14 @@ struct GLHookSet PFNGLGETFLOATI_VPROC glGetFloati_v; PFNGLGETINTEGER64I_VPROC glGetInteger64i_v; PFNGLCHECKFRAMEBUFFERSTATUSPROC glCheckFramebufferStatus; + PFNGLBLENDFUNCIPROC glBlendFunci; PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate; PFNGLBLENDFUNCSEPARATEIPROC glBlendFuncSeparatei; PFNGLBLENDEQUATIONSEPARATEPROC glBlendEquationSeparate; PFNGLBLENDEQUATIONSEPARATEIPROC glBlendEquationSeparatei; PFNGLCOLORMASKIPROC glColorMaski; + PFNGLDEPTHMASKPROC glDepthMask; + PFNGLDEPTHRANGEARRAYVPROC glDepthRangeArrayv; PFNGLCREATESHADERPROC glCreateShader; PFNGLDELETESHADERPROC glDeleteShader; PFNGLSHADERSOURCEPROC glShaderSource; @@ -125,6 +132,8 @@ struct GLHookSet PFNGLDEBUGMESSAGECALLBACKPROC glDebugMessageCallback; // aliases glDebugMessageCallbackARB PFNGLGETOBJECTLABELPROC glGetObjectLabel; PFNGLOBJECTLABELPROC glObjectLabel; + PFNGLENABLEIPROC glEnablei; + PFNGLDISABLEIPROC glDisablei; PFNGLGENBUFFERSPROC glGenBuffers; PFNGLBINDBUFFERPROC glBindBuffer; PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers; @@ -144,6 +153,7 @@ struct GLHookSet PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays; PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer; PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray; + PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray; PFNGLGETVERTEXATTRIBIVPROC glGetVertexAttribiv; PFNGLGETVERTEXATTRIBPOINTERVPROC glGetVertexAttribPointerv; PFNGLGENSAMPLERSPROC glGenSamplers; @@ -153,6 +163,9 @@ struct GLHookSet PFNGLCLEARBUFFERIVPROC glClearBufferiv; PFNGLCLEARBUFFERUIVPROC glClearBufferuiv; PFNGLCLEARBUFFERFIPROC glClearBufferfi; + PFNGLSCISSORARRAYVPROC glScissorArrayv; + PFNGLSCISSORINDEXEDPROC glScissorIndexed; + PFNGLSCISSORINDEXEDVPROC glScissorIndexedv; PFNGLVIEWPORTINDEXEDFPROC glViewportIndexedf; PFNGLVIEWPORTINDEXEDFVPROC glViewportIndexedfv; PFNGLVIEWPORTARRAYVPROC glViewportArrayv; diff --git a/renderdoc/driver/gl/gl_hookset_defs.h b/renderdoc/driver/gl/gl_hookset_defs.h index d84f5970e..659e92696 100644 --- a/renderdoc/driver/gl/gl_hookset_defs.h +++ b/renderdoc/driver/gl/gl_hookset_defs.h @@ -43,6 +43,8 @@ HookInit(glDisable); \ HookInit(glDrawArrays); \ HookInit(glEnable); \ + HookInit(glFlush); \ + HookInit(glFinish); \ HookInit(glFrontFace); \ HookInit(glGenTextures); \ HookInit(glDeleteTextures); \ @@ -60,8 +62,10 @@ HookInit(glPixelStorei); \ HookInit(glPixelStoref); \ HookInit(glPolygonMode); \ + HookInit(glPolygonOffset); \ HookInit(glReadPixels); \ HookInit(glReadBuffer); \ + HookInit(glScissor); \ HookInit(glTexImage1D); \ HookInit(glTexImage2D); \ HookInit(glTexParameteri); \ @@ -112,11 +116,14 @@ HookExtension(PFNGLGETFLOATI_VPROC, glGetFloati_v); \ HookExtension(PFNGLGETINTEGER64I_VPROC, glGetInteger64i_v); \ HookExtension(PFNGLCHECKFRAMEBUFFERSTATUSPROC, glCheckFramebufferStatus); \ + HookExtension(PFNGLBLENDFUNCIPROC, glBlendFunci); \ HookExtension(PFNGLBLENDFUNCSEPARATEPROC, glBlendFuncSeparate); \ HookExtension(PFNGLBLENDFUNCSEPARATEIPROC, glBlendFuncSeparatei); \ HookExtension(PFNGLBLENDEQUATIONSEPARATEPROC, glBlendEquationSeparate); \ HookExtension(PFNGLBLENDEQUATIONSEPARATEIPROC, glBlendEquationSeparatei); \ HookExtension(PFNGLCOLORMASKIPROC, glColorMaski); \ + HookExtension(PFNGLDEPTHMASKPROC, glDepthMask); \ + HookExtension(PFNGLDEPTHRANGEARRAYVPROC, glDepthRangeArrayv); \ HookExtension(PFNGLCREATESHADERPROC, glCreateShader); \ HookExtension(PFNGLDELETESHADERPROC, glDeleteShader); \ HookExtension(PFNGLSHADERSOURCEPROC, glShaderSource); \ @@ -137,6 +144,8 @@ HookExtensionAlias(PFNGLDEBUGMESSAGECALLBACKPROC, glDebugMessageCallback, glDebugMessageCallbackARB); \ HookExtension(PFNGLGETOBJECTLABELPROC, glGetObjectLabel); \ HookExtension(PFNGLOBJECTLABELPROC, glObjectLabel); \ + HookExtension(PFNGLENABLEIPROC, glEnablei); \ + HookExtension(PFNGLDISABLEIPROC, glDisablei); \ HookExtension(PFNGLGENBUFFERSPROC, glGenBuffers); \ HookExtension(PFNGLBINDBUFFERPROC, glBindBuffer); \ HookExtension(PFNGLGENFRAMEBUFFERSPROC, glGenFramebuffers); \ @@ -156,6 +165,7 @@ HookExtension(PFNGLDELETEVERTEXARRAYSPROC, glDeleteVertexArrays); \ HookExtension(PFNGLVERTEXATTRIBPOINTERPROC, glVertexAttribPointer); \ HookExtension(PFNGLENABLEVERTEXATTRIBARRAYPROC, glEnableVertexAttribArray); \ + HookExtension(PFNGLDISABLEVERTEXATTRIBARRAYPROC, glDisableVertexAttribArray); \ HookExtension(PFNGLGETVERTEXATTRIBIVPROC, glGetVertexAttribiv); \ HookExtension(PFNGLGETVERTEXATTRIBPOINTERVPROC, glGetVertexAttribPointerv); \ HookExtension(PFNGLGENSAMPLERSPROC, glGenSamplers); \ @@ -165,6 +175,9 @@ HookExtension(PFNGLCLEARBUFFERIVPROC, glClearBufferiv); \ HookExtension(PFNGLCLEARBUFFERUIVPROC, glClearBufferuiv); \ HookExtension(PFNGLCLEARBUFFERFIPROC, glClearBufferfi); \ + HookExtension(PFNGLSCISSORARRAYVPROC, glScissorArrayv); \ + HookExtension(PFNGLSCISSORINDEXEDPROC, glScissorIndexed); \ + HookExtension(PFNGLSCISSORINDEXEDVPROC, glScissorIndexedv); \ HookExtension(PFNGLVIEWPORTINDEXEDFPROC, glViewportIndexedf); \ HookExtension(PFNGLVIEWPORTINDEXEDFVPROC, glViewportIndexedfv); \ HookExtension(PFNGLVIEWPORTARRAYVPROC, glViewportArrayv); \ @@ -194,6 +207,8 @@ HookExtension(PFNGLDISABLEPROC, glDisable); \ HookExtension(PFNGLDRAWARRAYSPROC, glDrawArrays); \ HookExtension(PFNGLENABLEPROC, glEnable); \ + HookExtension(PFNGLFLUSHPROC, glFlush); \ + HookExtension(PFNGLFINISHPROC, glFinish); \ HookExtension(PFNGLFRONTFACEPROC, glFrontFace); \ HookExtension(PFNGLGENTEXTURESPROC, glGenTextures); \ HookExtension(PFNGLDELETETEXTURESPROC, glDeleteTextures); \ @@ -211,8 +226,10 @@ HookExtension(PFNGLPIXELSTOREIPROC, glPixelStorei); \ HookExtension(PFNGLPIXELSTOREFPROC, glPixelStoref); \ HookExtension(PFNGLPOLYGONMODEPROC, glPolygonMode); \ + HookExtension(PFNGLPOLYGONOFFSETPROC, glPolygonOffset); \ HookExtension(PFNGLREADPIXELSPROC, glReadPixels); \ HookExtension(PFNGLREADBUFFERPROC, glReadBuffer); \ + HookExtension(PFNGLSCISSORPROC, glScissor); \ HookExtension(PFNGLTEXIMAGE1DPROC, glTexImage1D); \ HookExtension(PFNGLTEXIMAGE2DPROC, glTexImage2D); \ HookExtension(PFNGLTEXPARAMETERIPROC, glTexParameteri); \ @@ -252,6 +269,8 @@ HookWrapper1(void, glDisable, GLenum, cap); \ HookWrapper3(void, glDrawArrays, GLenum, mode, GLint, first, GLsizei, count); \ HookWrapper1(void, glEnable, GLenum, cap); \ + HookWrapper0(void, glFlush); \ + HookWrapper0(void, glFinish); \ HookWrapper1(void, glFrontFace, GLenum, mode); \ HookWrapper2(void, glGenTextures, GLsizei, n, GLuint *, textures); \ HookWrapper2(void, glDeleteTextures, GLsizei, n, const GLuint *, textures); \ @@ -269,8 +288,10 @@ HookWrapper2(void, glPixelStorei, GLenum, pname, GLint, param); \ HookWrapper2(void, glPixelStoref, GLenum, pname, GLfloat, param); \ HookWrapper2(void, glPolygonMode, GLenum, face, GLenum, mode); \ + HookWrapper2(void, glPolygonOffset, GLfloat, factor, GLfloat, units); \ HookWrapper7(void, glReadPixels, GLint, x, GLint, y, GLsizei, width, GLsizei, height, GLenum, format, GLenum, type, void *, pixels); \ HookWrapper1(void, glReadBuffer, GLenum, mode); \ + HookWrapper4(void, glScissor, GLint, x, GLint, y, GLsizei, width, GLsizei, height); \ HookWrapper8(void, glTexImage1D, GLenum, target, GLint, level, GLint, internalformat, GLsizei, width, GLint, border, GLenum, format, GLenum, type, const void *, pixels); \ HookWrapper9(void, glTexImage2D, GLenum, target, GLint, level, GLint, internalformat, GLsizei, width, GLsizei, height, GLint, border, GLenum, format, GLenum, type, const void *, pixels); \ HookWrapper3(void, glTexParameteri, GLenum, target, GLenum, pname, GLint, param); \ @@ -321,11 +342,14 @@ HookWrapper3(void, glGetFloati_v, GLenum, target, GLuint, index, GLfloat *, data); \ HookWrapper3(void, glGetInteger64i_v, GLenum, target, GLuint, index, GLint64 *, data); \ HookWrapper1(GLenum, glCheckFramebufferStatus, GLenum, target); \ + HookWrapper3(void, glBlendFunci, GLuint, buf, GLenum, src, GLenum, dst); \ HookWrapper4(void, glBlendFuncSeparate, GLenum, sfactorRGB, GLenum, dfactorRGB, GLenum, sfactorAlpha, GLenum, dfactorAlpha); \ HookWrapper5(void, glBlendFuncSeparatei, GLuint, buf, GLenum, srcRGB, GLenum, dstRGB, GLenum, srcAlpha, GLenum, dstAlpha); \ HookWrapper2(void, glBlendEquationSeparate, GLenum, modeRGB, GLenum, modeAlpha); \ HookWrapper3(void, glBlendEquationSeparatei, GLuint, buf, GLenum, modeRGB, GLenum, modeAlpha); \ HookWrapper5(void, glColorMaski, GLuint, index, GLboolean, r, GLboolean, g, GLboolean, b, GLboolean, a); \ + HookWrapper1(void, glDepthMask, GLboolean, flag); \ + HookWrapper3(void, glDepthRangeArrayv, GLuint, first, GLsizei, count, const GLdouble *, v); \ HookWrapper1(GLuint, glCreateShader, GLenum, type); \ HookWrapper1(void, glDeleteShader, GLuint, shader); \ HookWrapper4(void, glShaderSource, GLuint, shader, GLsizei, count, const GLchar *const*, string, const GLint *, length); \ @@ -345,6 +369,8 @@ HookWrapper2(void, glDebugMessageCallback, GLDEBUGPROC, callback, const void *, userParam); \ HookWrapper5(void, glGetObjectLabel, GLenum, identifier, GLuint, name, GLsizei, bufSize, GLsizei *, length, GLchar *, label); \ HookWrapper4(void, glObjectLabel, GLenum, identifier, GLuint, name, GLsizei, length, const GLchar *, label); \ + HookWrapper2(void, glEnablei, GLenum, target, GLuint, index); \ + HookWrapper2(void, glDisablei, GLenum, target, GLuint, index); \ HookWrapper2(void, glGenBuffers, GLsizei, n, GLuint *, buffers); \ HookWrapper2(void, glBindBuffer, GLenum, target, GLuint, buffer); \ HookWrapper2(void, glGenFramebuffers, GLsizei, n, GLuint *, framebuffers); \ @@ -364,6 +390,7 @@ HookWrapper2(void, glDeleteVertexArrays, GLsizei, n, const GLuint *, arrays); \ HookWrapper6(void, glVertexAttribPointer, GLuint, index, GLint, size, GLenum, type, GLboolean, normalized, GLsizei, stride, const void *, pointer); \ HookWrapper1(void, glEnableVertexAttribArray, GLuint, index); \ + HookWrapper1(void, glDisableVertexAttribArray, GLuint, index); \ HookWrapper3(void, glGetVertexAttribiv, GLuint, index, GLenum, pname, GLint *, params); \ HookWrapper3(void, glGetVertexAttribPointerv, GLuint, index, GLenum, pname, void **, pointer); \ HookWrapper2(void, glGenSamplers, GLsizei, count, GLuint *, samplers); \ @@ -373,6 +400,9 @@ HookWrapper3(void, glClearBufferiv, GLenum, buffer, GLint, drawbuffer, const GLint *, value); \ HookWrapper3(void, glClearBufferuiv, GLenum, buffer, GLint, drawbuffer, const GLuint *, value); \ HookWrapper4(void, glClearBufferfi, GLenum, buffer, GLint, drawbuffer, GLfloat, depth, GLint, stencil); \ + HookWrapper3(void, glScissorArrayv, GLuint, first, GLsizei, count, const GLint *, v); \ + HookWrapper5(void, glScissorIndexed, GLuint, index, GLint, left, GLint, bottom, GLsizei, width, GLsizei, height); \ + HookWrapper2(void, glScissorIndexedv, GLuint, index, const GLint *, v); \ HookWrapper5(void, glViewportIndexedf, GLuint, index, GLfloat, x, GLfloat, y, GLfloat, w, GLfloat, h); \ HookWrapper2(void, glViewportIndexedfv, GLuint, index, const GLfloat *, v); \ HookWrapper3(void, glViewportArrayv, GLuint, first, GLsizei, count, const GLfloat *, v); \