vbo: don't store glVertex values temporarily into exec
[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/draw_validate.h"
44 #include "main/dispatch.h"
45 #include "util/bitscan.h"
46
47 #include "vbo_noop.h"
48 #include "vbo_private.h"
49
50
51 /** ID/name for immediate-mode VBO */
52 #define IMM_BUFFER_NAME 0xaabbccdd
53
54
55 static void
56 vbo_reset_all_attr(struct vbo_exec_context *exec);
57
58
59 /**
60 * Close off the last primitive, execute the buffer, restart the
61 * primitive. This is called when we fill a vertex buffer before
62 * hitting glEnd.
63 */
64 static void
65 vbo_exec_wrap_buffers(struct vbo_exec_context *exec)
66 {
67 if (exec->vtx.prim_count == 0) {
68 exec->vtx.copied.nr = 0;
69 exec->vtx.vert_count = 0;
70 exec->vtx.buffer_ptr = exec->vtx.buffer_map;
71 }
72 else {
73 struct _mesa_prim *last_prim = &exec->vtx.prim[exec->vtx.prim_count - 1];
74 const GLuint last_begin = last_prim->begin;
75 GLuint last_count;
76
77 if (_mesa_inside_begin_end(exec->ctx)) {
78 last_prim->count = exec->vtx.vert_count - last_prim->start;
79 }
80
81 last_count = last_prim->count;
82
83 /* Special handling for wrapping GL_LINE_LOOP */
84 if (last_prim->mode == GL_LINE_LOOP &&
85 last_count > 0 &&
86 !last_prim->end) {
87 /* draw this section of the incomplete line loop as a line strip */
88 last_prim->mode = GL_LINE_STRIP;
89 if (!last_prim->begin) {
90 /* This is not the first section of the line loop, so don't
91 * draw the 0th vertex. We're saving it until we draw the
92 * very last section of the loop.
93 */
94 last_prim->start++;
95 last_prim->count--;
96 }
97 }
98
99 /* Execute the buffer and save copied vertices.
100 */
101 if (exec->vtx.vert_count)
102 vbo_exec_vtx_flush(exec);
103 else {
104 exec->vtx.prim_count = 0;
105 exec->vtx.copied.nr = 0;
106 }
107
108 /* Emit a glBegin to start the new list.
109 */
110 assert(exec->vtx.prim_count == 0);
111
112 if (_mesa_inside_begin_end(exec->ctx)) {
113 exec->vtx.prim[0].mode = exec->ctx->Driver.CurrentExecPrimitive;
114 exec->vtx.prim[0].begin = 0;
115 exec->vtx.prim[0].end = 0;
116 exec->vtx.prim[0].start = 0;
117 exec->vtx.prim[0].count = 0;
118 exec->vtx.prim_count++;
119
120 if (exec->vtx.copied.nr == last_count)
121 exec->vtx.prim[0].begin = last_begin;
122 }
123 }
124 }
125
126
127 /**
128 * Deal with buffer wrapping where provoked by the vertex buffer
129 * filling up, as opposed to upgrade_vertex().
130 */
131 static void
132 vbo_exec_vtx_wrap(struct vbo_exec_context *exec)
133 {
134 unsigned numComponents;
135
136 /* Run pipeline on current vertices, copy wrapped vertices
137 * to exec->vtx.copied.
138 */
139 vbo_exec_wrap_buffers(exec);
140
141 if (!exec->vtx.buffer_ptr) {
142 /* probably ran out of memory earlier when allocating the VBO */
143 return;
144 }
145
146 /* Copy stored stored vertices to start of new list.
147 */
148 assert(exec->vtx.max_vert - exec->vtx.vert_count > exec->vtx.copied.nr);
149
150 numComponents = exec->vtx.copied.nr * exec->vtx.vertex_size;
151 memcpy(exec->vtx.buffer_ptr,
152 exec->vtx.copied.buffer,
153 numComponents * sizeof(fi_type));
154 exec->vtx.buffer_ptr += numComponents;
155 exec->vtx.vert_count += exec->vtx.copied.nr;
156
157 exec->vtx.copied.nr = 0;
158 }
159
160
161 /**
162 * Copy the active vertex's values to the ctx->Current fields.
163 */
164 static void
165 vbo_exec_copy_to_current(struct vbo_exec_context *exec)
166 {
167 struct gl_context *ctx = exec->ctx;
168 struct vbo_context *vbo = vbo_context(ctx);
169 GLbitfield64 enabled = exec->vtx.enabled & (~BITFIELD64_BIT(VBO_ATTRIB_POS));
170
171 while (enabled) {
172 const int i = u_bit_scan64(&enabled);
173
174 /* Note: the exec->vtx.current[i] pointers point into the
175 * ctx->Current.Attrib and ctx->Light.Material.Attrib arrays.
176 */
177 GLfloat *current = (GLfloat *)vbo->current[i].Ptr;
178 fi_type tmp[8]; /* space for doubles */
179 int dmul = 1;
180
181 if (exec->vtx.attr[i].type == GL_DOUBLE ||
182 exec->vtx.attr[i].type == GL_UNSIGNED_INT64_ARB)
183 dmul = 2;
184
185 assert(exec->vtx.attr[i].size);
186
187 if (exec->vtx.attr[i].type == GL_DOUBLE ||
188 exec->vtx.attr[i].type == GL_UNSIGNED_INT64_ARB) {
189 memset(tmp, 0, sizeof(tmp));
190 memcpy(tmp, exec->vtx.attrptr[i], exec->vtx.attr[i].size * sizeof(GLfloat));
191 } else {
192 COPY_CLEAN_4V_TYPE_AS_UNION(tmp,
193 exec->vtx.attr[i].size,
194 exec->vtx.attrptr[i],
195 exec->vtx.attr[i].type);
196 }
197
198 if (exec->vtx.attr[i].type != vbo->current[i].Format.Type ||
199 memcmp(current, tmp, 4 * sizeof(GLfloat) * dmul) != 0) {
200 memcpy(current, tmp, 4 * sizeof(GLfloat) * dmul);
201
202 /* Given that we explicitly state size here, there is no need
203 * for the COPY_CLEAN above, could just copy 16 bytes and be
204 * done. The only problem is when Mesa accesses ctx->Current
205 * directly.
206 */
207 /* Size here is in components - not bytes */
208 vbo_set_vertex_format(&vbo->current[i].Format,
209 exec->vtx.attr[i].size / dmul,
210 exec->vtx.attr[i].type);
211
212 /* This triggers rather too much recalculation of Mesa state
213 * that doesn't get used (eg light positions).
214 */
215 if (i >= VBO_ATTRIB_MAT_FRONT_AMBIENT &&
216 i <= VBO_ATTRIB_MAT_BACK_INDEXES)
217 ctx->NewState |= _NEW_LIGHT;
218
219 ctx->NewState |= _NEW_CURRENT_ATTRIB;
220 }
221 }
222
223 /* Colormaterial -- this kindof sucks.
224 */
225 if (ctx->Light.ColorMaterialEnabled &&
226 exec->vtx.attr[VBO_ATTRIB_COLOR0].size) {
227 _mesa_update_color_material(ctx,
228 ctx->Current.Attrib[VBO_ATTRIB_COLOR0]);
229 }
230 }
231
232
233 /**
234 * Copy current vertex attribute values into the current vertex.
235 */
236 static void
237 vbo_exec_copy_from_current(struct vbo_exec_context *exec)
238 {
239 struct gl_context *ctx = exec->ctx;
240 struct vbo_context *vbo = vbo_context(ctx);
241 GLint i;
242
243 for (i = VBO_ATTRIB_POS + 1; i < VBO_ATTRIB_MAX; i++) {
244 if (exec->vtx.attr[i].type == GL_DOUBLE ||
245 exec->vtx.attr[i].type == GL_UNSIGNED_INT64_ARB) {
246 memcpy(exec->vtx.attrptr[i], vbo->current[i].Ptr,
247 exec->vtx.attr[i].size * sizeof(GLfloat));
248 } else {
249 const fi_type *current = (fi_type *) vbo->current[i].Ptr;
250 switch (exec->vtx.attr[i].size) {
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 * \param attr VBO_ATTRIB_x vertex attribute value
269 */
270 static void
271 vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context *exec,
272 GLuint attr, GLuint newSize)
273 {
274 struct gl_context *ctx = exec->ctx;
275 struct vbo_context *vbo = vbo_context(ctx);
276 const GLint lastcount = exec->vtx.vert_count;
277 fi_type *old_attrptr[VBO_ATTRIB_MAX];
278 const GLuint old_vtx_size = exec->vtx.vertex_size; /* floats per vertex */
279 const GLuint oldSize = exec->vtx.attr[attr].size;
280 GLuint i;
281
282 assert(attr < VBO_ATTRIB_MAX);
283
284 /* Run pipeline on current vertices, copy wrapped vertices
285 * to exec->vtx.copied.
286 */
287 vbo_exec_wrap_buffers(exec);
288
289 if (unlikely(exec->vtx.copied.nr)) {
290 /* We're in the middle of a primitive, keep the old vertex
291 * format around to be able to translate the copied vertices to
292 * the new format.
293 */
294 memcpy(old_attrptr, exec->vtx.attrptr, sizeof(old_attrptr));
295 }
296
297 bool repopulate = unlikely(oldSize) || (attr != 0 && exec->vtx.attr[0].size);
298
299 if (repopulate) {
300 /* Do a COPY_TO_CURRENT to ensure back-copying works for the
301 * case when the attribute already exists in the vertex and is
302 * having its size increased.
303 */
304 vbo_exec_copy_to_current(exec);
305 }
306
307 /* Heuristic: Attempt to isolate attributes received outside
308 * begin/end so that they don't bloat the vertices.
309 */
310 if (!_mesa_inside_begin_end(ctx) &&
311 !oldSize && lastcount > 8 && exec->vtx.vertex_size) {
312 vbo_exec_copy_to_current(exec);
313 vbo_reset_all_attr(exec);
314 }
315
316 /* Fix up sizes:
317 */
318 exec->vtx.attr[attr].size = newSize;
319 exec->vtx.vertex_size += newSize - oldSize;
320 exec->vtx.vertex_size_no_pos = exec->vtx.vertex_size - exec->vtx.attr[0].size;
321 exec->vtx.max_vert = vbo_compute_max_verts(exec);
322 exec->vtx.vert_count = 0;
323 exec->vtx.buffer_ptr = exec->vtx.buffer_map;
324 exec->vtx.enabled |= BITFIELD64_BIT(attr);
325
326 if (repopulate) {
327 /* Size changed, recalculate all the attrptr[] values
328 */
329 fi_type *tmp = exec->vtx.vertex;
330
331 /* Iterate backwards to make the position last, because glVertex
332 * expects that.
333 */
334 for (int i = VBO_ATTRIB_MAX - 1; i >= 0; i--) {
335 if (exec->vtx.attr[i].size) {
336 exec->vtx.attrptr[i] = tmp;
337 tmp += exec->vtx.attr[i].size;
338 }
339 else
340 exec->vtx.attrptr[i] = NULL; /* will not be dereferenced */
341 }
342
343 /* Copy from current to repopulate the vertex with correct
344 * values.
345 */
346 vbo_exec_copy_from_current(exec);
347 }
348 else {
349 /* Just have to append the new attribute at the end */
350 exec->vtx.attrptr[attr] = exec->vtx.vertex +
351 exec->vtx.vertex_size - newSize;
352 }
353
354 /* Replay stored vertices to translate them
355 * to new format here.
356 *
357 * -- No need to replay - just copy piecewise
358 */
359 if (unlikely(exec->vtx.copied.nr)) {
360 fi_type *data = exec->vtx.copied.buffer;
361 fi_type *dest = exec->vtx.buffer_ptr;
362
363 assert(exec->vtx.buffer_ptr == exec->vtx.buffer_map);
364
365 for (i = 0 ; i < exec->vtx.copied.nr ; i++) {
366 GLbitfield64 enabled = exec->vtx.enabled;
367 while (enabled) {
368 const int j = u_bit_scan64(&enabled);
369 GLuint sz = exec->vtx.attr[j].size;
370 GLint old_offset = old_attrptr[j] - exec->vtx.vertex;
371 GLint new_offset = exec->vtx.attrptr[j] - exec->vtx.vertex;
372
373 assert(sz);
374
375 if (j == attr) {
376 if (oldSize) {
377 fi_type tmp[4];
378 COPY_CLEAN_4V_TYPE_AS_UNION(tmp, oldSize,
379 data + old_offset,
380 exec->vtx.attr[j].type);
381 COPY_SZ_4V(dest + new_offset, newSize, tmp);
382 } else {
383 fi_type *current = (fi_type *)vbo->current[j].Ptr;
384 COPY_SZ_4V(dest + new_offset, sz, current);
385 }
386 }
387 else {
388 COPY_SZ_4V(dest + new_offset, sz, data + old_offset);
389 }
390 }
391
392 data += old_vtx_size;
393 dest += exec->vtx.vertex_size;
394 }
395
396 exec->vtx.buffer_ptr = dest;
397 exec->vtx.vert_count += exec->vtx.copied.nr;
398 exec->vtx.copied.nr = 0;
399 }
400 }
401
402
403 /**
404 * This is when a vertex attribute transitions to a different size.
405 * For example, we saw a bunch of glTexCoord2f() calls and now we got a
406 * glTexCoord4f() call. We promote the array from size=2 to size=4.
407 * \param newSize size of new vertex (number of 32-bit words).
408 * \param attr VBO_ATTRIB_x vertex attribute value
409 */
410 static void
411 vbo_exec_fixup_vertex(struct gl_context *ctx, GLuint attr,
412 GLuint newSize, GLenum newType)
413 {
414 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
415
416 assert(attr < VBO_ATTRIB_MAX);
417
418 if (newSize > exec->vtx.attr[attr].size ||
419 newType != exec->vtx.attr[attr].type) {
420 /* New size is larger. Need to flush existing vertices and get
421 * an enlarged vertex format.
422 */
423 vbo_exec_wrap_upgrade_vertex(exec, attr, newSize);
424 }
425 else if (newSize < exec->vtx.attr[attr].active_size) {
426 GLuint i;
427 const fi_type *id =
428 vbo_get_default_vals_as_union(exec->vtx.attr[attr].type);
429
430 /* New size is smaller - just need to fill in some
431 * zeros. Don't need to flush or wrap.
432 */
433 for (i = newSize; i <= exec->vtx.attr[attr].size; i++)
434 exec->vtx.attrptr[attr][i-1] = id[i-1];
435 }
436
437 exec->vtx.attr[attr].active_size = newSize;
438 exec->vtx.attr[attr].type = newType;
439
440 /* Does setting NeedFlush belong here? Necessitates resetting
441 * vtxfmt on each flush (otherwise flags won't get reset
442 * afterwards).
443 */
444 if (attr == 0)
445 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES;
446 }
447
448
449 /**
450 * If index=0, does glVertexAttrib*() alias glVertex() to emit a vertex?
451 * It depends on a few things, including whether we're inside or outside
452 * of glBegin/glEnd.
453 */
454 static inline bool
455 is_vertex_position(const struct gl_context *ctx, GLuint index)
456 {
457 return (index == 0 &&
458 _mesa_attr_zero_aliases_vertex(ctx) &&
459 _mesa_inside_begin_end(ctx));
460 }
461
462 /* Write a 64-bit value into a 32-bit pointer by preserving endianness. */
463 #if UTIL_ARCH_LITTLE_ENDIAN
464 #define SET_64BIT(dst32, u64) do { \
465 *(dst32)++ = (u64); \
466 *(dst32)++ = (uint64_t)(u64) >> 32; \
467 } while (0)
468 #else
469 #define SET_64BIT(dst32, u64) do { \
470 *(dst32)++ = (uint64_t)(u64) >> 32; \
471 *(dst32)++ = (u64); \
472 } while (0)
473 #endif
474
475
476 /**
477 * This macro is used to implement all the glVertex, glColor, glTexCoord,
478 * glVertexAttrib, etc functions.
479 * \param A VBO_ATTRIB_x attribute index
480 * \param N attribute size (1..4)
481 * \param T type (GL_FLOAT, GL_DOUBLE, GL_INT, GL_UNSIGNED_INT)
482 * \param C cast type (uint32_t or uint64_t)
483 * \param V0, V1, v2, V3 attribute value
484 */
485 #define ATTR_UNION(A, N, T, C, V0, V1, V2, V3) \
486 do { \
487 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
488 int sz = (sizeof(C) / sizeof(GLfloat)); \
489 \
490 assert(sz == 1 || sz == 2); \
491 \
492 /* check if attribute size or type is changing */ \
493 if (unlikely(exec->vtx.attr[A].active_size != N * sz) || \
494 unlikely(exec->vtx.attr[A].type != T)) { \
495 vbo_exec_fixup_vertex(ctx, A, N * sz, T); \
496 } \
497 \
498 /* store a copy of the attribute in exec except for glVertex */ \
499 if ((A) != 0) { \
500 C *dest = (C *)exec->vtx.attrptr[A]; \
501 if (N>0) dest[0] = V0; \
502 if (N>1) dest[1] = V1; \
503 if (N>2) dest[2] = V2; \
504 if (N>3) dest[3] = V3; \
505 assert(exec->vtx.attr[A].type == T); \
506 } \
507 \
508 if ((A) == 0) { \
509 /* This is a glVertex call */ \
510 uint32_t *dst = (uint32_t *)exec->vtx.buffer_ptr; \
511 uint32_t *src = (uint32_t *)exec->vtx.vertex; \
512 unsigned vertex_size_no_pos = exec->vtx.vertex_size_no_pos; \
513 \
514 /* Copy over attributes from exec. */ \
515 for (unsigned i = 0; i < vertex_size_no_pos; i++) \
516 *dst++ = *src++; \
517 \
518 /* Store the position, which is always last and can have 32 or */ \
519 /* 64 bits per channel. */ \
520 if (sizeof(C) == 4) { \
521 if (N > 0) *dst++ = V0; \
522 if (N > 1) *dst++ = V1; \
523 if (N > 2) *dst++ = V2; \
524 if (N > 3) *dst++ = V3; \
525 } else { \
526 /* 64 bits: dst can be unaligned, so copy each 4-byte word */ \
527 /* separately */ \
528 if (N > 0) SET_64BIT(dst, V0); \
529 if (N > 1) SET_64BIT(dst, V1); \
530 if (N > 2) SET_64BIT(dst, V2); \
531 if (N > 3) SET_64BIT(dst, V3); \
532 } \
533 \
534 /* dst now points at the beginning of the next vertex */ \
535 exec->vtx.buffer_ptr = (fi_type*)dst; \
536 \
537 /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \
538 /* something to draw (not just updating a color or texcoord).*/ \
539 /* Don't set FLUSH_UPDATE_CURRENT because */ \
540 /* Current.Attrib[VBO_ATTRIB_POS] is never used. */ \
541 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \
542 \
543 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
544 vbo_exec_vtx_wrap(exec); \
545 } else { \
546 /* we now have accumulated per-vertex attributes */ \
547 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
548 } \
549 } while (0)
550
551
552 #undef ERROR
553 #define ERROR(err) _mesa_error(ctx, err, __func__)
554 #define TAG(x) vbo_exec_##x
555
556 #include "vbo_attrib_tmp.h"
557
558
559
560 /**
561 * Execute a glMaterial call. Note that if GL_COLOR_MATERIAL is enabled,
562 * this may be a (partial) no-op.
563 */
564 static void GLAPIENTRY
565 vbo_exec_Materialfv(GLenum face, GLenum pname, const GLfloat *params)
566 {
567 GLbitfield updateMats;
568 GET_CURRENT_CONTEXT(ctx);
569
570 /* This function should be a no-op when it tries to update material
571 * attributes which are currently tracking glColor via glColorMaterial.
572 * The updateMats var will be a mask of the MAT_BIT_FRONT/BACK_x bits
573 * indicating which material attributes can actually be updated below.
574 */
575 if (ctx->Light.ColorMaterialEnabled) {
576 updateMats = ~ctx->Light._ColorMaterialBitmask;
577 }
578 else {
579 /* GL_COLOR_MATERIAL is disabled so don't skip any material updates */
580 updateMats = ALL_MATERIAL_BITS;
581 }
582
583 if (ctx->API == API_OPENGL_COMPAT && face == GL_FRONT) {
584 updateMats &= FRONT_MATERIAL_BITS;
585 }
586 else if (ctx->API == API_OPENGL_COMPAT && face == GL_BACK) {
587 updateMats &= BACK_MATERIAL_BITS;
588 }
589 else if (face != GL_FRONT_AND_BACK) {
590 _mesa_error(ctx, GL_INVALID_ENUM, "glMaterial(invalid face)");
591 return;
592 }
593
594 switch (pname) {
595 case GL_EMISSION:
596 if (updateMats & MAT_BIT_FRONT_EMISSION)
597 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_EMISSION, 4, params);
598 if (updateMats & MAT_BIT_BACK_EMISSION)
599 MAT_ATTR(VBO_ATTRIB_MAT_BACK_EMISSION, 4, params);
600 break;
601 case GL_AMBIENT:
602 if (updateMats & MAT_BIT_FRONT_AMBIENT)
603 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT, 4, params);
604 if (updateMats & MAT_BIT_BACK_AMBIENT)
605 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT, 4, params);
606 break;
607 case GL_DIFFUSE:
608 if (updateMats & MAT_BIT_FRONT_DIFFUSE)
609 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE, 4, params);
610 if (updateMats & MAT_BIT_BACK_DIFFUSE)
611 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE, 4, params);
612 break;
613 case GL_SPECULAR:
614 if (updateMats & MAT_BIT_FRONT_SPECULAR)
615 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SPECULAR, 4, params);
616 if (updateMats & MAT_BIT_BACK_SPECULAR)
617 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SPECULAR, 4, params);
618 break;
619 case GL_SHININESS:
620 if (*params < 0 || *params > ctx->Const.MaxShininess) {
621 _mesa_error(ctx, GL_INVALID_VALUE,
622 "glMaterial(invalid shininess: %f out range [0, %f])",
623 *params, ctx->Const.MaxShininess);
624 return;
625 }
626 if (updateMats & MAT_BIT_FRONT_SHININESS)
627 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SHININESS, 1, params);
628 if (updateMats & MAT_BIT_BACK_SHININESS)
629 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SHININESS, 1, params);
630 break;
631 case GL_COLOR_INDEXES:
632 if (ctx->API != API_OPENGL_COMPAT) {
633 _mesa_error(ctx, GL_INVALID_ENUM, "glMaterialfv(pname)");
634 return;
635 }
636 if (updateMats & MAT_BIT_FRONT_INDEXES)
637 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_INDEXES, 3, params);
638 if (updateMats & MAT_BIT_BACK_INDEXES)
639 MAT_ATTR(VBO_ATTRIB_MAT_BACK_INDEXES, 3, params);
640 break;
641 case GL_AMBIENT_AND_DIFFUSE:
642 if (updateMats & MAT_BIT_FRONT_AMBIENT)
643 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT, 4, params);
644 if (updateMats & MAT_BIT_FRONT_DIFFUSE)
645 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE, 4, params);
646 if (updateMats & MAT_BIT_BACK_AMBIENT)
647 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT, 4, params);
648 if (updateMats & MAT_BIT_BACK_DIFFUSE)
649 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE, 4, params);
650 break;
651 default:
652 _mesa_error(ctx, GL_INVALID_ENUM, "glMaterialfv(pname)");
653 return;
654 }
655 }
656
657
658 /**
659 * Flush (draw) vertices.
660 */
661 static void
662 vbo_exec_FlushVertices_internal(struct vbo_exec_context *exec)
663 {
664 if (exec->vtx.vert_count) {
665 vbo_exec_vtx_flush(exec);
666 }
667
668 if (exec->vtx.vertex_size) {
669 vbo_exec_copy_to_current(exec);
670 vbo_reset_all_attr(exec);
671 }
672 }
673
674
675 static void GLAPIENTRY
676 vbo_exec_EvalCoord1f(GLfloat u)
677 {
678 GET_CURRENT_CONTEXT(ctx);
679 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
680
681 {
682 GLint i;
683 if (exec->eval.recalculate_maps)
684 vbo_exec_eval_update(exec);
685
686 for (i = 0; i <= VBO_ATTRIB_TEX7; i++) {
687 if (exec->eval.map1[i].map)
688 if (exec->vtx.attr[i].active_size != exec->eval.map1[i].sz)
689 vbo_exec_fixup_vertex(ctx, i, exec->eval.map1[i].sz, GL_FLOAT);
690 }
691 }
692
693 memcpy(exec->vtx.copied.buffer, exec->vtx.vertex,
694 exec->vtx.vertex_size * sizeof(GLfloat));
695
696 vbo_exec_do_EvalCoord1f(exec, u);
697
698 memcpy(exec->vtx.vertex, exec->vtx.copied.buffer,
699 exec->vtx.vertex_size * sizeof(GLfloat));
700 }
701
702
703 static void GLAPIENTRY
704 vbo_exec_EvalCoord2f(GLfloat u, GLfloat v)
705 {
706 GET_CURRENT_CONTEXT(ctx);
707 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
708
709 {
710 GLint i;
711 if (exec->eval.recalculate_maps)
712 vbo_exec_eval_update(exec);
713
714 for (i = 0; i <= VBO_ATTRIB_TEX7; i++) {
715 if (exec->eval.map2[i].map)
716 if (exec->vtx.attr[i].active_size != exec->eval.map2[i].sz)
717 vbo_exec_fixup_vertex(ctx, i, exec->eval.map2[i].sz, GL_FLOAT);
718 }
719
720 if (ctx->Eval.AutoNormal)
721 if (exec->vtx.attr[VBO_ATTRIB_NORMAL].active_size != 3)
722 vbo_exec_fixup_vertex(ctx, VBO_ATTRIB_NORMAL, 3, GL_FLOAT);
723 }
724
725 memcpy(exec->vtx.copied.buffer, exec->vtx.vertex,
726 exec->vtx.vertex_size * sizeof(GLfloat));
727
728 vbo_exec_do_EvalCoord2f(exec, u, v);
729
730 memcpy(exec->vtx.vertex, exec->vtx.copied.buffer,
731 exec->vtx.vertex_size * sizeof(GLfloat));
732 }
733
734
735 static void GLAPIENTRY
736 vbo_exec_EvalCoord1fv(const GLfloat *u)
737 {
738 vbo_exec_EvalCoord1f(u[0]);
739 }
740
741
742 static void GLAPIENTRY
743 vbo_exec_EvalCoord2fv(const GLfloat *u)
744 {
745 vbo_exec_EvalCoord2f(u[0], u[1]);
746 }
747
748
749 static void GLAPIENTRY
750 vbo_exec_EvalPoint1(GLint i)
751 {
752 GET_CURRENT_CONTEXT(ctx);
753 GLfloat du = ((ctx->Eval.MapGrid1u2 - ctx->Eval.MapGrid1u1) /
754 (GLfloat) ctx->Eval.MapGrid1un);
755 GLfloat u = i * du + ctx->Eval.MapGrid1u1;
756
757 vbo_exec_EvalCoord1f(u);
758 }
759
760
761 static void GLAPIENTRY
762 vbo_exec_EvalPoint2(GLint i, GLint j)
763 {
764 GET_CURRENT_CONTEXT(ctx);
765 GLfloat du = ((ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1) /
766 (GLfloat) ctx->Eval.MapGrid2un);
767 GLfloat dv = ((ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1) /
768 (GLfloat) ctx->Eval.MapGrid2vn);
769 GLfloat u = i * du + ctx->Eval.MapGrid2u1;
770 GLfloat v = j * dv + ctx->Eval.MapGrid2v1;
771
772 vbo_exec_EvalCoord2f(u, v);
773 }
774
775
776 /**
777 * Called via glBegin.
778 */
779 static void GLAPIENTRY
780 vbo_exec_Begin(GLenum mode)
781 {
782 GET_CURRENT_CONTEXT(ctx);
783 struct vbo_context *vbo = vbo_context(ctx);
784 struct vbo_exec_context *exec = &vbo->exec;
785 int i;
786
787 if (_mesa_inside_begin_end(ctx)) {
788 _mesa_error(ctx, GL_INVALID_OPERATION, "glBegin");
789 return;
790 }
791
792 if (!_mesa_valid_prim_mode(ctx, mode, "glBegin")) {
793 return;
794 }
795
796 if (!_mesa_valid_to_render(ctx, "glBegin")) {
797 return;
798 }
799
800 /* Heuristic: attempt to isolate attributes occurring outside
801 * begin/end pairs.
802 */
803 if (exec->vtx.vertex_size && !exec->vtx.attr[VBO_ATTRIB_POS].size)
804 vbo_exec_FlushVertices_internal(exec);
805
806 i = exec->vtx.prim_count++;
807 exec->vtx.prim[i].mode = mode;
808 exec->vtx.prim[i].begin = 1;
809 exec->vtx.prim[i].end = 0;
810 exec->vtx.prim[i].indexed = 0;
811 exec->vtx.prim[i].pad = 0;
812 exec->vtx.prim[i].start = exec->vtx.vert_count;
813 exec->vtx.prim[i].count = 0;
814 exec->vtx.prim[i].num_instances = 1;
815 exec->vtx.prim[i].base_instance = 0;
816 exec->vtx.prim[i].is_indirect = 0;
817
818 ctx->Driver.CurrentExecPrimitive = mode;
819
820 ctx->Exec = ctx->BeginEnd;
821
822 /* We may have been called from a display list, in which case we should
823 * leave dlist.c's dispatch table in place.
824 */
825 if (ctx->CurrentClientDispatch == ctx->MarshalExec) {
826 ctx->CurrentServerDispatch = ctx->Exec;
827 } else if (ctx->CurrentClientDispatch == ctx->OutsideBeginEnd) {
828 ctx->CurrentClientDispatch = ctx->Exec;
829 _glapi_set_dispatch(ctx->CurrentClientDispatch);
830 } else {
831 assert(ctx->CurrentClientDispatch == ctx->Save);
832 }
833 }
834
835
836 /**
837 * Try to merge / concatenate the two most recent VBO primitives.
838 */
839 static void
840 try_vbo_merge(struct vbo_exec_context *exec)
841 {
842 struct _mesa_prim *cur = &exec->vtx.prim[exec->vtx.prim_count - 1];
843
844 assert(exec->vtx.prim_count >= 1);
845
846 vbo_try_prim_conversion(cur);
847
848 if (exec->vtx.prim_count >= 2) {
849 struct _mesa_prim *prev = &exec->vtx.prim[exec->vtx.prim_count - 2];
850 assert(prev == cur - 1);
851
852 if (vbo_can_merge_prims(prev, cur)) {
853 assert(cur->begin);
854 assert(cur->end);
855 assert(prev->begin);
856 assert(prev->end);
857 vbo_merge_prims(prev, cur);
858 exec->vtx.prim_count--; /* drop the last primitive */
859 }
860 }
861 }
862
863
864 /**
865 * Called via glEnd.
866 */
867 static void GLAPIENTRY
868 vbo_exec_End(void)
869 {
870 GET_CURRENT_CONTEXT(ctx);
871 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
872
873 if (!_mesa_inside_begin_end(ctx)) {
874 _mesa_error(ctx, GL_INVALID_OPERATION, "glEnd");
875 return;
876 }
877
878 ctx->Exec = ctx->OutsideBeginEnd;
879
880 if (ctx->CurrentClientDispatch == ctx->MarshalExec) {
881 ctx->CurrentServerDispatch = ctx->Exec;
882 } else if (ctx->CurrentClientDispatch == ctx->BeginEnd) {
883 ctx->CurrentClientDispatch = ctx->Exec;
884 _glapi_set_dispatch(ctx->CurrentClientDispatch);
885 }
886
887 if (exec->vtx.prim_count > 0) {
888 /* close off current primitive */
889 struct _mesa_prim *last_prim = &exec->vtx.prim[exec->vtx.prim_count - 1];
890
891 last_prim->end = 1;
892 last_prim->count = exec->vtx.vert_count - last_prim->start;
893
894 /* Special handling for GL_LINE_LOOP */
895 if (last_prim->mode == GL_LINE_LOOP && last_prim->begin == 0) {
896 /* We're finishing drawing a line loop. Append 0th vertex onto
897 * end of vertex buffer so we can draw it as a line strip.
898 */
899 const fi_type *src = exec->vtx.buffer_map +
900 last_prim->start * exec->vtx.vertex_size;
901 fi_type *dst = exec->vtx.buffer_map +
902 exec->vtx.vert_count * exec->vtx.vertex_size;
903
904 /* copy 0th vertex to end of buffer */
905 memcpy(dst, src, exec->vtx.vertex_size * sizeof(fi_type));
906
907 last_prim->start++; /* skip vertex0 */
908 /* note that last_prim->count stays unchanged */
909 last_prim->mode = GL_LINE_STRIP;
910
911 /* Increment the vertex count so the next primitive doesn't
912 * overwrite the last vertex which we just added.
913 */
914 exec->vtx.vert_count++;
915 exec->vtx.buffer_ptr += exec->vtx.vertex_size;
916 }
917
918 try_vbo_merge(exec);
919 }
920
921 ctx->Driver.CurrentExecPrimitive = PRIM_OUTSIDE_BEGIN_END;
922
923 if (exec->vtx.prim_count == VBO_MAX_PRIM)
924 vbo_exec_vtx_flush(exec);
925
926 if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH) {
927 _mesa_flush(ctx);
928 }
929 }
930
931
932 /**
933 * Called via glPrimitiveRestartNV()
934 */
935 static void GLAPIENTRY
936 vbo_exec_PrimitiveRestartNV(void)
937 {
938 GLenum curPrim;
939 GET_CURRENT_CONTEXT(ctx);
940
941 curPrim = ctx->Driver.CurrentExecPrimitive;
942
943 if (curPrim == PRIM_OUTSIDE_BEGIN_END) {
944 _mesa_error(ctx, GL_INVALID_OPERATION, "glPrimitiveRestartNV");
945 }
946 else {
947 vbo_exec_End();
948 vbo_exec_Begin(curPrim);
949 }
950 }
951
952
953 static void
954 vbo_exec_vtxfmt_init(struct vbo_exec_context *exec)
955 {
956 struct gl_context *ctx = exec->ctx;
957 GLvertexformat *vfmt = &exec->vtxfmt;
958
959 #define NAME_AE(x) _ae_##x
960 #define NAME_CALLLIST(x) _mesa_##x
961 #define NAME(x) vbo_exec_##x
962 #define NAME_ES(x) _es_##x
963
964 #include "vbo_init_tmp.h"
965 }
966
967
968 /**
969 * Tell the VBO module to use a real OpenGL vertex buffer object to
970 * store accumulated immediate-mode vertex data.
971 * This replaces the malloced buffer which was created in
972 * vb_exec_vtx_init() below.
973 */
974 void
975 vbo_use_buffer_objects(struct gl_context *ctx)
976 {
977 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
978 /* Any buffer name but 0 can be used here since this bufferobj won't
979 * go into the bufferobj hashtable.
980 */
981 GLuint bufName = IMM_BUFFER_NAME;
982
983 /* Make sure this func is only used once */
984 assert(exec->vtx.bufferobj == ctx->Shared->NullBufferObj);
985
986 _mesa_align_free(exec->vtx.buffer_map);
987 exec->vtx.buffer_map = NULL;
988 exec->vtx.buffer_ptr = NULL;
989
990 /* Allocate a real buffer object now */
991 _mesa_reference_buffer_object(ctx, &exec->vtx.bufferobj, NULL);
992 exec->vtx.bufferobj = ctx->Driver.NewBufferObject(ctx, bufName);
993
994 /* Map the buffer. */
995 vbo_exec_vtx_map(exec);
996 assert(exec->vtx.buffer_ptr);
997 }
998
999
1000 void
1001 vbo_exec_vtx_init(struct vbo_exec_context *exec)
1002 {
1003 struct gl_context *ctx = exec->ctx;
1004 GLuint i;
1005
1006 /* Allocate a buffer object. Will just reuse this object
1007 * continuously, unless vbo_use_buffer_objects() is called to enable
1008 * use of real VBOs.
1009 */
1010 _mesa_reference_buffer_object(ctx,
1011 &exec->vtx.bufferobj,
1012 ctx->Shared->NullBufferObj);
1013
1014 assert(!exec->vtx.buffer_map);
1015 exec->vtx.buffer_map = _mesa_align_malloc(VBO_VERT_BUFFER_SIZE, 64);
1016 exec->vtx.buffer_ptr = exec->vtx.buffer_map;
1017
1018 vbo_exec_vtxfmt_init(exec);
1019 _mesa_noop_vtxfmt_init(ctx, &exec->vtxfmt_noop);
1020
1021 exec->vtx.enabled = 0;
1022 for (i = 0 ; i < ARRAY_SIZE(exec->vtx.attr); i++) {
1023 exec->vtx.attr[i].size = 0;
1024 exec->vtx.attr[i].type = GL_FLOAT;
1025 exec->vtx.attr[i].active_size = 0;
1026 }
1027
1028 exec->vtx.vertex_size = 0;
1029 }
1030
1031
1032 void
1033 vbo_exec_vtx_destroy(struct vbo_exec_context *exec)
1034 {
1035 /* using a real VBO for vertex data */
1036 struct gl_context *ctx = exec->ctx;
1037
1038 /* True VBOs should already be unmapped
1039 */
1040 if (exec->vtx.buffer_map) {
1041 assert(exec->vtx.bufferobj->Name == 0 ||
1042 exec->vtx.bufferobj->Name == IMM_BUFFER_NAME);
1043 if (exec->vtx.bufferobj->Name == 0) {
1044 _mesa_align_free(exec->vtx.buffer_map);
1045 exec->vtx.buffer_map = NULL;
1046 exec->vtx.buffer_ptr = NULL;
1047 }
1048 }
1049
1050 /* Free the vertex buffer. Unmap first if needed.
1051 */
1052 if (_mesa_bufferobj_mapped(exec->vtx.bufferobj, MAP_INTERNAL)) {
1053 ctx->Driver.UnmapBuffer(ctx, exec->vtx.bufferobj, MAP_INTERNAL);
1054 }
1055 _mesa_reference_buffer_object(ctx, &exec->vtx.bufferobj, NULL);
1056 }
1057
1058
1059 /**
1060 * If inside glBegin()/glEnd(), it should assert(0). Otherwise, if
1061 * FLUSH_STORED_VERTICES bit in \p flags is set flushes any buffered
1062 * vertices, if FLUSH_UPDATE_CURRENT bit is set updates
1063 * __struct gl_contextRec::Current and gl_light_attrib::Material
1064 *
1065 * Note that the default T&L engine never clears the
1066 * FLUSH_UPDATE_CURRENT bit, even after performing the update.
1067 *
1068 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1069 */
1070 void
1071 vbo_exec_FlushVertices(struct gl_context *ctx, GLuint flags)
1072 {
1073 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
1074
1075 #ifndef NDEBUG
1076 /* debug check: make sure we don't get called recursively */
1077 exec->flush_call_depth++;
1078 assert(exec->flush_call_depth == 1);
1079 #endif
1080
1081 if (_mesa_inside_begin_end(ctx)) {
1082 /* We've had glBegin but not glEnd! */
1083 #ifndef NDEBUG
1084 exec->flush_call_depth--;
1085 assert(exec->flush_call_depth == 0);
1086 #endif
1087 return;
1088 }
1089
1090 /* Flush (draw). */
1091 vbo_exec_FlushVertices_internal(exec);
1092
1093 /* Clear the dirty flush flags, because the flush is finished. */
1094 ctx->Driver.NeedFlush &= ~(FLUSH_UPDATE_CURRENT | flags);
1095
1096 #ifndef NDEBUG
1097 exec->flush_call_depth--;
1098 assert(exec->flush_call_depth == 0);
1099 #endif
1100 }
1101
1102
1103 /**
1104 * Reset the vertex attribute by setting its size to zero.
1105 */
1106 static void
1107 vbo_reset_attr(struct vbo_exec_context *exec, GLuint attr)
1108 {
1109 exec->vtx.attr[attr].size = 0;
1110 exec->vtx.attr[attr].type = GL_FLOAT;
1111 exec->vtx.attr[attr].active_size = 0;
1112 }
1113
1114
1115 static void
1116 vbo_reset_all_attr(struct vbo_exec_context *exec)
1117 {
1118 while (exec->vtx.enabled) {
1119 const int i = u_bit_scan64(&exec->vtx.enabled);
1120 vbo_reset_attr(exec, i);
1121 }
1122
1123 exec->vtx.vertex_size = 0;
1124 }
1125
1126
1127 void GLAPIENTRY
1128 _es_Color4f(GLfloat r, GLfloat g, GLfloat b, GLfloat a)
1129 {
1130 vbo_exec_Color4f(r, g, b, a);
1131 }
1132
1133
1134 void GLAPIENTRY
1135 _es_Normal3f(GLfloat x, GLfloat y, GLfloat z)
1136 {
1137 vbo_exec_Normal3f(x, y, z);
1138 }
1139
1140
1141 void GLAPIENTRY
1142 _es_MultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
1143 {
1144 vbo_exec_MultiTexCoord4f(target, s, t, r, q);
1145 }
1146
1147
1148 void GLAPIENTRY
1149 _es_Materialfv(GLenum face, GLenum pname, const GLfloat *params)
1150 {
1151 vbo_exec_Materialfv(face, pname, params);
1152 }
1153
1154
1155 void GLAPIENTRY
1156 _es_Materialf(GLenum face, GLenum pname, GLfloat param)
1157 {
1158 GLfloat p[4];
1159 p[0] = param;
1160 p[1] = p[2] = p[3] = 0.0F;
1161 vbo_exec_Materialfv(face, pname, p);
1162 }
1163
1164
1165 /**
1166 * A special version of glVertexAttrib4f that does not treat index 0 as
1167 * VBO_ATTRIB_POS.
1168 */
1169 static void
1170 VertexAttrib4f_nopos(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1171 {
1172 GET_CURRENT_CONTEXT(ctx);
1173 if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1174 ATTRF(VBO_ATTRIB_GENERIC0 + index, 4, x, y, z, w);
1175 else
1176 ERROR(GL_INVALID_VALUE);
1177 }
1178
1179 void GLAPIENTRY
1180 _es_VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1181 {
1182 VertexAttrib4f_nopos(index, x, y, z, w);
1183 }
1184
1185
1186 void GLAPIENTRY
1187 _es_VertexAttrib1f(GLuint indx, GLfloat x)
1188 {
1189 VertexAttrib4f_nopos(indx, x, 0.0f, 0.0f, 1.0f);
1190 }
1191
1192
1193 void GLAPIENTRY
1194 _es_VertexAttrib1fv(GLuint indx, const GLfloat* values)
1195 {
1196 VertexAttrib4f_nopos(indx, values[0], 0.0f, 0.0f, 1.0f);
1197 }
1198
1199
1200 void GLAPIENTRY
1201 _es_VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
1202 {
1203 VertexAttrib4f_nopos(indx, x, y, 0.0f, 1.0f);
1204 }
1205
1206
1207 void GLAPIENTRY
1208 _es_VertexAttrib2fv(GLuint indx, const GLfloat* values)
1209 {
1210 VertexAttrib4f_nopos(indx, values[0], values[1], 0.0f, 1.0f);
1211 }
1212
1213
1214 void GLAPIENTRY
1215 _es_VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
1216 {
1217 VertexAttrib4f_nopos(indx, x, y, z, 1.0f);
1218 }
1219
1220
1221 void GLAPIENTRY
1222 _es_VertexAttrib3fv(GLuint indx, const GLfloat* values)
1223 {
1224 VertexAttrib4f_nopos(indx, values[0], values[1], values[2], 1.0f);
1225 }
1226
1227
1228 void GLAPIENTRY
1229 _es_VertexAttrib4fv(GLuint indx, const GLfloat* values)
1230 {
1231 VertexAttrib4f_nopos(indx, values[0], values[1], values[2], values[3]);
1232 }