diff --git a/renderdoc/driver/gl/gl_common.h b/renderdoc/driver/gl/gl_common.h index 7a6df700d..86c1f4660 100644 --- a/renderdoc/driver/gl/gl_common.h +++ b/renderdoc/driver/gl/gl_common.h @@ -354,7 +354,10 @@ enum GLChunkType VERTEXATTRIBLFORMAT, VERTEXATTRIBDIVISOR, VERTEXATTRIBBINDING, + VAO_ELEMENT_BUFFER, + FEEDBACK_BUFFER_BASE, + FEEDBACK_BUFFER_RANGE, OBJECT_LABEL, BEGIN_EVENT, diff --git a/renderdoc/driver/gl/gl_driver.cpp b/renderdoc/driver/gl/gl_driver.cpp index e757febc6..8fec861d2 100644 --- a/renderdoc/driver/gl/gl_driver.cpp +++ b/renderdoc/driver/gl/gl_driver.cpp @@ -276,7 +276,8 @@ const char *GLChunkNames[] = "glVertexAttribBinding", "glVertexArrayElementBuffer", - + "glTransformFeedbackBufferBase", + "glTransformFeedbackBufferRange", "glObjectLabel", "glPushDebugGroup", @@ -1475,7 +1476,29 @@ vector WrappedOpenGL::Serialise_DebugMessages() return debugMessages; } - + +bool WrappedOpenGL::RecordUpdateCheck(GLResourceRecord *record) +{ + // if nothing is bound, don't serialise chunk + if(record == NULL) return false; + + // if we've already stopped tracking this object, return as such + if(record && record->UpdateCount > 64) + return false; + + // increase update count + record->UpdateCount++; + + // if update count is high, mark as dirty + if(record && record->UpdateCount > 64) + { + GetResourceManager()->MarkDirtyResource( record->GetResourceID() ); + + return false; + } + + return true; +} void WrappedOpenGL::DebugSnoop(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message) { @@ -2326,6 +2349,12 @@ void WrappedOpenGL::ProcessChunk(uint64_t offset, GLChunkType context) case VAO_ELEMENT_BUFFER: Serialise_glVertexArrayElementBuffer(0, 0); break; + case FEEDBACK_BUFFER_BASE: + Serialise_glTransformFeedbackBufferBase(0, 0, 0); + break; + case FEEDBACK_BUFFER_RANGE: + Serialise_glTransformFeedbackBufferRange(0, 0, 0, 0, 0); + break; case OBJECT_LABEL: Serialise_glObjectLabel(eGL_NONE, 0, 0, NULL); diff --git a/renderdoc/driver/gl/gl_driver.h b/renderdoc/driver/gl/gl_driver.h index e6d904225..68f3a0af3 100644 --- a/renderdoc/driver/gl/gl_driver.h +++ b/renderdoc/driver/gl/gl_driver.h @@ -106,16 +106,17 @@ class WrappedOpenGL static void APIENTRY DebugSnoopStatic(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam) { ((WrappedOpenGL *)userParam)->DebugSnoop(source, type, id, severity, length, message); } - // checks if the bound VAO object has tons of updates. If so it's probably - // in the vein of "one global VAO, updated per-draw as necessary", in which case - // we just want to save the state of it at frame start, then track changes while - // frame capturing - bool VertexArrayUpdateCheck(); + // checks if the given object has tons of updates. If so it's probably + // in the vein of "one global object, updated per-draw as necessary", or it's just + // really high traffic, in which case we just want to save the state of it at frame + // start, then track changes while frame capturing + bool RecordUpdateCheck(GLResourceRecord *record); // state GLResourceRecord *m_TextureRecord[256]; // TODO this needs on per texture type :( GLResourceRecord *m_BufferRecord[16]; GLResourceRecord *m_VertexArrayRecord; + GLResourceRecord *m_FeedbackRecord; GLResourceRecord *m_DrawFramebufferRecord; GLResourceRecord *m_ReadFramebufferRecord; bool m_ActiveQueries[8][8]; // first index type, second index (for some, always 0) @@ -620,6 +621,8 @@ class WrappedOpenGL // hack for now until ARB_dsa is serialised bool Serialise_glVertexArrayElementBuffer(GLuint vaobj, GLuint buffer); + bool Serialise_glTransformFeedbackBufferBase(GLuint xfb, GLuint index, GLuint buffer); + bool Serialise_glTransformFeedbackBufferRange(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizei size); IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib1d(GLuint index, GLdouble x)); IMPLEMENT_FUNCTION_SERIALISED(void, glVertexAttrib1dv(GLuint index, const GLdouble *v)); diff --git a/renderdoc/driver/gl/gl_manager.cpp b/renderdoc/driver/gl/gl_manager.cpp index df2f195f3..7b988d223 100644 --- a/renderdoc/driver/gl/gl_manager.cpp +++ b/renderdoc/driver/gl/gl_manager.cpp @@ -60,6 +60,17 @@ struct VAOInitialData ResourceId ElementArrayBuffer; }; +struct FeedbackInitialData +{ + FeedbackInitialData() + { + RDCEraseEl(*this); + } + ResourceId Buffer[4]; + uint64_t Offset[4]; + uint64_t Size[4]; +}; + template<> void Serialiser::Serialise(const char *name, VertexAttribInitialData &el) { @@ -83,6 +94,15 @@ void Serialiser::Serialise(const char *name, VertexBufferInitialData &el) Serialise("Divisor", el.Divisor); } +template<> +void Serialiser::Serialise(const char *name, FeedbackInitialData &el) +{ + ScopedContext scope(this, this, name, "FeedbackInitialData", 0, true); + Serialise<4>("Buffer", el.Buffer); + Serialise<4>("Offset", el.Offset); + Serialise<4>("Size", el.Size); +} + struct TextureStateInitialData { TextureStateInitialData() @@ -269,6 +289,30 @@ bool GLResourceManager::Prepare_InitialState(GLResource res) SetInitialContents(Id, InitialContentData(TextureRes(res.Context, tex), 0, (byte *)state)); } + else if(res.Namespace == eResFeedback) + { + GLuint prevfeedback = 0; + gl.glGetIntegerv(eGL_TRANSFORM_FEEDBACK, (GLint *)&prevfeedback); + + gl.glBindTransformFeedback(eGL_TRANSFORM_FEEDBACK, res.name); + + FeedbackInitialData *data = (FeedbackInitialData *)Serialiser::AllocAlignedBuffer(sizeof(FeedbackInitialData)); + + GLint maxCount = 0; + gl.glGetIntegerv(eGL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &maxCount); + + for(int i=0; i < ARRAY_COUNT(data->Buffer) && i < maxCount; i++) + { + GLuint buffer = 0; + gl.glGetIntegeri_v(eGL_TRANSFORM_FEEDBACK_BUFFER_BINDING, i, (GLint*)&buffer);data->Buffer[i] = GetID(BufferRes(res.Context, buffer)); + gl.glGetInteger64i_v(eGL_TRANSFORM_FEEDBACK_BUFFER_START, i, (GLint64*)&data->Offset[i]); + gl.glGetInteger64i_v(eGL_TRANSFORM_FEEDBACK_BUFFER_SIZE, i, (GLint64*)&data->Size[i]); + } + + SetInitialContents(Id, InitialContentData(GLResource(MakeNullResource), 0, (byte *)data)); + + gl.glBindTransformFeedback(eGL_TRANSFORM_FEEDBACK, prevfeedback); + } else if(res.Namespace == eResVertexArray) { GLuint VAO = 0; @@ -745,6 +789,26 @@ bool GLResourceManager::Serialise_InitialState(GLResource res) gl.glPixelStorei(eGL_UNPACK_ALIGNMENT, unpackParams[7]); } } + else if(res.Namespace == eResFeedback) + { + FeedbackInitialData data; + + if(m_State >= WRITING) + { + FeedbackInitialData *initialdata = (FeedbackInitialData *)GetInitialContents(Id).blob; + memcpy(&data, initialdata, sizeof(data)); + } + + m_pSerialiser->Serialise("Transform Feedback Buffers", data); + + if(m_State < WRITING) + { + byte *blob = Serialiser::AllocAlignedBuffer(sizeof(data)); + memcpy(blob, &data, sizeof(data)); + + SetInitialContents(Id, InitialContentData(GLResource(MakeNullResource), 0, blob)); + } + } else if(res.Namespace == eResVertexArray) { VAOInitialData data; @@ -858,6 +922,26 @@ void GLResourceManager::Apply_InitialState(GLResource live, InitialContentData i { CopyProgramUniforms(gl, initial.resource.name, live.name); } + else if(live.Namespace == eResFeedback) + { + GLuint prevfeedback = 0; + gl.glGetIntegerv(eGL_TRANSFORM_FEEDBACK, (GLint *)&prevfeedback); + + gl.glBindTransformFeedback(eGL_TRANSFORM_FEEDBACK, live.name); + + FeedbackInitialData *data = (FeedbackInitialData *)initial.blob; + + GLint maxCount = 0; + gl.glGetIntegerv(eGL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &maxCount); + + for(int i=0; i < ARRAY_COUNT(data->Buffer) && i < maxCount; i++) + { + GLuint buffer = data->Buffer[i] == ResourceId() ? 0 : GetLiveResource(data->Buffer[i]).name; + gl.glBindBufferRange(eGL_TRANSFORM_FEEDBACK_BUFFER, i, buffer, (GLintptr)data->Offset[i], (GLsizei)data->Size[i]); + } + + gl.glBindTransformFeedback(eGL_TRANSFORM_FEEDBACK, prevfeedback); + } else if(live.Namespace == eResVertexArray) { GLuint VAO = 0; diff --git a/renderdoc/driver/gl/gl_renderstate.cpp b/renderdoc/driver/gl/gl_renderstate.cpp index 9f61963a3..c3af6e3c2 100644 --- a/renderdoc/driver/gl/gl_renderstate.cpp +++ b/renderdoc/driver/gl/gl_renderstate.cpp @@ -338,8 +338,7 @@ void GLRenderState::ApplyState() m_Real->glActiveTexture(ActiveTexture); m_Real->glBindVertexArray(VAO); - if(FeedbackObj) - m_Real->glBindTransformFeedback(eGL_TRANSFORM_FEEDBACK, FeedbackObj); + m_Real->glBindTransformFeedback(eGL_TRANSFORM_FEEDBACK, FeedbackObj); // See FetchState(). The spec says that you have to SET the right format for the shader too, // but we couldn't query for the format so we can't set it here. diff --git a/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp b/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp index ac8d6004b..b1915e812 100644 --- a/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp +++ b/renderdoc/driver/gl/wrappers/gl_buffer_funcs.cpp @@ -162,7 +162,7 @@ void WrappedOpenGL::glBindBuffer(GLenum target, GLuint buffer) } // element array buffer binding is vertex array record state, record there (if we've not just stopped) - if(m_State == WRITING_IDLE && target == eGL_ELEMENT_ARRAY_BUFFER && m_VertexArrayRecord && VertexArrayUpdateCheck()) + if(m_State == WRITING_IDLE && target == eGL_ELEMENT_ARRAY_BUFFER && RecordUpdateCheck(m_VertexArrayRecord)) { GLuint vao = GetResourceManager()->GetCurrentResource(m_VertexArrayRecord->GetResourceID()).name; @@ -173,6 +173,19 @@ void WrappedOpenGL::glBindBuffer(GLenum target, GLuint buffer) m_VertexArrayRecord->AddChunk(scope.Get()); } + + // store as transform feedback record state + if(m_State == WRITING_IDLE && target == eGL_TRANSFORM_FEEDBACK_BUFFER && RecordUpdateCheck(m_FeedbackRecord)) + { + GLuint feedback = GetResourceManager()->GetCurrentResource(m_FeedbackRecord->GetResourceID()).name; + + // use glTransformFeedbackBufferBase to ensure the feedback object is bound when we bind the + // buffer + SCOPED_SERIALISE_CONTEXT(FEEDBACK_BUFFER_BASE); + Serialise_glTransformFeedbackBufferBase(feedback, 0, buffer); + + m_FeedbackRecord->AddChunk(scope.Get()); + } } } @@ -586,6 +599,19 @@ void WrappedOpenGL::glBindBufferBase(GLenum target, GLuint index, GLuint buffer) m_BufferRecord[idx] = GetResourceManager()->GetResourceRecord(BufferRes(GetCtx(), buffer)); } + // store as transform feedback record state + if(m_State == WRITING_IDLE && target == eGL_TRANSFORM_FEEDBACK_BUFFER && RecordUpdateCheck(m_FeedbackRecord)) + { + GLuint feedback = GetResourceManager()->GetCurrentResource(m_FeedbackRecord->GetResourceID()).name; + + // use glTransformFeedbackBufferBase to ensure the feedback object is bound when we bind the + // buffer + SCOPED_SERIALISE_CONTEXT(FEEDBACK_BUFFER_BASE); + Serialise_glTransformFeedbackBufferBase(feedback, index, buffer); + + m_FeedbackRecord->AddChunk(scope.Get()); + } + if(m_State == WRITING_CAPFRAME) { SCOPED_SERIALISE_CONTEXT(BIND_BUFFER_BASE); @@ -633,6 +659,19 @@ void WrappedOpenGL::glBindBufferRange(GLenum target, GLuint index, GLuint buffer m_BufferRecord[idx] = GetResourceManager()->GetResourceRecord(BufferRes(GetCtx(), buffer)); } + // store as transform feedback record state + if(m_State == WRITING_IDLE && target == eGL_TRANSFORM_FEEDBACK_BUFFER && RecordUpdateCheck(m_FeedbackRecord)) + { + GLuint feedback = GetResourceManager()->GetCurrentResource(m_FeedbackRecord->GetResourceID()).name; + + // use glTransformFeedbackBufferRange to ensure the feedback object is bound when we bind the + // buffer + SCOPED_SERIALISE_CONTEXT(FEEDBACK_BUFFER_RANGE); + Serialise_glTransformFeedbackBufferRange(feedback, index, buffer, offset, size); + + m_FeedbackRecord->AddChunk(scope.Get()); + } + if(m_State == WRITING_CAPFRAME) { SCOPED_SERIALISE_CONTEXT(BIND_BUFFER_RANGE); @@ -690,6 +729,22 @@ void WrappedOpenGL::glBindBuffersBase(GLenum target, GLuint first, GLsizei count m_BufferRecord[idx] = GetResourceManager()->GetResourceRecord(BufferRes(GetCtx(), buffers[0])); } + // store as transform feedback record state + if(m_State == WRITING_IDLE && target == eGL_TRANSFORM_FEEDBACK_BUFFER && RecordUpdateCheck(m_FeedbackRecord)) + { + GLuint feedback = GetResourceManager()->GetCurrentResource(m_FeedbackRecord->GetResourceID()).name; + + for(int i=0; i < count; i++) + { + // use glTransformFeedbackBufferBase to ensure the feedback object is bound when we bind the + // buffer + SCOPED_SERIALISE_CONTEXT(FEEDBACK_BUFFER_BASE); + Serialise_glTransformFeedbackBufferBase(feedback, first+i, buffers[i]); + + m_FeedbackRecord->AddChunk(scope.Get()); + } + } + if(m_State == WRITING_CAPFRAME) { SCOPED_SERIALISE_CONTEXT(BIND_BUFFERS_BASE); @@ -759,6 +814,22 @@ void WrappedOpenGL::glBindBuffersRange(GLenum target, GLuint first, GLsizei coun m_BufferRecord[idx] = GetResourceManager()->GetResourceRecord(BufferRes(GetCtx(), buffers[0])); } + // store as transform feedback record state + if(m_State == WRITING_IDLE && target == eGL_TRANSFORM_FEEDBACK_BUFFER && RecordUpdateCheck(m_FeedbackRecord)) + { + GLuint feedback = GetResourceManager()->GetCurrentResource(m_FeedbackRecord->GetResourceID()).name; + + for(int i=0; i < count; i++) + { + // use glTransformFeedbackBufferRange to ensure the feedback object is bound when we bind the + // buffer + SCOPED_SERIALISE_CONTEXT(FEEDBACK_BUFFER_RANGE); + Serialise_glTransformFeedbackBufferRange(feedback, first+i, buffers[i], offsets[i], sizes[i]); + + m_FeedbackRecord->AddChunk(scope.Get()); + } + } + if(m_State == WRITING_CAPFRAME) { SCOPED_SERIALISE_CONTEXT(BIND_BUFFERS_RANGE); @@ -1366,6 +1437,8 @@ bool WrappedOpenGL::Serialise_glGenTransformFeedbacks(GLsizei n, GLuint* ids) { GLuint real = 0; m_Real.glGenTransformFeedbacks(1, &real); + m_Real.glBindTransformFeedback(eGL_TRANSFORM_FEEDBACK, real); + m_Real.glBindTransformFeedback(eGL_TRANSFORM_FEEDBACK, 0); GLResource res = FeedbackRes(GetCtx(), real); @@ -1424,6 +1497,46 @@ void WrappedOpenGL::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids) m_Real.glDeleteTransformFeedbacks(n, ids); } +bool WrappedOpenGL::Serialise_glTransformFeedbackBufferBase(GLuint xfb, GLuint index, GLuint buffer) +{ + SERIALISE_ELEMENT(uint32_t, idx, index); + SERIALISE_ELEMENT(ResourceId, xid, GetResourceManager()->GetID(FeedbackRes(GetCtx(), xfb))); + SERIALISE_ELEMENT(ResourceId, bid, GetResourceManager()->GetID(BufferRes(GetCtx(), buffer))); + + if(m_State <= EXECUTING) + { + m_Real.glBindTransformFeedback(eGL_TRANSFORM_FEEDBACK, GetResourceManager()->GetLiveResource(xid).name); + + if(bid == ResourceId()) + m_Real.glBindBufferBase(eGL_TRANSFORM_FEEDBACK_BUFFER, idx, 0); + else + m_Real.glBindBufferBase(eGL_TRANSFORM_FEEDBACK_BUFFER, idx, GetResourceManager()->GetLiveResource(bid).name); + } + + return true; +} + +bool WrappedOpenGL::Serialise_glTransformFeedbackBufferRange(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizei size) +{ + SERIALISE_ELEMENT(uint32_t, idx, index); + SERIALISE_ELEMENT(ResourceId, xid, GetResourceManager()->GetID(FeedbackRes(GetCtx(), xfb))); + SERIALISE_ELEMENT(ResourceId, bid, GetResourceManager()->GetID(BufferRes(GetCtx(), buffer))); + SERIALISE_ELEMENT(uint64_t, offs, (uint64_t)offset); + SERIALISE_ELEMENT(uint64_t, sz, (uint64_t)size); + + if(m_State <= EXECUTING) + { + m_Real.glBindTransformFeedback(eGL_TRANSFORM_FEEDBACK, GetResourceManager()->GetLiveResource(xid).name); + + if(bid == ResourceId()) + m_Real.glBindBufferBase(eGL_TRANSFORM_FEEDBACK_BUFFER, idx, 0); // if we're unbinding, offset/size don't matter + else + m_Real.glBindBufferRange(eGL_TRANSFORM_FEEDBACK_BUFFER, idx, GetResourceManager()->GetLiveResource(bid).name, (GLintptr)offs, (GLsizei)sz); + } + + return true; +} + bool WrappedOpenGL::Serialise_glBindTransformFeedback(GLenum target, GLuint id) { SERIALISE_ELEMENT(GLenum, Target, target); @@ -1431,7 +1544,10 @@ bool WrappedOpenGL::Serialise_glBindTransformFeedback(GLenum target, GLuint id) if(m_State <= EXECUTING) { - m_Real.glBindTransformFeedback(Target, GetResourceManager()->GetLiveResource(fid).name); + if(fid != ResourceId()) + m_Real.glBindTransformFeedback(Target, GetResourceManager()->GetLiveResource(fid).name); + else + m_Real.glBindTransformFeedback(Target, 0); } return true; @@ -1441,6 +1557,18 @@ void WrappedOpenGL::glBindTransformFeedback(GLenum target, GLuint id) { m_Real.glBindTransformFeedback(target, id); + if(m_State >= WRITING) + { + if(id == 0) + { + m_FeedbackRecord = NULL; + } + else + { + m_FeedbackRecord = GetResourceManager()->GetResourceRecord(FeedbackRes(GetCtx(), id)); + } + } + if(m_State == WRITING_CAPFRAME) { SCOPED_SERIALISE_CONTEXT(BIND_FEEDBACK); @@ -1553,29 +1681,6 @@ void WrappedOpenGL::glEndTransformFeedback() #pragma region Vertex Arrays -bool WrappedOpenGL::VertexArrayUpdateCheck() -{ - // if no VAO is bound, nothing to check - if(m_VertexArrayRecord == NULL) return true; - - // if we've already stopped tracking this VAO, return as such - if(m_VertexArrayRecord && m_VertexArrayRecord->UpdateCount > 64) - return false; - - // increase update count - m_VertexArrayRecord->UpdateCount++; - - // if update count is high, mark as dirty - if(m_VertexArrayRecord && m_VertexArrayRecord->UpdateCount > 64) - { - GetResourceManager()->MarkDirtyResource( m_VertexArrayRecord->GetResourceID() ); - - return false; - } - - return true; -} - bool WrappedOpenGL::Serialise_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) { size_t bufidx = BufferIdx(eGL_ARRAY_BUFFER); @@ -1633,7 +1738,7 @@ void WrappedOpenGL::glVertexAttribPointer(GLuint index, GLint size, GLenum type, if(r) { - if(m_State == WRITING_IDLE && !VertexArrayUpdateCheck()) + if(m_State == WRITING_IDLE && !RecordUpdateCheck(m_VertexArrayRecord)) return; if(m_State == WRITING_CAPFRAME && m_VertexArrayRecord) GetResourceManager()->MarkResourceFrameReferenced(m_VertexArrayRecord->GetResourceID(), eFrameRef_Write); @@ -1704,7 +1809,7 @@ void WrappedOpenGL::glVertexAttribIPointer(GLuint index, GLint size, GLenum type if(r) { - if(m_State == WRITING_IDLE && !VertexArrayUpdateCheck()) + if(m_State == WRITING_IDLE && !RecordUpdateCheck(m_VertexArrayRecord)) return; if(m_State == WRITING_CAPFRAME && m_VertexArrayRecord) GetResourceManager()->MarkResourceFrameReferenced(m_VertexArrayRecord->GetResourceID(), eFrameRef_Write); @@ -1775,7 +1880,7 @@ void WrappedOpenGL::glVertexAttribLPointer(GLuint index, GLint size, GLenum type if(r) { - if(m_State == WRITING_IDLE && !VertexArrayUpdateCheck()) + if(m_State == WRITING_IDLE && !RecordUpdateCheck(m_VertexArrayRecord)) return; if(m_State == WRITING_CAPFRAME && m_VertexArrayRecord) GetResourceManager()->MarkResourceFrameReferenced(m_VertexArrayRecord->GetResourceID(), eFrameRef_Write); @@ -1823,7 +1928,7 @@ void WrappedOpenGL::glVertexAttribBinding(GLuint attribindex, GLuint bindinginde if(r) { - if(m_State == WRITING_IDLE && !VertexArrayUpdateCheck()) + if(m_State == WRITING_IDLE && !RecordUpdateCheck(m_VertexArrayRecord)) return; if(m_State == WRITING_CAPFRAME && m_VertexArrayRecord) GetResourceManager()->MarkResourceFrameReferenced(m_VertexArrayRecord->GetResourceID(), eFrameRef_Write); @@ -1875,7 +1980,7 @@ void WrappedOpenGL::glVertexAttribFormat(GLuint attribindex, GLint size, GLenum if(r) { - if(m_State == WRITING_IDLE && !VertexArrayUpdateCheck()) + if(m_State == WRITING_IDLE && !RecordUpdateCheck(m_VertexArrayRecord)) return; if(m_State == WRITING_CAPFRAME && m_VertexArrayRecord) GetResourceManager()->MarkResourceFrameReferenced(m_VertexArrayRecord->GetResourceID(), eFrameRef_Write); @@ -1926,7 +2031,7 @@ void WrappedOpenGL::glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum if(r) { - if(m_State == WRITING_IDLE && !VertexArrayUpdateCheck()) + if(m_State == WRITING_IDLE && !RecordUpdateCheck(m_VertexArrayRecord)) return; if(m_State == WRITING_CAPFRAME && m_VertexArrayRecord) GetResourceManager()->MarkResourceFrameReferenced(m_VertexArrayRecord->GetResourceID(), eFrameRef_Write); @@ -1977,7 +2082,7 @@ void WrappedOpenGL::glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum if(r) { - if(m_State == WRITING_IDLE && !VertexArrayUpdateCheck()) + if(m_State == WRITING_IDLE && !RecordUpdateCheck(m_VertexArrayRecord)) return; if(m_State == WRITING_CAPFRAME && m_VertexArrayRecord) GetResourceManager()->MarkResourceFrameReferenced(m_VertexArrayRecord->GetResourceID(), eFrameRef_Write); @@ -2026,7 +2131,7 @@ void WrappedOpenGL::glVertexAttribDivisor(GLuint index, GLuint divisor) if(r) { - if(m_State == WRITING_IDLE && !VertexArrayUpdateCheck()) + if(m_State == WRITING_IDLE && !RecordUpdateCheck(m_VertexArrayRecord)) return; if(m_State == WRITING_CAPFRAME && m_VertexArrayRecord) GetResourceManager()->MarkResourceFrameReferenced(m_VertexArrayRecord->GetResourceID(), eFrameRef_Write); @@ -2073,7 +2178,7 @@ void WrappedOpenGL::glEnableVertexAttribArray(GLuint index) if(r) { - if(m_State == WRITING_IDLE && !VertexArrayUpdateCheck()) + if(m_State == WRITING_IDLE && !RecordUpdateCheck(m_VertexArrayRecord)) return; if(m_State == WRITING_CAPFRAME && m_VertexArrayRecord) GetResourceManager()->MarkResourceFrameReferenced(m_VertexArrayRecord->GetResourceID(), eFrameRef_Write); @@ -2120,7 +2225,7 @@ void WrappedOpenGL::glDisableVertexAttribArray(GLuint index) if(r) { - if(m_State == WRITING_IDLE && !VertexArrayUpdateCheck()) + if(m_State == WRITING_IDLE && !RecordUpdateCheck(m_VertexArrayRecord)) return; if(m_State == WRITING_CAPFRAME && m_VertexArrayRecord) GetResourceManager()->MarkResourceFrameReferenced(m_VertexArrayRecord->GetResourceID(), eFrameRef_Write); @@ -2281,7 +2386,7 @@ void WrappedOpenGL::glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLint if(r) { - if(m_State == WRITING_IDLE && !VertexArrayUpdateCheck()) + if(m_State == WRITING_IDLE && !RecordUpdateCheck(m_VertexArrayRecord)) return; if(m_State == WRITING_CAPFRAME && m_VertexArrayRecord) GetResourceManager()->MarkResourceFrameReferenced(m_VertexArrayRecord->GetResourceID(), eFrameRef_Write); @@ -2351,7 +2456,7 @@ void WrappedOpenGL::glBindVertexBuffers(GLuint first, GLsizei count, const GLuin if(r) { - if(m_State == WRITING_IDLE && !VertexArrayUpdateCheck()) + if(m_State == WRITING_IDLE && !RecordUpdateCheck(m_VertexArrayRecord)) return; if(m_State == WRITING_CAPFRAME && m_VertexArrayRecord) GetResourceManager()->MarkResourceFrameReferenced(m_VertexArrayRecord->GetResourceID(), eFrameRef_Write); @@ -2387,7 +2492,7 @@ void WrappedOpenGL::glVertexBindingDivisor(GLuint bindingindex, GLuint divisor) if(r) { - if(m_State == WRITING_IDLE && !VertexArrayUpdateCheck()) + if(m_State == WRITING_IDLE && !RecordUpdateCheck(m_VertexArrayRecord)) return; if(m_State == WRITING_CAPFRAME && m_VertexArrayRecord) GetResourceManager()->MarkResourceFrameReferenced(m_VertexArrayRecord->GetResourceID(), eFrameRef_Write);