From 195bb990ed1a76e5ea9dd37af51f8270e9c3bf7d Mon Sep 17 00:00:00 2001 From: =?utf8?q?Mathias=20Fr=C3=B6hlich?= Date: Sat, 3 Feb 2018 19:42:20 +0100 Subject: [PATCH] vbo: Use _DrawVAO for array type draw commands. MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit 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. v2: Update comments. Signed-off-by: Mathias Fröhlich Reviewed-by: Brian Paul --- 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 7b1ebc68f16..222bdcf1f27 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 7e00d45de04..b00045c7c86 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 0c3c9017b14..50299373365 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 mask out arrays that would otherwise supersed required current + * 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->draw_arrays.inputs); if (exec->array.recalculate_inputs) { - recalculate_input_bindings(ctx); + /* Finally update the inputs array */ + _vbo_update_inputs(ctx, &vbo->draw_arrays); + 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); + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (ctx->NewState) _mesa_update_state(ctx); } else { + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (!_mesa_validate_DrawArrays(ctx, mode, count)) return; } @@ -646,9 +601,13 @@ vbo_exec_DrawArraysInstanced(GLenum mode, GLint start, GLsizei count, if (_mesa_is_no_error_enabled(ctx)) { FLUSH_CURRENT(ctx, 0); + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (ctx->NewState) _mesa_update_state(ctx); } else { + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (!_mesa_validate_DrawArraysInstanced(ctx, mode, start, count, numInstances)) return; @@ -683,9 +642,13 @@ vbo_exec_DrawArraysInstancedBaseInstance(GLenum mode, GLint first, if (_mesa_is_no_error_enabled(ctx)) { FLUSH_CURRENT(ctx, 0); + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (ctx->NewState) _mesa_update_state(ctx); } else { + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (!_mesa_validate_DrawArraysInstanced(ctx, mode, first, count, numInstances)) return; @@ -719,9 +682,13 @@ vbo_exec_MultiDrawArrays(GLenum mode, const GLint *first, if (_mesa_is_no_error_enabled(ctx)) { FLUSH_CURRENT(ctx, 0); + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (ctx->NewState) _mesa_update_state(ctx); } else { + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (!_mesa_validate_MultiDrawArrays(ctx, mode, count, primcount)) return; } @@ -941,9 +908,13 @@ vbo_exec_DrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, if (_mesa_is_no_error_enabled(ctx)) { FLUSH_CURRENT(ctx, 0); + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (ctx->NewState) _mesa_update_state(ctx); } else { + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (!_mesa_validate_DrawRangeElements(ctx, mode, start, end, count, type, indices)) return; @@ -1048,9 +1019,13 @@ vbo_exec_DrawElements(GLenum mode, GLsizei count, GLenum type, if (_mesa_is_no_error_enabled(ctx)) { FLUSH_CURRENT(ctx, 0); + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (ctx->NewState) _mesa_update_state(ctx); } else { + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (!_mesa_validate_DrawElements(ctx, mode, count, type, indices)) return; } @@ -1077,9 +1052,13 @@ vbo_exec_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, if (_mesa_is_no_error_enabled(ctx)) { FLUSH_CURRENT(ctx, 0); + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (ctx->NewState) _mesa_update_state(ctx); } else { + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (!_mesa_validate_DrawElements(ctx, mode, count, type, indices)) return; } @@ -1106,9 +1085,13 @@ vbo_exec_DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, if (_mesa_is_no_error_enabled(ctx)) { FLUSH_CURRENT(ctx, 0); + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (ctx->NewState) _mesa_update_state(ctx); } else { + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (!_mesa_validate_DrawElementsInstanced(ctx, mode, count, type, indices, numInstances)) return; @@ -1141,9 +1124,13 @@ vbo_exec_DrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, if (_mesa_is_no_error_enabled(ctx)) { FLUSH_CURRENT(ctx, 0); + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (ctx->NewState) _mesa_update_state(ctx); } else { + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (!_mesa_validate_DrawElementsInstanced(ctx, mode, count, type, indices, numInstances)) return; @@ -1178,9 +1165,13 @@ vbo_exec_DrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, if (_mesa_is_no_error_enabled(ctx)) { FLUSH_CURRENT(ctx, 0); + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (ctx->NewState) _mesa_update_state(ctx); } else { + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (!_mesa_validate_DrawElementsInstanced(ctx, mode, count, type, indices, numInstances)) return; @@ -1217,9 +1208,13 @@ vbo_exec_DrawElementsInstancedBaseVertexBaseInstance(GLenum mode, if (_mesa_is_no_error_enabled(ctx)) { FLUSH_CURRENT(ctx, 0); + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (ctx->NewState) _mesa_update_state(ctx); } else { + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (!_mesa_validate_DrawElementsInstanced(ctx, mode, count, type, indices, numInstances)) return; @@ -1377,6 +1372,8 @@ vbo_exec_MultiDrawElements(GLenum mode, { GET_CURRENT_CONTEXT(ctx); + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (!_mesa_validate_MultiDrawElements(ctx, mode, count, type, indices, primcount)) return; @@ -1401,9 +1398,13 @@ vbo_exec_MultiDrawElementsBaseVertex(GLenum mode, if (_mesa_is_no_error_enabled(ctx)) { FLUSH_CURRENT(ctx, 0); + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (ctx->NewState) _mesa_update_state(ctx); } else { + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (!_mesa_validate_MultiDrawElements(ctx, mode, count, type, indices, primcount)) return; @@ -1436,9 +1437,13 @@ vbo_draw_transform_feedback(struct gl_context *ctx, GLenum mode, if (_mesa_is_no_error_enabled(ctx)) { FLUSH_CURRENT(ctx, 0); + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (ctx->NewState) _mesa_update_state(ctx); } else { + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (!_mesa_validate_DrawTransformFeedback(ctx, mode, obj, stream, numInstances)) { return; @@ -1664,9 +1669,13 @@ vbo_exec_DrawArraysIndirect(GLenum mode, const GLvoid *indirect) if (_mesa_is_no_error_enabled(ctx)) { FLUSH_CURRENT(ctx, 0); + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (ctx->NewState) _mesa_update_state(ctx); } else { + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (!_mesa_validate_DrawArraysIndirect(ctx, mode, indirect)) return; } @@ -1691,9 +1700,13 @@ vbo_exec_DrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect) if (_mesa_is_no_error_enabled(ctx)) { FLUSH_CURRENT(ctx, 0); + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (ctx->NewState) _mesa_update_state(ctx); } else { + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (!_mesa_validate_DrawElementsIndirect(ctx, mode, type, indirect)) return; } @@ -1722,9 +1735,13 @@ vbo_exec_MultiDrawArraysIndirect(GLenum mode, const GLvoid *indirect, if (_mesa_is_no_error_enabled(ctx)) { FLUSH_CURRENT(ctx, 0); + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (ctx->NewState) _mesa_update_state(ctx); } else { + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (!_mesa_validate_MultiDrawArraysIndirect(ctx, mode, indirect, primcount, stride)) return; @@ -1757,9 +1774,13 @@ vbo_exec_MultiDrawElementsIndirect(GLenum mode, GLenum type, if (_mesa_is_no_error_enabled(ctx)) { FLUSH_CURRENT(ctx, 0); + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (ctx->NewState) _mesa_update_state(ctx); } else { + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (!_mesa_validate_MultiDrawElementsIndirect(ctx, mode, type, indirect, primcount, stride)) return; @@ -1854,9 +1875,13 @@ vbo_exec_MultiDrawArraysIndirectCount(GLenum mode, GLintptr indirect, if (_mesa_is_no_error_enabled(ctx)) { FLUSH_CURRENT(ctx, 0); + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (ctx->NewState) _mesa_update_state(ctx); } else { + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (!_mesa_validate_MultiDrawArraysIndirectCount(ctx, mode, indirect, drawcount_offset, @@ -1895,9 +1920,13 @@ vbo_exec_MultiDrawElementsIndirectCount(GLenum mode, GLenum type, if (_mesa_is_no_error_enabled(ctx)) { FLUSH_CURRENT(ctx, 0); + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (ctx->NewState) _mesa_update_state(ctx); } else { + _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx)); + if (!_mesa_validate_MultiDrawElementsIndirectCount(ctx, mode, type, indirect, drawcount_offset, -- 2.30.2