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
, GLenum newType
)
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
.attr
[attr
].active_size
= newSize
;
282 exec
->vtx
.attr
[attr
].type
= newType
;
283 exec
->vtx
.vertex_size
+= newSize
- oldSize
;
284 exec
->vtx
.vertex_size_no_pos
= exec
->vtx
.vertex_size
- exec
->vtx
.attr
[0].size
;
285 exec
->vtx
.max_vert
= vbo_compute_max_verts(exec
);
286 exec
->vtx
.vert_count
= 0;
287 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
288 exec
->vtx
.enabled
|= BITFIELD64_BIT(attr
);
291 if (unlikely(oldSize
)) {
292 unsigned offset
= exec
->vtx
.attrptr
[attr
] - exec
->vtx
.vertex
;
294 /* If there are attribs after the resized attrib... */
295 if (offset
+ oldSize
< old_vtx_size_no_pos
) {
296 int size_diff
= newSize
- oldSize
;
297 fi_type
*old_first
= exec
->vtx
.attrptr
[attr
] + oldSize
;
298 fi_type
*new_first
= exec
->vtx
.attrptr
[attr
] + newSize
;
299 fi_type
*old_last
= exec
->vtx
.vertex
+ old_vtx_size_no_pos
- 1;
300 fi_type
*new_last
= exec
->vtx
.vertex
+ exec
->vtx
.vertex_size_no_pos
- 1;
303 /* Decreasing the size: Copy from first to last to move
304 * elements to the left.
306 fi_type
*old_end
= old_last
+ 1;
307 fi_type
*old
= old_first
;
308 fi_type
*new = new_first
;
312 } while (old
!= old_end
);
314 /* Increasing the size: Copy from last to first to move
315 * elements to the right.
317 fi_type
*old_end
= old_first
- 1;
318 fi_type
*old
= old_last
;
319 fi_type
*new = new_last
;
323 } while (old
!= old_end
);
326 /* Update pointers to attribs, because we moved them. */
327 GLbitfield64 enabled
= exec
->vtx
.enabled
&
328 ~BITFIELD64_BIT(VBO_ATTRIB_POS
) &
329 ~BITFIELD64_BIT(attr
);
331 unsigned i
= u_bit_scan64(&enabled
);
333 if (exec
->vtx
.attrptr
[i
] > exec
->vtx
.attrptr
[attr
])
334 exec
->vtx
.attrptr
[i
] += size_diff
;
338 /* Just have to append the new attribute at the end */
339 exec
->vtx
.attrptr
[attr
] = exec
->vtx
.vertex
+
340 exec
->vtx
.vertex_size_no_pos
- newSize
;
344 /* The position is always last. */
345 exec
->vtx
.attrptr
[0] = exec
->vtx
.vertex
+ exec
->vtx
.vertex_size_no_pos
;
347 /* Replay stored vertices to translate them
348 * to new format here.
350 * -- No need to replay - just copy piecewise
352 if (unlikely(exec
->vtx
.copied
.nr
)) {
353 fi_type
*data
= exec
->vtx
.copied
.buffer
;
354 fi_type
*dest
= exec
->vtx
.buffer_ptr
;
356 assert(exec
->vtx
.buffer_ptr
== exec
->vtx
.buffer_map
);
358 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
359 GLbitfield64 enabled
= exec
->vtx
.enabled
;
361 const int j
= u_bit_scan64(&enabled
);
362 GLuint sz
= exec
->vtx
.attr
[j
].size
;
363 GLint old_offset
= old_attrptr
[j
] - exec
->vtx
.vertex
;
364 GLint new_offset
= exec
->vtx
.attrptr
[j
] - exec
->vtx
.vertex
;
371 COPY_CLEAN_4V_TYPE_AS_UNION(tmp
, oldSize
,
373 exec
->vtx
.attr
[j
].type
);
374 COPY_SZ_4V(dest
+ new_offset
, newSize
, tmp
);
376 fi_type
*current
= (fi_type
*)vbo
->current
[j
].Ptr
;
377 COPY_SZ_4V(dest
+ new_offset
, sz
, current
);
381 COPY_SZ_4V(dest
+ new_offset
, sz
, data
+ old_offset
);
385 data
+= old_vtx_size
;
386 dest
+= exec
->vtx
.vertex_size
;
389 exec
->vtx
.buffer_ptr
= dest
;
390 exec
->vtx
.vert_count
+= exec
->vtx
.copied
.nr
;
391 exec
->vtx
.copied
.nr
= 0;
397 * This is when a vertex attribute transitions to a different size.
398 * For example, we saw a bunch of glTexCoord2f() calls and now we got a
399 * glTexCoord4f() call. We promote the array from size=2 to size=4.
400 * \param newSize size of new vertex (number of 32-bit words).
401 * \param attr VBO_ATTRIB_x vertex attribute value
404 vbo_exec_fixup_vertex(struct gl_context
*ctx
, GLuint attr
,
405 GLuint newSize
, GLenum newType
)
407 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
409 assert(attr
< VBO_ATTRIB_MAX
);
411 if (newSize
> exec
->vtx
.attr
[attr
].size
||
412 newType
!= exec
->vtx
.attr
[attr
].type
) {
413 /* New size is larger. Need to flush existing vertices and get
414 * an enlarged vertex format.
416 vbo_exec_wrap_upgrade_vertex(exec
, attr
, newSize
, newType
);
418 else if (newSize
< exec
->vtx
.attr
[attr
].active_size
) {
421 vbo_get_default_vals_as_union(exec
->vtx
.attr
[attr
].type
);
423 /* New size is smaller - just need to fill in some
424 * zeros. Don't need to flush or wrap.
426 for (i
= newSize
; i
<= exec
->vtx
.attr
[attr
].size
; i
++)
427 exec
->vtx
.attrptr
[attr
][i
-1] = id
[i
-1];
429 exec
->vtx
.attr
[attr
].active_size
= newSize
;
435 * If index=0, does glVertexAttrib*() alias glVertex() to emit a vertex?
436 * It depends on a few things, including whether we're inside or outside
440 is_vertex_position(const struct gl_context
*ctx
, GLuint index
)
442 return (index
== 0 &&
443 _mesa_attr_zero_aliases_vertex(ctx
) &&
444 _mesa_inside_begin_end(ctx
));
447 /* Write a 64-bit value into a 32-bit pointer by preserving endianness. */
448 #if UTIL_ARCH_LITTLE_ENDIAN
449 #define SET_64BIT(dst32, u64) do { \
450 *(dst32)++ = (u64); \
451 *(dst32)++ = (uint64_t)(u64) >> 32; \
454 #define SET_64BIT(dst32, u64) do { \
455 *(dst32)++ = (uint64_t)(u64) >> 32; \
456 *(dst32)++ = (u64); \
462 * This macro is used to implement all the glVertex, glColor, glTexCoord,
463 * glVertexAttrib, etc functions.
464 * \param A VBO_ATTRIB_x attribute index
465 * \param N attribute size (1..4)
466 * \param T type (GL_FLOAT, GL_DOUBLE, GL_INT, GL_UNSIGNED_INT)
467 * \param C cast type (uint32_t or uint64_t)
468 * \param V0, V1, v2, V3 attribute value
470 #define ATTR_UNION(A, N, T, C, V0, V1, V2, V3) \
472 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
473 int sz = (sizeof(C) / sizeof(GLfloat)); \
475 assert(sz == 1 || sz == 2); \
477 /* store a copy of the attribute in exec except for glVertex */ \
479 /* Check if attribute size or type is changing. */ \
480 if (unlikely(exec->vtx.attr[A].active_size != N * sz || \
481 exec->vtx.attr[A].type != T)) { \
482 vbo_exec_fixup_vertex(ctx, A, N * sz, T); \
485 C *dest = (C *)exec->vtx.attrptr[A]; \
486 if (N>0) dest[0] = V0; \
487 if (N>1) dest[1] = V1; \
488 if (N>2) dest[2] = V2; \
489 if (N>3) dest[3] = V3; \
490 assert(exec->vtx.attr[A].type == T); \
492 /* we now have accumulated a per-vertex attribute */ \
493 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
495 /* This is a glVertex call */ \
496 /* Check if attribute size or type is changing. */ \
497 if (unlikely(exec->vtx.attr[0].size < N * sz || \
498 exec->vtx.attr[0].type != T)) { \
499 vbo_exec_wrap_upgrade_vertex(exec, 0, N * sz, T); \
502 uint32_t *dst = (uint32_t *)exec->vtx.buffer_ptr; \
503 uint32_t *src = (uint32_t *)exec->vtx.vertex; \
504 unsigned vertex_size_no_pos = exec->vtx.vertex_size_no_pos; \
506 /* Copy over attributes from exec. */ \
507 for (unsigned i = 0; i < vertex_size_no_pos; i++) \
510 /* Store the position, which is always last and can have 32 or */ \
511 /* 64 bits per channel. */ \
512 if (sizeof(C) == 4) { \
513 if (N > 0) *dst++ = V0; \
514 if (N > 1) *dst++ = V1; \
515 if (N > 2) *dst++ = V2; \
516 if (N > 3) *dst++ = V3; \
518 /* 64 bits: dst can be unaligned, so copy each 4-byte word */ \
520 if (N > 0) SET_64BIT(dst, V0); \
521 if (N > 1) SET_64BIT(dst, V1); \
522 if (N > 2) SET_64BIT(dst, V2); \
523 if (N > 3) SET_64BIT(dst, V3); \
526 /* dst now points at the beginning of the next vertex */ \
527 exec->vtx.buffer_ptr = (fi_type*)dst; \
529 /* Don't set FLUSH_UPDATE_CURRENT because */ \
530 /* Current.Attrib[VBO_ATTRIB_POS] is never used. */ \
532 if (unlikely(++exec->vtx.vert_count >= exec->vtx.max_vert)) \
533 vbo_exec_vtx_wrap(exec); \
539 #define ERROR(err) _mesa_error(ctx, err, __func__)
540 #define TAG(x) vbo_exec_##x
542 #include "vbo_attrib_tmp.h"
547 * Execute a glMaterial call. Note that if GL_COLOR_MATERIAL is enabled,
548 * this may be a (partial) no-op.
550 static void GLAPIENTRY
551 vbo_exec_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
553 GLbitfield updateMats
;
554 GET_CURRENT_CONTEXT(ctx
);
556 /* This function should be a no-op when it tries to update material
557 * attributes which are currently tracking glColor via glColorMaterial.
558 * The updateMats var will be a mask of the MAT_BIT_FRONT/BACK_x bits
559 * indicating which material attributes can actually be updated below.
561 if (ctx
->Light
.ColorMaterialEnabled
) {
562 updateMats
= ~ctx
->Light
._ColorMaterialBitmask
;
565 /* GL_COLOR_MATERIAL is disabled so don't skip any material updates */
566 updateMats
= ALL_MATERIAL_BITS
;
569 if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_FRONT
) {
570 updateMats
&= FRONT_MATERIAL_BITS
;
572 else if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_BACK
) {
573 updateMats
&= BACK_MATERIAL_BITS
;
575 else if (face
!= GL_FRONT_AND_BACK
) {
576 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterial(invalid face)");
582 if (updateMats
& MAT_BIT_FRONT_EMISSION
)
583 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_EMISSION
, 4, params
);
584 if (updateMats
& MAT_BIT_BACK_EMISSION
)
585 MAT_ATTR(VBO_ATTRIB_MAT_BACK_EMISSION
, 4, params
);
588 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
589 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
590 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
591 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
594 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
595 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
596 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
597 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
600 if (updateMats
& MAT_BIT_FRONT_SPECULAR
)
601 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SPECULAR
, 4, params
);
602 if (updateMats
& MAT_BIT_BACK_SPECULAR
)
603 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SPECULAR
, 4, params
);
606 if (*params
< 0 || *params
> ctx
->Const
.MaxShininess
) {
607 _mesa_error(ctx
, GL_INVALID_VALUE
,
608 "glMaterial(invalid shininess: %f out range [0, %f])",
609 *params
, ctx
->Const
.MaxShininess
);
612 if (updateMats
& MAT_BIT_FRONT_SHININESS
)
613 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SHININESS
, 1, params
);
614 if (updateMats
& MAT_BIT_BACK_SHININESS
)
615 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SHININESS
, 1, params
);
617 case GL_COLOR_INDEXES
:
618 if (ctx
->API
!= API_OPENGL_COMPAT
) {
619 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
622 if (updateMats
& MAT_BIT_FRONT_INDEXES
)
623 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_INDEXES
, 3, params
);
624 if (updateMats
& MAT_BIT_BACK_INDEXES
)
625 MAT_ATTR(VBO_ATTRIB_MAT_BACK_INDEXES
, 3, params
);
627 case GL_AMBIENT_AND_DIFFUSE
:
628 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
629 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
630 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
631 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
632 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
633 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
634 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
635 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
638 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
645 * Flush (draw) vertices.
647 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
650 vbo_exec_FlushVertices_internal(struct vbo_exec_context
*exec
, unsigned flags
)
652 struct gl_context
*ctx
= exec
->ctx
;
654 if (flags
& FLUSH_STORED_VERTICES
) {
655 if (exec
->vtx
.vert_count
) {
656 vbo_exec_vtx_flush(exec
);
659 if (exec
->vtx
.vertex_size
) {
660 vbo_exec_copy_to_current(exec
);
661 vbo_reset_all_attr(exec
);
665 ctx
->Driver
.NeedFlush
= 0;
667 assert(flags
== FLUSH_UPDATE_CURRENT
);
669 /* Note that the vertex size is unchanged.
670 * (vbo_reset_all_attr isn't called)
672 vbo_exec_copy_to_current(exec
);
674 /* Only FLUSH_UPDATE_CURRENT is done. */
675 ctx
->Driver
.NeedFlush
= ~FLUSH_UPDATE_CURRENT
;
680 static void GLAPIENTRY
681 vbo_exec_EvalCoord1f(GLfloat u
)
683 GET_CURRENT_CONTEXT(ctx
);
684 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
688 if (exec
->eval
.recalculate_maps
)
689 vbo_exec_eval_update(exec
);
691 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
692 if (exec
->eval
.map1
[i
].map
)
693 if (exec
->vtx
.attr
[i
].active_size
!= exec
->eval
.map1
[i
].sz
)
694 vbo_exec_fixup_vertex(ctx
, i
, exec
->eval
.map1
[i
].sz
, GL_FLOAT
);
698 memcpy(exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
699 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
701 vbo_exec_do_EvalCoord1f(exec
, u
);
703 memcpy(exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
704 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
708 static void GLAPIENTRY
709 vbo_exec_EvalCoord2f(GLfloat u
, GLfloat v
)
711 GET_CURRENT_CONTEXT(ctx
);
712 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
716 if (exec
->eval
.recalculate_maps
)
717 vbo_exec_eval_update(exec
);
719 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
720 if (exec
->eval
.map2
[i
].map
)
721 if (exec
->vtx
.attr
[i
].active_size
!= exec
->eval
.map2
[i
].sz
)
722 vbo_exec_fixup_vertex(ctx
, i
, exec
->eval
.map2
[i
].sz
, GL_FLOAT
);
725 if (ctx
->Eval
.AutoNormal
)
726 if (exec
->vtx
.attr
[VBO_ATTRIB_NORMAL
].active_size
!= 3)
727 vbo_exec_fixup_vertex(ctx
, VBO_ATTRIB_NORMAL
, 3, GL_FLOAT
);
730 memcpy(exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
731 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
733 vbo_exec_do_EvalCoord2f(exec
, u
, v
);
735 memcpy(exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
736 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
740 static void GLAPIENTRY
741 vbo_exec_EvalCoord1fv(const GLfloat
*u
)
743 vbo_exec_EvalCoord1f(u
[0]);
747 static void GLAPIENTRY
748 vbo_exec_EvalCoord2fv(const GLfloat
*u
)
750 vbo_exec_EvalCoord2f(u
[0], u
[1]);
754 static void GLAPIENTRY
755 vbo_exec_EvalPoint1(GLint i
)
757 GET_CURRENT_CONTEXT(ctx
);
758 GLfloat du
= ((ctx
->Eval
.MapGrid1u2
- ctx
->Eval
.MapGrid1u1
) /
759 (GLfloat
) ctx
->Eval
.MapGrid1un
);
760 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid1u1
;
762 vbo_exec_EvalCoord1f(u
);
766 static void GLAPIENTRY
767 vbo_exec_EvalPoint2(GLint i
, GLint j
)
769 GET_CURRENT_CONTEXT(ctx
);
770 GLfloat du
= ((ctx
->Eval
.MapGrid2u2
- ctx
->Eval
.MapGrid2u1
) /
771 (GLfloat
) ctx
->Eval
.MapGrid2un
);
772 GLfloat dv
= ((ctx
->Eval
.MapGrid2v2
- ctx
->Eval
.MapGrid2v1
) /
773 (GLfloat
) ctx
->Eval
.MapGrid2vn
);
774 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid2u1
;
775 GLfloat v
= j
* dv
+ ctx
->Eval
.MapGrid2v1
;
777 vbo_exec_EvalCoord2f(u
, v
);
782 * Called via glBegin.
784 static void GLAPIENTRY
785 vbo_exec_Begin(GLenum mode
)
787 GET_CURRENT_CONTEXT(ctx
);
788 struct vbo_context
*vbo
= vbo_context(ctx
);
789 struct vbo_exec_context
*exec
= &vbo
->exec
;
792 if (_mesa_inside_begin_end(ctx
)) {
793 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glBegin");
797 if (!_mesa_valid_prim_mode(ctx
, mode
, "glBegin")) {
801 if (!_mesa_valid_to_render(ctx
, "glBegin")) {
805 /* Heuristic: attempt to isolate attributes occurring outside
808 * Use FLUSH_STORED_VERTICES, because it updates current attribs and
809 * sets vertex_size to 0. (FLUSH_UPDATE_CURRENT doesn't change vertex_size)
811 if (exec
->vtx
.vertex_size
&& !exec
->vtx
.attr
[VBO_ATTRIB_POS
].size
)
812 vbo_exec_FlushVertices_internal(exec
, FLUSH_STORED_VERTICES
);
814 i
= exec
->vtx
.prim_count
++;
815 exec
->vtx
.prim
[i
].mode
= mode
;
816 exec
->vtx
.prim
[i
].begin
= 1;
817 exec
->vtx
.prim
[i
].end
= 0;
818 exec
->vtx
.prim
[i
].start
= exec
->vtx
.vert_count
;
819 exec
->vtx
.prim
[i
].count
= 0;
821 ctx
->Driver
.CurrentExecPrimitive
= mode
;
823 ctx
->Exec
= ctx
->BeginEnd
;
825 /* We may have been called from a display list, in which case we should
826 * leave dlist.c's dispatch table in place.
828 if (ctx
->CurrentClientDispatch
== ctx
->MarshalExec
) {
829 ctx
->CurrentServerDispatch
= ctx
->Exec
;
830 } else if (ctx
->CurrentClientDispatch
== ctx
->OutsideBeginEnd
) {
831 ctx
->CurrentClientDispatch
= ctx
->Exec
;
832 _glapi_set_dispatch(ctx
->CurrentClientDispatch
);
834 assert(ctx
->CurrentClientDispatch
== ctx
->Save
);
840 * Try to merge / concatenate the two most recent VBO primitives.
843 try_vbo_merge(struct vbo_exec_context
*exec
)
845 struct _mesa_prim
*cur
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
847 assert(exec
->vtx
.prim_count
>= 1);
849 vbo_try_prim_conversion(cur
);
851 if (exec
->vtx
.prim_count
>= 2) {
852 struct _mesa_prim
*prev
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 2];
853 assert(prev
== cur
- 1);
855 if (vbo_merge_draws(exec
->ctx
, false, prev
, cur
))
856 exec
->vtx
.prim_count
--; /* drop the last primitive */
864 static void GLAPIENTRY
867 GET_CURRENT_CONTEXT(ctx
);
868 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
870 if (!_mesa_inside_begin_end(ctx
)) {
871 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glEnd");
875 ctx
->Exec
= ctx
->OutsideBeginEnd
;
877 if (ctx
->CurrentClientDispatch
== ctx
->MarshalExec
) {
878 ctx
->CurrentServerDispatch
= ctx
->Exec
;
879 } else if (ctx
->CurrentClientDispatch
== ctx
->BeginEnd
) {
880 ctx
->CurrentClientDispatch
= ctx
->Exec
;
881 _glapi_set_dispatch(ctx
->CurrentClientDispatch
);
884 if (exec
->vtx
.prim_count
> 0) {
885 /* close off current primitive */
886 struct _mesa_prim
*last_prim
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
887 unsigned count
= exec
->vtx
.vert_count
- last_prim
->start
;
890 last_prim
->count
= count
;
893 ctx
->Driver
.NeedFlush
|= FLUSH_STORED_VERTICES
;
895 /* Special handling for GL_LINE_LOOP */
896 if (last_prim
->mode
== GL_LINE_LOOP
&& last_prim
->begin
== 0) {
897 /* We're finishing drawing a line loop. Append 0th vertex onto
898 * end of vertex buffer so we can draw it as a line strip.
900 const fi_type
*src
= exec
->vtx
.buffer_map
+
901 last_prim
->start
* exec
->vtx
.vertex_size
;
902 fi_type
*dst
= exec
->vtx
.buffer_map
+
903 exec
->vtx
.vert_count
* exec
->vtx
.vertex_size
;
905 /* copy 0th vertex to end of buffer */
906 memcpy(dst
, src
, exec
->vtx
.vertex_size
* sizeof(fi_type
));
908 last_prim
->start
++; /* skip vertex0 */
909 /* note that last_prim->count stays unchanged */
910 last_prim
->mode
= GL_LINE_STRIP
;
912 /* Increment the vertex count so the next primitive doesn't
913 * overwrite the last vertex which we just added.
915 exec
->vtx
.vert_count
++;
916 exec
->vtx
.buffer_ptr
+= exec
->vtx
.vertex_size
;
922 ctx
->Driver
.CurrentExecPrimitive
= PRIM_OUTSIDE_BEGIN_END
;
924 if (exec
->vtx
.prim_count
== VBO_MAX_PRIM
)
925 vbo_exec_vtx_flush(exec
);
927 if (MESA_DEBUG_FLAGS
& DEBUG_ALWAYS_FLUSH
) {
934 * Called via glPrimitiveRestartNV()
936 static void GLAPIENTRY
937 vbo_exec_PrimitiveRestartNV(void)
940 GET_CURRENT_CONTEXT(ctx
);
942 curPrim
= ctx
->Driver
.CurrentExecPrimitive
;
944 if (curPrim
== PRIM_OUTSIDE_BEGIN_END
) {
945 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPrimitiveRestartNV");
949 vbo_exec_Begin(curPrim
);
955 vbo_exec_vtxfmt_init(struct vbo_exec_context
*exec
)
957 struct gl_context
*ctx
= exec
->ctx
;
958 GLvertexformat
*vfmt
= &exec
->vtxfmt
;
960 #define NAME_AE(x) _ae_##x
961 #define NAME_CALLLIST(x) _mesa_##x
962 #define NAME(x) vbo_exec_##x
963 #define NAME_ES(x) _es_##x
965 #include "vbo_init_tmp.h"
970 vbo_reset_all_attr(struct vbo_exec_context
*exec
)
972 while (exec
->vtx
.enabled
) {
973 const int i
= u_bit_scan64(&exec
->vtx
.enabled
);
975 /* Reset the vertex attribute by setting its size to zero. */
976 exec
->vtx
.attr
[i
].size
= 0;
977 exec
->vtx
.attr
[i
].type
= GL_FLOAT
;
978 exec
->vtx
.attr
[i
].active_size
= 0;
979 exec
->vtx
.attrptr
[i
] = NULL
;
982 exec
->vtx
.vertex_size
= 0;
987 vbo_exec_vtx_init(struct vbo_exec_context
*exec
, bool use_buffer_objects
)
989 struct gl_context
*ctx
= exec
->ctx
;
991 if (use_buffer_objects
) {
992 /* Use buffer objects for immediate mode. */
993 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
995 exec
->vtx
.bufferobj
= ctx
->Driver
.NewBufferObject(ctx
, IMM_BUFFER_NAME
);
997 /* Map the buffer. */
998 vbo_exec_vtx_map(exec
);
999 assert(exec
->vtx
.buffer_ptr
);
1001 /* Use allocated memory for immediate mode. */
1002 _mesa_reference_buffer_object(ctx
,
1003 &exec
->vtx
.bufferobj
,
1004 ctx
->Shared
->NullBufferObj
);
1006 exec
->vtx
.buffer_map
= _mesa_align_malloc(VBO_VERT_BUFFER_SIZE
, 64);
1007 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
1010 vbo_exec_vtxfmt_init(exec
);
1011 _mesa_noop_vtxfmt_init(ctx
, &exec
->vtxfmt_noop
);
1013 exec
->vtx
.enabled
= u_bit_consecutive64(0, VBO_ATTRIB_MAX
); /* reset all */
1014 vbo_reset_all_attr(exec
);
1019 vbo_exec_vtx_destroy(struct vbo_exec_context
*exec
)
1021 /* using a real VBO for vertex data */
1022 struct gl_context
*ctx
= exec
->ctx
;
1024 /* True VBOs should already be unmapped
1026 if (exec
->vtx
.buffer_map
) {
1027 assert(exec
->vtx
.bufferobj
->Name
== 0 ||
1028 exec
->vtx
.bufferobj
->Name
== IMM_BUFFER_NAME
);
1029 if (exec
->vtx
.bufferobj
->Name
== 0) {
1030 _mesa_align_free(exec
->vtx
.buffer_map
);
1031 exec
->vtx
.buffer_map
= NULL
;
1032 exec
->vtx
.buffer_ptr
= NULL
;
1036 /* Free the vertex buffer. Unmap first if needed.
1038 if (_mesa_bufferobj_mapped(exec
->vtx
.bufferobj
, MAP_INTERNAL
)) {
1039 ctx
->Driver
.UnmapBuffer(ctx
, exec
->vtx
.bufferobj
, MAP_INTERNAL
);
1041 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1046 * If inside glBegin()/glEnd(), it should assert(0). Otherwise, if
1047 * FLUSH_STORED_VERTICES bit in \p flags is set flushes any buffered
1048 * vertices, if FLUSH_UPDATE_CURRENT bit is set updates
1049 * __struct gl_contextRec::Current and gl_light_attrib::Material
1051 * Note that the default T&L engine never clears the
1052 * FLUSH_UPDATE_CURRENT bit, even after performing the update.
1054 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1057 vbo_exec_FlushVertices(struct gl_context
*ctx
, GLuint flags
)
1059 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1062 /* debug check: make sure we don't get called recursively */
1063 exec
->flush_call_depth
++;
1064 assert(exec
->flush_call_depth
== 1);
1067 if (_mesa_inside_begin_end(ctx
)) {
1068 /* We've had glBegin but not glEnd! */
1070 exec
->flush_call_depth
--;
1071 assert(exec
->flush_call_depth
== 0);
1077 vbo_exec_FlushVertices_internal(exec
, flags
);
1080 exec
->flush_call_depth
--;
1081 assert(exec
->flush_call_depth
== 0);
1087 _es_Color4f(GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
1089 vbo_exec_Color4f(r
, g
, b
, a
);
1094 _es_Normal3f(GLfloat x
, GLfloat y
, GLfloat z
)
1096 vbo_exec_Normal3f(x
, y
, z
);
1101 _es_MultiTexCoord4f(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1103 vbo_exec_MultiTexCoord4f(target
, s
, t
, r
, q
);
1108 _es_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
1110 vbo_exec_Materialfv(face
, pname
, params
);
1115 _es_Materialf(GLenum face
, GLenum pname
, GLfloat param
)
1119 p
[1] = p
[2] = p
[3] = 0.0F
;
1120 vbo_exec_Materialfv(face
, pname
, p
);
1125 * A special version of glVertexAttrib4f that does not treat index 0 as
1129 VertexAttrib4f_nopos(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1131 GET_CURRENT_CONTEXT(ctx
);
1132 if (index
< MAX_VERTEX_GENERIC_ATTRIBS
)
1133 ATTRF(VBO_ATTRIB_GENERIC0
+ index
, 4, x
, y
, z
, w
);
1135 ERROR(GL_INVALID_VALUE
);
1139 _es_VertexAttrib4f(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1141 VertexAttrib4f_nopos(index
, x
, y
, z
, w
);
1146 _es_VertexAttrib1f(GLuint indx
, GLfloat x
)
1148 VertexAttrib4f_nopos(indx
, x
, 0.0f
, 0.0f
, 1.0f
);
1153 _es_VertexAttrib1fv(GLuint indx
, const GLfloat
* values
)
1155 VertexAttrib4f_nopos(indx
, values
[0], 0.0f
, 0.0f
, 1.0f
);
1160 _es_VertexAttrib2f(GLuint indx
, GLfloat x
, GLfloat y
)
1162 VertexAttrib4f_nopos(indx
, x
, y
, 0.0f
, 1.0f
);
1167 _es_VertexAttrib2fv(GLuint indx
, const GLfloat
* values
)
1169 VertexAttrib4f_nopos(indx
, values
[0], values
[1], 0.0f
, 1.0f
);
1174 _es_VertexAttrib3f(GLuint indx
, GLfloat x
, GLfloat y
, GLfloat z
)
1176 VertexAttrib4f_nopos(indx
, x
, y
, z
, 1.0f
);
1181 _es_VertexAttrib3fv(GLuint indx
, const GLfloat
* values
)
1183 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], 1.0f
);
1188 _es_VertexAttrib4fv(GLuint indx
, const GLfloat
* values
)
1190 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], values
[3]);