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 * Copy current vertex attribute values into the current vertex.
237 vbo_exec_copy_from_current(struct vbo_exec_context
*exec
)
239 struct gl_context
*ctx
= exec
->ctx
;
240 struct vbo_context
*vbo
= vbo_context(ctx
);
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
));
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];
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
271 vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context
*exec
,
272 GLuint attr
, GLuint newSize
)
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
;
282 assert(attr
< VBO_ATTRIB_MAX
);
284 /* Run pipeline on current vertices, copy wrapped vertices
285 * to exec->vtx.copied.
287 vbo_exec_wrap_buffers(exec
);
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
294 memcpy(old_attrptr
, exec
->vtx
.attrptr
, sizeof(old_attrptr
));
297 bool repopulate
= unlikely(oldSize
) || (attr
!= 0 && exec
->vtx
.attr
[0].size
);
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.
304 vbo_exec_copy_to_current(exec
);
307 /* Heuristic: Attempt to isolate attributes received outside
308 * begin/end so that they don't bloat the vertices.
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
);
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
);
327 /* Size changed, recalculate all the attrptr[] values
329 fi_type
*tmp
= exec
->vtx
.vertex
;
331 /* Iterate backwards to make the position last, because glVertex
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
;
340 exec
->vtx
.attrptr
[i
] = NULL
; /* will not be dereferenced */
343 /* Copy from current to repopulate the vertex with correct
346 vbo_exec_copy_from_current(exec
);
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
;
354 /* Replay stored vertices to translate them
355 * to new format here.
357 * -- No need to replay - just copy piecewise
359 if (unlikely(exec
->vtx
.copied
.nr
)) {
360 fi_type
*data
= exec
->vtx
.copied
.buffer
;
361 fi_type
*dest
= exec
->vtx
.buffer_ptr
;
363 assert(exec
->vtx
.buffer_ptr
== exec
->vtx
.buffer_map
);
365 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
366 GLbitfield64 enabled
= exec
->vtx
.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
;
378 COPY_CLEAN_4V_TYPE_AS_UNION(tmp
, oldSize
,
380 exec
->vtx
.attr
[j
].type
);
381 COPY_SZ_4V(dest
+ new_offset
, newSize
, tmp
);
383 fi_type
*current
= (fi_type
*)vbo
->current
[j
].Ptr
;
384 COPY_SZ_4V(dest
+ new_offset
, sz
, current
);
388 COPY_SZ_4V(dest
+ new_offset
, sz
, data
+ old_offset
);
392 data
+= old_vtx_size
;
393 dest
+= exec
->vtx
.vertex_size
;
396 exec
->vtx
.buffer_ptr
= dest
;
397 exec
->vtx
.vert_count
+= exec
->vtx
.copied
.nr
;
398 exec
->vtx
.copied
.nr
= 0;
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
411 vbo_exec_fixup_vertex(struct gl_context
*ctx
, GLuint attr
,
412 GLuint newSize
, GLenum newType
)
414 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
416 assert(attr
< VBO_ATTRIB_MAX
);
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.
423 vbo_exec_wrap_upgrade_vertex(exec
, attr
, newSize
);
425 else if (newSize
< exec
->vtx
.attr
[attr
].active_size
) {
428 vbo_get_default_vals_as_union(exec
->vtx
.attr
[attr
].type
);
430 /* New size is smaller - just need to fill in some
431 * zeros. Don't need to flush or wrap.
433 for (i
= newSize
; i
<= exec
->vtx
.attr
[attr
].size
; i
++)
434 exec
->vtx
.attrptr
[attr
][i
-1] = id
[i
-1];
437 exec
->vtx
.attr
[attr
].active_size
= newSize
;
438 exec
->vtx
.attr
[attr
].type
= newType
;
440 /* Does setting NeedFlush belong here? Necessitates resetting
441 * vtxfmt on each flush (otherwise flags won't get reset
445 ctx
->Driver
.NeedFlush
|= FLUSH_STORED_VERTICES
;
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
455 is_vertex_position(const struct gl_context
*ctx
, GLuint index
)
457 return (index
== 0 &&
458 _mesa_attr_zero_aliases_vertex(ctx
) &&
459 _mesa_inside_begin_end(ctx
));
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; \
469 #define SET_64BIT(dst32, u64) do { \
470 *(dst32)++ = (uint64_t)(u64) >> 32; \
471 *(dst32)++ = (u64); \
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
485 #define ATTR_UNION(A, N, T, C, V0, V1, V2, V3) \
487 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
488 int sz = (sizeof(C) / sizeof(GLfloat)); \
490 assert(sz == 1 || sz == 2); \
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); \
498 /* store a copy of the attribute in exec except for glVertex */ \
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); \
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; \
514 /* Copy over attributes from exec. */ \
515 for (unsigned i = 0; i < vertex_size_no_pos; i++) \
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; \
526 /* 64 bits: dst can be unaligned, so copy each 4-byte word */ \
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); \
534 /* dst now points at the beginning of the next vertex */ \
535 exec->vtx.buffer_ptr = (fi_type*)dst; \
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; \
543 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
544 vbo_exec_vtx_wrap(exec); \
546 /* we now have accumulated per-vertex attributes */ \
547 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
553 #define ERROR(err) _mesa_error(ctx, err, __func__)
554 #define TAG(x) vbo_exec_##x
556 #include "vbo_attrib_tmp.h"
561 * Execute a glMaterial call. Note that if GL_COLOR_MATERIAL is enabled,
562 * this may be a (partial) no-op.
564 static void GLAPIENTRY
565 vbo_exec_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
567 GLbitfield updateMats
;
568 GET_CURRENT_CONTEXT(ctx
);
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.
575 if (ctx
->Light
.ColorMaterialEnabled
) {
576 updateMats
= ~ctx
->Light
._ColorMaterialBitmask
;
579 /* GL_COLOR_MATERIAL is disabled so don't skip any material updates */
580 updateMats
= ALL_MATERIAL_BITS
;
583 if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_FRONT
) {
584 updateMats
&= FRONT_MATERIAL_BITS
;
586 else if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_BACK
) {
587 updateMats
&= BACK_MATERIAL_BITS
;
589 else if (face
!= GL_FRONT_AND_BACK
) {
590 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterial(invalid face)");
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
);
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
);
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
);
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
);
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
);
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
);
631 case GL_COLOR_INDEXES
:
632 if (ctx
->API
!= API_OPENGL_COMPAT
) {
633 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
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
);
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
);
652 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
659 * Flush (draw) vertices.
662 vbo_exec_FlushVertices_internal(struct vbo_exec_context
*exec
)
664 if (exec
->vtx
.vert_count
) {
665 vbo_exec_vtx_flush(exec
);
668 if (exec
->vtx
.vertex_size
) {
669 vbo_exec_copy_to_current(exec
);
670 vbo_reset_all_attr(exec
);
675 static void GLAPIENTRY
676 vbo_exec_EvalCoord1f(GLfloat u
)
678 GET_CURRENT_CONTEXT(ctx
);
679 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
683 if (exec
->eval
.recalculate_maps
)
684 vbo_exec_eval_update(exec
);
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
);
693 memcpy(exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
694 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
696 vbo_exec_do_EvalCoord1f(exec
, u
);
698 memcpy(exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
699 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
703 static void GLAPIENTRY
704 vbo_exec_EvalCoord2f(GLfloat u
, GLfloat v
)
706 GET_CURRENT_CONTEXT(ctx
);
707 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
711 if (exec
->eval
.recalculate_maps
)
712 vbo_exec_eval_update(exec
);
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
);
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
);
725 memcpy(exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
726 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
728 vbo_exec_do_EvalCoord2f(exec
, u
, v
);
730 memcpy(exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
731 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
735 static void GLAPIENTRY
736 vbo_exec_EvalCoord1fv(const GLfloat
*u
)
738 vbo_exec_EvalCoord1f(u
[0]);
742 static void GLAPIENTRY
743 vbo_exec_EvalCoord2fv(const GLfloat
*u
)
745 vbo_exec_EvalCoord2f(u
[0], u
[1]);
749 static void GLAPIENTRY
750 vbo_exec_EvalPoint1(GLint i
)
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
;
757 vbo_exec_EvalCoord1f(u
);
761 static void GLAPIENTRY
762 vbo_exec_EvalPoint2(GLint i
, GLint j
)
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
;
772 vbo_exec_EvalCoord2f(u
, v
);
777 * Called via glBegin.
779 static void GLAPIENTRY
780 vbo_exec_Begin(GLenum mode
)
782 GET_CURRENT_CONTEXT(ctx
);
783 struct vbo_context
*vbo
= vbo_context(ctx
);
784 struct vbo_exec_context
*exec
= &vbo
->exec
;
787 if (_mesa_inside_begin_end(ctx
)) {
788 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glBegin");
792 if (!_mesa_valid_prim_mode(ctx
, mode
, "glBegin")) {
796 if (!_mesa_valid_to_render(ctx
, "glBegin")) {
800 /* Heuristic: attempt to isolate attributes occurring outside
803 if (exec
->vtx
.vertex_size
&& !exec
->vtx
.attr
[VBO_ATTRIB_POS
].size
)
804 vbo_exec_FlushVertices_internal(exec
);
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;
818 ctx
->Driver
.CurrentExecPrimitive
= mode
;
820 ctx
->Exec
= ctx
->BeginEnd
;
822 /* We may have been called from a display list, in which case we should
823 * leave dlist.c's dispatch table in place.
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
);
831 assert(ctx
->CurrentClientDispatch
== ctx
->Save
);
837 * Try to merge / concatenate the two most recent VBO primitives.
840 try_vbo_merge(struct vbo_exec_context
*exec
)
842 struct _mesa_prim
*cur
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
844 assert(exec
->vtx
.prim_count
>= 1);
846 vbo_try_prim_conversion(cur
);
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);
852 if (vbo_can_merge_prims(prev
, cur
)) {
857 vbo_merge_prims(prev
, cur
);
858 exec
->vtx
.prim_count
--; /* drop the last primitive */
867 static void GLAPIENTRY
870 GET_CURRENT_CONTEXT(ctx
);
871 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
873 if (!_mesa_inside_begin_end(ctx
)) {
874 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glEnd");
878 ctx
->Exec
= ctx
->OutsideBeginEnd
;
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
);
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];
892 last_prim
->count
= exec
->vtx
.vert_count
- last_prim
->start
;
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.
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
;
904 /* copy 0th vertex to end of buffer */
905 memcpy(dst
, src
, exec
->vtx
.vertex_size
* sizeof(fi_type
));
907 last_prim
->start
++; /* skip vertex0 */
908 /* note that last_prim->count stays unchanged */
909 last_prim
->mode
= GL_LINE_STRIP
;
911 /* Increment the vertex count so the next primitive doesn't
912 * overwrite the last vertex which we just added.
914 exec
->vtx
.vert_count
++;
915 exec
->vtx
.buffer_ptr
+= exec
->vtx
.vertex_size
;
921 ctx
->Driver
.CurrentExecPrimitive
= PRIM_OUTSIDE_BEGIN_END
;
923 if (exec
->vtx
.prim_count
== VBO_MAX_PRIM
)
924 vbo_exec_vtx_flush(exec
);
926 if (MESA_DEBUG_FLAGS
& DEBUG_ALWAYS_FLUSH
) {
933 * Called via glPrimitiveRestartNV()
935 static void GLAPIENTRY
936 vbo_exec_PrimitiveRestartNV(void)
939 GET_CURRENT_CONTEXT(ctx
);
941 curPrim
= ctx
->Driver
.CurrentExecPrimitive
;
943 if (curPrim
== PRIM_OUTSIDE_BEGIN_END
) {
944 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPrimitiveRestartNV");
948 vbo_exec_Begin(curPrim
);
954 vbo_exec_vtxfmt_init(struct vbo_exec_context
*exec
)
956 struct gl_context
*ctx
= exec
->ctx
;
957 GLvertexformat
*vfmt
= &exec
->vtxfmt
;
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
964 #include "vbo_init_tmp.h"
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.
975 vbo_use_buffer_objects(struct gl_context
*ctx
)
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.
981 GLuint bufName
= IMM_BUFFER_NAME
;
983 /* Make sure this func is only used once */
984 assert(exec
->vtx
.bufferobj
== ctx
->Shared
->NullBufferObj
);
986 _mesa_align_free(exec
->vtx
.buffer_map
);
987 exec
->vtx
.buffer_map
= NULL
;
988 exec
->vtx
.buffer_ptr
= NULL
;
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
);
994 /* Map the buffer. */
995 vbo_exec_vtx_map(exec
);
996 assert(exec
->vtx
.buffer_ptr
);
1001 vbo_exec_vtx_init(struct vbo_exec_context
*exec
)
1003 struct gl_context
*ctx
= exec
->ctx
;
1006 /* Allocate a buffer object. Will just reuse this object
1007 * continuously, unless vbo_use_buffer_objects() is called to enable
1010 _mesa_reference_buffer_object(ctx
,
1011 &exec
->vtx
.bufferobj
,
1012 ctx
->Shared
->NullBufferObj
);
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
;
1018 vbo_exec_vtxfmt_init(exec
);
1019 _mesa_noop_vtxfmt_init(ctx
, &exec
->vtxfmt_noop
);
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;
1028 exec
->vtx
.vertex_size
= 0;
1033 vbo_exec_vtx_destroy(struct vbo_exec_context
*exec
)
1035 /* using a real VBO for vertex data */
1036 struct gl_context
*ctx
= exec
->ctx
;
1038 /* True VBOs should already be unmapped
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
;
1050 /* Free the vertex buffer. Unmap first if needed.
1052 if (_mesa_bufferobj_mapped(exec
->vtx
.bufferobj
, MAP_INTERNAL
)) {
1053 ctx
->Driver
.UnmapBuffer(ctx
, exec
->vtx
.bufferobj
, MAP_INTERNAL
);
1055 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
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
1065 * Note that the default T&L engine never clears the
1066 * FLUSH_UPDATE_CURRENT bit, even after performing the update.
1068 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1071 vbo_exec_FlushVertices(struct gl_context
*ctx
, GLuint flags
)
1073 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1076 /* debug check: make sure we don't get called recursively */
1077 exec
->flush_call_depth
++;
1078 assert(exec
->flush_call_depth
== 1);
1081 if (_mesa_inside_begin_end(ctx
)) {
1082 /* We've had glBegin but not glEnd! */
1084 exec
->flush_call_depth
--;
1085 assert(exec
->flush_call_depth
== 0);
1091 vbo_exec_FlushVertices_internal(exec
);
1093 /* Clear the dirty flush flags, because the flush is finished. */
1094 ctx
->Driver
.NeedFlush
&= ~(FLUSH_UPDATE_CURRENT
| flags
);
1097 exec
->flush_call_depth
--;
1098 assert(exec
->flush_call_depth
== 0);
1104 * Reset the vertex attribute by setting its size to zero.
1107 vbo_reset_attr(struct vbo_exec_context
*exec
, GLuint attr
)
1109 exec
->vtx
.attr
[attr
].size
= 0;
1110 exec
->vtx
.attr
[attr
].type
= GL_FLOAT
;
1111 exec
->vtx
.attr
[attr
].active_size
= 0;
1116 vbo_reset_all_attr(struct vbo_exec_context
*exec
)
1118 while (exec
->vtx
.enabled
) {
1119 const int i
= u_bit_scan64(&exec
->vtx
.enabled
);
1120 vbo_reset_attr(exec
, i
);
1123 exec
->vtx
.vertex_size
= 0;
1128 _es_Color4f(GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
1130 vbo_exec_Color4f(r
, g
, b
, a
);
1135 _es_Normal3f(GLfloat x
, GLfloat y
, GLfloat z
)
1137 vbo_exec_Normal3f(x
, y
, z
);
1142 _es_MultiTexCoord4f(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1144 vbo_exec_MultiTexCoord4f(target
, s
, t
, r
, q
);
1149 _es_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
1151 vbo_exec_Materialfv(face
, pname
, params
);
1156 _es_Materialf(GLenum face
, GLenum pname
, GLfloat param
)
1160 p
[1] = p
[2] = p
[3] = 0.0F
;
1161 vbo_exec_Materialfv(face
, pname
, p
);
1166 * A special version of glVertexAttrib4f that does not treat index 0 as
1170 VertexAttrib4f_nopos(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1172 GET_CURRENT_CONTEXT(ctx
);
1173 if (index
< MAX_VERTEX_GENERIC_ATTRIBS
)
1174 ATTRF(VBO_ATTRIB_GENERIC0
+ index
, 4, x
, y
, z
, w
);
1176 ERROR(GL_INVALID_VALUE
);
1180 _es_VertexAttrib4f(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1182 VertexAttrib4f_nopos(index
, x
, y
, z
, w
);
1187 _es_VertexAttrib1f(GLuint indx
, GLfloat x
)
1189 VertexAttrib4f_nopos(indx
, x
, 0.0f
, 0.0f
, 1.0f
);
1194 _es_VertexAttrib1fv(GLuint indx
, const GLfloat
* values
)
1196 VertexAttrib4f_nopos(indx
, values
[0], 0.0f
, 0.0f
, 1.0f
);
1201 _es_VertexAttrib2f(GLuint indx
, GLfloat x
, GLfloat y
)
1203 VertexAttrib4f_nopos(indx
, x
, y
, 0.0f
, 1.0f
);
1208 _es_VertexAttrib2fv(GLuint indx
, const GLfloat
* values
)
1210 VertexAttrib4f_nopos(indx
, values
[0], values
[1], 0.0f
, 1.0f
);
1215 _es_VertexAttrib3f(GLuint indx
, GLfloat x
, GLfloat y
, GLfloat z
)
1217 VertexAttrib4f_nopos(indx
, x
, y
, z
, 1.0f
);
1222 _es_VertexAttrib3fv(GLuint indx
, const GLfloat
* values
)
1224 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], 1.0f
);
1229 _es_VertexAttrib4fv(GLuint indx
, const GLfloat
* values
)
1231 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], values
[3]);