1 /**************************************************************************
3 Copyright 2002-2008 VMware, Inc.
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:
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
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.
26 **************************************************************************/
30 * Keith Whitwell <keithw@vmware.com>
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"
48 #include "vbo_private.h"
51 /** ID/name for immediate-mode VBO */
52 #define IMM_BUFFER_NAME 0xaabbccdd
56 vbo_reset_all_attr(struct vbo_exec_context
*exec
);
60 * Close off the last primitive, execute the buffer, restart the
61 * primitive. This is called when we fill a vertex buffer before
65 vbo_exec_wrap_buffers(struct vbo_exec_context
*exec
)
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
;
73 struct _mesa_prim
*last_prim
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
74 const GLuint last_begin
= last_prim
->begin
;
77 if (_mesa_inside_begin_end(exec
->ctx
)) {
78 last_prim
->count
= exec
->vtx
.vert_count
- last_prim
->start
;
81 last_count
= last_prim
->count
;
83 /* Special handling for wrapping GL_LINE_LOOP */
84 if (last_prim
->mode
== GL_LINE_LOOP
&&
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.
99 /* Execute the buffer and save copied vertices.
101 if (exec
->vtx
.vert_count
)
102 vbo_exec_vtx_flush(exec
);
104 exec
->vtx
.prim_count
= 0;
105 exec
->vtx
.copied
.nr
= 0;
108 /* Emit a glBegin to start the new list.
110 assert(exec
->vtx
.prim_count
== 0);
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
++;
120 if (exec
->vtx
.copied
.nr
== last_count
)
121 exec
->vtx
.prim
[0].begin
= last_begin
;
128 * Deal with buffer wrapping where provoked by the vertex buffer
129 * filling up, as opposed to upgrade_vertex().
132 vbo_exec_vtx_wrap(struct vbo_exec_context
*exec
)
134 unsigned numComponents
;
136 /* Run pipeline on current vertices, copy wrapped vertices
137 * to exec->vtx.copied.
139 vbo_exec_wrap_buffers(exec
);
141 if (!exec
->vtx
.buffer_ptr
) {
142 /* probably ran out of memory earlier when allocating the VBO */
146 /* Copy stored stored vertices to start of new list.
148 assert(exec
->vtx
.max_vert
- exec
->vtx
.vert_count
> exec
->vtx
.copied
.nr
);
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
;
157 exec
->vtx
.copied
.nr
= 0;
162 * Copy the active vertex's values to the ctx->Current fields.
165 vbo_exec_copy_to_current(struct vbo_exec_context
*exec
)
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
));
172 const int i
= u_bit_scan64(&enabled
);
174 /* Note: the exec->vtx.current[i] pointers point into the
175 * ctx->Current.Attrib and ctx->Light.Material.Attrib arrays.
177 GLfloat
*current
= (GLfloat
*)vbo
->current
[i
].Ptr
;
178 fi_type tmp
[8]; /* space for doubles */
181 if (exec
->vtx
.attr
[i
].type
== GL_DOUBLE
||
182 exec
->vtx
.attr
[i
].type
== GL_UNSIGNED_INT64_ARB
)
185 assert(exec
->vtx
.attr
[i
].size
);
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
));
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
);
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
);
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
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
);
212 /* This triggers rather too much recalculation of Mesa state
213 * that doesn't get used (eg light positions).
215 if (i
>= VBO_ATTRIB_MAT_FRONT_AMBIENT
&&
216 i
<= VBO_ATTRIB_MAT_BACK_INDEXES
)
217 ctx
->NewState
|= _NEW_LIGHT
;
219 ctx
->NewState
|= _NEW_CURRENT_ATTRIB
;
223 /* Colormaterial -- this kindof sucks.
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
]);
234 * Flush existing data, set new attrib size, replay copied vertices.
235 * This is called when we transition from a small vertex attribute size
236 * to a larger one. Ex: glTexCoord2f -> glTexCoord4f.
237 * We need to go back over the previous 2-component texcoords and insert
238 * zero and one values.
239 * \param attr VBO_ATTRIB_x vertex attribute value
242 vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context
*exec
,
243 GLuint attr
, GLuint newSize
)
245 struct gl_context
*ctx
= exec
->ctx
;
246 struct vbo_context
*vbo
= vbo_context(ctx
);
247 const GLint lastcount
= exec
->vtx
.vert_count
;
248 fi_type
*old_attrptr
[VBO_ATTRIB_MAX
];
249 const GLuint old_vtx_size_no_pos
= exec
->vtx
.vertex_size_no_pos
;
250 const GLuint old_vtx_size
= exec
->vtx
.vertex_size
; /* floats per vertex */
251 const GLuint oldSize
= exec
->vtx
.attr
[attr
].size
;
254 assert(attr
< VBO_ATTRIB_MAX
);
256 /* Run pipeline on current vertices, copy wrapped vertices
257 * to exec->vtx.copied.
259 vbo_exec_wrap_buffers(exec
);
261 if (unlikely(exec
->vtx
.copied
.nr
)) {
262 /* We're in the middle of a primitive, keep the old vertex
263 * format around to be able to translate the copied vertices to
266 memcpy(old_attrptr
, exec
->vtx
.attrptr
, sizeof(old_attrptr
));
269 /* Heuristic: Attempt to isolate attributes received outside
270 * begin/end so that they don't bloat the vertices.
272 if (!_mesa_inside_begin_end(ctx
) &&
273 !oldSize
&& lastcount
> 8 && exec
->vtx
.vertex_size
) {
274 vbo_exec_copy_to_current(exec
);
275 vbo_reset_all_attr(exec
);
280 exec
->vtx
.attr
[attr
].size
= newSize
;
281 exec
->vtx
.vertex_size
+= newSize
- oldSize
;
282 exec
->vtx
.vertex_size_no_pos
= exec
->vtx
.vertex_size
- exec
->vtx
.attr
[0].size
;
283 exec
->vtx
.max_vert
= vbo_compute_max_verts(exec
);
284 exec
->vtx
.vert_count
= 0;
285 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
286 exec
->vtx
.enabled
|= BITFIELD64_BIT(attr
);
289 if (unlikely(oldSize
)) {
290 unsigned offset
= exec
->vtx
.attrptr
[attr
] - exec
->vtx
.vertex
;
292 /* If there are attribs after the resized attrib... */
293 if (offset
+ oldSize
< old_vtx_size_no_pos
) {
294 int size_diff
= newSize
- oldSize
;
295 fi_type
*old_first
= exec
->vtx
.attrptr
[attr
] + oldSize
;
296 fi_type
*new_first
= exec
->vtx
.attrptr
[attr
] + newSize
;
297 fi_type
*old_last
= exec
->vtx
.vertex
+ old_vtx_size_no_pos
- 1;
298 fi_type
*new_last
= exec
->vtx
.vertex
+ exec
->vtx
.vertex_size_no_pos
- 1;
301 /* Decreasing the size: Copy from first to last to move
302 * elements to the left.
304 fi_type
*old_end
= old_last
+ 1;
305 fi_type
*old
= old_first
;
306 fi_type
*new = new_first
;
310 } while (old
!= old_end
);
312 /* Increasing the size: Copy from last to first to move
313 * elements to the right.
315 fi_type
*old_end
= old_first
- 1;
316 fi_type
*old
= old_last
;
317 fi_type
*new = new_last
;
321 } while (old
!= old_end
);
324 /* Update pointers to attribs, because we moved them. */
325 GLbitfield64 enabled
= exec
->vtx
.enabled
&
326 ~BITFIELD64_BIT(VBO_ATTRIB_POS
) &
327 ~BITFIELD64_BIT(attr
);
329 unsigned i
= u_bit_scan64(&enabled
);
331 if (exec
->vtx
.attrptr
[i
] > exec
->vtx
.attrptr
[attr
])
332 exec
->vtx
.attrptr
[i
] += size_diff
;
336 /* Just have to append the new attribute at the end */
337 exec
->vtx
.attrptr
[attr
] = exec
->vtx
.vertex
+
338 exec
->vtx
.vertex_size_no_pos
- newSize
;
342 /* The position is always last. */
343 exec
->vtx
.attrptr
[0] = exec
->vtx
.vertex
+ exec
->vtx
.vertex_size_no_pos
;
345 /* Replay stored vertices to translate them
346 * to new format here.
348 * -- No need to replay - just copy piecewise
350 if (unlikely(exec
->vtx
.copied
.nr
)) {
351 fi_type
*data
= exec
->vtx
.copied
.buffer
;
352 fi_type
*dest
= exec
->vtx
.buffer_ptr
;
354 assert(exec
->vtx
.buffer_ptr
== exec
->vtx
.buffer_map
);
356 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
357 GLbitfield64 enabled
= exec
->vtx
.enabled
;
359 const int j
= u_bit_scan64(&enabled
);
360 GLuint sz
= exec
->vtx
.attr
[j
].size
;
361 GLint old_offset
= old_attrptr
[j
] - exec
->vtx
.vertex
;
362 GLint new_offset
= exec
->vtx
.attrptr
[j
] - exec
->vtx
.vertex
;
369 COPY_CLEAN_4V_TYPE_AS_UNION(tmp
, oldSize
,
371 exec
->vtx
.attr
[j
].type
);
372 COPY_SZ_4V(dest
+ new_offset
, newSize
, tmp
);
374 fi_type
*current
= (fi_type
*)vbo
->current
[j
].Ptr
;
375 COPY_SZ_4V(dest
+ new_offset
, sz
, current
);
379 COPY_SZ_4V(dest
+ new_offset
, sz
, data
+ old_offset
);
383 data
+= old_vtx_size
;
384 dest
+= exec
->vtx
.vertex_size
;
387 exec
->vtx
.buffer_ptr
= dest
;
388 exec
->vtx
.vert_count
+= exec
->vtx
.copied
.nr
;
389 exec
->vtx
.copied
.nr
= 0;
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 * \param attr VBO_ATTRIB_x vertex attribute value
402 vbo_exec_fixup_vertex(struct gl_context
*ctx
, GLuint attr
,
403 GLuint newSize
, GLenum newType
)
405 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
407 assert(attr
< VBO_ATTRIB_MAX
);
409 if (newSize
> exec
->vtx
.attr
[attr
].size
||
410 newType
!= exec
->vtx
.attr
[attr
].type
) {
411 /* New size is larger. Need to flush existing vertices and get
412 * an enlarged vertex format.
414 vbo_exec_wrap_upgrade_vertex(exec
, attr
, newSize
);
416 else if (newSize
< exec
->vtx
.attr
[attr
].active_size
) {
419 vbo_get_default_vals_as_union(exec
->vtx
.attr
[attr
].type
);
421 /* New size is smaller - just need to fill in some
422 * zeros. Don't need to flush or wrap.
424 for (i
= newSize
; i
<= exec
->vtx
.attr
[attr
].size
; i
++)
425 exec
->vtx
.attrptr
[attr
][i
-1] = id
[i
-1];
428 exec
->vtx
.attr
[attr
].active_size
= newSize
;
429 exec
->vtx
.attr
[attr
].type
= newType
;
431 /* Does setting NeedFlush belong here? Necessitates resetting
432 * vtxfmt on each flush (otherwise flags won't get reset
436 ctx
->Driver
.NeedFlush
|= FLUSH_STORED_VERTICES
;
441 * If index=0, does glVertexAttrib*() alias glVertex() to emit a vertex?
442 * It depends on a few things, including whether we're inside or outside
446 is_vertex_position(const struct gl_context
*ctx
, GLuint index
)
448 return (index
== 0 &&
449 _mesa_attr_zero_aliases_vertex(ctx
) &&
450 _mesa_inside_begin_end(ctx
));
453 /* Write a 64-bit value into a 32-bit pointer by preserving endianness. */
454 #if UTIL_ARCH_LITTLE_ENDIAN
455 #define SET_64BIT(dst32, u64) do { \
456 *(dst32)++ = (u64); \
457 *(dst32)++ = (uint64_t)(u64) >> 32; \
460 #define SET_64BIT(dst32, u64) do { \
461 *(dst32)++ = (uint64_t)(u64) >> 32; \
462 *(dst32)++ = (u64); \
468 * This macro is used to implement all the glVertex, glColor, glTexCoord,
469 * glVertexAttrib, etc functions.
470 * \param A VBO_ATTRIB_x attribute index
471 * \param N attribute size (1..4)
472 * \param T type (GL_FLOAT, GL_DOUBLE, GL_INT, GL_UNSIGNED_INT)
473 * \param C cast type (uint32_t or uint64_t)
474 * \param V0, V1, v2, V3 attribute value
476 #define ATTR_UNION(A, N, T, C, V0, V1, V2, V3) \
478 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
479 int sz = (sizeof(C) / sizeof(GLfloat)); \
481 assert(sz == 1 || sz == 2); \
483 /* check if attribute size or type is changing */ \
484 if (unlikely(exec->vtx.attr[A].active_size != N * sz) || \
485 unlikely(exec->vtx.attr[A].type != T)) { \
486 vbo_exec_fixup_vertex(ctx, A, N * sz, T); \
489 /* store a copy of the attribute in exec except for glVertex */ \
491 C *dest = (C *)exec->vtx.attrptr[A]; \
492 if (N>0) dest[0] = V0; \
493 if (N>1) dest[1] = V1; \
494 if (N>2) dest[2] = V2; \
495 if (N>3) dest[3] = V3; \
496 assert(exec->vtx.attr[A].type == T); \
500 /* This is a glVertex call */ \
501 uint32_t *dst = (uint32_t *)exec->vtx.buffer_ptr; \
502 uint32_t *src = (uint32_t *)exec->vtx.vertex; \
503 unsigned vertex_size_no_pos = exec->vtx.vertex_size_no_pos; \
505 /* Copy over attributes from exec. */ \
506 for (unsigned i = 0; i < vertex_size_no_pos; i++) \
509 /* Store the position, which is always last and can have 32 or */ \
510 /* 64 bits per channel. */ \
511 if (sizeof(C) == 4) { \
512 if (N > 0) *dst++ = V0; \
513 if (N > 1) *dst++ = V1; \
514 if (N > 2) *dst++ = V2; \
515 if (N > 3) *dst++ = V3; \
517 /* 64 bits: dst can be unaligned, so copy each 4-byte word */ \
519 if (N > 0) SET_64BIT(dst, V0); \
520 if (N > 1) SET_64BIT(dst, V1); \
521 if (N > 2) SET_64BIT(dst, V2); \
522 if (N > 3) SET_64BIT(dst, V3); \
525 /* dst now points at the beginning of the next vertex */ \
526 exec->vtx.buffer_ptr = (fi_type*)dst; \
528 /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \
529 /* something to draw (not just updating a color or texcoord).*/ \
530 /* Don't set FLUSH_UPDATE_CURRENT because */ \
531 /* Current.Attrib[VBO_ATTRIB_POS] is never used. */ \
532 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \
534 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
535 vbo_exec_vtx_wrap(exec); \
537 /* we now have accumulated per-vertex attributes */ \
538 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
544 #define ERROR(err) _mesa_error(ctx, err, __func__)
545 #define TAG(x) vbo_exec_##x
547 #include "vbo_attrib_tmp.h"
552 * Execute a glMaterial call. Note that if GL_COLOR_MATERIAL is enabled,
553 * this may be a (partial) no-op.
555 static void GLAPIENTRY
556 vbo_exec_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
558 GLbitfield updateMats
;
559 GET_CURRENT_CONTEXT(ctx
);
561 /* This function should be a no-op when it tries to update material
562 * attributes which are currently tracking glColor via glColorMaterial.
563 * The updateMats var will be a mask of the MAT_BIT_FRONT/BACK_x bits
564 * indicating which material attributes can actually be updated below.
566 if (ctx
->Light
.ColorMaterialEnabled
) {
567 updateMats
= ~ctx
->Light
._ColorMaterialBitmask
;
570 /* GL_COLOR_MATERIAL is disabled so don't skip any material updates */
571 updateMats
= ALL_MATERIAL_BITS
;
574 if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_FRONT
) {
575 updateMats
&= FRONT_MATERIAL_BITS
;
577 else if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_BACK
) {
578 updateMats
&= BACK_MATERIAL_BITS
;
580 else if (face
!= GL_FRONT_AND_BACK
) {
581 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterial(invalid face)");
587 if (updateMats
& MAT_BIT_FRONT_EMISSION
)
588 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_EMISSION
, 4, params
);
589 if (updateMats
& MAT_BIT_BACK_EMISSION
)
590 MAT_ATTR(VBO_ATTRIB_MAT_BACK_EMISSION
, 4, params
);
593 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
594 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
595 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
596 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
599 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
600 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
601 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
602 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
605 if (updateMats
& MAT_BIT_FRONT_SPECULAR
)
606 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SPECULAR
, 4, params
);
607 if (updateMats
& MAT_BIT_BACK_SPECULAR
)
608 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SPECULAR
, 4, params
);
611 if (*params
< 0 || *params
> ctx
->Const
.MaxShininess
) {
612 _mesa_error(ctx
, GL_INVALID_VALUE
,
613 "glMaterial(invalid shininess: %f out range [0, %f])",
614 *params
, ctx
->Const
.MaxShininess
);
617 if (updateMats
& MAT_BIT_FRONT_SHININESS
)
618 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SHININESS
, 1, params
);
619 if (updateMats
& MAT_BIT_BACK_SHININESS
)
620 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SHININESS
, 1, params
);
622 case GL_COLOR_INDEXES
:
623 if (ctx
->API
!= API_OPENGL_COMPAT
) {
624 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
627 if (updateMats
& MAT_BIT_FRONT_INDEXES
)
628 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_INDEXES
, 3, params
);
629 if (updateMats
& MAT_BIT_BACK_INDEXES
)
630 MAT_ATTR(VBO_ATTRIB_MAT_BACK_INDEXES
, 3, params
);
632 case GL_AMBIENT_AND_DIFFUSE
:
633 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
634 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
635 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
636 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
637 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
638 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
639 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
640 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
643 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
650 * Flush (draw) vertices.
652 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
655 vbo_exec_FlushVertices_internal(struct vbo_exec_context
*exec
, unsigned flags
)
657 struct gl_context
*ctx
= exec
->ctx
;
659 if (flags
& FLUSH_STORED_VERTICES
) {
660 if (exec
->vtx
.vert_count
) {
661 vbo_exec_vtx_flush(exec
);
664 if (exec
->vtx
.vertex_size
) {
665 vbo_exec_copy_to_current(exec
);
666 vbo_reset_all_attr(exec
);
670 ctx
->Driver
.NeedFlush
= 0;
672 assert(flags
== FLUSH_UPDATE_CURRENT
);
674 /* Note that the vertex size is unchanged.
675 * (vbo_reset_all_attr isn't called)
677 vbo_exec_copy_to_current(exec
);
679 /* Only FLUSH_UPDATE_CURRENT is done. */
680 ctx
->Driver
.NeedFlush
= ~FLUSH_UPDATE_CURRENT
;
685 static void GLAPIENTRY
686 vbo_exec_EvalCoord1f(GLfloat u
)
688 GET_CURRENT_CONTEXT(ctx
);
689 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
693 if (exec
->eval
.recalculate_maps
)
694 vbo_exec_eval_update(exec
);
696 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
697 if (exec
->eval
.map1
[i
].map
)
698 if (exec
->vtx
.attr
[i
].active_size
!= exec
->eval
.map1
[i
].sz
)
699 vbo_exec_fixup_vertex(ctx
, i
, exec
->eval
.map1
[i
].sz
, GL_FLOAT
);
703 memcpy(exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
704 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
706 vbo_exec_do_EvalCoord1f(exec
, u
);
708 memcpy(exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
709 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
713 static void GLAPIENTRY
714 vbo_exec_EvalCoord2f(GLfloat u
, GLfloat v
)
716 GET_CURRENT_CONTEXT(ctx
);
717 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
721 if (exec
->eval
.recalculate_maps
)
722 vbo_exec_eval_update(exec
);
724 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
725 if (exec
->eval
.map2
[i
].map
)
726 if (exec
->vtx
.attr
[i
].active_size
!= exec
->eval
.map2
[i
].sz
)
727 vbo_exec_fixup_vertex(ctx
, i
, exec
->eval
.map2
[i
].sz
, GL_FLOAT
);
730 if (ctx
->Eval
.AutoNormal
)
731 if (exec
->vtx
.attr
[VBO_ATTRIB_NORMAL
].active_size
!= 3)
732 vbo_exec_fixup_vertex(ctx
, VBO_ATTRIB_NORMAL
, 3, GL_FLOAT
);
735 memcpy(exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
736 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
738 vbo_exec_do_EvalCoord2f(exec
, u
, v
);
740 memcpy(exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
741 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
745 static void GLAPIENTRY
746 vbo_exec_EvalCoord1fv(const GLfloat
*u
)
748 vbo_exec_EvalCoord1f(u
[0]);
752 static void GLAPIENTRY
753 vbo_exec_EvalCoord2fv(const GLfloat
*u
)
755 vbo_exec_EvalCoord2f(u
[0], u
[1]);
759 static void GLAPIENTRY
760 vbo_exec_EvalPoint1(GLint i
)
762 GET_CURRENT_CONTEXT(ctx
);
763 GLfloat du
= ((ctx
->Eval
.MapGrid1u2
- ctx
->Eval
.MapGrid1u1
) /
764 (GLfloat
) ctx
->Eval
.MapGrid1un
);
765 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid1u1
;
767 vbo_exec_EvalCoord1f(u
);
771 static void GLAPIENTRY
772 vbo_exec_EvalPoint2(GLint i
, GLint j
)
774 GET_CURRENT_CONTEXT(ctx
);
775 GLfloat du
= ((ctx
->Eval
.MapGrid2u2
- ctx
->Eval
.MapGrid2u1
) /
776 (GLfloat
) ctx
->Eval
.MapGrid2un
);
777 GLfloat dv
= ((ctx
->Eval
.MapGrid2v2
- ctx
->Eval
.MapGrid2v1
) /
778 (GLfloat
) ctx
->Eval
.MapGrid2vn
);
779 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid2u1
;
780 GLfloat v
= j
* dv
+ ctx
->Eval
.MapGrid2v1
;
782 vbo_exec_EvalCoord2f(u
, v
);
787 * Called via glBegin.
789 static void GLAPIENTRY
790 vbo_exec_Begin(GLenum mode
)
792 GET_CURRENT_CONTEXT(ctx
);
793 struct vbo_context
*vbo
= vbo_context(ctx
);
794 struct vbo_exec_context
*exec
= &vbo
->exec
;
797 if (_mesa_inside_begin_end(ctx
)) {
798 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glBegin");
802 if (!_mesa_valid_prim_mode(ctx
, mode
, "glBegin")) {
806 if (!_mesa_valid_to_render(ctx
, "glBegin")) {
810 /* Heuristic: attempt to isolate attributes occurring outside
813 * Use FLUSH_STORED_VERTICES, because it updates current attribs and
814 * sets vertex_size to 0. (FLUSH_UPDATE_CURRENT doesn't change vertex_size)
816 if (exec
->vtx
.vertex_size
&& !exec
->vtx
.attr
[VBO_ATTRIB_POS
].size
)
817 vbo_exec_FlushVertices_internal(exec
, FLUSH_STORED_VERTICES
);
819 i
= exec
->vtx
.prim_count
++;
820 exec
->vtx
.prim
[i
].mode
= mode
;
821 exec
->vtx
.prim
[i
].begin
= 1;
822 exec
->vtx
.prim
[i
].end
= 0;
823 exec
->vtx
.prim
[i
].indexed
= 0;
824 exec
->vtx
.prim
[i
].pad
= 0;
825 exec
->vtx
.prim
[i
].start
= exec
->vtx
.vert_count
;
826 exec
->vtx
.prim
[i
].count
= 0;
827 exec
->vtx
.prim
[i
].num_instances
= 1;
828 exec
->vtx
.prim
[i
].base_instance
= 0;
829 exec
->vtx
.prim
[i
].is_indirect
= 0;
831 ctx
->Driver
.CurrentExecPrimitive
= mode
;
833 ctx
->Exec
= ctx
->BeginEnd
;
835 /* We may have been called from a display list, in which case we should
836 * leave dlist.c's dispatch table in place.
838 if (ctx
->CurrentClientDispatch
== ctx
->MarshalExec
) {
839 ctx
->CurrentServerDispatch
= ctx
->Exec
;
840 } else if (ctx
->CurrentClientDispatch
== ctx
->OutsideBeginEnd
) {
841 ctx
->CurrentClientDispatch
= ctx
->Exec
;
842 _glapi_set_dispatch(ctx
->CurrentClientDispatch
);
844 assert(ctx
->CurrentClientDispatch
== ctx
->Save
);
850 * Try to merge / concatenate the two most recent VBO primitives.
853 try_vbo_merge(struct vbo_exec_context
*exec
)
855 struct _mesa_prim
*cur
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
857 assert(exec
->vtx
.prim_count
>= 1);
859 vbo_try_prim_conversion(cur
);
861 if (exec
->vtx
.prim_count
>= 2) {
862 struct _mesa_prim
*prev
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 2];
863 assert(prev
== cur
- 1);
865 if (vbo_can_merge_prims(prev
, cur
)) {
870 vbo_merge_prims(prev
, cur
);
871 exec
->vtx
.prim_count
--; /* drop the last primitive */
880 static void GLAPIENTRY
883 GET_CURRENT_CONTEXT(ctx
);
884 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
886 if (!_mesa_inside_begin_end(ctx
)) {
887 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glEnd");
891 ctx
->Exec
= ctx
->OutsideBeginEnd
;
893 if (ctx
->CurrentClientDispatch
== ctx
->MarshalExec
) {
894 ctx
->CurrentServerDispatch
= ctx
->Exec
;
895 } else if (ctx
->CurrentClientDispatch
== ctx
->BeginEnd
) {
896 ctx
->CurrentClientDispatch
= ctx
->Exec
;
897 _glapi_set_dispatch(ctx
->CurrentClientDispatch
);
900 if (exec
->vtx
.prim_count
> 0) {
901 /* close off current primitive */
902 struct _mesa_prim
*last_prim
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
905 last_prim
->count
= exec
->vtx
.vert_count
- last_prim
->start
;
907 /* Special handling for GL_LINE_LOOP */
908 if (last_prim
->mode
== GL_LINE_LOOP
&& last_prim
->begin
== 0) {
909 /* We're finishing drawing a line loop. Append 0th vertex onto
910 * end of vertex buffer so we can draw it as a line strip.
912 const fi_type
*src
= exec
->vtx
.buffer_map
+
913 last_prim
->start
* exec
->vtx
.vertex_size
;
914 fi_type
*dst
= exec
->vtx
.buffer_map
+
915 exec
->vtx
.vert_count
* exec
->vtx
.vertex_size
;
917 /* copy 0th vertex to end of buffer */
918 memcpy(dst
, src
, exec
->vtx
.vertex_size
* sizeof(fi_type
));
920 last_prim
->start
++; /* skip vertex0 */
921 /* note that last_prim->count stays unchanged */
922 last_prim
->mode
= GL_LINE_STRIP
;
924 /* Increment the vertex count so the next primitive doesn't
925 * overwrite the last vertex which we just added.
927 exec
->vtx
.vert_count
++;
928 exec
->vtx
.buffer_ptr
+= exec
->vtx
.vertex_size
;
934 ctx
->Driver
.CurrentExecPrimitive
= PRIM_OUTSIDE_BEGIN_END
;
936 if (exec
->vtx
.prim_count
== VBO_MAX_PRIM
)
937 vbo_exec_vtx_flush(exec
);
939 if (MESA_DEBUG_FLAGS
& DEBUG_ALWAYS_FLUSH
) {
946 * Called via glPrimitiveRestartNV()
948 static void GLAPIENTRY
949 vbo_exec_PrimitiveRestartNV(void)
952 GET_CURRENT_CONTEXT(ctx
);
954 curPrim
= ctx
->Driver
.CurrentExecPrimitive
;
956 if (curPrim
== PRIM_OUTSIDE_BEGIN_END
) {
957 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPrimitiveRestartNV");
961 vbo_exec_Begin(curPrim
);
967 vbo_exec_vtxfmt_init(struct vbo_exec_context
*exec
)
969 struct gl_context
*ctx
= exec
->ctx
;
970 GLvertexformat
*vfmt
= &exec
->vtxfmt
;
972 #define NAME_AE(x) _ae_##x
973 #define NAME_CALLLIST(x) _mesa_##x
974 #define NAME(x) vbo_exec_##x
975 #define NAME_ES(x) _es_##x
977 #include "vbo_init_tmp.h"
982 * Tell the VBO module to use a real OpenGL vertex buffer object to
983 * store accumulated immediate-mode vertex data.
984 * This replaces the malloced buffer which was created in
985 * vb_exec_vtx_init() below.
988 vbo_use_buffer_objects(struct gl_context
*ctx
)
990 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
991 /* Any buffer name but 0 can be used here since this bufferobj won't
992 * go into the bufferobj hashtable.
994 GLuint bufName
= IMM_BUFFER_NAME
;
996 /* Make sure this func is only used once */
997 assert(exec
->vtx
.bufferobj
== ctx
->Shared
->NullBufferObj
);
999 _mesa_align_free(exec
->vtx
.buffer_map
);
1000 exec
->vtx
.buffer_map
= NULL
;
1001 exec
->vtx
.buffer_ptr
= NULL
;
1003 /* Allocate a real buffer object now */
1004 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1005 exec
->vtx
.bufferobj
= ctx
->Driver
.NewBufferObject(ctx
, bufName
);
1007 /* Map the buffer. */
1008 vbo_exec_vtx_map(exec
);
1009 assert(exec
->vtx
.buffer_ptr
);
1014 vbo_exec_vtx_init(struct vbo_exec_context
*exec
)
1016 struct gl_context
*ctx
= exec
->ctx
;
1019 /* Allocate a buffer object. Will just reuse this object
1020 * continuously, unless vbo_use_buffer_objects() is called to enable
1023 _mesa_reference_buffer_object(ctx
,
1024 &exec
->vtx
.bufferobj
,
1025 ctx
->Shared
->NullBufferObj
);
1027 assert(!exec
->vtx
.buffer_map
);
1028 exec
->vtx
.buffer_map
= _mesa_align_malloc(VBO_VERT_BUFFER_SIZE
, 64);
1029 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
1031 vbo_exec_vtxfmt_init(exec
);
1032 _mesa_noop_vtxfmt_init(ctx
, &exec
->vtxfmt_noop
);
1034 exec
->vtx
.enabled
= 0;
1035 for (i
= 0 ; i
< ARRAY_SIZE(exec
->vtx
.attr
); i
++) {
1036 exec
->vtx
.attr
[i
].size
= 0;
1037 exec
->vtx
.attr
[i
].type
= GL_FLOAT
;
1038 exec
->vtx
.attr
[i
].active_size
= 0;
1041 exec
->vtx
.vertex_size
= 0;
1046 vbo_exec_vtx_destroy(struct vbo_exec_context
*exec
)
1048 /* using a real VBO for vertex data */
1049 struct gl_context
*ctx
= exec
->ctx
;
1051 /* True VBOs should already be unmapped
1053 if (exec
->vtx
.buffer_map
) {
1054 assert(exec
->vtx
.bufferobj
->Name
== 0 ||
1055 exec
->vtx
.bufferobj
->Name
== IMM_BUFFER_NAME
);
1056 if (exec
->vtx
.bufferobj
->Name
== 0) {
1057 _mesa_align_free(exec
->vtx
.buffer_map
);
1058 exec
->vtx
.buffer_map
= NULL
;
1059 exec
->vtx
.buffer_ptr
= NULL
;
1063 /* Free the vertex buffer. Unmap first if needed.
1065 if (_mesa_bufferobj_mapped(exec
->vtx
.bufferobj
, MAP_INTERNAL
)) {
1066 ctx
->Driver
.UnmapBuffer(ctx
, exec
->vtx
.bufferobj
, MAP_INTERNAL
);
1068 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1073 * If inside glBegin()/glEnd(), it should assert(0). Otherwise, if
1074 * FLUSH_STORED_VERTICES bit in \p flags is set flushes any buffered
1075 * vertices, if FLUSH_UPDATE_CURRENT bit is set updates
1076 * __struct gl_contextRec::Current and gl_light_attrib::Material
1078 * Note that the default T&L engine never clears the
1079 * FLUSH_UPDATE_CURRENT bit, even after performing the update.
1081 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1084 vbo_exec_FlushVertices(struct gl_context
*ctx
, GLuint flags
)
1086 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1089 /* debug check: make sure we don't get called recursively */
1090 exec
->flush_call_depth
++;
1091 assert(exec
->flush_call_depth
== 1);
1094 if (_mesa_inside_begin_end(ctx
)) {
1095 /* We've had glBegin but not glEnd! */
1097 exec
->flush_call_depth
--;
1098 assert(exec
->flush_call_depth
== 0);
1104 vbo_exec_FlushVertices_internal(exec
, flags
);
1107 exec
->flush_call_depth
--;
1108 assert(exec
->flush_call_depth
== 0);
1114 * Reset the vertex attribute by setting its size to zero.
1117 vbo_reset_attr(struct vbo_exec_context
*exec
, GLuint attr
)
1119 exec
->vtx
.attr
[attr
].size
= 0;
1120 exec
->vtx
.attr
[attr
].type
= GL_FLOAT
;
1121 exec
->vtx
.attr
[attr
].active_size
= 0;
1126 vbo_reset_all_attr(struct vbo_exec_context
*exec
)
1128 while (exec
->vtx
.enabled
) {
1129 const int i
= u_bit_scan64(&exec
->vtx
.enabled
);
1130 vbo_reset_attr(exec
, i
);
1133 exec
->vtx
.vertex_size
= 0;
1138 _es_Color4f(GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
1140 vbo_exec_Color4f(r
, g
, b
, a
);
1145 _es_Normal3f(GLfloat x
, GLfloat y
, GLfloat z
)
1147 vbo_exec_Normal3f(x
, y
, z
);
1152 _es_MultiTexCoord4f(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1154 vbo_exec_MultiTexCoord4f(target
, s
, t
, r
, q
);
1159 _es_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
1161 vbo_exec_Materialfv(face
, pname
, params
);
1166 _es_Materialf(GLenum face
, GLenum pname
, GLfloat param
)
1170 p
[1] = p
[2] = p
[3] = 0.0F
;
1171 vbo_exec_Materialfv(face
, pname
, p
);
1176 * A special version of glVertexAttrib4f that does not treat index 0 as
1180 VertexAttrib4f_nopos(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1182 GET_CURRENT_CONTEXT(ctx
);
1183 if (index
< MAX_VERTEX_GENERIC_ATTRIBS
)
1184 ATTRF(VBO_ATTRIB_GENERIC0
+ index
, 4, x
, y
, z
, w
);
1186 ERROR(GL_INVALID_VALUE
);
1190 _es_VertexAttrib4f(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1192 VertexAttrib4f_nopos(index
, x
, y
, z
, w
);
1197 _es_VertexAttrib1f(GLuint indx
, GLfloat x
)
1199 VertexAttrib4f_nopos(indx
, x
, 0.0f
, 0.0f
, 1.0f
);
1204 _es_VertexAttrib1fv(GLuint indx
, const GLfloat
* values
)
1206 VertexAttrib4f_nopos(indx
, values
[0], 0.0f
, 0.0f
, 1.0f
);
1211 _es_VertexAttrib2f(GLuint indx
, GLfloat x
, GLfloat y
)
1213 VertexAttrib4f_nopos(indx
, x
, y
, 0.0f
, 1.0f
);
1218 _es_VertexAttrib2fv(GLuint indx
, const GLfloat
* values
)
1220 VertexAttrib4f_nopos(indx
, values
[0], values
[1], 0.0f
, 1.0f
);
1225 _es_VertexAttrib3f(GLuint indx
, GLfloat x
, GLfloat y
, GLfloat z
)
1227 VertexAttrib4f_nopos(indx
, x
, y
, z
, 1.0f
);
1232 _es_VertexAttrib3fv(GLuint indx
, const GLfloat
* values
)
1234 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], 1.0f
);
1239 _es_VertexAttrib4fv(GLuint indx
, const GLfloat
* values
)
1241 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], values
[3]);