From 403456a82f38f6403fe1d01b0914553c2c71e997 Mon Sep 17 00:00:00 2001 From: baldurk Date: Sun, 23 Nov 2014 19:30:23 +0000 Subject: [PATCH] Add some missing hooked gl state functions * glClipControl, glProvokingVertex, glPrimitiveRestartIndex, glDepthRangeIndexed, glClearDepthf --- renderdoc/driver/gl/gl_common.h | 4 + renderdoc/driver/gl/gl_driver.cpp | 16 +++ renderdoc/driver/gl/gl_driver.h | 7 +- renderdoc/driver/gl/gl_hookset.h | 5 + renderdoc/driver/gl/gl_hookset_defs.h | 10 ++ renderdoc/driver/gl/gl_renderstate.cpp | 15 +++ renderdoc/driver/gl/gl_renderstate.h | 5 + .../driver/gl/wrappers/gl_state_funcs.cpp | 118 +++++++++++++++++- 8 files changed, 177 insertions(+), 3 deletions(-) diff --git a/renderdoc/driver/gl/gl_common.h b/renderdoc/driver/gl/gl_common.h index 6d852c845..52d622646 100644 --- a/renderdoc/driver/gl/gl_common.h +++ b/renderdoc/driver/gl/gl_common.h @@ -210,8 +210,12 @@ enum GLChunkType DEPTH_MASK, DEPTH_RANGE, DEPTH_RANGEF, + DEPTH_RANGE_IDX, DEPTH_RANGEARRAY, DEPTH_BOUNDS, + CLIP_CONTROL, + PROVOKING_VERTEX, + PRIMITIVE_RESTART, PATCH_PARAMI, PATCH_PARAMFV, LINE_WIDTH, diff --git a/renderdoc/driver/gl/gl_driver.cpp b/renderdoc/driver/gl/gl_driver.cpp index df0384e23..9461cf5cc 100644 --- a/renderdoc/driver/gl/gl_driver.cpp +++ b/renderdoc/driver/gl/gl_driver.cpp @@ -155,8 +155,12 @@ const char *GLChunkNames[] = "glDepthMask", "glDepthRange", "glDepthRangef", + "glDepthRangeIndexed", "glDepthRangeArrayv", "glDepthBoundsEXT", + "glClipControl", + "glProvokingVertex", + "glPrimitiveRestartIndex", "glPatchParameteri", "glPatchParameterfv", "glLineWidth", @@ -1883,12 +1887,24 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) case DEPTH_RANGEF: Serialise_glDepthRangef(0, 0); break; + case DEPTH_RANGE_IDX: + Serialise_glDepthRangeIndexed(0, 0.0, 0.0); + break; case DEPTH_RANGEARRAY: Serialise_glDepthRangeArrayv(0, 0, NULL); break; case DEPTH_BOUNDS: Serialise_glDepthBoundsEXT(0, 0); break; + case CLIP_CONTROL: + Serialise_glClipControl(eGL_NONE, eGL_NONE); + break; + case PROVOKING_VERTEX: + Serialise_glProvokingVertex(eGL_NONE); + break; + case PRIMITIVE_RESTART: + Serialise_glPrimitiveRestartIndex(0); + break; case PATCH_PARAMI: Serialise_glPatchParameteri(eGL_NONE, 0); break; diff --git a/renderdoc/driver/gl/gl_driver.h b/renderdoc/driver/gl/gl_driver.h index f7e449c81..9bec125b2 100644 --- a/renderdoc/driver/gl/gl_driver.h +++ b/renderdoc/driver/gl/gl_driver.h @@ -356,15 +356,20 @@ class WrappedOpenGL IMPLEMENT_FUNCTION_SERIALISED(void, glSampleCoverage(GLfloat value, GLboolean invert)); IMPLEMENT_FUNCTION_SERIALISED(void, glClear(GLbitfield mask)); IMPLEMENT_FUNCTION_SERIALISED(void, glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)); - IMPLEMENT_FUNCTION_SERIALISED(void, glClearDepth(GLclampd depth)); + IMPLEMENT_FUNCTION_SERIALISED(void, glClearDepth(GLdouble depth)); + IMPLEMENT_FUNCTION_SERIALISED(void, glClearDepthf(GLfloat depth)); IMPLEMENT_FUNCTION_SERIALISED(void, glClearStencil(GLint stencil)); 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, glDepthRange(GLdouble nearVal, GLdouble farVal)); IMPLEMENT_FUNCTION_SERIALISED(void, glDepthRangef(GLfloat nearVal, GLfloat farVal)); + IMPLEMENT_FUNCTION_SERIALISED(void, glDepthRangeIndexed(GLuint index, GLdouble nearVal, GLdouble farVal)); IMPLEMENT_FUNCTION_SERIALISED(void, glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)); IMPLEMENT_FUNCTION_SERIALISED(void, glDepthBoundsEXT(GLclampd nearVal, GLclampd farVal)); + IMPLEMENT_FUNCTION_SERIALISED(void, glClipControl(GLenum origin, GLenum depth)); + IMPLEMENT_FUNCTION_SERIALISED(void, glProvokingVertex(GLenum mode)); + IMPLEMENT_FUNCTION_SERIALISED(void, glPrimitiveRestartIndex(GLuint index)); IMPLEMENT_FUNCTION_SERIALISED(void, glDisable(GLenum cap)); IMPLEMENT_FUNCTION_SERIALISED(void, glEnable(GLenum cap)); IMPLEMENT_FUNCTION_SERIALISED(void, glDisablei(GLenum cap, GLuint index)); diff --git a/renderdoc/driver/gl/gl_hookset.h b/renderdoc/driver/gl/gl_hookset.h index 39b64da2c..cf2f6fee8 100644 --- a/renderdoc/driver/gl/gl_hookset.h +++ b/renderdoc/driver/gl/gl_hookset.h @@ -247,8 +247,12 @@ struct GLHookSet PFNGLSAMPLECOVERAGEPROC glSampleCoverage; PFNGLDEPTHRANGEPROC glDepthRange; PFNGLDEPTHRANGEFPROC glDepthRangef; + PFNGLDEPTHRANGEINDEXEDPROC glDepthRangeIndexed; PFNGLDEPTHRANGEARRAYVPROC glDepthRangeArrayv; PFNGLDEPTHBOUNDSEXTPROC glDepthBoundsEXT; + PFNGLCLIPCONTROLPROC glClipControl; + PFNGLPROVOKINGVERTEXPROC glProvokingVertex; + PFNGLPRIMITIVERESTARTINDEXPROC glPrimitiveRestartIndex; PFNGLCREATESHADERPROC glCreateShader; PFNGLDELETESHADERPROC glDeleteShader; PFNGLSHADERSOURCEPROC glShaderSource; @@ -441,6 +445,7 @@ struct GLHookSet PFNGLDISPATCHCOMPUTEPROC glDispatchCompute; PFNGLDISPATCHCOMPUTEINDIRECTPROC glDispatchComputeIndirect; PFNGLMEMORYBARRIERPROC glMemoryBarrier; + PFNGLCLEARDEPTHFPROC glClearDepthf; PFNGLCLEARBUFFERFVPROC glClearBufferfv; PFNGLCLEARBUFFERIVPROC glClearBufferiv; PFNGLCLEARBUFFERUIVPROC glClearBufferuiv; diff --git a/renderdoc/driver/gl/gl_hookset_defs.h b/renderdoc/driver/gl/gl_hookset_defs.h index 2d6d15048..d26f23e19 100644 --- a/renderdoc/driver/gl/gl_hookset_defs.h +++ b/renderdoc/driver/gl/gl_hookset_defs.h @@ -267,8 +267,12 @@ HookExtension(PFNGLSAMPLECOVERAGEPROC, glSampleCoverage); \ HookExtension(PFNGLDEPTHRANGEPROC, glDepthRange); \ HookExtension(PFNGLDEPTHRANGEFPROC, glDepthRangef); \ + HookExtension(PFNGLDEPTHRANGEINDEXEDPROC, glDepthRangeIndexed); \ HookExtension(PFNGLDEPTHRANGEARRAYVPROC, glDepthRangeArrayv); \ HookExtension(PFNGLDEPTHBOUNDSEXTPROC, glDepthBoundsEXT); \ + HookExtension(PFNGLCLIPCONTROLPROC, glClipControl); \ + HookExtension(PFNGLPROVOKINGVERTEXPROC, glProvokingVertex); \ + HookExtension(PFNGLPRIMITIVERESTARTINDEXPROC, glPrimitiveRestartIndex); \ HookExtension(PFNGLCREATESHADERPROC, glCreateShader); \ HookExtension(PFNGLDELETESHADERPROC, glDeleteShader); \ HookExtension(PFNGLSHADERSOURCEPROC, glShaderSource); \ @@ -471,6 +475,7 @@ HookExtension(PFNGLDISPATCHCOMPUTEPROC, glDispatchCompute); \ HookExtension(PFNGLDISPATCHCOMPUTEINDIRECTPROC, glDispatchComputeIndirect); \ HookExtension(PFNGLMEMORYBARRIERPROC, glMemoryBarrier); \ + HookExtension(PFNGLCLEARDEPTHFPROC, glClearDepthf); \ HookExtension(PFNGLCLEARBUFFERFVPROC, glClearBufferfv); \ HookExtension(PFNGLCLEARBUFFERIVPROC, glClearBufferiv); \ HookExtension(PFNGLCLEARBUFFERUIVPROC, glClearBufferuiv); \ @@ -935,8 +940,12 @@ HookWrapper2(void, glSampleCoverage, GLfloat, value, GLboolean, invert); \ HookWrapper2(void, glDepthRange, GLdouble, near, GLdouble, far); \ HookWrapper2(void, glDepthRangef, GLfloat, n, GLfloat, f); \ + HookWrapper3(void, glDepthRangeIndexed, GLuint, index, GLdouble, n, GLdouble, f); \ HookWrapper3(void, glDepthRangeArrayv, GLuint, first, GLsizei, count, const GLdouble *, v); \ HookWrapper2(void, glDepthBoundsEXT, GLclampd, zmin, GLclampd, zmax); \ + HookWrapper2(void, glClipControl, GLenum, origin, GLenum, depth); \ + HookWrapper1(void, glProvokingVertex, GLenum, mode); \ + HookWrapper1(void, glPrimitiveRestartIndex, GLuint, index); \ HookWrapper1(GLuint, glCreateShader, GLenum, type); \ HookWrapper1(void, glDeleteShader, GLuint, shader); \ HookWrapper4(void, glShaderSource, GLuint, shader, GLsizei, count, const GLchar *const*, string, const GLint *, length); \ @@ -1129,6 +1138,7 @@ HookWrapper3(void, glDispatchCompute, GLuint, num_groups_x, GLuint, num_groups_y, GLuint, num_groups_z); \ HookWrapper1(void, glDispatchComputeIndirect, GLintptr, indirect); \ HookWrapper1(void, glMemoryBarrier, GLbitfield, barriers); \ + HookWrapper1(void, glClearDepthf, GLfloat, d); \ HookWrapper3(void, glClearBufferfv, GLenum, buffer, GLint, drawbuffer, const GLfloat *, value); \ HookWrapper3(void, glClearBufferiv, GLenum, buffer, GLint, drawbuffer, const GLint *, value); \ HookWrapper3(void, glClearBufferuiv, GLenum, buffer, GLint, drawbuffer, const GLuint *, value); \ diff --git a/renderdoc/driver/gl/gl_renderstate.cpp b/renderdoc/driver/gl/gl_renderstate.cpp index ed89d03f0..28c50b48d 100644 --- a/renderdoc/driver/gl/gl_renderstate.cpp +++ b/renderdoc/driver/gl/gl_renderstate.cpp @@ -68,6 +68,7 @@ void GLRenderState::FetchState() eGL_POLYGON_OFFSET_POINT, eGL_PROGRAM_POINT_SIZE, eGL_PRIMITIVE_RESTART, + eGL_PRIMITIVE_RESTART_FIXED_INDEX, eGL_SAMPLE_ALPHA_TO_COVERAGE, eGL_SAMPLE_ALPHA_TO_ONE, eGL_SAMPLE_COVERAGE, @@ -156,6 +157,11 @@ void GLRenderState::FetchState() m_Real->glGetFloatv(eGL_LINE_WIDTH, &LineWidth); m_Real->glGetFloatv(eGL_POINT_SIZE, &PointSize); + m_Real->glGetIntegerv(eGL_PRIMITIVE_RESTART_INDEX, (GLint *)&PrimitiveRestartIndex); + m_Real->glGetIntegerv(eGL_CLIP_ORIGIN, (GLint *)&ClipOrigin); + m_Real->glGetIntegerv(eGL_CLIP_DEPTH_MODE, (GLint *)&ClipDepth); + m_Real->glGetIntegerv(eGL_PROVOKING_VERTEX, (GLint *)&ProvokingVertex); + m_Real->glGetIntegerv(eGL_CURRENT_PROGRAM, (GLint *)&Program); m_Real->glGetIntegerv(eGL_PROGRAM_PIPELINE_BINDING, (GLint *)&Pipeline); @@ -362,6 +368,10 @@ void GLRenderState::ApplyState() m_Real->glPointParameteri(eGL_POINT_SPRITE_COORD_ORIGIN, (GLint)PointSpriteOrigin); m_Real->glLineWidth(LineWidth); m_Real->glPointSize(PointSize); + + m_Real->glPrimitiveRestartIndex(PrimitiveRestartIndex); + m_Real->glClipControl(ClipOrigin, ClipDepth); + m_Real->glProvokingVertex(ProvokingVertex); m_Real->glUseProgram(Program); m_Real->glBindProgramPipeline(Pipeline); @@ -618,6 +628,11 @@ void GLRenderState::Serialise(LogState state, void *ctx, WrappedOpenGL *gl) m_pSerialiser->Serialise("GL_POINT_SPRITE_COORD_ORIGIN", PointSpriteOrigin); m_pSerialiser->Serialise("GL_LINE_WIDTH", LineWidth); m_pSerialiser->Serialise("GL_POINT_SIZE", PointSize); + + m_pSerialiser->Serialise("GL_PRIMITIVE_RESTART_INDEX", PrimitiveRestartIndex); + m_pSerialiser->Serialise("GL_CLIP_ORIGIN", ClipOrigin); + m_pSerialiser->Serialise("GL_CLIP_DEPTH_MODE", ClipDepth); + m_pSerialiser->Serialise("GL_PROVOKING_VERTEX", ProvokingVertex); for(size_t i=0; i < ARRAY_COUNT(BufferBindings); i++) { diff --git a/renderdoc/driver/gl/gl_renderstate.h b/renderdoc/driver/gl/gl_renderstate.h index 2ca9dde4b..e5319d54f 100644 --- a/renderdoc/driver/gl/gl_renderstate.h +++ b/renderdoc/driver/gl/gl_renderstate.h @@ -65,6 +65,7 @@ struct GLRenderState eEnabled_PolyOffsetPoint, eEnabled_ProgramPointSize, eEnabled_PrimitiveRestart, + eEnabled_PrimitiveRestartFixedIndex, eEnabled_SampleAlphaToCoverage, eEnabled_SampleAlphaToOne, eEnabled_SampleCoverage, @@ -115,6 +116,10 @@ struct GLRenderState float LineWidth; float PointSize; + uint32_t PrimitiveRestartIndex; + GLenum ClipOrigin, ClipDepth; + GLenum ProvokingVertex; + uint32_t BufferBindings[10]; struct IdxRangeBuffer { diff --git a/renderdoc/driver/gl/wrappers/gl_state_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_state_funcs.cpp index 8dff126c7..e2760e645 100644 --- a/renderdoc/driver/gl/wrappers/gl_state_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_state_funcs.cpp @@ -508,7 +508,7 @@ void WrappedOpenGL::glClearStencil(GLint stencil) } } -bool WrappedOpenGL::Serialise_glClearDepth(GLclampd depth) +bool WrappedOpenGL::Serialise_glClearDepth(GLdouble depth) { SERIALISE_ELEMENT(double, d, depth); @@ -520,7 +520,7 @@ bool WrappedOpenGL::Serialise_glClearDepth(GLclampd depth) return true; } -void WrappedOpenGL::glClearDepth(GLclampd depth) +void WrappedOpenGL::glClearDepth(GLdouble depth) { m_Real.glClearDepth(depth); @@ -533,6 +533,19 @@ void WrappedOpenGL::glClearDepth(GLclampd depth) } } +void WrappedOpenGL::glClearDepthf(GLfloat depth) +{ + m_Real.glClearDepthf(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); @@ -631,6 +644,31 @@ void WrappedOpenGL::glDepthRangef(GLfloat nearVal, GLfloat farVal) } } +bool WrappedOpenGL::Serialise_glDepthRangeIndexed(GLuint index, GLdouble nearVal, GLdouble farVal) +{ + SERIALISE_ELEMENT(GLuint, i, index); + SERIALISE_ELEMENT(GLdouble, n, nearVal); + SERIALISE_ELEMENT(GLdouble, f, farVal); + + if(m_State <= EXECUTING) + m_Real.glDepthRangeIndexed(i, n, f); + + return true; +} + +void WrappedOpenGL::glDepthRangeIndexed(GLuint index, GLdouble nearVal, GLdouble farVal) +{ + m_Real.glDepthRangeIndexed(index, nearVal, farVal); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(DEPTH_RANGE_IDX); + Serialise_glDepthRangeIndexed(index, nearVal, farVal); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + bool WrappedOpenGL::Serialise_glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v) { SERIALISE_ELEMENT(uint32_t, idx, first); @@ -686,6 +724,82 @@ void WrappedOpenGL::glDepthBoundsEXT(GLclampd nearVal, GLclampd farVal) } } +bool WrappedOpenGL::Serialise_glClipControl(GLenum origin, GLenum depth) +{ + SERIALISE_ELEMENT(GLenum, o, origin); + SERIALISE_ELEMENT(GLenum, d, depth); + + if(m_State <= EXECUTING) + { + m_Real.glClipControl(o, d); + } + + return true; +} + +void WrappedOpenGL::glClipControl(GLenum origin, GLenum depth) +{ + m_Real.glClipControl(origin, depth); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(CLIP_CONTROL); + Serialise_glClipControl(origin, depth); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glProvokingVertex(GLenum mode) +{ + SERIALISE_ELEMENT(GLenum, m, mode); + + if(m_State <= EXECUTING) + { + m_Real.glProvokingVertex(m); + } + + return true; +} + +void WrappedOpenGL::glProvokingVertex(GLenum mode) +{ + m_Real.glProvokingVertex(mode); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(PROVOKING_VERTEX); + Serialise_glProvokingVertex(mode); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + +bool WrappedOpenGL::Serialise_glPrimitiveRestartIndex(GLuint index) +{ + SERIALISE_ELEMENT(GLuint, i, index); + + if(m_State <= EXECUTING) + { + m_Real.glPrimitiveRestartIndex(i); + } + + return true; +} + +void WrappedOpenGL::glPrimitiveRestartIndex(GLuint index) +{ + m_Real.glPrimitiveRestartIndex(index); + + if(m_State == WRITING_CAPFRAME) + { + SCOPED_SERIALISE_CONTEXT(PRIMITIVE_RESTART); + Serialise_glPrimitiveRestartIndex(index); + + m_ContextRecord->AddChunk(scope.Get()); + } +} + bool WrappedOpenGL::Serialise_glDisable(GLenum cap) { SERIALISE_ELEMENT(GLenum, c, cap);