vbo: rename reset_attrfv() to vbo_reset_all_attr()
[mesa.git] / src / mesa / vbo / vbo_exec_api.c
1 /**************************************************************************
2
3 Copyright 2002-2008 VMware, Inc.
4
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 "Software"),
9 to deal in the Software without restriction, including without limitation
10 on the rights to use, copy, modify, merge, publish, distribute, sub
11 license, and/or sell copies of the Software, and to permit persons to whom
12 the Software is furnished to do so, subject to the following conditions:
13
14 The above copyright notice and this permission notice (including the next
15 paragraph) shall be included in all copies or substantial portions of the
16 Software.
17
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
21 VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
22 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
23 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
24 USE OR OTHER DEALINGS IN THE SOFTWARE.
25
26 **************************************************************************/
27
28 /*
29 * Authors:
30 * Keith Whitwell <keithw@vmware.com>
31 */
32
33 #include "main/glheader.h"
34 #include "main/bufferobj.h"
35 #include "main/context.h"
36 #include "main/macros.h"
37 #include "main/vtxfmt.h"
38 #include "main/dlist.h"
39 #include "main/eval.h"
40 #include "main/state.h"
41 #include "main/light.h"
42 #include "main/api_arrayelt.h"
43 #include "main/api_validate.h"
44 #include "main/dispatch.h"
45 #include "util/bitscan.h"
46
47 #include "vbo_context.h"
48 #include "vbo_noop.h"
49
50
51 #ifdef ERROR
52 #undef ERROR
53 #endif
54
55
56 /** ID/name for immediate-mode VBO */
57 #define IMM_BUFFER_NAME 0xaabbccdd
58
59
60 static void
61 vbo_reset_all_attr(struct vbo_exec_context *exec);
62
63
64 /**
65 * Close off the last primitive, execute the buffer, restart the
66 * primitive. This is called when we fill a vertex buffer before
67 * hitting glEnd.
68 */
69 static void vbo_exec_wrap_buffers( struct vbo_exec_context *exec )
70 {
71 if (exec->vtx.prim_count == 0) {
72 exec->vtx.copied.nr = 0;
73 exec->vtx.vert_count = 0;
74 exec->vtx.buffer_ptr = exec->vtx.buffer_map;
75 }
76 else {
77 struct _mesa_prim *last_prim = &exec->vtx.prim[exec->vtx.prim_count - 1];
78 const GLuint last_begin = last_prim->begin;
79 GLuint last_count;
80
81 if (_mesa_inside_begin_end(exec->ctx)) {
82 last_prim->count = exec->vtx.vert_count - last_prim->start;
83 }
84
85 last_count = last_prim->count;
86
87 /* Special handling for wrapping GL_LINE_LOOP */
88 if (last_prim->mode == GL_LINE_LOOP &&
89 last_count > 0 &&
90 !last_prim->end) {
91 /* draw this section of the incomplete line loop as a line strip */
92 last_prim->mode = GL_LINE_STRIP;
93 if (!last_prim->begin) {
94 /* This is not the first section of the line loop, so don't
95 * draw the 0th vertex. We're saving it until we draw the
96 * very last section of the loop.
97 */
98 last_prim->start++;
99 last_prim->count--;
100 }
101 }
102
103 /* Execute the buffer and save copied vertices.
104 */
105 if (exec->vtx.vert_count)
106 vbo_exec_vtx_flush( exec, GL_FALSE );
107 else {
108 exec->vtx.prim_count = 0;
109 exec->vtx.copied.nr = 0;
110 }
111
112 /* Emit a glBegin to start the new list.
113 */
114 assert(exec->vtx.prim_count == 0);
115
116 if (_mesa_inside_begin_end(exec->ctx)) {
117 exec->vtx.prim[0].mode = exec->ctx->Driver.CurrentExecPrimitive;
118 exec->vtx.prim[0].begin = 0;
119 exec->vtx.prim[0].end = 0;
120 exec->vtx.prim[0].start = 0;
121 exec->vtx.prim[0].count = 0;
122 exec->vtx.prim_count++;
123
124 if (exec->vtx.copied.nr == last_count)
125 exec->vtx.prim[0].begin = last_begin;
126 }
127 }
128 }
129
130
131 /**
132 * Deal with buffer wrapping where provoked by the vertex buffer
133 * filling up, as opposed to upgrade_vertex().
134 */
135 static void
136 vbo_exec_vtx_wrap(struct vbo_exec_context *exec)
137 {
138 unsigned numComponents;
139
140 /* Run pipeline on current vertices, copy wrapped vertices
141 * to exec->vtx.copied.
142 */
143 vbo_exec_wrap_buffers( exec );
144
145 if (!exec->vtx.buffer_ptr) {
146 /* probably ran out of memory earlier when allocating the VBO */
147 return;
148 }
149
150 /* Copy stored stored vertices to start of new list.
151 */
152 assert(exec->vtx.max_vert - exec->vtx.vert_count > exec->vtx.copied.nr);
153
154 numComponents = exec->vtx.copied.nr * exec->vtx.vertex_size;
155 memcpy(exec->vtx.buffer_ptr,
156 exec->vtx.copied.buffer,
157 numComponents * sizeof(fi_type));
158 exec->vtx.buffer_ptr += numComponents;
159 exec->vtx.vert_count += exec->vtx.copied.nr;
160
161 exec->vtx.copied.nr = 0;
162 }
163
164
165 /**
166 * Copy the active vertex's values to the ctx->Current fields.
167 */
168 static void vbo_exec_copy_to_current( struct vbo_exec_context *exec )
169 {
170 struct gl_context *ctx = exec->ctx;
171 struct vbo_context *vbo = vbo_context(ctx);
172 GLbitfield64 enabled = exec->vtx.enabled & (~BITFIELD64_BIT(VBO_ATTRIB_POS));
173
174 while (enabled) {
175 const int i = u_bit_scan64(&enabled);
176
177 /* Note: the exec->vtx.current[i] pointers point into the
178 * ctx->Current.Attrib and ctx->Light.Material.Attrib arrays.
179 */
180 GLfloat *current = (GLfloat *)vbo->currval[i].Ptr;
181 fi_type tmp[8]; /* space for doubles */
182 int dmul = exec->vtx.attrtype[i] == GL_DOUBLE ? 2 : 1;
183
184 assert(exec->vtx.attrsz[i]);
185
186 if (exec->vtx.attrtype[i] == GL_DOUBLE) {
187 memset(tmp, 0, sizeof(tmp));
188 memcpy(tmp, exec->vtx.attrptr[i], exec->vtx.attrsz[i] * sizeof(GLfloat));
189 } else {
190 COPY_CLEAN_4V_TYPE_AS_UNION(tmp,
191 exec->vtx.attrsz[i],
192 exec->vtx.attrptr[i],
193 exec->vtx.attrtype[i]);
194 }
195
196 if (exec->vtx.attrtype[i] != vbo->currval[i].Type ||
197 memcmp(current, tmp, 4 * sizeof(GLfloat) * dmul) != 0) {
198 memcpy(current, tmp, 4 * sizeof(GLfloat) * dmul);
199
200 /* Given that we explicitly state size here, there is no need
201 * for the COPY_CLEAN above, could just copy 16 bytes and be
202 * done. The only problem is when Mesa accesses ctx->Current
203 * directly.
204 */
205 /* Size here is in components - not bytes */
206 vbo->currval[i].Size = exec->vtx.attrsz[i] / dmul;
207 vbo->currval[i]._ElementSize = vbo->currval[i].Size * sizeof(GLfloat) * dmul;
208 vbo->currval[i].Type = exec->vtx.attrtype[i];
209 vbo->currval[i].Integer =
210 vbo_attrtype_to_integer_flag(exec->vtx.attrtype[i]);
211 vbo->currval[i].Doubles =
212 vbo_attrtype_to_double_flag(exec->vtx.attrtype[i]);
213
214 /* This triggers rather too much recalculation of Mesa state
215 * that doesn't get used (eg light positions).
216 */
217 if (i >= VBO_ATTRIB_MAT_FRONT_AMBIENT &&
218 i <= VBO_ATTRIB_MAT_BACK_INDEXES)
219 ctx->NewState |= _NEW_LIGHT;
220
221 ctx->NewState |= _NEW_CURRENT_ATTRIB;
222 }
223 }
224
225 /* Colormaterial -- this kindof sucks.
226 */
227 if (ctx->Light.ColorMaterialEnabled &&
228 exec->vtx.attrsz[VBO_ATTRIB_COLOR0]) {
229 _mesa_update_color_material(ctx,
230 ctx->Current.Attrib[VBO_ATTRIB_COLOR0]);
231 }
232 }
233
234
235 /**
236 * Copy current vertex attribute values into the current vertex.
237 */
238 static void
239 vbo_exec_copy_from_current(struct vbo_exec_context *exec)
240 {
241 struct gl_context *ctx = exec->ctx;
242 struct vbo_context *vbo = vbo_context(ctx);
243 GLint i;
244
245 for (i = VBO_ATTRIB_POS + 1; i < VBO_ATTRIB_MAX; i++) {
246 if (exec->vtx.attrtype[i] == GL_DOUBLE) {
247 memcpy(exec->vtx.attrptr[i], vbo->currval[i].Ptr, exec->vtx.attrsz[i] * sizeof(GLfloat));
248 } else {
249 const fi_type *current = (fi_type *) vbo->currval[i].Ptr;
250 switch (exec->vtx.attrsz[i]) {
251 case 4: exec->vtx.attrptr[i][3] = current[3];
252 case 3: exec->vtx.attrptr[i][2] = current[2];
253 case 2: exec->vtx.attrptr[i][1] = current[1];
254 case 1: exec->vtx.attrptr[i][0] = current[0];
255 break;
256 }
257 }
258 }
259 }
260
261
262 /**
263 * Flush existing data, set new attrib size, replay copied vertices.
264 * This is called when we transition from a small vertex attribute size
265 * to a larger one. Ex: glTexCoord2f -> glTexCoord4f.
266 * We need to go back over the previous 2-component texcoords and insert
267 * zero and one values.
268 */
269 static void
270 vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context *exec,
271 GLuint attr, GLuint newSize )
272 {
273 struct gl_context *ctx = exec->ctx;
274 struct vbo_context *vbo = vbo_context(ctx);
275 const GLint lastcount = exec->vtx.vert_count;
276 fi_type *old_attrptr[VBO_ATTRIB_MAX];
277 const GLuint old_vtx_size = exec->vtx.vertex_size; /* floats per vertex */
278 const GLuint oldSize = exec->vtx.attrsz[attr];
279 GLuint i;
280
281 /* Run pipeline on current vertices, copy wrapped vertices
282 * to exec->vtx.copied.
283 */
284 vbo_exec_wrap_buffers( exec );
285
286 if (unlikely(exec->vtx.copied.nr)) {
287 /* We're in the middle of a primitive, keep the old vertex
288 * format around to be able to translate the copied vertices to
289 * the new format.
290 */
291 memcpy(old_attrptr, exec->vtx.attrptr, sizeof(old_attrptr));
292 }
293
294 if (unlikely(oldSize)) {
295 /* Do a COPY_TO_CURRENT to ensure back-copying works for the
296 * case when the attribute already exists in the vertex and is
297 * having its size increased.
298 */
299 vbo_exec_copy_to_current( exec );
300 }
301
302 /* Heuristic: Attempt to isolate attributes received outside
303 * begin/end so that they don't bloat the vertices.
304 */
305 if (!_mesa_inside_begin_end(ctx) &&
306 !oldSize && lastcount > 8 && exec->vtx.vertex_size) {
307 vbo_exec_copy_to_current( exec );
308 vbo_reset_all_attr(exec);
309 }
310
311 /* Fix up sizes:
312 */
313 exec->vtx.attrsz[attr] = newSize;
314 exec->vtx.vertex_size += newSize - oldSize;
315 exec->vtx.max_vert = vbo_compute_max_verts(exec);
316 exec->vtx.vert_count = 0;
317 exec->vtx.buffer_ptr = exec->vtx.buffer_map;
318 exec->vtx.enabled |= BITFIELD64_BIT(attr);
319
320 if (unlikely(oldSize)) {
321 /* Size changed, recalculate all the attrptr[] values
322 */
323 fi_type *tmp = exec->vtx.vertex;
324
325 for (i = 0 ; i < VBO_ATTRIB_MAX ; i++) {
326 if (exec->vtx.attrsz[i]) {
327 exec->vtx.attrptr[i] = tmp;
328 tmp += exec->vtx.attrsz[i];
329 }
330 else
331 exec->vtx.attrptr[i] = NULL; /* will not be dereferenced */
332 }
333
334 /* Copy from current to repopulate the vertex with correct
335 * values.
336 */
337 vbo_exec_copy_from_current( exec );
338 }
339 else {
340 /* Just have to append the new attribute at the end */
341 exec->vtx.attrptr[attr] = exec->vtx.vertex +
342 exec->vtx.vertex_size - newSize;
343 }
344
345 /* Replay stored vertices to translate them
346 * to new format here.
347 *
348 * -- No need to replay - just copy piecewise
349 */
350 if (unlikely(exec->vtx.copied.nr)) {
351 fi_type *data = exec->vtx.copied.buffer;
352 fi_type *dest = exec->vtx.buffer_ptr;
353
354 assert(exec->vtx.buffer_ptr == exec->vtx.buffer_map);
355
356 for (i = 0 ; i < exec->vtx.copied.nr ; i++) {
357 GLbitfield64 enabled = exec->vtx.enabled;
358 while (enabled) {
359 const int j = u_bit_scan64(&enabled);
360 GLuint sz = exec->vtx.attrsz[j];
361 GLint old_offset = old_attrptr[j] - exec->vtx.vertex;
362 GLint new_offset = exec->vtx.attrptr[j] - exec->vtx.vertex;
363
364 assert(sz);
365
366 if (j == attr) {
367 if (oldSize) {
368 fi_type tmp[4];
369 COPY_CLEAN_4V_TYPE_AS_UNION(tmp, oldSize,
370 data + old_offset,
371 exec->vtx.attrtype[j]);
372 COPY_SZ_4V(dest + new_offset, newSize, tmp);
373 } else {
374 fi_type *current = (fi_type *)vbo->currval[j].Ptr;
375 COPY_SZ_4V(dest + new_offset, sz, current);
376 }
377 }
378 else {
379 COPY_SZ_4V(dest + new_offset, sz, data + old_offset);
380 }
381 }
382
383 data += old_vtx_size;
384 dest += exec->vtx.vertex_size;
385 }
386
387 exec->vtx.buffer_ptr = dest;
388 exec->vtx.vert_count += exec->vtx.copied.nr;
389 exec->vtx.copied.nr = 0;
390 }
391 }
392
393
394 /**
395 * This is when a vertex attribute transitions to a different size.
396 * For example, we saw a bunch of glTexCoord2f() calls and now we got a
397 * glTexCoord4f() call. We promote the array from size=2 to size=4.
398 * \param newSize size of new vertex (number of 32-bit words).
399 */
400 static void
401 vbo_exec_fixup_vertex(struct gl_context *ctx, GLuint attr,
402 GLuint newSize, GLenum newType)
403 {
404 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
405
406 if (newSize > exec->vtx.attrsz[attr] ||
407 newType != exec->vtx.attrtype[attr]) {
408 /* New size is larger. Need to flush existing vertices and get
409 * an enlarged vertex format.
410 */
411 vbo_exec_wrap_upgrade_vertex( exec, attr, newSize );
412 }
413 else if (newSize < exec->vtx.active_sz[attr]) {
414 GLuint i;
415 const fi_type *id =
416 vbo_get_default_vals_as_union(exec->vtx.attrtype[attr]);
417
418 /* New size is smaller - just need to fill in some
419 * zeros. Don't need to flush or wrap.
420 */
421 for (i = newSize; i <= exec->vtx.attrsz[attr]; i++)
422 exec->vtx.attrptr[attr][i-1] = id[i-1];
423 }
424
425 exec->vtx.active_sz[attr] = newSize;
426
427 /* Does setting NeedFlush belong here? Necessitates resetting
428 * vtxfmt on each flush (otherwise flags won't get reset
429 * afterwards).
430 */
431 if (attr == 0)
432 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES;
433 }
434
435
436 /**
437 * Called upon first glVertex, glColor, glTexCoord, etc.
438 */
439 static void
440 vbo_exec_begin_vertices(struct gl_context *ctx)
441 {
442 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
443
444 vbo_exec_vtx_map( exec );
445
446 assert((ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) == 0);
447 assert(exec->begin_vertices_flags);
448
449 ctx->Driver.NeedFlush |= exec->begin_vertices_flags;
450 }
451
452
453 /**
454 * This macro is used to implement all the glVertex, glColor, glTexCoord,
455 * glVertexAttrib, etc functions.
456 * \param A attribute index
457 * \param N attribute size (1..4)
458 * \param T type (GL_FLOAT, GL_DOUBLE, GL_INT, GL_UNSIGNED_INT)
459 * \param C cast type (fi_type or double)
460 * \param V0, V1, v2, V3 attribute value
461 */
462 #define ATTR_UNION( A, N, T, C, V0, V1, V2, V3 ) \
463 do { \
464 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
465 int sz = (sizeof(C) / sizeof(GLfloat)); \
466 \
467 assert(sz == 1 || sz == 2); \
468 \
469 /* check if attribute size or type is changing */ \
470 if (unlikely(exec->vtx.active_sz[A] != N * sz) || \
471 unlikely(exec->vtx.attrtype[A] != T)) { \
472 vbo_exec_fixup_vertex(ctx, A, N * sz, T); \
473 } \
474 \
475 /* store vertex attribute in vertex buffer */ \
476 { \
477 C *dest = (C *)exec->vtx.attrptr[A]; \
478 if (N>0) dest[0] = V0; \
479 if (N>1) dest[1] = V1; \
480 if (N>2) dest[2] = V2; \
481 if (N>3) dest[3] = V3; \
482 exec->vtx.attrtype[A] = T; \
483 } \
484 \
485 if ((A) == 0) { \
486 /* This is a glVertex call */ \
487 GLuint i; \
488 \
489 if (unlikely((ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) == 0)) { \
490 vbo_exec_begin_vertices(ctx); \
491 } \
492 \
493 if (unlikely(!exec->vtx.buffer_ptr)) { \
494 vbo_exec_vtx_map(exec); \
495 } \
496 assert(exec->vtx.buffer_ptr); \
497 \
498 /* copy 32-bit words */ \
499 for (i = 0; i < exec->vtx.vertex_size; i++) \
500 exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i]; \
501 \
502 exec->vtx.buffer_ptr += exec->vtx.vertex_size; \
503 \
504 /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \
505 /* something to draw (not just updating a color or texcoord).*/ \
506 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \
507 \
508 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
509 vbo_exec_vtx_wrap( exec ); \
510 } else { \
511 /* we now have accumulated per-vertex attributes */ \
512 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
513 } \
514 } while (0)
515
516 #define ERROR(err) _mesa_error( ctx, err, __func__ )
517 #define TAG(x) vbo_##x
518
519 #include "vbo_attrib_tmp.h"
520
521
522
523 /**
524 * Execute a glMaterial call. Note that if GL_COLOR_MATERIAL is enabled,
525 * this may be a (partial) no-op.
526 */
527 static void GLAPIENTRY
528 vbo_Materialfv(GLenum face, GLenum pname, const GLfloat *params)
529 {
530 GLbitfield updateMats;
531 GET_CURRENT_CONTEXT(ctx);
532
533 /* This function should be a no-op when it tries to update material
534 * attributes which are currently tracking glColor via glColorMaterial.
535 * The updateMats var will be a mask of the MAT_BIT_FRONT/BACK_x bits
536 * indicating which material attributes can actually be updated below.
537 */
538 if (ctx->Light.ColorMaterialEnabled) {
539 updateMats = ~ctx->Light._ColorMaterialBitmask;
540 }
541 else {
542 /* GL_COLOR_MATERIAL is disabled so don't skip any material updates */
543 updateMats = ALL_MATERIAL_BITS;
544 }
545
546 if (ctx->API == API_OPENGL_COMPAT && face == GL_FRONT) {
547 updateMats &= FRONT_MATERIAL_BITS;
548 }
549 else if (ctx->API == API_OPENGL_COMPAT && face == GL_BACK) {
550 updateMats &= BACK_MATERIAL_BITS;
551 }
552 else if (face != GL_FRONT_AND_BACK) {
553 _mesa_error(ctx, GL_INVALID_ENUM, "glMaterial(invalid face)");
554 return;
555 }
556
557 switch (pname) {
558 case GL_EMISSION:
559 if (updateMats & MAT_BIT_FRONT_EMISSION)
560 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_EMISSION, 4, params);
561 if (updateMats & MAT_BIT_BACK_EMISSION)
562 MAT_ATTR(VBO_ATTRIB_MAT_BACK_EMISSION, 4, params);
563 break;
564 case GL_AMBIENT:
565 if (updateMats & MAT_BIT_FRONT_AMBIENT)
566 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT, 4, params);
567 if (updateMats & MAT_BIT_BACK_AMBIENT)
568 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT, 4, params);
569 break;
570 case GL_DIFFUSE:
571 if (updateMats & MAT_BIT_FRONT_DIFFUSE)
572 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE, 4, params);
573 if (updateMats & MAT_BIT_BACK_DIFFUSE)
574 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE, 4, params);
575 break;
576 case GL_SPECULAR:
577 if (updateMats & MAT_BIT_FRONT_SPECULAR)
578 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SPECULAR, 4, params);
579 if (updateMats & MAT_BIT_BACK_SPECULAR)
580 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SPECULAR, 4, params);
581 break;
582 case GL_SHININESS:
583 if (*params < 0 || *params > ctx->Const.MaxShininess) {
584 _mesa_error(ctx, GL_INVALID_VALUE,
585 "glMaterial(invalid shininess: %f out range [0, %f])",
586 *params, ctx->Const.MaxShininess);
587 return;
588 }
589 if (updateMats & MAT_BIT_FRONT_SHININESS)
590 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SHININESS, 1, params);
591 if (updateMats & MAT_BIT_BACK_SHININESS)
592 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SHININESS, 1, params);
593 break;
594 case GL_COLOR_INDEXES:
595 if (ctx->API != API_OPENGL_COMPAT) {
596 _mesa_error(ctx, GL_INVALID_ENUM, "glMaterialfv(pname)");
597 return;
598 }
599 if (updateMats & MAT_BIT_FRONT_INDEXES)
600 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_INDEXES, 3, params);
601 if (updateMats & MAT_BIT_BACK_INDEXES)
602 MAT_ATTR(VBO_ATTRIB_MAT_BACK_INDEXES, 3, params);
603 break;
604 case GL_AMBIENT_AND_DIFFUSE:
605 if (updateMats & MAT_BIT_FRONT_AMBIENT)
606 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT, 4, params);
607 if (updateMats & MAT_BIT_FRONT_DIFFUSE)
608 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE, 4, params);
609 if (updateMats & MAT_BIT_BACK_AMBIENT)
610 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT, 4, params);
611 if (updateMats & MAT_BIT_BACK_DIFFUSE)
612 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE, 4, params);
613 break;
614 default:
615 _mesa_error(ctx, GL_INVALID_ENUM, "glMaterialfv(pname)");
616 return;
617 }
618 }
619
620
621 /**
622 * Flush (draw) vertices.
623 * \param unmap - leave VBO unmapped after flushing?
624 */
625 static void
626 vbo_exec_FlushVertices_internal(struct vbo_exec_context *exec, GLboolean unmap)
627 {
628 if (exec->vtx.vert_count || unmap) {
629 vbo_exec_vtx_flush( exec, unmap );
630 }
631
632 if (exec->vtx.vertex_size) {
633 vbo_exec_copy_to_current( exec );
634 vbo_reset_all_attr(exec);
635 }
636 }
637
638
639 static void GLAPIENTRY vbo_exec_EvalCoord1f( GLfloat u )
640 {
641 GET_CURRENT_CONTEXT( ctx );
642 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
643
644 {
645 GLint i;
646 if (exec->eval.recalculate_maps)
647 vbo_exec_eval_update( exec );
648
649 for (i = 0; i <= VBO_ATTRIB_TEX7; i++) {
650 if (exec->eval.map1[i].map)
651 if (exec->vtx.active_sz[i] != exec->eval.map1[i].sz)
652 vbo_exec_fixup_vertex( ctx, i, exec->eval.map1[i].sz, GL_FLOAT );
653 }
654 }
655
656
657 memcpy( exec->vtx.copied.buffer, exec->vtx.vertex,
658 exec->vtx.vertex_size * sizeof(GLfloat));
659
660 vbo_exec_do_EvalCoord1f( exec, u );
661
662 memcpy( exec->vtx.vertex, exec->vtx.copied.buffer,
663 exec->vtx.vertex_size * sizeof(GLfloat));
664 }
665
666 static void GLAPIENTRY vbo_exec_EvalCoord2f( GLfloat u, GLfloat v )
667 {
668 GET_CURRENT_CONTEXT( ctx );
669 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
670
671 {
672 GLint i;
673 if (exec->eval.recalculate_maps)
674 vbo_exec_eval_update( exec );
675
676 for (i = 0; i <= VBO_ATTRIB_TEX7; i++) {
677 if (exec->eval.map2[i].map)
678 if (exec->vtx.active_sz[i] != exec->eval.map2[i].sz)
679 vbo_exec_fixup_vertex( ctx, i, exec->eval.map2[i].sz, GL_FLOAT );
680 }
681
682 if (ctx->Eval.AutoNormal)
683 if (exec->vtx.active_sz[VBO_ATTRIB_NORMAL] != 3)
684 vbo_exec_fixup_vertex( ctx, VBO_ATTRIB_NORMAL, 3, GL_FLOAT );
685 }
686
687 memcpy( exec->vtx.copied.buffer, exec->vtx.vertex,
688 exec->vtx.vertex_size * sizeof(GLfloat));
689
690 vbo_exec_do_EvalCoord2f( exec, u, v );
691
692 memcpy( exec->vtx.vertex, exec->vtx.copied.buffer,
693 exec->vtx.vertex_size * sizeof(GLfloat));
694 }
695
696 static void GLAPIENTRY vbo_exec_EvalCoord1fv( const GLfloat *u )
697 {
698 vbo_exec_EvalCoord1f( u[0] );
699 }
700
701 static void GLAPIENTRY vbo_exec_EvalCoord2fv( const GLfloat *u )
702 {
703 vbo_exec_EvalCoord2f( u[0], u[1] );
704 }
705
706 static void GLAPIENTRY vbo_exec_EvalPoint1( GLint i )
707 {
708 GET_CURRENT_CONTEXT( ctx );
709 GLfloat du = ((ctx->Eval.MapGrid1u2 - ctx->Eval.MapGrid1u1) /
710 (GLfloat) ctx->Eval.MapGrid1un);
711 GLfloat u = i * du + ctx->Eval.MapGrid1u1;
712
713 vbo_exec_EvalCoord1f( u );
714 }
715
716
717 static void GLAPIENTRY vbo_exec_EvalPoint2( GLint i, GLint j )
718 {
719 GET_CURRENT_CONTEXT( ctx );
720 GLfloat du = ((ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1) /
721 (GLfloat) ctx->Eval.MapGrid2un);
722 GLfloat dv = ((ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1) /
723 (GLfloat) ctx->Eval.MapGrid2vn);
724 GLfloat u = i * du + ctx->Eval.MapGrid2u1;
725 GLfloat v = j * dv + ctx->Eval.MapGrid2v1;
726
727 vbo_exec_EvalCoord2f( u, v );
728 }
729
730
731 /**
732 * Called via glBegin.
733 */
734 static void GLAPIENTRY vbo_exec_Begin( GLenum mode )
735 {
736 GET_CURRENT_CONTEXT( ctx );
737 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
738 int i;
739
740 if (_mesa_inside_begin_end(ctx)) {
741 _mesa_error(ctx, GL_INVALID_OPERATION, "glBegin");
742 return;
743 }
744
745 if (!_mesa_valid_prim_mode(ctx, mode, "glBegin")) {
746 return;
747 }
748
749 vbo_draw_method(vbo_context(ctx), DRAW_BEGIN_END);
750
751 if (ctx->NewState) {
752 _mesa_update_state( ctx );
753
754 CALL_Begin(ctx->Exec, (mode));
755 return;
756 }
757
758 if (!_mesa_valid_to_render(ctx, "glBegin")) {
759 return;
760 }
761
762 /* Heuristic: attempt to isolate attributes occurring outside
763 * begin/end pairs.
764 */
765 if (exec->vtx.vertex_size && !exec->vtx.attrsz[0])
766 vbo_exec_FlushVertices_internal(exec, GL_FALSE);
767
768 i = exec->vtx.prim_count++;
769 exec->vtx.prim[i].mode = mode;
770 exec->vtx.prim[i].begin = 1;
771 exec->vtx.prim[i].end = 0;
772 exec->vtx.prim[i].indexed = 0;
773 exec->vtx.prim[i].weak = 0;
774 exec->vtx.prim[i].pad = 0;
775 exec->vtx.prim[i].start = exec->vtx.vert_count;
776 exec->vtx.prim[i].count = 0;
777 exec->vtx.prim[i].num_instances = 1;
778 exec->vtx.prim[i].base_instance = 0;
779 exec->vtx.prim[i].is_indirect = 0;
780
781 ctx->Driver.CurrentExecPrimitive = mode;
782
783 ctx->Exec = ctx->BeginEnd;
784 /* We may have been called from a display list, in which case we should
785 * leave dlist.c's dispatch table in place.
786 */
787 if (ctx->CurrentDispatch == ctx->OutsideBeginEnd) {
788 ctx->CurrentDispatch = ctx->BeginEnd;
789 _glapi_set_dispatch(ctx->CurrentDispatch);
790 } else {
791 assert(ctx->CurrentDispatch == ctx->Save);
792 }
793 }
794
795
796 /**
797 * Try to merge / concatenate the two most recent VBO primitives.
798 */
799 static void
800 try_vbo_merge(struct vbo_exec_context *exec)
801 {
802 struct _mesa_prim *cur = &exec->vtx.prim[exec->vtx.prim_count - 1];
803
804 assert(exec->vtx.prim_count >= 1);
805
806 vbo_try_prim_conversion(cur);
807
808 if (exec->vtx.prim_count >= 2) {
809 struct _mesa_prim *prev = &exec->vtx.prim[exec->vtx.prim_count - 2];
810 assert(prev == cur - 1);
811
812 if (vbo_can_merge_prims(prev, cur)) {
813 assert(cur->begin);
814 assert(cur->end);
815 assert(prev->begin);
816 assert(prev->end);
817 vbo_merge_prims(prev, cur);
818 exec->vtx.prim_count--; /* drop the last primitive */
819 }
820 }
821 }
822
823
824 /**
825 * Called via glEnd.
826 */
827 static void GLAPIENTRY vbo_exec_End( void )
828 {
829 GET_CURRENT_CONTEXT( ctx );
830 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
831
832 if (!_mesa_inside_begin_end(ctx)) {
833 _mesa_error(ctx, GL_INVALID_OPERATION, "glEnd");
834 return;
835 }
836
837 ctx->Exec = ctx->OutsideBeginEnd;
838 if (ctx->CurrentDispatch == ctx->BeginEnd) {
839 ctx->CurrentDispatch = ctx->OutsideBeginEnd;
840 _glapi_set_dispatch(ctx->CurrentDispatch);
841 }
842
843 if (exec->vtx.prim_count > 0) {
844 /* close off current primitive */
845 struct _mesa_prim *last_prim = &exec->vtx.prim[exec->vtx.prim_count - 1];
846
847 last_prim->end = 1;
848 last_prim->count = exec->vtx.vert_count - last_prim->start;
849
850 /* Special handling for GL_LINE_LOOP */
851 if (last_prim->mode == GL_LINE_LOOP && last_prim->begin == 0) {
852 /* We're finishing drawing a line loop. Append 0th vertex onto
853 * end of vertex buffer so we can draw it as a line strip.
854 */
855 const fi_type *src = exec->vtx.buffer_map +
856 last_prim->start * exec->vtx.vertex_size;
857 fi_type *dst = exec->vtx.buffer_map +
858 exec->vtx.vert_count * exec->vtx.vertex_size;
859
860 /* copy 0th vertex to end of buffer */
861 memcpy(dst, src, exec->vtx.vertex_size * sizeof(fi_type));
862
863 last_prim->start++; /* skip vertex0 */
864 /* note that last_prim->count stays unchanged */
865 last_prim->mode = GL_LINE_STRIP;
866
867 /* Increment the vertex count so the next primitive doesn't
868 * overwrite the last vertex which we just added.
869 */
870 exec->vtx.vert_count++;
871 exec->vtx.buffer_ptr += exec->vtx.vertex_size;
872 }
873
874 try_vbo_merge(exec);
875 }
876
877 ctx->Driver.CurrentExecPrimitive = PRIM_OUTSIDE_BEGIN_END;
878
879 if (exec->vtx.prim_count == VBO_MAX_PRIM)
880 vbo_exec_vtx_flush( exec, GL_FALSE );
881
882 if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH) {
883 _mesa_flush(ctx);
884 }
885 }
886
887
888 /**
889 * Called via glPrimitiveRestartNV()
890 */
891 static void GLAPIENTRY
892 vbo_exec_PrimitiveRestartNV(void)
893 {
894 GLenum curPrim;
895 GET_CURRENT_CONTEXT( ctx );
896
897 curPrim = ctx->Driver.CurrentExecPrimitive;
898
899 if (curPrim == PRIM_OUTSIDE_BEGIN_END) {
900 _mesa_error( ctx, GL_INVALID_OPERATION, "glPrimitiveRestartNV" );
901 }
902 else {
903 vbo_exec_End();
904 vbo_exec_Begin(curPrim);
905 }
906 }
907
908
909
910 static void vbo_exec_vtxfmt_init( struct vbo_exec_context *exec )
911 {
912 struct gl_context *ctx = exec->ctx;
913 GLvertexformat *vfmt = &exec->vtxfmt;
914
915 vfmt->ArrayElement = _ae_ArrayElement;
916
917 vfmt->Begin = vbo_exec_Begin;
918 vfmt->End = vbo_exec_End;
919 vfmt->PrimitiveRestartNV = vbo_exec_PrimitiveRestartNV;
920
921 vfmt->CallList = _mesa_CallList;
922 vfmt->CallLists = _mesa_CallLists;
923
924 vfmt->EvalCoord1f = vbo_exec_EvalCoord1f;
925 vfmt->EvalCoord1fv = vbo_exec_EvalCoord1fv;
926 vfmt->EvalCoord2f = vbo_exec_EvalCoord2f;
927 vfmt->EvalCoord2fv = vbo_exec_EvalCoord2fv;
928 vfmt->EvalPoint1 = vbo_exec_EvalPoint1;
929 vfmt->EvalPoint2 = vbo_exec_EvalPoint2;
930
931 /* from attrib_tmp.h:
932 */
933 vfmt->Color3f = vbo_Color3f;
934 vfmt->Color3fv = vbo_Color3fv;
935 vfmt->Color4f = vbo_Color4f;
936 vfmt->Color4fv = vbo_Color4fv;
937 vfmt->FogCoordfEXT = vbo_FogCoordfEXT;
938 vfmt->FogCoordfvEXT = vbo_FogCoordfvEXT;
939 vfmt->MultiTexCoord1fARB = vbo_MultiTexCoord1f;
940 vfmt->MultiTexCoord1fvARB = vbo_MultiTexCoord1fv;
941 vfmt->MultiTexCoord2fARB = vbo_MultiTexCoord2f;
942 vfmt->MultiTexCoord2fvARB = vbo_MultiTexCoord2fv;
943 vfmt->MultiTexCoord3fARB = vbo_MultiTexCoord3f;
944 vfmt->MultiTexCoord3fvARB = vbo_MultiTexCoord3fv;
945 vfmt->MultiTexCoord4fARB = vbo_MultiTexCoord4f;
946 vfmt->MultiTexCoord4fvARB = vbo_MultiTexCoord4fv;
947 vfmt->Normal3f = vbo_Normal3f;
948 vfmt->Normal3fv = vbo_Normal3fv;
949 vfmt->SecondaryColor3fEXT = vbo_SecondaryColor3fEXT;
950 vfmt->SecondaryColor3fvEXT = vbo_SecondaryColor3fvEXT;
951 vfmt->TexCoord1f = vbo_TexCoord1f;
952 vfmt->TexCoord1fv = vbo_TexCoord1fv;
953 vfmt->TexCoord2f = vbo_TexCoord2f;
954 vfmt->TexCoord2fv = vbo_TexCoord2fv;
955 vfmt->TexCoord3f = vbo_TexCoord3f;
956 vfmt->TexCoord3fv = vbo_TexCoord3fv;
957 vfmt->TexCoord4f = vbo_TexCoord4f;
958 vfmt->TexCoord4fv = vbo_TexCoord4fv;
959 vfmt->Vertex2f = vbo_Vertex2f;
960 vfmt->Vertex2fv = vbo_Vertex2fv;
961 vfmt->Vertex3f = vbo_Vertex3f;
962 vfmt->Vertex3fv = vbo_Vertex3fv;
963 vfmt->Vertex4f = vbo_Vertex4f;
964 vfmt->Vertex4fv = vbo_Vertex4fv;
965
966 if (ctx->API == API_OPENGLES2) {
967 vfmt->VertexAttrib1fARB = _es_VertexAttrib1f;
968 vfmt->VertexAttrib1fvARB = _es_VertexAttrib1fv;
969 vfmt->VertexAttrib2fARB = _es_VertexAttrib2f;
970 vfmt->VertexAttrib2fvARB = _es_VertexAttrib2fv;
971 vfmt->VertexAttrib3fARB = _es_VertexAttrib3f;
972 vfmt->VertexAttrib3fvARB = _es_VertexAttrib3fv;
973 vfmt->VertexAttrib4fARB = _es_VertexAttrib4f;
974 vfmt->VertexAttrib4fvARB = _es_VertexAttrib4fv;
975 } else {
976 vfmt->VertexAttrib1fARB = vbo_VertexAttrib1fARB;
977 vfmt->VertexAttrib1fvARB = vbo_VertexAttrib1fvARB;
978 vfmt->VertexAttrib2fARB = vbo_VertexAttrib2fARB;
979 vfmt->VertexAttrib2fvARB = vbo_VertexAttrib2fvARB;
980 vfmt->VertexAttrib3fARB = vbo_VertexAttrib3fARB;
981 vfmt->VertexAttrib3fvARB = vbo_VertexAttrib3fvARB;
982 vfmt->VertexAttrib4fARB = vbo_VertexAttrib4fARB;
983 vfmt->VertexAttrib4fvARB = vbo_VertexAttrib4fvARB;
984 }
985
986 /* Note that VertexAttrib4fNV is used from dlist.c and api_arrayelt.c so
987 * they can have a single entrypoint for updating any of the legacy
988 * attribs.
989 */
990 vfmt->VertexAttrib1fNV = vbo_VertexAttrib1fNV;
991 vfmt->VertexAttrib1fvNV = vbo_VertexAttrib1fvNV;
992 vfmt->VertexAttrib2fNV = vbo_VertexAttrib2fNV;
993 vfmt->VertexAttrib2fvNV = vbo_VertexAttrib2fvNV;
994 vfmt->VertexAttrib3fNV = vbo_VertexAttrib3fNV;
995 vfmt->VertexAttrib3fvNV = vbo_VertexAttrib3fvNV;
996 vfmt->VertexAttrib4fNV = vbo_VertexAttrib4fNV;
997 vfmt->VertexAttrib4fvNV = vbo_VertexAttrib4fvNV;
998
999 /* integer-valued */
1000 vfmt->VertexAttribI1i = vbo_VertexAttribI1i;
1001 vfmt->VertexAttribI2i = vbo_VertexAttribI2i;
1002 vfmt->VertexAttribI3i = vbo_VertexAttribI3i;
1003 vfmt->VertexAttribI4i = vbo_VertexAttribI4i;
1004 vfmt->VertexAttribI2iv = vbo_VertexAttribI2iv;
1005 vfmt->VertexAttribI3iv = vbo_VertexAttribI3iv;
1006 vfmt->VertexAttribI4iv = vbo_VertexAttribI4iv;
1007
1008 /* unsigned integer-valued */
1009 vfmt->VertexAttribI1ui = vbo_VertexAttribI1ui;
1010 vfmt->VertexAttribI2ui = vbo_VertexAttribI2ui;
1011 vfmt->VertexAttribI3ui = vbo_VertexAttribI3ui;
1012 vfmt->VertexAttribI4ui = vbo_VertexAttribI4ui;
1013 vfmt->VertexAttribI2uiv = vbo_VertexAttribI2uiv;
1014 vfmt->VertexAttribI3uiv = vbo_VertexAttribI3uiv;
1015 vfmt->VertexAttribI4uiv = vbo_VertexAttribI4uiv;
1016
1017 vfmt->Materialfv = vbo_Materialfv;
1018
1019 vfmt->EdgeFlag = vbo_EdgeFlag;
1020 vfmt->Indexf = vbo_Indexf;
1021 vfmt->Indexfv = vbo_Indexfv;
1022
1023 /* ARB_vertex_type_2_10_10_10_rev */
1024 vfmt->VertexP2ui = vbo_VertexP2ui;
1025 vfmt->VertexP2uiv = vbo_VertexP2uiv;
1026 vfmt->VertexP3ui = vbo_VertexP3ui;
1027 vfmt->VertexP3uiv = vbo_VertexP3uiv;
1028 vfmt->VertexP4ui = vbo_VertexP4ui;
1029 vfmt->VertexP4uiv = vbo_VertexP4uiv;
1030
1031 vfmt->TexCoordP1ui = vbo_TexCoordP1ui;
1032 vfmt->TexCoordP1uiv = vbo_TexCoordP1uiv;
1033 vfmt->TexCoordP2ui = vbo_TexCoordP2ui;
1034 vfmt->TexCoordP2uiv = vbo_TexCoordP2uiv;
1035 vfmt->TexCoordP3ui = vbo_TexCoordP3ui;
1036 vfmt->TexCoordP3uiv = vbo_TexCoordP3uiv;
1037 vfmt->TexCoordP4ui = vbo_TexCoordP4ui;
1038 vfmt->TexCoordP4uiv = vbo_TexCoordP4uiv;
1039
1040 vfmt->MultiTexCoordP1ui = vbo_MultiTexCoordP1ui;
1041 vfmt->MultiTexCoordP1uiv = vbo_MultiTexCoordP1uiv;
1042 vfmt->MultiTexCoordP2ui = vbo_MultiTexCoordP2ui;
1043 vfmt->MultiTexCoordP2uiv = vbo_MultiTexCoordP2uiv;
1044 vfmt->MultiTexCoordP3ui = vbo_MultiTexCoordP3ui;
1045 vfmt->MultiTexCoordP3uiv = vbo_MultiTexCoordP3uiv;
1046 vfmt->MultiTexCoordP4ui = vbo_MultiTexCoordP4ui;
1047 vfmt->MultiTexCoordP4uiv = vbo_MultiTexCoordP4uiv;
1048
1049 vfmt->NormalP3ui = vbo_NormalP3ui;
1050 vfmt->NormalP3uiv = vbo_NormalP3uiv;
1051
1052 vfmt->ColorP3ui = vbo_ColorP3ui;
1053 vfmt->ColorP3uiv = vbo_ColorP3uiv;
1054 vfmt->ColorP4ui = vbo_ColorP4ui;
1055 vfmt->ColorP4uiv = vbo_ColorP4uiv;
1056
1057 vfmt->SecondaryColorP3ui = vbo_SecondaryColorP3ui;
1058 vfmt->SecondaryColorP3uiv = vbo_SecondaryColorP3uiv;
1059
1060 vfmt->VertexAttribP1ui = vbo_VertexAttribP1ui;
1061 vfmt->VertexAttribP1uiv = vbo_VertexAttribP1uiv;
1062 vfmt->VertexAttribP2ui = vbo_VertexAttribP2ui;
1063 vfmt->VertexAttribP2uiv = vbo_VertexAttribP2uiv;
1064 vfmt->VertexAttribP3ui = vbo_VertexAttribP3ui;
1065 vfmt->VertexAttribP3uiv = vbo_VertexAttribP3uiv;
1066 vfmt->VertexAttribP4ui = vbo_VertexAttribP4ui;
1067 vfmt->VertexAttribP4uiv = vbo_VertexAttribP4uiv;
1068
1069 vfmt->VertexAttribL1d = vbo_VertexAttribL1d;
1070 vfmt->VertexAttribL2d = vbo_VertexAttribL2d;
1071 vfmt->VertexAttribL3d = vbo_VertexAttribL3d;
1072 vfmt->VertexAttribL4d = vbo_VertexAttribL4d;
1073
1074 vfmt->VertexAttribL1dv = vbo_VertexAttribL1dv;
1075 vfmt->VertexAttribL2dv = vbo_VertexAttribL2dv;
1076 vfmt->VertexAttribL3dv = vbo_VertexAttribL3dv;
1077 vfmt->VertexAttribL4dv = vbo_VertexAttribL4dv;
1078 }
1079
1080
1081 /**
1082 * Tell the VBO module to use a real OpenGL vertex buffer object to
1083 * store accumulated immediate-mode vertex data.
1084 * This replaces the malloced buffer which was created in
1085 * vb_exec_vtx_init() below.
1086 */
1087 void vbo_use_buffer_objects(struct gl_context *ctx)
1088 {
1089 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
1090 /* Any buffer name but 0 can be used here since this bufferobj won't
1091 * go into the bufferobj hashtable.
1092 */
1093 GLuint bufName = IMM_BUFFER_NAME;
1094 GLenum target = GL_ARRAY_BUFFER_ARB;
1095 GLenum usage = GL_STREAM_DRAW_ARB;
1096 GLsizei size = VBO_VERT_BUFFER_SIZE;
1097
1098 /* Make sure this func is only used once */
1099 assert(exec->vtx.bufferobj == ctx->Shared->NullBufferObj);
1100
1101 _mesa_align_free(exec->vtx.buffer_map);
1102 exec->vtx.buffer_map = NULL;
1103 exec->vtx.buffer_ptr = NULL;
1104
1105 /* Allocate a real buffer object now */
1106 _mesa_reference_buffer_object(ctx, &exec->vtx.bufferobj, NULL);
1107 exec->vtx.bufferobj = ctx->Driver.NewBufferObject(ctx, bufName);
1108 if (!ctx->Driver.BufferData(ctx, target, size, NULL, usage,
1109 GL_MAP_WRITE_BIT |
1110 GL_DYNAMIC_STORAGE_BIT |
1111 GL_CLIENT_STORAGE_BIT,
1112 exec->vtx.bufferobj)) {
1113 _mesa_error(ctx, GL_OUT_OF_MEMORY, "VBO allocation");
1114 }
1115 }
1116
1117
1118 /**
1119 * If this function is called, all VBO buffers will be unmapped when
1120 * we flush.
1121 * Otherwise, if a simple command like glColor3f() is called and we flush,
1122 * the current VBO may be left mapped.
1123 */
1124 void
1125 vbo_always_unmap_buffers(struct gl_context *ctx)
1126 {
1127 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
1128 exec->begin_vertices_flags |= FLUSH_STORED_VERTICES;
1129 }
1130
1131
1132 void vbo_exec_vtx_init( struct vbo_exec_context *exec )
1133 {
1134 struct gl_context *ctx = exec->ctx;
1135 struct vbo_context *vbo = vbo_context(ctx);
1136 GLuint i;
1137
1138 /* Allocate a buffer object. Will just reuse this object
1139 * continuously, unless vbo_use_buffer_objects() is called to enable
1140 * use of real VBOs.
1141 */
1142 _mesa_reference_buffer_object(ctx,
1143 &exec->vtx.bufferobj,
1144 ctx->Shared->NullBufferObj);
1145
1146 assert(!exec->vtx.buffer_map);
1147 exec->vtx.buffer_map = _mesa_align_malloc(VBO_VERT_BUFFER_SIZE, 64);
1148 exec->vtx.buffer_ptr = exec->vtx.buffer_map;
1149
1150 vbo_exec_vtxfmt_init( exec );
1151 _mesa_noop_vtxfmt_init(&exec->vtxfmt_noop);
1152
1153 exec->vtx.enabled = 0;
1154 for (i = 0 ; i < VBO_ATTRIB_MAX ; i++) {
1155 assert(i < ARRAY_SIZE(exec->vtx.attrsz));
1156 exec->vtx.attrsz[i] = 0;
1157 assert(i < ARRAY_SIZE(exec->vtx.attrtype));
1158 exec->vtx.attrtype[i] = GL_FLOAT;
1159 assert(i < ARRAY_SIZE(exec->vtx.active_sz));
1160 exec->vtx.active_sz[i] = 0;
1161 }
1162 for (i = 0 ; i < VERT_ATTRIB_MAX; i++) {
1163 assert(i < ARRAY_SIZE(exec->vtx.inputs));
1164 assert(i < ARRAY_SIZE(exec->vtx.arrays));
1165 exec->vtx.inputs[i] = &exec->vtx.arrays[i];
1166 }
1167
1168 {
1169 struct gl_client_array *arrays = exec->vtx.arrays;
1170 unsigned i;
1171
1172 memcpy(arrays, &vbo->currval[VBO_ATTRIB_POS],
1173 VERT_ATTRIB_FF_MAX * sizeof(arrays[0]));
1174 for (i = 0; i < VERT_ATTRIB_FF_MAX; ++i) {
1175 struct gl_client_array *array;
1176 array = &arrays[VERT_ATTRIB_FF(i)];
1177 array->BufferObj = NULL;
1178 _mesa_reference_buffer_object(ctx, &array->BufferObj,
1179 vbo->currval[VBO_ATTRIB_POS+i].BufferObj);
1180 }
1181
1182 memcpy(arrays + VERT_ATTRIB_GENERIC(0),
1183 &vbo->currval[VBO_ATTRIB_GENERIC0],
1184 VERT_ATTRIB_GENERIC_MAX * sizeof(arrays[0]));
1185
1186 for (i = 0; i < VERT_ATTRIB_GENERIC_MAX; ++i) {
1187 struct gl_client_array *array;
1188 array = &arrays[VERT_ATTRIB_GENERIC(i)];
1189 array->BufferObj = NULL;
1190 _mesa_reference_buffer_object(ctx, &array->BufferObj,
1191 vbo->currval[VBO_ATTRIB_GENERIC0+i].BufferObj);
1192 }
1193 }
1194
1195 exec->vtx.vertex_size = 0;
1196
1197 exec->begin_vertices_flags = FLUSH_UPDATE_CURRENT;
1198 }
1199
1200
1201 void vbo_exec_vtx_destroy( struct vbo_exec_context *exec )
1202 {
1203 /* using a real VBO for vertex data */
1204 struct gl_context *ctx = exec->ctx;
1205 unsigned i;
1206
1207 /* True VBOs should already be unmapped
1208 */
1209 if (exec->vtx.buffer_map) {
1210 assert(exec->vtx.bufferobj->Name == 0 ||
1211 exec->vtx.bufferobj->Name == IMM_BUFFER_NAME);
1212 if (exec->vtx.bufferobj->Name == 0) {
1213 _mesa_align_free(exec->vtx.buffer_map);
1214 exec->vtx.buffer_map = NULL;
1215 exec->vtx.buffer_ptr = NULL;
1216 }
1217 }
1218
1219 /* Drop any outstanding reference to the vertex buffer
1220 */
1221 for (i = 0; i < ARRAY_SIZE(exec->vtx.arrays); i++) {
1222 _mesa_reference_buffer_object(ctx,
1223 &exec->vtx.arrays[i].BufferObj,
1224 NULL);
1225 }
1226
1227 /* Free the vertex buffer. Unmap first if needed.
1228 */
1229 if (_mesa_bufferobj_mapped(exec->vtx.bufferobj, MAP_INTERNAL)) {
1230 ctx->Driver.UnmapBuffer(ctx, exec->vtx.bufferobj, MAP_INTERNAL);
1231 }
1232 _mesa_reference_buffer_object(ctx, &exec->vtx.bufferobj, NULL);
1233 }
1234
1235
1236 /**
1237 * If inside glBegin()/glEnd(), it should assert(0). Otherwise, if
1238 * FLUSH_STORED_VERTICES bit in \p flags is set flushes any buffered
1239 * vertices, if FLUSH_UPDATE_CURRENT bit is set updates
1240 * __struct gl_contextRec::Current and gl_light_attrib::Material
1241 *
1242 * Note that the default T&L engine never clears the
1243 * FLUSH_UPDATE_CURRENT bit, even after performing the update.
1244 *
1245 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1246 */
1247 void vbo_exec_FlushVertices( struct gl_context *ctx, GLuint flags )
1248 {
1249 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
1250
1251 #ifdef DEBUG
1252 /* debug check: make sure we don't get called recursively */
1253 exec->flush_call_depth++;
1254 assert(exec->flush_call_depth == 1);
1255 #endif
1256
1257 if (_mesa_inside_begin_end(ctx)) {
1258 /* We've had glBegin but not glEnd! */
1259 #ifdef DEBUG
1260 exec->flush_call_depth--;
1261 assert(exec->flush_call_depth == 0);
1262 #endif
1263 return;
1264 }
1265
1266 /* Flush (draw), and make sure VBO is left unmapped when done */
1267 vbo_exec_FlushVertices_internal(exec, GL_TRUE);
1268
1269 /* Need to do this to ensure vbo_exec_begin_vertices gets called again:
1270 */
1271 ctx->Driver.NeedFlush &= ~(FLUSH_UPDATE_CURRENT | flags);
1272
1273 #ifdef DEBUG
1274 exec->flush_call_depth--;
1275 assert(exec->flush_call_depth == 0);
1276 #endif
1277 }
1278
1279 /**
1280 * Reset the vertex attribute by setting its size to zero.
1281 */
1282 static void
1283 vbo_reset_attr(struct vbo_exec_context *exec, GLuint attr)
1284 {
1285 exec->vtx.attrsz[attr] = 0;
1286 exec->vtx.attrtype[attr] = GL_FLOAT;
1287 exec->vtx.active_sz[attr] = 0;
1288 }
1289
1290 static void
1291 vbo_reset_all_attr(struct vbo_exec_context *exec)
1292 {
1293 while (exec->vtx.enabled) {
1294 const int i = u_bit_scan64(&exec->vtx.enabled);
1295 vbo_reset_attr(exec, i);
1296 }
1297
1298 exec->vtx.vertex_size = 0;
1299 }
1300
1301
1302 void GLAPIENTRY
1303 _es_Color4f(GLfloat r, GLfloat g, GLfloat b, GLfloat a)
1304 {
1305 vbo_Color4f(r, g, b, a);
1306 }
1307
1308
1309 void GLAPIENTRY
1310 _es_Normal3f(GLfloat x, GLfloat y, GLfloat z)
1311 {
1312 vbo_Normal3f(x, y, z);
1313 }
1314
1315
1316 void GLAPIENTRY
1317 _es_MultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
1318 {
1319 vbo_MultiTexCoord4f(target, s, t, r, q);
1320 }
1321
1322
1323 void GLAPIENTRY
1324 _es_Materialfv(GLenum face, GLenum pname, const GLfloat *params)
1325 {
1326 vbo_Materialfv(face, pname, params);
1327 }
1328
1329
1330 void GLAPIENTRY
1331 _es_Materialf(GLenum face, GLenum pname, GLfloat param)
1332 {
1333 GLfloat p[4];
1334 p[0] = param;
1335 p[1] = p[2] = p[3] = 0.0F;
1336 vbo_Materialfv(face, pname, p);
1337 }
1338
1339
1340 /**
1341 * A special version of glVertexAttrib4f that does not treat index 0 as
1342 * VBO_ATTRIB_POS.
1343 */
1344 static void
1345 VertexAttrib4f_nopos(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1346 {
1347 GET_CURRENT_CONTEXT(ctx);
1348 if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1349 ATTRF(VBO_ATTRIB_GENERIC0 + index, 4, x, y, z, w);
1350 else
1351 ERROR(GL_INVALID_VALUE);
1352 }
1353
1354 void GLAPIENTRY
1355 _es_VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1356 {
1357 VertexAttrib4f_nopos(index, x, y, z, w);
1358 }
1359
1360
1361 void GLAPIENTRY
1362 _es_VertexAttrib1f(GLuint indx, GLfloat x)
1363 {
1364 VertexAttrib4f_nopos(indx, x, 0.0f, 0.0f, 1.0f);
1365 }
1366
1367
1368 void GLAPIENTRY
1369 _es_VertexAttrib1fv(GLuint indx, const GLfloat* values)
1370 {
1371 VertexAttrib4f_nopos(indx, values[0], 0.0f, 0.0f, 1.0f);
1372 }
1373
1374
1375 void GLAPIENTRY
1376 _es_VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
1377 {
1378 VertexAttrib4f_nopos(indx, x, y, 0.0f, 1.0f);
1379 }
1380
1381
1382 void GLAPIENTRY
1383 _es_VertexAttrib2fv(GLuint indx, const GLfloat* values)
1384 {
1385 VertexAttrib4f_nopos(indx, values[0], values[1], 0.0f, 1.0f);
1386 }
1387
1388
1389 void GLAPIENTRY
1390 _es_VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
1391 {
1392 VertexAttrib4f_nopos(indx, x, y, z, 1.0f);
1393 }
1394
1395
1396 void GLAPIENTRY
1397 _es_VertexAttrib3fv(GLuint indx, const GLfloat* values)
1398 {
1399 VertexAttrib4f_nopos(indx, values[0], values[1], values[2], 1.0f);
1400 }
1401
1402
1403 void GLAPIENTRY
1404 _es_VertexAttrib4fv(GLuint indx, const GLfloat* values)
1405 {
1406 VertexAttrib4f_nopos(indx, values[0], values[1], values[2], values[3]);
1407 }