projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
mesa/vbo: reduce prim array size
[mesa.git] / src / mesa / vbo / vbo_exec_array.c
1 /**************************************************************************
2 *
3 * Copyright 2003 VMware, Inc.
4 * Copyright 2009 VMware, Inc.
5 * All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the
9 * "Software"), to deal in the Software without restriction, including
10 * without limitation the rights to use, copy, modify, merge, publish,
11 * distribute, sub license, and/or sell copies of the Software, and to
12 * permit persons to whom the Software is furnished to do so, subject to
13 * the following conditions:
14 *
15 * The above copyright notice and this permission notice (including the
16 * next paragraph) shall be included in all copies or substantial portions
17 * of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
22 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
23 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
24 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
25 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 *
27 **************************************************************************/
28
29 #include <stdio.h>
30 #include "main/arrayobj.h"
31 #include "main/glheader.h"
32 #include "main/context.h"
33 #include "main/state.h"
34 #include "main/api_validate.h"
35 #include "main/dispatch.h"
36 #include "main/varray.h"
37 #include "main/bufferobj.h"
38 #include "main/enums.h"
39 #include "main/macros.h"
40 #include "main/transformfeedback.h"
41
42 #include "vbo_context.h"
43
44
45 /**
46 * Check that element 'j' of the array has reasonable data.
47 * Map VBO if needed.
48 * For debugging purposes; not normally used.
49 */
50 static void
51 check_array_data(struct gl_context *ctx, struct gl_vertex_array_object *vao,
52 GLuint attrib, GLuint j)
53 {
54 const struct gl_array_attributes *array = &vao->VertexAttrib[attrib];
55 if (array->Enabled) {
56 const struct gl_vertex_buffer_binding *binding =
57 &vao->BufferBinding[array->BufferBindingIndex];
58 struct gl_buffer_object *bo = binding->BufferObj;
59 const void *data = array->Ptr;
60 if (_mesa_is_bufferobj(bo)) {
61 if (!bo->Mappings[MAP_INTERNAL].Pointer) {
62 /* need to map now */
63 bo->Mappings[MAP_INTERNAL].Pointer =
64 ctx->Driver.MapBufferRange(ctx, 0, bo->Size,
65 GL_MAP_READ_BIT, bo, MAP_INTERNAL);
66 }
67 data = ADD_POINTERS(_mesa_vertex_attrib_address(array, binding),
68 bo->Mappings[MAP_INTERNAL].Pointer);
69 }
70 switch (array->Type) {
71 case GL_FLOAT:
72 {
73 GLfloat *f = (GLfloat *) ((GLubyte *) data + binding->Stride * j);
74 GLint k;
75 for (k = 0; k < array->Size; k++) {
76 if (IS_INF_OR_NAN(f[k]) || f[k] >= 1.0e20F || f[k] <= -1.0e10F) {
77 printf("Bad array data:\n");
78 printf(" Element[%u].%u = %f\n", j, k, f[k]);
79 printf(" Array %u at %p\n", attrib, (void *) array);
80 printf(" Type 0x%x, Size %d, Stride %d\n",
81 array->Type, array->Size, binding->Stride);
82 printf(" Address/offset %p in Buffer Object %u\n",
83 array->Ptr, bo->Name);
84 f[k] = 1.0F; /* XXX replace the bad value! */
85 }
86 /*assert(!IS_INF_OR_NAN(f[k])); */
87 }
88 }
89 break;
90 default:
91 ;
92 }
93 }
94 }
95
96
97 /**
98 * Unmap the buffer object referenced by given array, if mapped.
99 */
100 static void
101 unmap_array_buffer(struct gl_context *ctx, struct gl_vertex_array_object *vao,
102 GLuint attrib)
103 {
104 const struct gl_array_attributes *array = &vao->VertexAttrib[attrib];
105 if (array->Enabled) {
106 const struct gl_vertex_buffer_binding *binding =
107 &vao->BufferBinding[array->BufferBindingIndex];
108 struct gl_buffer_object *bo = binding->BufferObj;
109 if (_mesa_is_bufferobj(bo) && _mesa_bufferobj_mapped(bo, MAP_INTERNAL)) {
110 ctx->Driver.UnmapBuffer(ctx, bo, MAP_INTERNAL);
111 }
112 }
113 }
114
115
116 /**
117 * Examine the array's data for NaNs, etc.
118 * For debug purposes; not normally used.
119 */
120 static void
121 check_draw_elements_data(struct gl_context *ctx, GLsizei count,
122 GLenum elemType, const void *elements,
123 GLint basevertex)
124 {
125 struct gl_vertex_array_object *vao = ctx->Array.VAO;
126 const void *elemMap;
127 GLint i;
128 GLuint k;
129
130 if (_mesa_is_bufferobj(vao->IndexBufferObj)) {
131 elemMap = ctx->Driver.MapBufferRange(ctx, 0,
132 vao->IndexBufferObj->Size,
133 GL_MAP_READ_BIT,
134 vao->IndexBufferObj, MAP_INTERNAL);
135 elements = ADD_POINTERS(elements, elemMap);
136 }
137
138 for (i = 0; i < count; i++) {
139 GLuint j;
140
141 /* j = element[i] */
142 switch (elemType) {
143 case GL_UNSIGNED_BYTE:
144 j = ((const GLubyte *) elements)[i];
145 break;
146 case GL_UNSIGNED_SHORT:
147 j = ((const GLushort *) elements)[i];
148 break;
149 case GL_UNSIGNED_INT:
150 j = ((const GLuint *) elements)[i];
151 break;
152 default:
153 assert(0);
154 }
155
156 /* check element j of each enabled array */
157 for (k = 0; k < VERT_ATTRIB_MAX; k++) {
158 check_array_data(ctx, vao, k, j);
159 }
160 }
161
162 if (_mesa_is_bufferobj(vao->IndexBufferObj)) {
163 ctx->Driver.UnmapBuffer(ctx, vao->IndexBufferObj, MAP_INTERNAL);
164 }
165
166 for (k = 0; k < VERT_ATTRIB_MAX; k++) {
167 unmap_array_buffer(ctx, vao, k);
168 }
169 }
170
171
172 /**
173 * Check array data, looking for NaNs, etc.
174 */
175 static void
176 check_draw_arrays_data(struct gl_context *ctx, GLint start, GLsizei count)
177 {
178 /* TO DO */
179 }
180
181
182 /**
183 * Check if we should skip the draw call even after validation was successful.
184 */
185 static bool
186 skip_validated_draw(struct gl_context *ctx)
187 {
188 switch (ctx->API) {
189 case API_OPENGLES2:
190 /* For ES2, we can draw if we have a vertex program/shader). */
191 return ctx->VertexProgram._Current == NULL;
192
193 case API_OPENGLES:
194 /* For OpenGL ES, only draw if we have vertex positions
195 */
196 if (ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_POS].Enabled)
197 return false;
198 break;
199
200 case API_OPENGL_CORE:
201 /* Section 7.3 (Program Objects) of the OpenGL 4.5 Core Profile spec
202 * says:
203 *
204 * "If there is no active program for the vertex or fragment shader
205 * stages, the results of vertex and/or fragment processing will be
206 * undefined. However, this is not an error."
207 *
208 * The fragment shader is not tested here because other state (e.g.,
209 * GL_RASTERIZER_DISCARD) affects whether or not we actually care.
210 */
211 return ctx->VertexProgram._Current == NULL;
212
213 case API_OPENGL_COMPAT:
214 if (ctx->VertexProgram._Current != NULL) {
215 /* Draw regardless of whether or not we have any vertex arrays.
216 * (Ex: could draw a point using a constant vertex pos)
217 */
218 return false;
219 } else {
220 /* Draw if we have vertex positions (GL_VERTEX_ARRAY or generic
221 * array [0]).
222 */
223 return (!ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_POS].Enabled &&
224 !ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_GENERIC0].Enabled);
225 }
226 break;
227
228 default:
229 unreachable("Invalid API value in check_valid_to_render()");
230 }
231
232 return false;
233 }
234
235
236 /**
237 * Print info/data for glDrawArrays(), for debugging.
238 */
239 static void
240 print_draw_arrays(struct gl_context *ctx,
241 GLenum mode, GLint start, GLsizei count)
242 {
243 const struct gl_vertex_array_object *vao = ctx->Array.VAO;
244
245 printf("vbo_exec_DrawArrays(mode 0x%x, start %d, count %d):\n",
246 mode, start, count);
247
248 unsigned i;
249 for (i = 0; i < VERT_ATTRIB_MAX; ++i) {
250 const struct gl_array_attributes *array = &vao->VertexAttrib[i];
251 if (!array->Enabled)
252 continue;
253
254 const struct gl_vertex_buffer_binding *binding =
255 &vao->BufferBinding[array->BufferBindingIndex];
256 struct gl_buffer_object *bufObj = binding->BufferObj;
257
258 printf("attr %s: size %d stride %d enabled %d "
259 "ptr %p Bufobj %u\n",
260 gl_vert_attrib_name((gl_vert_attrib) i),
261 array->Size, binding->Stride, array->Enabled,
262 array->Ptr, bufObj->Name);
263
264 if (_mesa_is_bufferobj(bufObj)) {
265 GLubyte *p = ctx->Driver.MapBufferRange(ctx, 0, bufObj->Size,
266 GL_MAP_READ_BIT, bufObj,
267 MAP_INTERNAL);
268 int offset = (int) (GLintptr)
269 _mesa_vertex_attrib_address(array, binding);
270 float *f = (float *) (p + offset);
271 int *k = (int *) f;
272 int i;
273 int n = (count * binding->Stride) / 4;
274 if (n > 32)
275 n = 32;
276 printf(" Data at offset %d:\n", offset);
277 for (i = 0; i < n; i++) {
278 printf(" float[%d] = 0x%08x %f\n", i, k[i], f[i]);
279 }
280 ctx->Driver.UnmapBuffer(ctx, bufObj, MAP_INTERNAL);
281 }
282 }
283 }
284
285
286 /**
287 * Set the vbo->exec->inputs[] pointers to point to the enabled
288 * vertex arrays. This depends on the current vertex program/shader
289 * being executed because of whether or not generic vertex arrays
290 * alias the conventional vertex arrays.
291 * For arrays that aren't enabled, we set the input[attrib] pointer
292 * to point at a zero-stride current value "array".
293 */
294 static void
295 recalculate_input_bindings(struct gl_context *ctx)
296 {
297 struct vbo_context *vbo = vbo_context(ctx);
298 struct vbo_exec_context *exec = &vbo->exec;
299 const struct gl_array_attributes *array = ctx->Array.VAO->VertexAttrib;
300 struct gl_vertex_array *vertexAttrib = ctx->Array.VAO->_VertexAttrib;
301 const struct gl_vertex_array **inputs = &exec->array.inputs[0];
302 GLbitfield64 const_inputs = 0x0;
303 GLuint i;
304
305 switch (get_program_mode(ctx)) {
306 case VP_NONE:
307 /* When no vertex program is active (or the vertex program is generated
308 * from fixed-function state). We put the material values into the
309 * generic slots. This is the only situation where material values
310 * are available as per-vertex attributes.
311 */
312 for (i = 0; i < VERT_ATTRIB_FF_MAX; i++) {
313 if (array[VERT_ATTRIB_FF(i)].Enabled)
314 inputs[i] = &vertexAttrib[VERT_ATTRIB_FF(i)];
315 else {
316 inputs[i] = &vbo->currval[VBO_ATTRIB_POS + i];
317 const_inputs |= VERT_BIT(i);
318 }
319 }
320
321 for (i = 0; i < MAT_ATTRIB_MAX; i++) {
322 inputs[VERT_ATTRIB_GENERIC(i)] =
323 &vbo->currval[VBO_ATTRIB_MAT_FRONT_AMBIENT + i];
324 const_inputs |= VERT_BIT_GENERIC(i);
325 }
326
327 /* Could use just about anything, just to fill in the empty
328 * slots:
329 */
330 for (i = MAT_ATTRIB_MAX; i < VERT_ATTRIB_GENERIC_MAX; i++) {
331 inputs[VERT_ATTRIB_GENERIC(i)] =
332 &vbo->currval[VBO_ATTRIB_GENERIC0 + i];
333 const_inputs |= VERT_BIT_GENERIC(i);
334 }
335 break;
336
337 case VP_ARB:
338 /* There are no shaders in OpenGL ES 1.x, so this code path should be
339 * impossible to reach. The meta code is careful to not use shaders in
340 * ES1.
341 */
342 assert(ctx->API != API_OPENGLES);
343
344 /* In the compatibility profile of desktop OpenGL, the generic[0]
345 * attribute array aliases and overrides the legacy position array.
346 * Otherwise, legacy attributes available in the legacy slots,
347 * generic attributes in the generic slots and materials are not
348 * available as per-vertex attributes.
349 *
350 * In all other APIs, only the generic attributes exist, and none of the
351 * slots are considered "magic."
352 */
353 if (ctx->API == API_OPENGL_COMPAT) {
354 if (array[VERT_ATTRIB_GENERIC0].Enabled)
355 inputs[0] = &vertexAttrib[VERT_ATTRIB_GENERIC0];
356 else if (array[VERT_ATTRIB_POS].Enabled)
357 inputs[0] = &vertexAttrib[VERT_ATTRIB_POS];
358 else {
359 inputs[0] = &vbo->currval[VBO_ATTRIB_POS];
360 const_inputs |= VERT_BIT_POS;
361 }
362
363 for (i = 1; i < VERT_ATTRIB_FF_MAX; i++) {
364 if (array[VERT_ATTRIB_FF(i)].Enabled)
365 inputs[i] = &vertexAttrib[VERT_ATTRIB_FF(i)];
366 else {
367 inputs[i] = &vbo->currval[VBO_ATTRIB_POS + i];
368 const_inputs |= VERT_BIT_FF(i);
369 }
370 }
371
372 for (i = 1; i < VERT_ATTRIB_GENERIC_MAX; i++) {
373 if (array[VERT_ATTRIB_GENERIC(i)].Enabled)
374 inputs[VERT_ATTRIB_GENERIC(i)] =
375 &vertexAttrib[VERT_ATTRIB_GENERIC(i)];
376 else {
377 inputs[VERT_ATTRIB_GENERIC(i)] =
378 &vbo->currval[VBO_ATTRIB_GENERIC0 + i];
379 const_inputs |= VERT_BIT_GENERIC(i);
380 }
381 }
382
383 inputs[VERT_ATTRIB_GENERIC0] = inputs[0];
384 } else {
385 /* Other parts of the code assume that inputs[0] through
386 * inputs[VERT_ATTRIB_FF_MAX] will be non-NULL. However, in OpenGL
387 * ES 2.0+ or OpenGL core profile, none of these arrays should ever
388 * be enabled.
389 */
390 for (i = 0; i < VERT_ATTRIB_FF_MAX; i++) {
391 assert(!array[VERT_ATTRIB_FF(i)].Enabled);
392
393 inputs[i] = &vbo->currval[VBO_ATTRIB_POS + i];
394 const_inputs |= VERT_BIT_FF(i);
395 }
396
397 for (i = 0; i < VERT_ATTRIB_GENERIC_MAX; i++) {
398 if (array[VERT_ATTRIB_GENERIC(i)].Enabled)
399 inputs[VERT_ATTRIB_GENERIC(i)] =
400 &vertexAttrib[VERT_ATTRIB_GENERIC(i)];
401 else {
402 inputs[VERT_ATTRIB_GENERIC(i)] =
403 &vbo->currval[VBO_ATTRIB_GENERIC0 + i];
404 const_inputs |= VERT_BIT_GENERIC(i);
405 }
406 }
407 }
408
409 break;
410 }
411
412 _mesa_set_varying_vp_inputs(ctx, VERT_BIT_ALL & (~const_inputs));
413 ctx->NewDriverState |= ctx->DriverFlags.NewArray;
414 }
415
416
417 /**
418 * Examine the enabled vertex arrays to set the exec->array.inputs[] values.
419 * These will point to the arrays to actually use for drawing. Some will
420 * be user-provided arrays, other will be zero-stride const-valued arrays.
421 * Note that this might set the _NEW_VARYING_VP_INPUTS dirty flag so state
422 * validation must be done after this call.
423 */
424 void
425 vbo_bind_arrays(struct gl_context *ctx)
426 {
427 struct vbo_context *vbo = vbo_context(ctx);
428 struct vbo_exec_context *exec = &vbo->exec;
429
430 vbo_draw_method(vbo, DRAW_ARRAYS);
431
432 if (exec->array.recalculate_inputs) {
433 recalculate_input_bindings(ctx);
434 exec->array.recalculate_inputs = GL_FALSE;
435
436 /* Again... because we may have changed the bitmask of per-vertex varying
437 * attributes. If we regenerate the fixed-function vertex program now
438 * we may be able to prune down the number of vertex attributes which we
439 * need in the shader.
440 */
441 if (ctx->NewState) {
442 /* Setting "validating" to TRUE prevents _mesa_update_state from
443 * invalidating what we just did.
444 */
445 exec->validating = GL_TRUE;
446 _mesa_update_state(ctx);
447 exec->validating = GL_FALSE;
448 }
449 }
450 }
451
452
453 /**
454 * Helper function called by the other DrawArrays() functions below.
455 * This is where we handle primitive restart for drawing non-indexed
456 * arrays. If primitive restart is enabled, it typically means
457 * splitting one DrawArrays() into two.
458 */
459 static void
460 vbo_draw_arrays(struct gl_context *ctx, GLenum mode, GLint start,
461 GLsizei count, GLuint numInstances, GLuint baseInstance,
462 GLuint drawID)
463 {
464 struct vbo_context *vbo = vbo_context(ctx);
465 struct _mesa_prim prim;
466
467 if (skip_validated_draw(ctx))
468 return;
469
470 vbo_bind_arrays(ctx);
471
472 /* OpenGL 4.5 says that primitive restart is ignored with non-indexed
473 * draws.
474 */
475 memset(&prim, 0, sizeof(prim));
476 prim.begin = 1;
477 prim.end = 1;
478 prim.mode = mode;
479 prim.num_instances = numInstances;
480 prim.base_instance = baseInstance;
481 prim.draw_id = drawID;
482 prim.is_indirect = 0;
483 prim.start = start;
484 prim.count = count;
485
486 vbo->draw_prims(ctx, &prim, 1, NULL,
487 GL_TRUE, start, start + count - 1, NULL, 0, NULL);
488
489 if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH) {
490 _mesa_flush(ctx);
491 }
492 }
493
494
495 /**
496 * Execute a glRectf() function.
497 */
498 static void GLAPIENTRY
499 vbo_exec_Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
500 {
501 GET_CURRENT_CONTEXT(ctx);
502 ASSERT_OUTSIDE_BEGIN_END(ctx);
503
504 CALL_Begin(GET_DISPATCH(), (GL_QUADS));
505 CALL_Vertex2f(GET_DISPATCH(), (x1, y1));
506 CALL_Vertex2f(GET_DISPATCH(), (x2, y1));
507 CALL_Vertex2f(GET_DISPATCH(), (x2, y2));
508 CALL_Vertex2f(GET_DISPATCH(), (x1, y2));
509 CALL_End(GET_DISPATCH(), ());
510 }
511
512
513 static void GLAPIENTRY
514 vbo_exec_EvalMesh1(GLenum mode, GLint i1, GLint i2)
515 {
516 GET_CURRENT_CONTEXT(ctx);
517 GLint i;
518 GLfloat u, du;
519 GLenum prim;
520
521 switch (mode) {
522 case GL_POINT:
523 prim = GL_POINTS;
524 break;
525 case GL_LINE:
526 prim = GL_LINE_STRIP;
527 break;
528 default:
529 _mesa_error(ctx, GL_INVALID_ENUM, "glEvalMesh1(mode)");
530 return;
531 }
532
533 /* No effect if vertex maps disabled.
534 */
535 if (!ctx->Eval.Map1Vertex4 && !ctx->Eval.Map1Vertex3)
536 return;
537
538 du = ctx->Eval.MapGrid1du;
539 u = ctx->Eval.MapGrid1u1 + i1 * du;
540
541 CALL_Begin(GET_DISPATCH(), (prim));
542 for (i = i1; i <= i2; i++, u += du) {
543 CALL_EvalCoord1f(GET_DISPATCH(), (u));
544 }
545 CALL_End(GET_DISPATCH(), ());
546 }
547
548
549 static void GLAPIENTRY
550 vbo_exec_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
551 {
552 GET_CURRENT_CONTEXT(ctx);
553 GLfloat u, du, v, dv, v1, u1;
554 GLint i, j;
555
556 switch (mode) {
557 case GL_POINT:
558 case GL_LINE:
559 case GL_FILL:
560 break;
561 default:
562 _mesa_error(ctx, GL_INVALID_ENUM, "glEvalMesh2(mode)");
563 return;
564 }
565
566 /* No effect if vertex maps disabled.
567 */
568 if (!ctx->Eval.Map2Vertex4 && !ctx->Eval.Map2Vertex3)
569 return;
570
571 du = ctx->Eval.MapGrid2du;
572 dv = ctx->Eval.MapGrid2dv;
573 v1 = ctx->Eval.MapGrid2v1 + j1 * dv;
574 u1 = ctx->Eval.MapGrid2u1 + i1 * du;
575
576 switch (mode) {
577 case GL_POINT:
578 CALL_Begin(GET_DISPATCH(), (GL_POINTS));
579 for (v = v1, j = j1; j <= j2; j++, v += dv) {
580 for (u = u1, i = i1; i <= i2; i++, u += du) {
581 CALL_EvalCoord2f(GET_DISPATCH(), (u, v));
582 }
583 }
584 CALL_End(GET_DISPATCH(), ());
585 break;
586 case GL_LINE:
587 for (v = v1, j = j1; j <= j2; j++, v += dv) {
588 CALL_Begin(GET_DISPATCH(), (GL_LINE_STRIP));
589 for (u = u1, i = i1; i <= i2; i++, u += du) {
590 CALL_EvalCoord2f(GET_DISPATCH(), (u, v));
591 }
592 CALL_End(GET_DISPATCH(), ());
593 }
594 for (u = u1, i = i1; i <= i2; i++, u += du) {
595 CALL_Begin(GET_DISPATCH(), (GL_LINE_STRIP));
596 for (v = v1, j = j1; j <= j2; j++, v += dv) {
597 CALL_EvalCoord2f(GET_DISPATCH(), (u, v));
598 }
599 CALL_End(GET_DISPATCH(), ());
600 }
601 break;
602 case GL_FILL:
603 for (v = v1, j = j1; j < j2; j++, v += dv) {
604 CALL_Begin(GET_DISPATCH(), (GL_TRIANGLE_STRIP));
605 for (u = u1, i = i1; i <= i2; i++, u += du) {
606 CALL_EvalCoord2f(GET_DISPATCH(), (u, v));
607 CALL_EvalCoord2f(GET_DISPATCH(), (u, v + dv));
608 }
609 CALL_End(GET_DISPATCH(), ());
610 }
611 break;
612 }
613 }
614
615
616 /**
617 * Called from glDrawArrays when in immediate mode (not display list mode).
618 */
619 static void GLAPIENTRY
620 vbo_exec_DrawArrays(GLenum mode, GLint start, GLsizei count)
621 {
622 GET_CURRENT_CONTEXT(ctx);
623
624 if (MESA_VERBOSE & VERBOSE_DRAW)
625 _mesa_debug(ctx, "glDrawArrays(%s, %d, %d)\n",
626 _mesa_enum_to_string(mode), start, count);
627
628 if (_mesa_is_no_error_enabled(ctx)) {
629 FLUSH_CURRENT(ctx, 0);
630
631 if (ctx->NewState)
632 _mesa_update_state(ctx);
633 } else {
634 if (!_mesa_validate_DrawArrays(ctx, mode, count))
635 return;
636 }
637
638 if (0)
639 check_draw_arrays_data(ctx, start, count);
640
641 vbo_draw_arrays(ctx, mode, start, count, 1, 0, 0);
642
643 if (0)
644 print_draw_arrays(ctx, mode, start, count);
645 }
646
647
648 /**
649 * Called from glDrawArraysInstanced when in immediate mode (not
650 * display list mode).
651 */
652 static void GLAPIENTRY
653 vbo_exec_DrawArraysInstanced(GLenum mode, GLint start, GLsizei count,
654 GLsizei numInstances)
655 {
656 GET_CURRENT_CONTEXT(ctx);
657
658 if (MESA_VERBOSE & VERBOSE_DRAW)
659 _mesa_debug(ctx, "glDrawArraysInstanced(%s, %d, %d, %d)\n",
660 _mesa_enum_to_string(mode), start, count, numInstances);
661
662
663 if (_mesa_is_no_error_enabled(ctx)) {
664 FLUSH_CURRENT(ctx, 0);
665
666 if (ctx->NewState)
667 _mesa_update_state(ctx);
668 } else {
669 if (!_mesa_validate_DrawArraysInstanced(ctx, mode, start, count,
670 numInstances))
671 return;
672 }
673
674 if (0)
675 check_draw_arrays_data(ctx, start, count);
676
677 vbo_draw_arrays(ctx, mode, start, count, numInstances, 0, 0);
678
679 if (0)
680 print_draw_arrays(ctx, mode, start, count);
681 }
682
683
684 /**
685 * Called from glDrawArraysInstancedBaseInstance when in immediate mode.
686 */
687 static void GLAPIENTRY
688 vbo_exec_DrawArraysInstancedBaseInstance(GLenum mode, GLint first,
689 GLsizei count, GLsizei numInstances,
690 GLuint baseInstance)
691 {
692 GET_CURRENT_CONTEXT(ctx);
693
694 if (MESA_VERBOSE & VERBOSE_DRAW)
695 _mesa_debug(ctx,
696 "glDrawArraysInstancedBaseInstance(%s, %d, %d, %d, %d)\n",
697 _mesa_enum_to_string(mode), first, count,
698 numInstances, baseInstance);
699
700 if (_mesa_is_no_error_enabled(ctx)) {
701 FLUSH_CURRENT(ctx, 0);
702
703 if (ctx->NewState)
704 _mesa_update_state(ctx);
705 } else {
706 if (!_mesa_validate_DrawArraysInstanced(ctx, mode, first, count,
707 numInstances))
708 return;
709 }
710
711 if (0)
712 check_draw_arrays_data(ctx, first, count);
713
714 vbo_draw_arrays(ctx, mode, first, count, numInstances, baseInstance, 0);
715
716 if (0)
717 print_draw_arrays(ctx, mode, first, count);
718 }
719
720
721 /**
722 * Called from glMultiDrawArrays when in immediate mode.
723 */
724 static void GLAPIENTRY
725 vbo_exec_MultiDrawArrays(GLenum mode, const GLint *first,
726 const GLsizei *count, GLsizei primcount)
727 {
728 GET_CURRENT_CONTEXT(ctx);
729 GLint i;
730
731 if (MESA_VERBOSE & VERBOSE_DRAW)
732 _mesa_debug(ctx,
733 "glMultiDrawArrays(%s, %p, %p, %d)\n",
734 _mesa_enum_to_string(mode), first, count, primcount);
735
736 if (!_mesa_validate_MultiDrawArrays(ctx, mode, count, primcount))
737 return;
738
739 for (i = 0; i < primcount; i++) {
740 if (count[i] > 0) {
741 if (0)
742 check_draw_arrays_data(ctx, first[i], count[i]);
743
744 /* The GL_ARB_shader_draw_parameters spec adds the following after the
745 * pseudo-code describing glMultiDrawArrays:
746 *
747 * "The index of the draw (<i> in the above pseudo-code) may be
748 * read by a vertex shader as <gl_DrawIDARB>, as described in
749 * Section 11.1.3.9."
750 */
751 vbo_draw_arrays(ctx, mode, first[i], count[i], 1, 0, i);
752
753 if (0)
754 print_draw_arrays(ctx, mode, first[i], count[i]);
755 }
756 }
757 }
758
759
760
761 /**
762 * Map GL_ELEMENT_ARRAY_BUFFER and print contents.
763 * For debugging.
764 */
765 #if 0
766 static void
767 dump_element_buffer(struct gl_context *ctx, GLenum type)
768 {
769 const GLvoid *map =
770 ctx->Driver.MapBufferRange(ctx, 0,
771 ctx->Array.VAO->IndexBufferObj->Size,
772 GL_MAP_READ_BIT,
773 ctx->Array.VAO->IndexBufferObj,
774 MAP_INTERNAL);
775 switch (type) {
776 case GL_UNSIGNED_BYTE:
777 {
778 const GLubyte *us = (const GLubyte *) map;
779 GLint i;
780 for (i = 0; i < ctx->Array.VAO->IndexBufferObj->Size; i++) {
781 printf("%02x ", us[i]);
782 if (i % 32 == 31)
783 printf("\n");
784 }
785 printf("\n");
786 }
787 break;
788 case GL_UNSIGNED_SHORT:
789 {
790 const GLushort *us = (const GLushort *) map;
791 GLint i;
792 for (i = 0; i < ctx->Array.VAO->IndexBufferObj->Size / 2; i++) {
793 printf("%04x ", us[i]);
794 if (i % 16 == 15)
795 printf("\n");
796 }
797 printf("\n");
798 }
799 break;
800 case GL_UNSIGNED_INT:
801 {
802 const GLuint *us = (const GLuint *) map;
803 GLint i;
804 for (i = 0; i < ctx->Array.VAO->IndexBufferObj->Size / 4; i++) {
805 printf("%08x ", us[i]);
806 if (i % 8 == 7)
807 printf("\n");
808 }
809 printf("\n");
810 }
811 break;
812 default:
813 ;
814 }
815
816 ctx->Driver.UnmapBuffer(ctx, ctx->Array.VAO->IndexBufferObj, MAP_INTERNAL);
817 }
818 #endif
819
820
821 static bool
822 skip_draw_elements(struct gl_context *ctx, GLsizei count,
823 const GLvoid *indices)
824 {
825 if (count == 0)
826 return true;
827
828 /* Not using a VBO for indices, so avoid NULL pointer derefs later.
829 */
830 if (!_mesa_is_bufferobj(ctx->Array.VAO->IndexBufferObj) && indices == NULL)
831 return true;
832
833 if (skip_validated_draw(ctx))
834 return true;
835
836 return false;
837 }
838
839
840 /**
841 * Inner support for both _mesa_DrawElements and _mesa_DrawRangeElements.
842 * Do the rendering for a glDrawElements or glDrawRangeElements call after
843 * we've validated buffer bounds, etc.
844 */
845 static void
846 vbo_validated_drawrangeelements(struct gl_context *ctx, GLenum mode,
847 GLboolean index_bounds_valid,
848 GLuint start, GLuint end,
849 GLsizei count, GLenum type,
850 const GLvoid * indices,
851 GLint basevertex, GLuint numInstances,
852 GLuint baseInstance)
853 {
854 struct vbo_context *vbo = vbo_context(ctx);
855 struct _mesa_index_buffer ib;
856 struct _mesa_prim prim;
857
858 if (skip_draw_elements(ctx, count, indices))
859 return;
860
861 vbo_bind_arrays(ctx);
862
863 ib.count = count;
864 ib.index_size = vbo_sizeof_ib_type(type);
865 ib.obj = ctx->Array.VAO->IndexBufferObj;
866 ib.ptr = indices;
867
868 prim.begin = 1;
869 prim.end = 1;
870 prim.weak = 0;
871 prim.pad = 0;
872 prim.mode = mode;
873 prim.start = 0;
874 prim.count = count;
875 prim.indexed = 1;
876 prim.is_indirect = 0;
877 prim.basevertex = basevertex;
878 prim.num_instances = numInstances;
879 prim.base_instance = baseInstance;
880 prim.draw_id = 0;
881
882 /* Need to give special consideration to rendering a range of
883 * indices starting somewhere above zero. Typically the
884 * application is issuing multiple DrawRangeElements() to draw
885 * successive primitives layed out linearly in the vertex arrays.
886 * Unless the vertex arrays are all in a VBO (or locked as with
887 * CVA), the OpenGL semantics imply that we need to re-read or
888 * re-upload the vertex data on each draw call.
889 *
890 * In the case of hardware tnl, we want to avoid starting the
891 * upload at zero, as it will mean every draw call uploads an
892 * increasing amount of not-used vertex data. Worse - in the
893 * software tnl module, all those vertices might be transformed and
894 * lit but never rendered.
895 *
896 * If we just upload or transform the vertices in start..end,
897 * however, the indices will be incorrect.
898 *
899 * At this level, we don't know exactly what the requirements of
900 * the backend are going to be, though it will likely boil down to
901 * either:
902 *
903 * 1) Do nothing, everything is in a VBO and is processed once
904 * only.
905 *
906 * 2) Adjust the indices and vertex arrays so that start becomes
907 * zero.
908 *
909 * Rather than doing anything here, I'll provide a helper function
910 * for the latter case elsewhere.
911 */
912
913 vbo->draw_prims(ctx, &prim, 1, &ib,
914 index_bounds_valid, start, end, NULL, 0, NULL);
915
916 if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH) {
917 _mesa_flush(ctx);
918 }
919 }
920
921
922 /**
923 * Called by glDrawRangeElementsBaseVertex() in immediate mode.
924 */
925 static void GLAPIENTRY
926 vbo_exec_DrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end,
927 GLsizei count, GLenum type,
928 const GLvoid * indices, GLint basevertex)
929 {
930 static GLuint warnCount = 0;
931 GLboolean index_bounds_valid = GL_TRUE;
932
933 /* This is only useful to catch invalid values in the "end" parameter
934 * like ~0.
935 */
936 GLuint max_element = 2 * 1000 * 1000 * 1000; /* just a big number */
937
938 GET_CURRENT_CONTEXT(ctx);
939
940 if (MESA_VERBOSE & VERBOSE_DRAW)
941 _mesa_debug(ctx,
942 "glDrawRangeElementsBaseVertex(%s, %u, %u, %d, %s, %p, %d)\n",
943 _mesa_enum_to_string(mode), start, end, count,
944 _mesa_enum_to_string(type), indices, basevertex);
945
946 if (!_mesa_validate_DrawRangeElements(ctx, mode, start, end, count,
947 type, indices))
948 return;
949
950 if ((int) end + basevertex < 0 || start + basevertex >= max_element) {
951 /* The application requested we draw using a range of indices that's
952 * outside the bounds of the current VBO. This is invalid and appears
953 * to give undefined results. The safest thing to do is to simply
954 * ignore the range, in case the application botched their range tracking
955 * but did provide valid indices. Also issue a warning indicating that
956 * the application is broken.
957 */
958 if (warnCount++ < 10) {
959 _mesa_warning(ctx, "glDrawRangeElements(start %u, end %u, "
960 "basevertex %d, count %d, type 0x%x, indices=%p):\n"
961 "\trange is outside VBO bounds (max=%u); ignoring.\n"
962 "\tThis should be fixed in the application.",
963 start, end, basevertex, count, type, indices,
964 max_element - 1);
965 }
966 index_bounds_valid = GL_FALSE;
967 }
968
969 /* NOTE: It's important that 'end' is a reasonable value.
970 * in _tnl_draw_prims(), we use end to determine how many vertices
971 * to transform. If it's too large, we can unnecessarily split prims
972 * or we can read/write out of memory in several different places!
973 */
974
975 /* Catch/fix some potential user errors */
976 if (type == GL_UNSIGNED_BYTE) {
977 start = MIN2(start, 0xff);
978 end = MIN2(end, 0xff);
979 }
980 else if (type == GL_UNSIGNED_SHORT) {
981 start = MIN2(start, 0xffff);
982 end = MIN2(end, 0xffff);
983 }
984
985 if (0) {
986 printf("glDraw[Range]Elements{,BaseVertex}"
987 "(start %u, end %u, type 0x%x, count %d) ElemBuf %u, "
988 "base %d\n",
989 start, end, type, count,
990 ctx->Array.VAO->IndexBufferObj->Name, basevertex);
991 }
992
993 if ((int) start + basevertex < 0 || end + basevertex >= max_element)
994 index_bounds_valid = GL_FALSE;
995
996 #if 0
997 check_draw_elements_data(ctx, count, type, indices, basevertex);
998 #else
999 (void) check_draw_elements_data;
1000 #endif
1001
1002 vbo_validated_drawrangeelements(ctx, mode, index_bounds_valid, start, end,
1003 count, type, indices, basevertex, 1, 0);
1004 }
1005
1006
1007 /**
1008 * Called by glDrawRangeElements() in immediate mode.
1009 */
1010 static void GLAPIENTRY
1011 vbo_exec_DrawRangeElements(GLenum mode, GLuint start, GLuint end,
1012 GLsizei count, GLenum type, const GLvoid * indices)
1013 {
1014 if (MESA_VERBOSE & VERBOSE_DRAW) {
1015 GET_CURRENT_CONTEXT(ctx);
1016 _mesa_debug(ctx,
1017 "glDrawRangeElements(%s, %u, %u, %d, %s, %p)\n",
1018 _mesa_enum_to_string(mode), start, end, count,
1019 _mesa_enum_to_string(type), indices);
1020 }
1021
1022 vbo_exec_DrawRangeElementsBaseVertex(mode, start, end, count, type,
1023 indices, 0);
1024 }
1025
1026
1027 /**
1028 * Called by glDrawElements() in immediate mode.
1029 */
1030 static void GLAPIENTRY
1031 vbo_exec_DrawElements(GLenum mode, GLsizei count, GLenum type,
1032 const GLvoid * indices)
1033 {
1034 GET_CURRENT_CONTEXT(ctx);
1035
1036 if (MESA_VERBOSE & VERBOSE_DRAW)
1037 _mesa_debug(ctx, "glDrawElements(%s, %u, %s, %p)\n",
1038 _mesa_enum_to_string(mode), count,
1039 _mesa_enum_to_string(type), indices);
1040
1041 if (_mesa_is_no_error_enabled(ctx)) {
1042 FLUSH_CURRENT(ctx, 0);
1043
1044 if (ctx->NewState)
1045 _mesa_update_state(ctx);
1046 } else {
1047 if (!_mesa_validate_DrawElements(ctx, mode, count, type, indices))
1048 return;
1049 }
1050
1051 vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, ~0, ~0,
1052 count, type, indices, 0, 1, 0);
1053 }
1054
1055
1056 /**
1057 * Called by glDrawElementsBaseVertex() in immediate mode.
1058 */
1059 static void GLAPIENTRY
1060 vbo_exec_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
1061 const GLvoid * indices, GLint basevertex)
1062 {
1063 GET_CURRENT_CONTEXT(ctx);
1064
1065 if (MESA_VERBOSE & VERBOSE_DRAW)
1066 _mesa_debug(ctx, "glDrawElements(%s, %u, %s, %p)\n",
1067 _mesa_enum_to_string(mode), count,
1068 _mesa_enum_to_string(type), indices);
1069
1070 if (_mesa_is_no_error_enabled(ctx)) {
1071 FLUSH_CURRENT(ctx, 0);
1072
1073 if (ctx->NewState)
1074 _mesa_update_state(ctx);
1075 } else {
1076 if (!_mesa_validate_DrawElements(ctx, mode, count, type, indices))
1077 return;
1078 }
1079
1080 vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, ~0, ~0,
1081 count, type, indices, basevertex, 1, 0);
1082 }
1083
1084
1085 /**
1086 * Called by glDrawElementsInstanced() in immediate mode.
1087 */
1088 static void GLAPIENTRY
1089 vbo_exec_DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type,
1090 const GLvoid * indices, GLsizei numInstances)
1091 {
1092 GET_CURRENT_CONTEXT(ctx);
1093
1094 if (MESA_VERBOSE & VERBOSE_DRAW)
1095 _mesa_debug(ctx, "glDrawElements(%s, %u, %s, %p)\n",
1096 _mesa_enum_to_string(mode), count,
1097 _mesa_enum_to_string(type), indices);
1098
1099 if (_mesa_is_no_error_enabled(ctx)) {
1100 FLUSH_CURRENT(ctx, 0);
1101
1102 if (ctx->NewState)
1103 _mesa_update_state(ctx);
1104 } else {
1105 if (!_mesa_validate_DrawElementsInstanced(ctx, mode, count, type,
1106 indices, numInstances))
1107 return;
1108 }
1109
1110 vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, ~0, ~0,
1111 count, type, indices, 0, numInstances, 0);
1112 }
1113
1114
1115 /**
1116 * Called by glDrawElementsInstancedBaseVertex() in immediate mode.
1117 */
1118 static void GLAPIENTRY
1119 vbo_exec_DrawElementsInstancedBaseVertex(GLenum mode, GLsizei count,
1120 GLenum type, const GLvoid * indices,
1121 GLsizei numInstances,
1122 GLint basevertex)
1123 {
1124 GET_CURRENT_CONTEXT(ctx);
1125
1126 if (MESA_VERBOSE & VERBOSE_DRAW)
1127 _mesa_debug(ctx,
1128 "glDrawElementsInstancedBaseVertex"
1129 "(%s, %d, %s, %p, %d; %d)\n",
1130 _mesa_enum_to_string(mode), count,
1131 _mesa_enum_to_string(type), indices,
1132 numInstances, basevertex);
1133
1134 if (_mesa_is_no_error_enabled(ctx)) {
1135 FLUSH_CURRENT(ctx, 0);
1136
1137 if (ctx->NewState)
1138 _mesa_update_state(ctx);
1139 } else {
1140 if (!_mesa_validate_DrawElementsInstanced(ctx, mode, count, type,
1141 indices, numInstances))
1142 return;
1143 }
1144
1145 vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, ~0, ~0,
1146 count, type, indices,
1147 basevertex, numInstances, 0);
1148 }
1149
1150
1151 /**
1152 * Called by glDrawElementsInstancedBaseInstance() in immediate mode.
1153 */
1154 static void GLAPIENTRY
1155 vbo_exec_DrawElementsInstancedBaseInstance(GLenum mode, GLsizei count,
1156 GLenum type,
1157 const GLvoid *indices,
1158 GLsizei numInstances,
1159 GLuint baseInstance)
1160 {
1161 GET_CURRENT_CONTEXT(ctx);
1162
1163 if (MESA_VERBOSE & VERBOSE_DRAW)
1164 _mesa_debug(ctx,
1165 "glDrawElementsInstancedBaseInstance"
1166 "(%s, %d, %s, %p, %d, %d)\n",
1167 _mesa_enum_to_string(mode), count,
1168 _mesa_enum_to_string(type), indices,
1169 numInstances, baseInstance);
1170
1171 if (_mesa_is_no_error_enabled(ctx)) {
1172 FLUSH_CURRENT(ctx, 0);
1173
1174 if (ctx->NewState)
1175 _mesa_update_state(ctx);
1176 } else {
1177 if (!_mesa_validate_DrawElementsInstanced(ctx, mode, count, type,
1178 indices, numInstances))
1179 return;
1180 }
1181
1182 vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, ~0, ~0,
1183 count, type, indices, 0, numInstances,
1184 baseInstance);
1185 }
1186
1187
1188 /**
1189 * Called by glDrawElementsInstancedBaseVertexBaseInstance() in immediate mode.
1190 */
1191 static void GLAPIENTRY
1192 vbo_exec_DrawElementsInstancedBaseVertexBaseInstance(GLenum mode,
1193 GLsizei count,
1194 GLenum type,
1195 const GLvoid *indices,
1196 GLsizei numInstances,
1197 GLint basevertex,
1198 GLuint baseInstance)
1199 {
1200 GET_CURRENT_CONTEXT(ctx);
1201
1202 if (MESA_VERBOSE & VERBOSE_DRAW)
1203 _mesa_debug(ctx,
1204 "glDrawElementsInstancedBaseVertexBaseInstance"
1205 "(%s, %d, %s, %p, %d, %d, %d)\n",
1206 _mesa_enum_to_string(mode), count,
1207 _mesa_enum_to_string(type), indices,
1208 numInstances, basevertex, baseInstance);
1209
1210 if (_mesa_is_no_error_enabled(ctx)) {
1211 FLUSH_CURRENT(ctx, 0);
1212
1213 if (ctx->NewState)
1214 _mesa_update_state(ctx);
1215 } else {
1216 if (!_mesa_validate_DrawElementsInstanced(ctx, mode, count, type,
1217 indices, numInstances))
1218 return;
1219 }
1220
1221 vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, ~0, ~0,
1222 count, type, indices, basevertex,
1223 numInstances, baseInstance);
1224 }
1225
1226
1227 /**
1228 * Inner support for both _mesa_MultiDrawElements() and
1229 * _mesa_MultiDrawRangeElements().
1230 * This does the actual rendering after we've checked array indexes, etc.
1231 */
1232 static void
1233 vbo_validated_multidrawelements(struct gl_context *ctx, GLenum mode,
1234 const GLsizei *count, GLenum type,
1235 const GLvoid * const *indices,
1236 GLsizei primcount, const GLint *basevertex)
1237 {
1238 struct vbo_context *vbo = vbo_context(ctx);
1239 struct _mesa_index_buffer ib;
1240 struct _mesa_prim *prim;
1241 unsigned int index_type_size = vbo_sizeof_ib_type(type);
1242 uintptr_t min_index_ptr, max_index_ptr;
1243 GLboolean fallback = GL_FALSE;
1244 int i;
1245
1246 if (primcount == 0)
1247 return;
1248
1249 prim = calloc(primcount, sizeof(*prim));
1250 if (prim == NULL) {
1251 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMultiDrawElements");
1252 return;
1253 }
1254
1255 vbo_bind_arrays(ctx);
1256
1257 min_index_ptr = (uintptr_t) indices[0];
1258 max_index_ptr = 0;
1259 for (i = 0; i < primcount; i++) {
1260 min_index_ptr = MIN2(min_index_ptr, (uintptr_t) indices[i]);
1261 max_index_ptr = MAX2(max_index_ptr, (uintptr_t) indices[i] +
1262 index_type_size * count[i]);
1263 }
1264
1265 /* Check if we can handle this thing as a bunch of index offsets from the
1266 * same index pointer. If we can't, then we have to fall back to doing
1267 * a draw_prims per primitive.
1268 * Check that the difference between each prim's indexes is a multiple of
1269 * the index/element size.
1270 */
1271 if (index_type_size != 1) {
1272 for (i = 0; i < primcount; i++) {
1273 if ((((uintptr_t) indices[i] - min_index_ptr) % index_type_size) !=
1274 0) {
1275 fallback = GL_TRUE;
1276 break;
1277 }
1278 }
1279 }
1280
1281 /* Draw primitives individually if one count is zero, so we can easily skip
1282 * that primitive.
1283 */
1284 for (i = 0; i < primcount; i++) {
1285 if (count[i] == 0) {
1286 fallback = GL_TRUE;
1287 break;
1288 }
1289 }
1290
1291 /* If the index buffer isn't in a VBO, then treating the application's
1292 * subranges of the index buffer as one large index buffer may lead to
1293 * us reading unmapped memory.
1294 */
1295 if (!_mesa_is_bufferobj(ctx->Array.VAO->IndexBufferObj))
1296 fallback = GL_TRUE;
1297
1298 if (!fallback) {
1299 ib.count = (max_index_ptr - min_index_ptr) / index_type_size;
1300 ib.index_size = vbo_sizeof_ib_type(type);
1301 ib.obj = ctx->Array.VAO->IndexBufferObj;
1302 ib.ptr = (void *) min_index_ptr;
1303
1304 for (i = 0; i < primcount; i++) {
1305 prim[i].begin = (i == 0);
1306 prim[i].end = (i == primcount - 1);
1307 prim[i].weak = 0;
1308 prim[i].pad = 0;
1309 prim[i].mode = mode;
1310 prim[i].start =
1311 ((uintptr_t) indices[i] - min_index_ptr) / index_type_size;
1312 prim[i].count = count[i];
1313 prim[i].indexed = 1;
1314 prim[i].num_instances = 1;
1315 prim[i].base_instance = 0;
1316 prim[i].draw_id = i;
1317 prim[i].is_indirect = 0;
1318 if (basevertex != NULL)
1319 prim[i].basevertex = basevertex[i];
1320 else
1321 prim[i].basevertex = 0;
1322 }
1323
1324 vbo->draw_prims(ctx, prim, primcount, &ib,
1325 false, 0, ~0, NULL, 0, NULL);
1326 }
1327 else {
1328 /* render one prim at a time */
1329 for (i = 0; i < primcount; i++) {
1330 if (count[i] == 0)
1331 continue;
1332 ib.count = count[i];
1333 ib.index_size = vbo_sizeof_ib_type(type);
1334 ib.obj = ctx->Array.VAO->IndexBufferObj;
1335 ib.ptr = indices[i];
1336
1337 prim[0].begin = 1;
1338 prim[0].end = 1;
1339 prim[0].weak = 0;
1340 prim[0].pad = 0;
1341 prim[0].mode = mode;
1342 prim[0].start = 0;
1343 prim[0].count = count[i];
1344 prim[0].indexed = 1;
1345 prim[0].num_instances = 1;
1346 prim[0].base_instance = 0;
1347 prim[0].draw_id = i;
1348 prim[0].is_indirect = 0;
1349 if (basevertex != NULL)
1350 prim[0].basevertex = basevertex[i];
1351 else
1352 prim[0].basevertex = 0;
1353
1354 vbo->draw_prims(ctx, prim, 1, &ib, false, 0, ~0, NULL, 0, NULL);
1355 }
1356 }
1357
1358 free(prim);
1359
1360 if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH) {
1361 _mesa_flush(ctx);
1362 }
1363 }
1364
1365
1366 static void GLAPIENTRY
1367 vbo_exec_MultiDrawElements(GLenum mode,
1368 const GLsizei *count, GLenum type,
1369 const GLvoid * const *indices, GLsizei primcount)
1370 {
1371 GET_CURRENT_CONTEXT(ctx);
1372
1373 if (!_mesa_validate_MultiDrawElements(ctx, mode, count, type, indices,
1374 primcount))
1375 return;
1376
1377 if (skip_validated_draw(ctx))
1378 return;
1379
1380 vbo_validated_multidrawelements(ctx, mode, count, type, indices, primcount,
1381 NULL);
1382 }
1383
1384
1385 static void GLAPIENTRY
1386 vbo_exec_MultiDrawElementsBaseVertex(GLenum mode,
1387 const GLsizei *count, GLenum type,
1388 const GLvoid * const *indices,
1389 GLsizei primcount,
1390 const GLsizei *basevertex)
1391 {
1392 GET_CURRENT_CONTEXT(ctx);
1393
1394 if (!_mesa_validate_MultiDrawElements(ctx, mode, count, type, indices,
1395 primcount))
1396 return;
1397
1398 if (skip_validated_draw(ctx))
1399 return;
1400
1401 vbo_validated_multidrawelements(ctx, mode, count, type, indices, primcount,
1402 basevertex);
1403 }
1404
1405
1406 static void
1407 vbo_draw_transform_feedback(struct gl_context *ctx, GLenum mode,
1408 struct gl_transform_feedback_object *obj,
1409 GLuint stream, GLuint numInstances)
1410 {
1411 struct vbo_context *vbo = vbo_context(ctx);
1412 struct _mesa_prim prim;
1413
1414 if (!_mesa_validate_DrawTransformFeedback(ctx, mode, obj, stream,
1415 numInstances)) {
1416 return;
1417 }
1418
1419 if (ctx->Driver.GetTransformFeedbackVertexCount &&
1420 (ctx->Const.AlwaysUseGetTransformFeedbackVertexCount ||
1421 !_mesa_all_varyings_in_vbos(ctx->Array.VAO))) {
1422 GLsizei n =
1423 ctx->Driver.GetTransformFeedbackVertexCount(ctx, obj, stream);
1424 vbo_draw_arrays(ctx, mode, 0, n, numInstances, 0, 0);
1425 return;
1426 }
1427
1428 if (skip_validated_draw(ctx))
1429 return;
1430
1431 vbo_bind_arrays(ctx);
1432
1433 /* init most fields to zero */
1434 memset(&prim, 0, sizeof(prim));
1435 prim.begin = 1;
1436 prim.end = 1;
1437 prim.mode = mode;
1438 prim.num_instances = numInstances;
1439 prim.base_instance = 0;
1440 prim.is_indirect = 0;
1441
1442 /* Maybe we should do some primitive splitting for primitive restart
1443 * (like in DrawArrays), but we have no way to know how many vertices
1444 * will be rendered. */
1445
1446 vbo->draw_prims(ctx, &prim, 1, NULL, GL_FALSE, 0, ~0, obj, stream, NULL);
1447
1448 if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH) {
1449 _mesa_flush(ctx);
1450 }
1451 }
1452
1453
1454 /**
1455 * Like DrawArrays, but take the count from a transform feedback object.
1456 * \param mode GL_POINTS, GL_LINES, GL_TRIANGLE_STRIP, etc.
1457 * \param name the transform feedback object
1458 * User still has to setup of the vertex attribute info with
1459 * glVertexPointer, glColorPointer, etc.
1460 * Part of GL_ARB_transform_feedback2.
1461 */
1462 static void GLAPIENTRY
1463 vbo_exec_DrawTransformFeedback(GLenum mode, GLuint name)
1464 {
1465 GET_CURRENT_CONTEXT(ctx);
1466 struct gl_transform_feedback_object *obj =
1467 _mesa_lookup_transform_feedback_object(ctx, name);
1468
1469 if (MESA_VERBOSE & VERBOSE_DRAW)
1470 _mesa_debug(ctx, "glDrawTransformFeedback(%s, %d)\n",
1471 _mesa_enum_to_string(mode), name);
1472
1473 vbo_draw_transform_feedback(ctx, mode, obj, 0, 1);
1474 }
1475
1476
1477 static void GLAPIENTRY
1478 vbo_exec_DrawTransformFeedbackStream(GLenum mode, GLuint name, GLuint stream)
1479 {
1480 GET_CURRENT_CONTEXT(ctx);
1481 struct gl_transform_feedback_object *obj =
1482 _mesa_lookup_transform_feedback_object(ctx, name);
1483
1484 if (MESA_VERBOSE & VERBOSE_DRAW)
1485 _mesa_debug(ctx, "glDrawTransformFeedbackStream(%s, %u, %u)\n",
1486 _mesa_enum_to_string(mode), name, stream);
1487
1488 vbo_draw_transform_feedback(ctx, mode, obj, stream, 1);
1489 }
1490
1491
1492 static void GLAPIENTRY
1493 vbo_exec_DrawTransformFeedbackInstanced(GLenum mode, GLuint name,
1494 GLsizei primcount)
1495 {
1496 GET_CURRENT_CONTEXT(ctx);
1497 struct gl_transform_feedback_object *obj =
1498 _mesa_lookup_transform_feedback_object(ctx, name);
1499
1500 if (MESA_VERBOSE & VERBOSE_DRAW)
1501 _mesa_debug(ctx, "glDrawTransformFeedbackInstanced(%s, %d)\n",
1502 _mesa_enum_to_string(mode), name);
1503
1504 vbo_draw_transform_feedback(ctx, mode, obj, 0, primcount);
1505 }
1506
1507
1508 static void GLAPIENTRY
1509 vbo_exec_DrawTransformFeedbackStreamInstanced(GLenum mode, GLuint name,
1510 GLuint stream,
1511 GLsizei primcount)
1512 {
1513 GET_CURRENT_CONTEXT(ctx);
1514 struct gl_transform_feedback_object *obj =
1515 _mesa_lookup_transform_feedback_object(ctx, name);
1516
1517 if (MESA_VERBOSE & VERBOSE_DRAW)
1518 _mesa_debug(ctx, "glDrawTransformFeedbackStreamInstanced"
1519 "(%s, %u, %u, %i)\n",
1520 _mesa_enum_to_string(mode), name, stream, primcount);
1521
1522 vbo_draw_transform_feedback(ctx, mode, obj, stream, primcount);
1523 }
1524
1525
1526 static void
1527 vbo_validated_drawarraysindirect(struct gl_context *ctx,
1528 GLenum mode, const GLvoid *indirect)
1529 {
1530 struct vbo_context *vbo = vbo_context(ctx);
1531
1532 vbo_bind_arrays(ctx);
1533
1534 vbo->draw_indirect_prims(ctx, mode,
1535 ctx->DrawIndirectBuffer, (GLsizeiptr) indirect,
1536 1 /* draw_count */ , 16 /* stride */ ,
1537 NULL, 0, NULL);
1538
1539 if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH)
1540 _mesa_flush(ctx);
1541 }
1542
1543
1544 static void
1545 vbo_validated_multidrawarraysindirect(struct gl_context *ctx,
1546 GLenum mode,
1547 const GLvoid *indirect,
1548 GLsizei primcount, GLsizei stride)
1549 {
1550 struct vbo_context *vbo = vbo_context(ctx);
1551 GLsizeiptr offset = (GLsizeiptr) indirect;
1552
1553 if (primcount == 0)
1554 return;
1555
1556 vbo_bind_arrays(ctx);
1557
1558 vbo->draw_indirect_prims(ctx, mode, ctx->DrawIndirectBuffer, offset,
1559 primcount, stride, NULL, 0, NULL);
1560
1561 if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH)
1562 _mesa_flush(ctx);
1563 }
1564
1565
1566 static void
1567 vbo_validated_drawelementsindirect(struct gl_context *ctx,
1568 GLenum mode, GLenum type,
1569 const GLvoid *indirect)
1570 {
1571 struct vbo_context *vbo = vbo_context(ctx);
1572 struct _mesa_index_buffer ib;
1573
1574 vbo_bind_arrays(ctx);
1575
1576 ib.count = 0; /* unknown */
1577 ib.index_size = vbo_sizeof_ib_type(type);
1578 ib.obj = ctx->Array.VAO->IndexBufferObj;
1579 ib.ptr = NULL;
1580
1581 vbo->draw_indirect_prims(ctx, mode,
1582 ctx->DrawIndirectBuffer, (GLsizeiptr) indirect,
1583 1 /* draw_count */ , 20 /* stride */ ,
1584 NULL, 0, &ib);
1585
1586 if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH)
1587 _mesa_flush(ctx);
1588 }
1589
1590
1591 static void
1592 vbo_validated_multidrawelementsindirect(struct gl_context *ctx,
1593 GLenum mode, GLenum type,
1594 const GLvoid *indirect,
1595 GLsizei primcount, GLsizei stride)
1596 {
1597 struct vbo_context *vbo = vbo_context(ctx);
1598 struct _mesa_index_buffer ib;
1599 GLsizeiptr offset = (GLsizeiptr) indirect;
1600
1601 if (primcount == 0)
1602 return;
1603
1604 vbo_bind_arrays(ctx);
1605
1606 /* NOTE: IndexBufferObj is guaranteed to be a VBO. */
1607
1608 ib.count = 0; /* unknown */
1609 ib.index_size = vbo_sizeof_ib_type(type);
1610 ib.obj = ctx->Array.VAO->IndexBufferObj;
1611 ib.ptr = NULL;
1612
1613 vbo->draw_indirect_prims(ctx, mode,
1614 ctx->DrawIndirectBuffer, offset,
1615 primcount, stride, NULL, 0, &ib);
1616
1617 if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH)
1618 _mesa_flush(ctx);
1619 }
1620
1621
1622 /**
1623 * Like [Multi]DrawArrays/Elements, but they take most arguments from
1624 * a buffer object.
1625 */
1626 static void GLAPIENTRY
1627 vbo_exec_DrawArraysIndirect(GLenum mode, const GLvoid *indirect)
1628 {
1629 GET_CURRENT_CONTEXT(ctx);
1630
1631 if (MESA_VERBOSE & VERBOSE_DRAW)
1632 _mesa_debug(ctx, "glDrawArraysIndirect(%s, %p)\n",
1633 _mesa_enum_to_string(mode), indirect);
1634
1635 if (_mesa_is_no_error_enabled(ctx)) {
1636 FLUSH_CURRENT(ctx, 0);
1637
1638 if (ctx->NewState)
1639 _mesa_update_state(ctx);
1640 } else {
1641 if (!_mesa_validate_DrawArraysIndirect(ctx, mode, indirect))
1642 return;
1643 }
1644
1645 if (skip_validated_draw(ctx))
1646 return;
1647
1648 vbo_validated_drawarraysindirect(ctx, mode, indirect);
1649 }
1650
1651
1652 static void GLAPIENTRY
1653 vbo_exec_DrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect)
1654 {
1655 GET_CURRENT_CONTEXT(ctx);
1656
1657 if (MESA_VERBOSE & VERBOSE_DRAW)
1658 _mesa_debug(ctx, "glDrawElementsIndirect(%s, %s, %p)\n",
1659 _mesa_enum_to_string(mode),
1660 _mesa_enum_to_string(type), indirect);
1661
1662 if (_mesa_is_no_error_enabled(ctx)) {
1663 FLUSH_CURRENT(ctx, 0);
1664
1665 if (ctx->NewState)
1666 _mesa_update_state(ctx);
1667 } else {
1668 if (!_mesa_validate_DrawElementsIndirect(ctx, mode, type, indirect))
1669 return;
1670 }
1671
1672 if (skip_validated_draw(ctx))
1673 return;
1674
1675 vbo_validated_drawelementsindirect(ctx, mode, type, indirect);
1676 }
1677
1678
1679 static void GLAPIENTRY
1680 vbo_exec_MultiDrawArraysIndirect(GLenum mode, const GLvoid *indirect,
1681 GLsizei primcount, GLsizei stride)
1682 {
1683 GET_CURRENT_CONTEXT(ctx);
1684
1685 if (MESA_VERBOSE & VERBOSE_DRAW)
1686 _mesa_debug(ctx, "glMultiDrawArraysIndirect(%s, %p, %i, %i)\n",
1687 _mesa_enum_to_string(mode), indirect, primcount, stride);
1688
1689 /* If <stride> is zero, the array elements are treated as tightly packed. */
1690 if (stride == 0)
1691 stride = 4 * sizeof(GLuint); /* sizeof(DrawArraysIndirectCommand) */
1692
1693 if (!_mesa_validate_MultiDrawArraysIndirect(ctx, mode, indirect,
1694 primcount, stride))
1695 return;
1696
1697 if (skip_validated_draw(ctx))
1698 return;
1699
1700 vbo_validated_multidrawarraysindirect(ctx, mode, indirect,
1701 primcount, stride);
1702 }
1703
1704
1705 static void GLAPIENTRY
1706 vbo_exec_MultiDrawElementsIndirect(GLenum mode, GLenum type,
1707 const GLvoid *indirect,
1708 GLsizei primcount, GLsizei stride)
1709 {
1710 GET_CURRENT_CONTEXT(ctx);
1711
1712 if (MESA_VERBOSE & VERBOSE_DRAW)
1713 _mesa_debug(ctx, "glMultiDrawElementsIndirect(%s, %s, %p, %i, %i)\n",
1714 _mesa_enum_to_string(mode),
1715 _mesa_enum_to_string(type), indirect, primcount, stride);
1716
1717 /* If <stride> is zero, the array elements are treated as tightly packed. */
1718 if (stride == 0)
1719 stride = 5 * sizeof(GLuint); /* sizeof(DrawElementsIndirectCommand) */
1720
1721 if (!_mesa_validate_MultiDrawElementsIndirect(ctx, mode, type, indirect,
1722 primcount, stride))
1723 return;
1724
1725 if (skip_validated_draw(ctx))
1726 return;
1727
1728 vbo_validated_multidrawelementsindirect(ctx, mode, type, indirect,
1729 primcount, stride);
1730 }
1731
1732
1733 static void
1734 vbo_validated_multidrawarraysindirectcount(struct gl_context *ctx,
1735 GLenum mode,
1736 GLintptr indirect,
1737 GLintptr drawcount,
1738 GLsizei maxdrawcount,
1739 GLsizei stride)
1740 {
1741 struct vbo_context *vbo = vbo_context(ctx);
1742 GLsizeiptr offset = indirect;
1743
1744 if (maxdrawcount == 0)
1745 return;
1746
1747 vbo_bind_arrays(ctx);
1748
1749 vbo->draw_indirect_prims(ctx, mode,
1750 ctx->DrawIndirectBuffer, offset,
1751 maxdrawcount, stride,
1752 ctx->ParameterBuffer, drawcount, NULL);
1753
1754 if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH)
1755 _mesa_flush(ctx);
1756 }
1757
1758
1759 static void
1760 vbo_validated_multidrawelementsindirectcount(struct gl_context *ctx,
1761 GLenum mode, GLenum type,
1762 GLintptr indirect,
1763 GLintptr drawcount,
1764 GLsizei maxdrawcount,
1765 GLsizei stride)
1766 {
1767 struct vbo_context *vbo = vbo_context(ctx);
1768 struct _mesa_index_buffer ib;
1769 GLsizeiptr offset = (GLsizeiptr) indirect;
1770
1771 if (maxdrawcount == 0)
1772 return;
1773
1774 vbo_bind_arrays(ctx);
1775
1776 /* NOTE: IndexBufferObj is guaranteed to be a VBO. */
1777
1778 ib.count = 0; /* unknown */
1779 ib.index_size = vbo_sizeof_ib_type(type);
1780 ib.obj = ctx->Array.VAO->IndexBufferObj;
1781 ib.ptr = NULL;
1782
1783 vbo->draw_indirect_prims(ctx, mode,
1784 ctx->DrawIndirectBuffer, offset,
1785 maxdrawcount, stride,
1786 ctx->ParameterBuffer, drawcount, &ib);
1787
1788 if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH)
1789 _mesa_flush(ctx);
1790 }
1791
1792
1793 static void GLAPIENTRY
1794 vbo_exec_MultiDrawArraysIndirectCount(GLenum mode, GLintptr indirect,
1795 GLintptr drawcount,
1796 GLsizei maxdrawcount, GLsizei stride)
1797 {
1798 GET_CURRENT_CONTEXT(ctx);
1799
1800 if (MESA_VERBOSE & VERBOSE_DRAW)
1801 _mesa_debug(ctx, "glMultiDrawArraysIndirectCountARB"
1802 "(%s, %lx, %lx, %i, %i)\n",
1803 _mesa_enum_to_string(mode),
1804 (unsigned long) indirect, (unsigned long) drawcount,
1805 maxdrawcount, stride);
1806
1807 /* If <stride> is zero, the array elements are treated as tightly packed. */
1808 if (stride == 0)
1809 stride = 4 * sizeof(GLuint); /* sizeof(DrawArraysIndirectCommand) */
1810
1811 if (!_mesa_validate_MultiDrawArraysIndirectCount(ctx, mode,
1812 indirect, drawcount,
1813 maxdrawcount, stride))
1814 return;
1815
1816 if (skip_validated_draw(ctx))
1817 return;
1818
1819 vbo_validated_multidrawarraysindirectcount(ctx, mode, indirect, drawcount,
1820 maxdrawcount, stride);
1821 }
1822
1823
1824 static void GLAPIENTRY
1825 vbo_exec_MultiDrawElementsIndirectCount(GLenum mode, GLenum type,
1826 GLintptr indirect, GLintptr drawcount,
1827 GLsizei maxdrawcount, GLsizei stride)
1828 {
1829 GET_CURRENT_CONTEXT(ctx);
1830
1831 if (MESA_VERBOSE & VERBOSE_DRAW)
1832 _mesa_debug(ctx, "glMultiDrawElementsIndirectCountARB"
1833 "(%s, %s, %lx, %lx, %i, %i)\n",
1834 _mesa_enum_to_string(mode), _mesa_enum_to_string(type),
1835 (unsigned long) indirect, (unsigned long) drawcount,
1836 maxdrawcount, stride);
1837
1838 /* If <stride> is zero, the array elements are treated as tightly packed. */
1839 if (stride == 0)
1840 stride = 5 * sizeof(GLuint); /* sizeof(DrawElementsIndirectCommand) */
1841
1842 if (!_mesa_validate_MultiDrawElementsIndirectCount(ctx, mode, type,
1843 indirect, drawcount,
1844 maxdrawcount, stride))
1845 return;
1846
1847 if (skip_validated_draw(ctx))
1848 return;
1849
1850 vbo_validated_multidrawelementsindirectcount(ctx, mode, type, indirect,
1851 drawcount, maxdrawcount,
1852 stride);
1853 }
1854
1855
1856 /**
1857 * Initialize the dispatch table with the VBO functions for drawing.
1858 */
1859 void
1860 vbo_initialize_exec_dispatch(const struct gl_context *ctx,
1861 struct _glapi_table *exec)
1862 {
1863 SET_DrawArrays(exec, vbo_exec_DrawArrays);
1864 SET_DrawElements(exec, vbo_exec_DrawElements);
1865
1866 if (_mesa_is_desktop_gl(ctx) || _mesa_is_gles3(ctx)) {
1867 SET_DrawRangeElements(exec, vbo_exec_DrawRangeElements);
1868 }
1869
1870 SET_MultiDrawArrays(exec, vbo_exec_MultiDrawArrays);
1871 SET_MultiDrawElementsEXT(exec, vbo_exec_MultiDrawElements);
1872
1873 if (ctx->API == API_OPENGL_COMPAT) {
1874 SET_Rectf(exec, vbo_exec_Rectf);
1875 SET_EvalMesh1(exec, vbo_exec_EvalMesh1);
1876 SET_EvalMesh2(exec, vbo_exec_EvalMesh2);
1877 }
1878
1879 if (ctx->API != API_OPENGLES &&
1880 ctx->Extensions.ARB_draw_elements_base_vertex) {
1881 SET_DrawElementsBaseVertex(exec, vbo_exec_DrawElementsBaseVertex);
1882 SET_MultiDrawElementsBaseVertex(exec,
1883 vbo_exec_MultiDrawElementsBaseVertex);
1884
1885 if (_mesa_is_desktop_gl(ctx) || _mesa_is_gles3(ctx)) {
1886 SET_DrawRangeElementsBaseVertex(exec,
1887 vbo_exec_DrawRangeElementsBaseVertex);
1888 SET_DrawElementsInstancedBaseVertex(exec,
1889 vbo_exec_DrawElementsInstancedBaseVertex);
1890 }
1891 }
1892
1893 if (_mesa_is_desktop_gl(ctx) || _mesa_is_gles3(ctx)) {
1894 SET_DrawArraysInstancedBaseInstance(exec,
1895 vbo_exec_DrawArraysInstancedBaseInstance);
1896 SET_DrawElementsInstancedBaseInstance(exec,
1897 vbo_exec_DrawElementsInstancedBaseInstance);
1898 SET_DrawElementsInstancedBaseVertexBaseInstance(exec,
1899 vbo_exec_DrawElementsInstancedBaseVertexBaseInstance);
1900 }
1901
1902 if (ctx->API == API_OPENGL_CORE || _mesa_is_gles31(ctx)) {
1903 SET_DrawArraysIndirect(exec, vbo_exec_DrawArraysIndirect);
1904 SET_DrawElementsIndirect(exec, vbo_exec_DrawElementsIndirect);
1905 }
1906
1907 if (ctx->API == API_OPENGL_CORE) {
1908 SET_MultiDrawArraysIndirect(exec, vbo_exec_MultiDrawArraysIndirect);
1909 SET_MultiDrawElementsIndirect(exec, vbo_exec_MultiDrawElementsIndirect);
1910 SET_MultiDrawArraysIndirectCountARB(exec,
1911 vbo_exec_MultiDrawArraysIndirectCount);
1912 SET_MultiDrawElementsIndirectCountARB(exec,
1913 vbo_exec_MultiDrawElementsIndirectCount);
1914 }
1915
1916 if (_mesa_is_desktop_gl(ctx) || _mesa_is_gles3(ctx)) {
1917 SET_DrawArraysInstancedARB(exec, vbo_exec_DrawArraysInstanced);
1918 SET_DrawElementsInstancedARB(exec, vbo_exec_DrawElementsInstanced);
1919 }
1920
1921 if (_mesa_is_desktop_gl(ctx)) {
1922 SET_DrawTransformFeedback(exec, vbo_exec_DrawTransformFeedback);
1923 SET_DrawTransformFeedbackStream(exec,
1924 vbo_exec_DrawTransformFeedbackStream);
1925 SET_DrawTransformFeedbackInstanced(exec,
1926 vbo_exec_DrawTransformFeedbackInstanced);
1927 SET_DrawTransformFeedbackStreamInstanced(exec,
1928 vbo_exec_DrawTransformFeedbackStreamInstanced);
1929 }
1930 }
1931
1932
1933
1934 /**
1935 * The following functions are only used for OpenGL ES 1/2 support.
1936 * And some aren't even supported (yet) in ES 1/2.
1937 */
1938
1939
1940 void GLAPIENTRY
1941 _mesa_DrawArrays(GLenum mode, GLint first, GLsizei count)
1942 {
1943 vbo_exec_DrawArrays(mode, first, count);
1944 }
1945
1946
1947 void GLAPIENTRY
1948 _mesa_DrawArraysInstanced(GLenum mode, GLint first, GLsizei count,
1949 GLsizei primcount)
1950 {
1951 vbo_exec_DrawArraysInstanced(mode, first, count, primcount);
1952 }
1953
1954
1955 void GLAPIENTRY
1956 _mesa_DrawElements(GLenum mode, GLsizei count, GLenum type,
1957 const GLvoid *indices)
1958 {
1959 vbo_exec_DrawElements(mode, count, type, indices);
1960 }
1961
1962
1963 void GLAPIENTRY
1964 _mesa_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
1965 const GLvoid *indices, GLint basevertex)
1966 {
1967 vbo_exec_DrawElementsBaseVertex(mode, count, type, indices, basevertex);
1968 }
1969
1970
1971 void GLAPIENTRY
1972 _mesa_DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count,
1973 GLenum type, const GLvoid * indices)
1974 {
1975 vbo_exec_DrawRangeElements(mode, start, end, count, type, indices);
1976 }
1977
1978
1979 void GLAPIENTRY
1980 _mesa_DrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end,
1981 GLsizei count, GLenum type,
1982 const GLvoid *indices, GLint basevertex)
1983 {
1984 vbo_exec_DrawRangeElementsBaseVertex(mode, start, end, count, type,
1985 indices, basevertex);
1986 }
1987
1988
1989 void GLAPIENTRY
1990 _mesa_MultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type,
1991 const GLvoid ** indices, GLsizei primcount)
1992 {
1993 vbo_exec_MultiDrawElements(mode, count, type, indices, primcount);
1994 }
1995
1996
1997 void GLAPIENTRY
1998 _mesa_MultiDrawElementsBaseVertex(GLenum mode,
1999 const GLsizei *count, GLenum type,
2000 const GLvoid **indices, GLsizei primcount,
2001 const GLint *basevertex)
2002 {
2003 vbo_exec_MultiDrawElementsBaseVertex(mode, count, type, indices,
2004 primcount, basevertex);
2005 }
2006
2007
2008 void GLAPIENTRY
2009 _mesa_DrawTransformFeedback(GLenum mode, GLuint name)
2010 {
2011 vbo_exec_DrawTransformFeedback(mode, name);
2012 }