mesa: Track the current vertex/element array buffers for glthread.

We want to support glthread on GLES contexts with reasonable apps, and on
desktop for apps that use VBOs but haven't completely moved to core GL.
To do so, we have to deal with the "the user may or may not pass user
pointers to draw calls" problem.

Acked-by: Timothy Arceri <[email protected]>
Acked-by: Marek Olšák <[email protected]>
Tested-by: Dieter Nützel <[email protected]>
Tested-by: Mike Lothian <[email protected]>

1 files changed, 57 insertions, 0 deletions

diff --git a/src/mesa/main/marshal.h b/src/mesa/main/marshal.h
index 0e0e9b280c6..23b33002e42 100644
--- a/src/mesa/main/marshal.h
+++ b/src/mesa/main/marshal.h
@@ -109,8 +109,58 @@ _mesa_post_marshal_hook(struct gl_context *ctx)
       _mesa_glthread_finish(ctx);
 }
 
+
+/**
+ * Checks whether we're on a compat context for code-generated
+ * glBindVertexArray().
+ *
+ * In order to decide whether a draw call uses only VBOs for vertex and index
+ * buffers, we track the current vertex and index buffer bindings by
+ * glBindBuffer().  However, the index buffer binding is stored in the vertex
+ * array as opposed to the context.  If we were to accurately track whether
+ * the index buffer was a user pointer ot not, we'd have to track it per
+ * vertex array, which would mean synchronizing with the client thread and
+ * looking into the hash table to find the actual vertex array object.  That's
+ * more tracking than we'd like to do in the main thread, if possible.
+ *
+ * Instead, just punt for now and disable threading on apps using vertex
+ * arrays and compat contexts.  Apps using vertex arrays can probably use a
+ * core context.
+ */
+static inline bool
+_mesa_glthread_is_compat_bind_vertex_array(const struct gl_context *ctx)
+{
+   return ctx->API != API_OPENGL_CORE;
+}
+
+/**
+ * Instead of conditionally handling marshaling previously-bound user vertex
+ * array data in draw calls (deprecated and removed in GL core), we just
+ * disable threading at the point where the user sets a user vertex array.
+ */
+static inline bool
+_mesa_glthread_is_non_vbo_vertex_attrib_pointer(const struct gl_context *ctx)
+{
+   struct glthread_state *glthread = ctx->GLThread;
+
+   return ctx->API != API_OPENGL_CORE && !glthread->vertex_array_is_vbo;
+}
+
+/**
+ * Instead of conditionally handling marshaling immediate index data in draw
+ * calls (deprecated and removed in GL core), we just disable threading.
+ */
+static inline bool
+_mesa_glthread_is_non_vbo_draw_elements(const struct gl_context *ctx)
+{
+   struct glthread_state *glthread = ctx->GLThread;
+
+   return ctx->API != API_OPENGL_CORE && !glthread->element_array_is_vbo;
+}
+
 struct marshal_cmd_ShaderSource;
 struct marshal_cmd_Flush;
+struct marshal_cmd_BindBuffer;
 
 void GLAPIENTRY
 _mesa_marshal_ShaderSource(GLuint shader, GLsizei count,
@@ -127,4 +177,11 @@ void
 _mesa_unmarshal_Flush(struct gl_context *ctx,
                       const struct marshal_cmd_Flush *cmd);
 
+void GLAPIENTRY
+_mesa_marshal_BindBuffer(GLenum target, GLuint buffer);
+
+void
+_mesa_unmarshal_BindBuffer(struct gl_context *ctx,
+                           const struct marshal_cmd_BindBuffer *cmd);
+
 #endif /* MARSHAL_H */