#include "main/glheader.h"
#include "main/context.h"
#include "main/state.h"
-#include "main/api_validate.h"
+#include "main/draw_validate.h"
#include "main/dispatch.h"
#include "main/varray.h"
#include "main/bufferobj.h"
#include "main/macros.h"
#include "main/transformfeedback.h"
-#include "vbo_private.h"
+typedef struct {
+ GLuint count;
+ GLuint primCount;
+ GLuint first;
+ GLuint baseInstance;
+} DrawArraysIndirectCommand;
+
+typedef struct {
+ GLuint count;
+ GLuint primCount;
+ GLuint firstIndex;
+ GLint baseVertex;
+ GLuint baseInstance;
+} DrawElementsIndirectCommand;
/**
/**
- * 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->_VertexAttrib;
- 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 enum vp_mode program_mode = get_vp_mode(ctx);
- const GLubyte *const map = _vbo_attribute_alias_map[program_mode];
- switch (program_mode) {
- case VP_FF:
+ 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
* generic slots. Since the vao has no material arrays, mute these
* slots from the enabled arrays so that the current material values
* are pulled instead of the vao arrays.
*/
- vp_inputs &= VERT_BIT_FF_ALL;
+ return VERT_BIT_FF_ALL;
- break;
-
- case VP_SHADER:
+ case VP_MODE_SHADER:
/* There are no shaders in OpenGL ES 1.x, so this code path should be
* impossible to reach. The meta code is careful to not use shaders in
* ES1.
*/
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);
- }
-
- 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;
-}
-
-
-/**
- * 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)
-{
- struct vbo_context *vbo = vbo_context(ctx);
- struct vbo_exec_context *exec = &vbo->exec;
-
- _mesa_set_drawing_arrays(ctx, vbo->exec.array.inputs);
-
- if (exec->array.recalculate_inputs) {
- recalculate_input_bindings(ctx);
- 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;
- }
+ return 0;
}
}
GLsizei count, GLuint numInstances, GLuint baseInstance,
GLuint drawID)
{
- struct vbo_context *vbo = vbo_context(ctx);
struct _mesa_prim prim;
if (skip_validated_draw(ctx))
return;
- vbo_bind_arrays(ctx);
-
/* OpenGL 4.5 says that primitive restart is ignored with non-indexed
* draws.
*/
prim.start = start;
prim.count = count;
- vbo->draw_prims(ctx, &prim, 1, NULL,
- GL_TRUE, start, start + count - 1, NULL, 0, NULL);
+ ctx->Driver.Draw(ctx, &prim, 1, NULL,
+ GL_TRUE, start, start + count - 1, NULL, 0, NULL);
if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH) {
_mesa_flush(ctx);
_mesa_debug(ctx, "glDrawArrays(%s, %d, %d)\n",
_mesa_enum_to_string(mode), start, count);
+ FLUSH_FOR_DRAW(ctx);
+
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;
}
_mesa_debug(ctx, "glDrawArraysInstanced(%s, %d, %d, %d)\n",
_mesa_enum_to_string(mode), start, count, numInstances);
+ FLUSH_FOR_DRAW(ctx);
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;
_mesa_enum_to_string(mode), first, count,
numInstances, baseInstance);
+ FLUSH_FOR_DRAW(ctx);
+
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;
"glMultiDrawArrays(%s, %p, %p, %d)\n",
_mesa_enum_to_string(mode), first, count, primcount);
+ FLUSH_FOR_DRAW(ctx);
+
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;
}
GLint basevertex, GLuint numInstances,
GLuint baseInstance)
{
- struct vbo_context *vbo = vbo_context(ctx);
struct _mesa_index_buffer ib;
struct _mesa_prim prim;
if (skip_draw_elements(ctx, count, indices))
return;
- vbo_bind_arrays(ctx);
-
ib.count = count;
ib.index_size = sizeof_ib_type(type);
ib.obj = ctx->Array.VAO->IndexBufferObj;
* for the latter case elsewhere.
*/
- vbo->draw_prims(ctx, &prim, 1, &ib,
- index_bounds_valid, start, end, NULL, 0, NULL);
+ ctx->Driver.Draw(ctx, &prim, 1, &ib,
+ index_bounds_valid, start, end, NULL, 0, NULL);
if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH) {
_mesa_flush(ctx);
_mesa_enum_to_string(mode), start, end, count,
_mesa_enum_to_string(type), indices, basevertex);
+ FLUSH_FOR_DRAW(ctx);
+
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;
_mesa_enum_to_string(mode), count,
_mesa_enum_to_string(type), indices);
+ FLUSH_FOR_DRAW(ctx);
+
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;
}
_mesa_enum_to_string(mode), count,
_mesa_enum_to_string(type), indices);
+ FLUSH_FOR_DRAW(ctx);
+
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;
}
_mesa_enum_to_string(mode), count,
_mesa_enum_to_string(type), indices);
+ FLUSH_FOR_DRAW(ctx);
+
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;
_mesa_enum_to_string(type), indices,
numInstances, basevertex);
+ FLUSH_FOR_DRAW(ctx);
+
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;
_mesa_enum_to_string(type), indices,
numInstances, baseInstance);
+ FLUSH_FOR_DRAW(ctx);
+
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;
_mesa_enum_to_string(type), indices,
numInstances, basevertex, baseInstance);
+ FLUSH_FOR_DRAW(ctx);
+
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;
const GLvoid * const *indices,
GLsizei primcount, const GLint *basevertex)
{
- struct vbo_context *vbo = vbo_context(ctx);
struct _mesa_index_buffer ib;
struct _mesa_prim *prim;
unsigned int index_type_size = sizeof_ib_type(type);
return;
}
- vbo_bind_arrays(ctx);
-
min_index_ptr = (uintptr_t) indices[0];
max_index_ptr = 0;
for (i = 0; i < primcount; i++) {
prim[i].basevertex = 0;
}
- vbo->draw_prims(ctx, prim, primcount, &ib,
- false, 0, ~0, NULL, 0, NULL);
+ ctx->Driver.Draw(ctx, prim, primcount, &ib,
+ false, 0, ~0, NULL, 0, NULL);
}
else {
/* render one prim at a time */
else
prim[0].basevertex = 0;
- vbo->draw_prims(ctx, prim, 1, &ib, false, 0, ~0, NULL, 0, NULL);
+ ctx->Driver.Draw(ctx, prim, 1, &ib, false, 0, ~0, NULL, 0, NULL);
}
}
{
GET_CURRENT_CONTEXT(ctx);
+ FLUSH_FOR_DRAW(ctx);
+
+ _mesa_set_draw_vao(ctx, ctx->Array.VAO, enabled_filter(ctx));
+
if (!_mesa_validate_MultiDrawElements(ctx, mode, count, type, indices,
primcount))
return;
{
GET_CURRENT_CONTEXT(ctx);
+ FLUSH_FOR_DRAW(ctx);
+
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;
}
+/**
+ * Draw a GL primitive using a vertex count obtained from transform feedback.
+ * \param mode the type of GL primitive to draw
+ * \param obj the transform feedback object to use
+ * \param stream index of the transform feedback stream from which to
+ * get the primitive count.
+ * \param numInstances number of instances to draw
+ */
static void
vbo_draw_transform_feedback(struct gl_context *ctx, GLenum mode,
struct gl_transform_feedback_object *obj,
GLuint stream, GLuint numInstances)
{
- struct vbo_context *vbo = vbo_context(ctx);
struct _mesa_prim prim;
+ FLUSH_FOR_DRAW(ctx);
+
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;
if (skip_validated_draw(ctx))
return;
- vbo_bind_arrays(ctx);
-
/* init most fields to zero */
memset(&prim, 0, sizeof(prim));
prim.begin = 1;
* (like in DrawArrays), but we have no way to know how many vertices
* will be rendered. */
- vbo->draw_prims(ctx, &prim, 1, NULL, GL_FALSE, 0, ~0, obj, stream, NULL);
+ ctx->Driver.Draw(ctx, &prim, 1, NULL, GL_FALSE, 0, ~0, obj, stream, NULL);
if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH) {
_mesa_flush(ctx);
vbo_validated_drawarraysindirect(struct gl_context *ctx,
GLenum mode, const GLvoid *indirect)
{
- struct vbo_context *vbo = vbo_context(ctx);
-
- vbo_bind_arrays(ctx);
-
- vbo->draw_indirect_prims(ctx, mode,
+ ctx->Driver.DrawIndirect(ctx, mode,
ctx->DrawIndirectBuffer, (GLsizeiptr) indirect,
1 /* draw_count */ , 16 /* stride */ ,
NULL, 0, NULL);
const GLvoid *indirect,
GLsizei primcount, GLsizei stride)
{
- struct vbo_context *vbo = vbo_context(ctx);
GLsizeiptr offset = (GLsizeiptr) indirect;
if (primcount == 0)
return;
- vbo_bind_arrays(ctx);
-
- vbo->draw_indirect_prims(ctx, mode, ctx->DrawIndirectBuffer, offset,
+ ctx->Driver.DrawIndirect(ctx, mode, ctx->DrawIndirectBuffer, offset,
primcount, stride, NULL, 0, NULL);
if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH)
GLenum mode, GLenum type,
const GLvoid *indirect)
{
- struct vbo_context *vbo = vbo_context(ctx);
struct _mesa_index_buffer ib;
- vbo_bind_arrays(ctx);
-
ib.count = 0; /* unknown */
ib.index_size = sizeof_ib_type(type);
ib.obj = ctx->Array.VAO->IndexBufferObj;
ib.ptr = NULL;
- vbo->draw_indirect_prims(ctx, mode,
+ ctx->Driver.DrawIndirect(ctx, mode,
ctx->DrawIndirectBuffer, (GLsizeiptr) indirect,
1 /* draw_count */ , 20 /* stride */ ,
NULL, 0, &ib);
const GLvoid *indirect,
GLsizei primcount, GLsizei stride)
{
- struct vbo_context *vbo = vbo_context(ctx);
struct _mesa_index_buffer ib;
GLsizeiptr offset = (GLsizeiptr) indirect;
if (primcount == 0)
return;
- vbo_bind_arrays(ctx);
-
/* NOTE: IndexBufferObj is guaranteed to be a VBO. */
ib.count = 0; /* unknown */
ib.obj = ctx->Array.VAO->IndexBufferObj;
ib.ptr = NULL;
- vbo->draw_indirect_prims(ctx, mode,
+ ctx->Driver.DrawIndirect(ctx, mode,
ctx->DrawIndirectBuffer, offset,
primcount, stride, NULL, 0, &ib);
_mesa_debug(ctx, "glDrawArraysIndirect(%s, %p)\n",
_mesa_enum_to_string(mode), indirect);
+ /* From the ARB_draw_indirect spec:
+ *
+ * "Initially zero is bound to DRAW_INDIRECT_BUFFER. In the
+ * compatibility profile, this indicates that DrawArraysIndirect and
+ * DrawElementsIndirect are to source their arguments directly from the
+ * pointer passed as their <indirect> parameters."
+ */
+ if (ctx->API == API_OPENGL_COMPAT &&
+ !_mesa_is_bufferobj(ctx->DrawIndirectBuffer)) {
+ DrawArraysIndirectCommand *cmd = (DrawArraysIndirectCommand *) indirect;
+
+ vbo_exec_DrawArraysInstancedBaseInstance(mode, cmd->first, cmd->count,
+ cmd->primCount,
+ cmd->baseInstance);
+ return;
+ }
+
+ FLUSH_FOR_DRAW(ctx);
+
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;
}
_mesa_enum_to_string(mode),
_mesa_enum_to_string(type), indirect);
+ /* From the ARB_draw_indirect spec:
+ *
+ * "Initially zero is bound to DRAW_INDIRECT_BUFFER. In the
+ * compatibility profile, this indicates that DrawArraysIndirect and
+ * DrawElementsIndirect are to source their arguments directly from the
+ * pointer passed as their <indirect> parameters."
+ */
+ if (ctx->API == API_OPENGL_COMPAT &&
+ !_mesa_is_bufferobj(ctx->DrawIndirectBuffer)) {
+ /*
+ * Unlike regular DrawElementsInstancedBaseVertex commands, the indices
+ * may not come from a client array and must come from an index buffer.
+ * If no element array buffer is bound, an INVALID_OPERATION error is
+ * generated.
+ */
+ if (!_mesa_is_bufferobj(ctx->Array.VAO->IndexBufferObj)) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glDrawElementsIndirect(no buffer bound "
+ "to GL_ELEMENT_ARRAY_BUFFER)");
+ } else {
+ DrawElementsIndirectCommand *cmd =
+ (DrawElementsIndirectCommand *) indirect;
+
+ /* Convert offset to pointer */
+ void *offset = (void *)
+ ((cmd->firstIndex * _mesa_sizeof_type(type)) & 0xffffffffUL);
+
+ vbo_exec_DrawElementsInstancedBaseVertexBaseInstance(mode, cmd->count,
+ type, offset,
+ cmd->primCount,
+ cmd->baseVertex,
+ cmd->baseInstance);
+ }
+
+ return;
+ }
+
+ FLUSH_FOR_DRAW(ctx);
+
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;
}
/* If <stride> is zero, the array elements are treated as tightly packed. */
if (stride == 0)
- stride = 4 * sizeof(GLuint); /* sizeof(DrawArraysIndirectCommand) */
+ stride = sizeof(DrawArraysIndirectCommand);
+
+ /* From the ARB_draw_indirect spec:
+ *
+ * "Initially zero is bound to DRAW_INDIRECT_BUFFER. In the
+ * compatibility profile, this indicates that DrawArraysIndirect and
+ * DrawElementsIndirect are to source their arguments directly from the
+ * pointer passed as their <indirect> parameters."
+ */
+ if (ctx->API == API_OPENGL_COMPAT &&
+ !_mesa_is_bufferobj(ctx->DrawIndirectBuffer)) {
+
+ if (!_mesa_valid_draw_indirect_multi(ctx, primcount, stride,
+ "glMultiDrawArraysIndirect"))
+ return;
+
+ const ubyte *ptr = (const ubyte *) indirect;
+ for (unsigned i = 0; i < primcount; i++) {
+ DrawArraysIndirectCommand *cmd = (DrawArraysIndirectCommand *) ptr;
+ vbo_exec_DrawArraysInstancedBaseInstance(mode, cmd->first,
+ cmd->count, cmd->primCount,
+ cmd->baseInstance);
+
+ if (stride == 0) {
+ ptr += sizeof(DrawArraysIndirectCommand);
+ } else {
+ ptr += stride;
+ }
+ }
+
+ return;
+ }
+
+ FLUSH_FOR_DRAW(ctx);
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;
/* If <stride> is zero, the array elements are treated as tightly packed. */
if (stride == 0)
- stride = 5 * sizeof(GLuint); /* sizeof(DrawElementsIndirectCommand) */
+ stride = sizeof(DrawElementsIndirectCommand);
+
+
+ /* From the ARB_draw_indirect spec:
+ *
+ * "Initially zero is bound to DRAW_INDIRECT_BUFFER. In the
+ * compatibility profile, this indicates that DrawArraysIndirect and
+ * DrawElementsIndirect are to source their arguments directly from the
+ * pointer passed as their <indirect> parameters."
+ */
+ if (ctx->API == API_OPENGL_COMPAT &&
+ !_mesa_is_bufferobj(ctx->DrawIndirectBuffer)) {
+ /*
+ * Unlike regular DrawElementsInstancedBaseVertex commands, the indices
+ * may not come from a client array and must come from an index buffer.
+ * If no element array buffer is bound, an INVALID_OPERATION error is
+ * generated.
+ */
+ if (!_mesa_is_bufferobj(ctx->Array.VAO->IndexBufferObj)) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glMultiDrawElementsIndirect(no buffer bound "
+ "to GL_ELEMENT_ARRAY_BUFFER)");
+
+ return;
+ }
+
+ if (!_mesa_valid_draw_indirect_multi(ctx, primcount, stride,
+ "glMultiDrawArraysIndirect"))
+ return;
+
+ const ubyte *ptr = (const ubyte *) indirect;
+ for (unsigned i = 0; i < primcount; i++) {
+ vbo_exec_DrawElementsIndirect(mode, type, ptr);
+
+ if (stride == 0) {
+ ptr += sizeof(DrawElementsIndirectCommand);
+ } else {
+ ptr += stride;
+ }
+ }
+
+ return;
+ }
+
+ FLUSH_FOR_DRAW(ctx);
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;
GLsizei maxdrawcount,
GLsizei stride)
{
- struct vbo_context *vbo = vbo_context(ctx);
GLsizeiptr offset = indirect;
if (maxdrawcount == 0)
return;
- vbo_bind_arrays(ctx);
-
- vbo->draw_indirect_prims(ctx, mode,
+ ctx->Driver.DrawIndirect(ctx, mode,
ctx->DrawIndirectBuffer, offset,
maxdrawcount, stride,
ctx->ParameterBuffer, drawcount_offset, NULL);
GLsizei maxdrawcount,
GLsizei stride)
{
- struct vbo_context *vbo = vbo_context(ctx);
struct _mesa_index_buffer ib;
GLsizeiptr offset = (GLsizeiptr) indirect;
if (maxdrawcount == 0)
return;
- vbo_bind_arrays(ctx);
-
/* NOTE: IndexBufferObj is guaranteed to be a VBO. */
ib.count = 0; /* unknown */
ib.obj = ctx->Array.VAO->IndexBufferObj;
ib.ptr = NULL;
- vbo->draw_indirect_prims(ctx, mode,
+ ctx->Driver.DrawIndirect(ctx, mode,
ctx->DrawIndirectBuffer, offset,
maxdrawcount, stride,
ctx->ParameterBuffer, drawcount_offset, &ib);
if (stride == 0)
stride = 4 * sizeof(GLuint); /* sizeof(DrawArraysIndirectCommand) */
+ FLUSH_FOR_DRAW(ctx);
+
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,
if (stride == 0)
stride = 5 * sizeof(GLuint); /* sizeof(DrawElementsIndirectCommand) */
+ FLUSH_FOR_DRAW(ctx);
+
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,
vbo_exec_DrawElementsInstancedBaseVertexBaseInstance);
}
- if (ctx->API == API_OPENGL_CORE || _mesa_is_gles31(ctx)) {
+ if (_mesa_is_desktop_gl(ctx) || _mesa_is_gles31(ctx)) {
SET_DrawArraysIndirect(exec, vbo_exec_DrawArraysIndirect);
SET_DrawElementsIndirect(exec, vbo_exec_DrawElementsIndirect);
}
- if (ctx->API == API_OPENGL_CORE) {
- SET_MultiDrawArraysIndirect(exec, vbo_exec_MultiDrawArraysIndirect);
- SET_MultiDrawElementsIndirect(exec, vbo_exec_MultiDrawElementsIndirect);
- SET_MultiDrawArraysIndirectCountARB(exec,
- vbo_exec_MultiDrawArraysIndirectCount);
- SET_MultiDrawElementsIndirectCountARB(exec,
- vbo_exec_MultiDrawElementsIndirectCount);
- }
-
if (_mesa_is_desktop_gl(ctx) || _mesa_is_gles3(ctx)) {
SET_DrawArraysInstancedARB(exec, vbo_exec_DrawArraysInstanced);
SET_DrawElementsInstancedARB(exec, vbo_exec_DrawElementsInstanced);
vbo_exec_DrawTransformFeedbackInstanced);
SET_DrawTransformFeedbackStreamInstanced(exec,
vbo_exec_DrawTransformFeedbackStreamInstanced);
+ SET_MultiDrawArraysIndirect(exec, vbo_exec_MultiDrawArraysIndirect);
+ SET_MultiDrawElementsIndirect(exec, vbo_exec_MultiDrawElementsIndirect);
+ SET_MultiDrawArraysIndirectCountARB(exec,
+ vbo_exec_MultiDrawArraysIndirectCount);
+ SET_MultiDrawElementsIndirectCountARB(exec,
+ vbo_exec_MultiDrawElementsIndirectCount);
}
}
projects / mesa.git / blobdiff