Serialise transform feedback buffer bindings into feedback record

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,

renderdoc/driver/gl/gl_driver.cpp

@@ -276,7 +276,8 @@ const char *GLChunkNames[] =
 	"glVertexAttribBinding",
 
 	"glVertexArrayElementBuffer",
-	
+	"glTransformFeedbackBufferBase",
+	"glTransformFeedbackBufferRange",
 	
 	"glObjectLabel",
 	"glPushDebugGroup",
@@ -1475,7 +1476,29 @@ vector<DebugMessage> 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);

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));

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;

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.

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);