Re: [Mesa-dev] [PATCH 06/13] vbo: Use _DrawVAO for array type draw commands.

Brian Paul Thu, 15 Feb 2018 15:27:49 -0800

On 02/15/2018 12:55 PM, mathias.froehl...@gmx.net wrote:

From: Mathias Fröhlich <mathias.froehl...@web.de>


Switch over to use the _DrawVAO for all the array type draws.
The _DrawVAO needs to be set before we enter _mesa_update_state,
so move setting the draw method in front of the first call
to _mesa_update_state which is in turn called from the *validate*Draw*
calls. Using the gl_vertex_array_object::_Enabled bitmask,
gl_vertex_program_state::_VPMode and gl_vertex_array_object::_AttributeMapMode
we can already set varying_vp_inputs before we call _mesa_update_state
the first time. Thus remove duplicate state validation.

Signed-off-by: Mathias Fröhlich <mathias.froehl...@web.de>
---
  src/mesa/vbo/vbo_context.c    |   8 ++-
  src/mesa/vbo/vbo_exec.h       |   6 --
  src/mesa/vbo/vbo_exec_array.c | 159 +++++++++++++++++++++++++-----------------
  3 files changed, 100 insertions(+), 73 deletions(-)

diff --git a/src/mesa/vbo/vbo_context.c b/src/mesa/vbo/vbo_context.c
index cc9cbffc51..1a9935d5e8 100644
--- a/src/mesa/vbo/vbo_context.c
+++ b/src/mesa/vbo/vbo_context.c
@@ -206,11 +206,15 @@ vbo_exec_invalidate_state(struct gl_context *ctx)
     struct vbo_exec_context *exec = &vbo->exec;

if (ctx->NewState & (_NEW_PROGRAM | _NEW_ARRAY)) {

-      if (!exec->validating)
-         exec->array.recalculate_inputs = GL_TRUE;
+      exec->array.recalculate_inputs = GL_TRUE;

_ae_invalidate_state(ctx);

     }
+   /* If _mesa_update_state is called in a non draw code path,
+    * changes in the VAO need to be captured.
+    */
+   if (ctx->Array.VAO->NewArrays)
+      exec->array.recalculate_inputs = GL_TRUE;

if (ctx->NewState & _NEW_EVAL)

        exec->eval.recalculate_maps = GL_TRUE;
diff --git a/src/mesa/vbo/vbo_exec.h b/src/mesa/vbo/vbo_exec.h
index 7e00d45de0..b00045c7c8 100644
--- a/src/mesa/vbo/vbo_exec.h
+++ b/src/mesa/vbo/vbo_exec.h
@@ -76,7 +76,6 @@ struct vbo_exec_context
     struct gl_context *ctx;
     GLvertexformat vtxfmt;
     GLvertexformat vtxfmt_noop;
-   GLboolean validating; /**< if we're in the middle of state validation */

struct {

        struct gl_buffer_object *bufferobj;
@@ -119,11 +118,6 @@ struct vbo_exec_context
     } eval;

struct {

-      /* Arrays and current values manipulated according to program
-       * mode, etc.  These are the attributes as seen by vertex
-       * programs:
-       */
-      const struct gl_vertex_array *inputs[VERT_ATTRIB_MAX];
        GLboolean recalculate_inputs;
     } array;

diff --git a/src/mesa/vbo/vbo_exec_array.c b/src/mesa/vbo/vbo_exec_array.c

index 0c3c9017b1..5741696943 100644
--- a/src/mesa/vbo/vbo_exec_array.c
+++ b/src/mesa/vbo/vbo_exec_array.c
@@ -319,29 +319,14 @@ print_draw_arrays(struct gl_context *ctx,

/**

- * Set the vbo->exec->inputs[] pointers to point to the enabled
- * vertex arrays.  This depends on the current vertex program/shader
- * being executed because of whether or not generic vertex arrays
- * alias the conventional vertex arrays.
- * For arrays that aren't enabled, we set the input[attrib] pointer
- * to point at a zero-stride current value "array".
+ * Return a filter mask for the net enabled vao arrays.
+ * This is to maks out arrays that would otherwise superseed required current


"mask", "supersede"

I don't have time to review the rest of the series today. I'll try toresume tomorrow.


-Brian

+ * values for the fixed function shaders for example.
   */
-static void
-recalculate_input_bindings(struct gl_context *ctx)
+static GLbitfield
+enabled_filter(const struct gl_context *ctx)
  {
-   struct vbo_context *vbo = vbo_context(ctx);
-   struct vbo_exec_context *exec = &vbo->exec;
-   const struct gl_vertex_array_object *vao = ctx->Array.VAO;
-   const struct gl_vertex_array *vertexAttrib = vao->_VertexArray;
-   const struct gl_vertex_array **inputs = &exec->array.inputs[0];
-
-   /* May shuffle the position and generic0 bits around */
-   GLbitfield vp_inputs = _mesa_get_vao_vp_inputs(vao);
-
-   const gl_vertex_processing_mode processing_mode
-      = ctx->VertexProgram._VPMode;
-   const GLubyte * const map = _vbo_attribute_alias_map[processing_mode];
-   switch (processing_mode) {
+   switch (ctx->VertexProgram._VPMode) {
     case VP_MODE_FF:
        /* When no vertex program is active (or the vertex program is generated
         * from fixed-function state).  We put the material values into the
@@ -349,9 +334,7 @@ recalculate_input_bindings(struct gl_context *ctx)
         * slots from the enabled arrays so that the current material values
         * are pulled instead of the vao arrays.
         */
-      vp_inputs &= VERT_BIT_FF_ALL;
-
-      break;
+      return VERT_BIT_FF_ALL;

case VP_MODE_SHADER:

        /* There are no shaders in OpenGL ES 1.x, so this code path should be
@@ -360,40 +343,20 @@ recalculate_input_bindings(struct gl_context *ctx)
         */
        assert(ctx->API != API_OPENGLES);

- /* In the compatibility profile of desktop OpenGL, the generic[0]

-       * attribute array aliases and overrides the legacy position array.
-       * Otherwise, legacy attributes available in the legacy slots,
-       * generic attributes in the generic slots and materials are not
-       * available as per-vertex attributes.
-       *
-       * In all other APIs, only the generic attributes exist, and none of the
-       * slots are considered "magic."
-       */
-
        /* Other parts of the code assume that inputs[VERT_ATTRIB_POS] through
         * inputs[VERT_ATTRIB_FF_MAX] will be non-NULL.  However, in OpenGL
         * ES 2.0+ or OpenGL core profile, none of these arrays should ever
         * be enabled.
         */
        if (ctx->API != API_OPENGL_COMPAT)
-         vp_inputs &= VERT_BIT_GENERIC_ALL;
+         return VERT_BIT_GENERIC_ALL;
+
+      return VERT_BIT_ALL;

- break;

     default:
        assert(0);
+      return 0;
     }
-
-   const gl_attribute_map_mode mode = vao->_AttributeMapMode;
-   const GLubyte *const vao_map = _mesa_vao_attribute_map[mode];
-   for (unsigned vp_attrib = 0; vp_attrib < VERT_ATTRIB_MAX; ++vp_attrib) {
-      if (unlikely(vp_inputs & VERT_BIT(vp_attrib)))
-         inputs[vp_attrib] = &vertexAttrib[vao_map[vp_attrib]];
-      else
-         inputs[vp_attrib] = &vbo->currval[map[vp_attrib]];
-   }
-
-   _mesa_set_varying_vp_inputs(ctx, vp_inputs);
-   ctx->NewDriverState |= ctx->DriverFlags.NewArray;
  }

@@ -401,8 +364,6 @@ recalculate_input_bindings(struct gl_context *ctx)

   * Examine the enabled vertex arrays to set the exec->array.inputs[] values.
   * These will point to the arrays to actually use for drawing.  Some will
   * be user-provided arrays, other will be zero-stride const-valued arrays.
- * Note that this might set the _NEW_VARYING_VP_INPUTS dirty flag so state
- * validation must be done after this call.
   */
  static void
  vbo_bind_arrays(struct gl_context *ctx)
@@ -410,25 +371,15 @@ vbo_bind_arrays(struct gl_context *ctx)
     struct vbo_context *vbo = vbo_context(ctx);
     struct vbo_exec_context *exec = &vbo->exec;

- _mesa_set_drawing_arrays(ctx, vbo->exec.array.inputs);

+   _mesa_set_drawing_arrays(ctx, vbo->array.inputs);

if (exec->array.recalculate_inputs) {

-      recalculate_input_bindings(ctx);
+      /* Finally update the inputs array */
+      _vbo_update_inputs(ctx, &vbo->array);
+      ctx->NewDriverState |= ctx->DriverFlags.NewArray;
        exec->array.recalculate_inputs = GL_FALSE;

- /* Again... because we may have changed the bitmask of per-vertex varying

-       * attributes.  If we regenerate the fixed-function vertex program now
-       * we may be able to prune down the number of vertex attributes which we
-       * need in the shader.
-       */
-      if (ctx->NewState) {
-         /* Setting "validating" to TRUE prevents _mesa_update_state from
-          * invalidating what we just did.
-          */
-         exec->validating = GL_TRUE;
-         _mesa_update_state(ctx);
-         exec->validating = GL_FALSE;
-      }
+      assert(ctx->NewState == 0);
     }
  }

@@ -611,9 +562,13 @@ vbo_exec_DrawArrays(GLenum mode, GLint start, GLsizei count)

     if (_mesa_is_no_error_enabled(ctx)) {
        FLUSH_CURRENT(ctx, 0);