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/api_validate.h"
44 #include "main/dispatch.h"
45 #include "util/bitscan.h"
47 #include "vbo_context.h"
49 #include "vbo_private.h"
52 /** ID/name for immediate-mode VBO */
53 #define IMM_BUFFER_NAME 0xaabbccdd
57 vbo_reset_all_attr(struct vbo_exec_context
*exec
);
61 * Close off the last primitive, execute the buffer, restart the
62 * primitive. This is called when we fill a vertex buffer before
66 vbo_exec_wrap_buffers(struct vbo_exec_context
*exec
)
68 if (exec
->vtx
.prim_count
== 0) {
69 exec
->vtx
.copied
.nr
= 0;
70 exec
->vtx
.vert_count
= 0;
71 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
74 struct _mesa_prim
*last_prim
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
75 const GLuint last_begin
= last_prim
->begin
;
78 if (_mesa_inside_begin_end(exec
->ctx
)) {
79 last_prim
->count
= exec
->vtx
.vert_count
- last_prim
->start
;
82 last_count
= last_prim
->count
;
84 /* Special handling for wrapping GL_LINE_LOOP */
85 if (last_prim
->mode
== GL_LINE_LOOP
&&
88 /* draw this section of the incomplete line loop as a line strip */
89 last_prim
->mode
= GL_LINE_STRIP
;
90 if (!last_prim
->begin
) {
91 /* This is not the first section of the line loop, so don't
92 * draw the 0th vertex. We're saving it until we draw the
93 * very last section of the loop.
100 /* Execute the buffer and save copied vertices.
102 if (exec
->vtx
.vert_count
)
103 vbo_exec_vtx_flush(exec
, GL_FALSE
);
105 exec
->vtx
.prim_count
= 0;
106 exec
->vtx
.copied
.nr
= 0;
109 /* Emit a glBegin to start the new list.
111 assert(exec
->vtx
.prim_count
== 0);
113 if (_mesa_inside_begin_end(exec
->ctx
)) {
114 exec
->vtx
.prim
[0].mode
= exec
->ctx
->Driver
.CurrentExecPrimitive
;
115 exec
->vtx
.prim
[0].begin
= 0;
116 exec
->vtx
.prim
[0].end
= 0;
117 exec
->vtx
.prim
[0].start
= 0;
118 exec
->vtx
.prim
[0].count
= 0;
119 exec
->vtx
.prim_count
++;
121 if (exec
->vtx
.copied
.nr
== last_count
)
122 exec
->vtx
.prim
[0].begin
= last_begin
;
129 * Deal with buffer wrapping where provoked by the vertex buffer
130 * filling up, as opposed to upgrade_vertex().
133 vbo_exec_vtx_wrap(struct vbo_exec_context
*exec
)
135 unsigned numComponents
;
137 /* Run pipeline on current vertices, copy wrapped vertices
138 * to exec->vtx.copied.
140 vbo_exec_wrap_buffers(exec
);
142 if (!exec
->vtx
.buffer_ptr
) {
143 /* probably ran out of memory earlier when allocating the VBO */
147 /* Copy stored stored vertices to start of new list.
149 assert(exec
->vtx
.max_vert
- exec
->vtx
.vert_count
> exec
->vtx
.copied
.nr
);
151 numComponents
= exec
->vtx
.copied
.nr
* exec
->vtx
.vertex_size
;
152 memcpy(exec
->vtx
.buffer_ptr
,
153 exec
->vtx
.copied
.buffer
,
154 numComponents
* sizeof(fi_type
));
155 exec
->vtx
.buffer_ptr
+= numComponents
;
156 exec
->vtx
.vert_count
+= exec
->vtx
.copied
.nr
;
158 exec
->vtx
.copied
.nr
= 0;
163 * Copy the active vertex's values to the ctx->Current fields.
166 vbo_exec_copy_to_current(struct vbo_exec_context
*exec
)
168 struct gl_context
*ctx
= exec
->ctx
;
169 struct vbo_context
*vbo
= vbo_context(ctx
);
170 GLbitfield64 enabled
= exec
->vtx
.enabled
& (~BITFIELD64_BIT(VBO_ATTRIB_POS
));
173 const int i
= u_bit_scan64(&enabled
);
175 /* Note: the exec->vtx.current[i] pointers point into the
176 * ctx->Current.Attrib and ctx->Light.Material.Attrib arrays.
178 GLfloat
*current
= (GLfloat
*)vbo
->currval
[i
].Ptr
;
179 fi_type tmp
[8]; /* space for doubles */
182 if (exec
->vtx
.attrtype
[i
] == GL_DOUBLE
||
183 exec
->vtx
.attrtype
[i
] == GL_UNSIGNED_INT64_ARB
)
186 assert(exec
->vtx
.attrsz
[i
]);
188 if (exec
->vtx
.attrtype
[i
] == GL_DOUBLE
||
189 exec
->vtx
.attrtype
[i
] == GL_UNSIGNED_INT64_ARB
) {
190 memset(tmp
, 0, sizeof(tmp
));
191 memcpy(tmp
, exec
->vtx
.attrptr
[i
], exec
->vtx
.attrsz
[i
] * sizeof(GLfloat
));
193 COPY_CLEAN_4V_TYPE_AS_UNION(tmp
,
195 exec
->vtx
.attrptr
[i
],
196 exec
->vtx
.attrtype
[i
]);
199 if (exec
->vtx
.attrtype
[i
] != vbo
->currval
[i
].Type
||
200 memcmp(current
, tmp
, 4 * sizeof(GLfloat
) * dmul
) != 0) {
201 memcpy(current
, tmp
, 4 * sizeof(GLfloat
) * dmul
);
203 /* Given that we explicitly state size here, there is no need
204 * for the COPY_CLEAN above, could just copy 16 bytes and be
205 * done. The only problem is when Mesa accesses ctx->Current
208 /* Size here is in components - not bytes */
209 vbo
->currval
[i
].Size
= exec
->vtx
.attrsz
[i
] / dmul
;
210 vbo
->currval
[i
]._ElementSize
=
211 vbo
->currval
[i
].Size
* sizeof(GLfloat
) * dmul
;
212 vbo
->currval
[i
].Type
= exec
->vtx
.attrtype
[i
];
213 vbo
->currval
[i
].Integer
=
214 vbo_attrtype_to_integer_flag(exec
->vtx
.attrtype
[i
]);
215 vbo
->currval
[i
].Doubles
=
216 vbo_attrtype_to_double_flag(exec
->vtx
.attrtype
[i
]);
218 /* This triggers rather too much recalculation of Mesa state
219 * that doesn't get used (eg light positions).
221 if (i
>= VBO_ATTRIB_MAT_FRONT_AMBIENT
&&
222 i
<= VBO_ATTRIB_MAT_BACK_INDEXES
)
223 ctx
->NewState
|= _NEW_LIGHT
;
225 ctx
->NewState
|= _NEW_CURRENT_ATTRIB
;
229 /* Colormaterial -- this kindof sucks.
231 if (ctx
->Light
.ColorMaterialEnabled
&&
232 exec
->vtx
.attrsz
[VBO_ATTRIB_COLOR0
]) {
233 _mesa_update_color_material(ctx
,
234 ctx
->Current
.Attrib
[VBO_ATTRIB_COLOR0
]);
240 * Copy current vertex attribute values into the current vertex.
243 vbo_exec_copy_from_current(struct vbo_exec_context
*exec
)
245 struct gl_context
*ctx
= exec
->ctx
;
246 struct vbo_context
*vbo
= vbo_context(ctx
);
249 for (i
= VBO_ATTRIB_POS
+ 1; i
< VBO_ATTRIB_MAX
; i
++) {
250 if (exec
->vtx
.attrtype
[i
] == GL_DOUBLE
||
251 exec
->vtx
.attrtype
[i
] == GL_UNSIGNED_INT64_ARB
) {
252 memcpy(exec
->vtx
.attrptr
[i
], vbo
->currval
[i
].Ptr
,
253 exec
->vtx
.attrsz
[i
] * sizeof(GLfloat
));
255 const fi_type
*current
= (fi_type
*) vbo
->currval
[i
].Ptr
;
256 switch (exec
->vtx
.attrsz
[i
]) {
257 case 4: exec
->vtx
.attrptr
[i
][3] = current
[3];
258 case 3: exec
->vtx
.attrptr
[i
][2] = current
[2];
259 case 2: exec
->vtx
.attrptr
[i
][1] = current
[1];
260 case 1: exec
->vtx
.attrptr
[i
][0] = current
[0];
269 * Flush existing data, set new attrib size, replay copied vertices.
270 * This is called when we transition from a small vertex attribute size
271 * to a larger one. Ex: glTexCoord2f -> glTexCoord4f.
272 * We need to go back over the previous 2-component texcoords and insert
273 * zero and one values.
274 * \param attr VBO_ATTRIB_x vertex attribute value
277 vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context
*exec
,
278 GLuint attr
, GLuint newSize
)
280 struct gl_context
*ctx
= exec
->ctx
;
281 struct vbo_context
*vbo
= vbo_context(ctx
);
282 const GLint lastcount
= exec
->vtx
.vert_count
;
283 fi_type
*old_attrptr
[VBO_ATTRIB_MAX
];
284 const GLuint old_vtx_size
= exec
->vtx
.vertex_size
; /* floats per vertex */
285 const GLuint oldSize
= exec
->vtx
.attrsz
[attr
];
288 assert(attr
< VBO_ATTRIB_MAX
);
290 /* Run pipeline on current vertices, copy wrapped vertices
291 * to exec->vtx.copied.
293 vbo_exec_wrap_buffers(exec
);
295 if (unlikely(exec
->vtx
.copied
.nr
)) {
296 /* We're in the middle of a primitive, keep the old vertex
297 * format around to be able to translate the copied vertices to
300 memcpy(old_attrptr
, exec
->vtx
.attrptr
, sizeof(old_attrptr
));
303 if (unlikely(oldSize
)) {
304 /* Do a COPY_TO_CURRENT to ensure back-copying works for the
305 * case when the attribute already exists in the vertex and is
306 * having its size increased.
308 vbo_exec_copy_to_current(exec
);
311 /* Heuristic: Attempt to isolate attributes received outside
312 * begin/end so that they don't bloat the vertices.
314 if (!_mesa_inside_begin_end(ctx
) &&
315 !oldSize
&& lastcount
> 8 && exec
->vtx
.vertex_size
) {
316 vbo_exec_copy_to_current(exec
);
317 vbo_reset_all_attr(exec
);
322 exec
->vtx
.attrsz
[attr
] = newSize
;
323 exec
->vtx
.vertex_size
+= newSize
- oldSize
;
324 exec
->vtx
.max_vert
= vbo_compute_max_verts(exec
);
325 exec
->vtx
.vert_count
= 0;
326 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
327 exec
->vtx
.enabled
|= BITFIELD64_BIT(attr
);
329 if (unlikely(oldSize
)) {
330 /* Size changed, recalculate all the attrptr[] values
332 fi_type
*tmp
= exec
->vtx
.vertex
;
334 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
335 if (exec
->vtx
.attrsz
[i
]) {
336 exec
->vtx
.attrptr
[i
] = tmp
;
337 tmp
+= exec
->vtx
.attrsz
[i
];
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
.attrsz
[j
];
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
.attrtype
[j
]);
381 COPY_SZ_4V(dest
+ new_offset
, newSize
, tmp
);
383 fi_type
*current
= (fi_type
*)vbo
->currval
[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
.attrsz
[attr
] ||
419 newType
!= exec
->vtx
.attrtype
[attr
]) {
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
.active_sz
[attr
]) {
428 vbo_get_default_vals_as_union(exec
->vtx
.attrtype
[attr
]);
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
.attrsz
[attr
]; i
++)
434 exec
->vtx
.attrptr
[attr
][i
-1] = id
[i
-1];
437 exec
->vtx
.active_sz
[attr
] = newSize
;
438 exec
->vtx
.attrtype
[attr
] = 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 * Called upon first glVertex, glColor, glTexCoord, etc.
453 vbo_exec_begin_vertices(struct gl_context
*ctx
)
455 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
457 vbo_exec_vtx_map(exec
);
459 assert((ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
) == 0);
460 assert(exec
->begin_vertices_flags
);
462 ctx
->Driver
.NeedFlush
|= exec
->begin_vertices_flags
;
467 * This macro is used to implement all the glVertex, glColor, glTexCoord,
468 * glVertexAttrib, etc functions.
469 * \param A VBO_ATTRIB_x attribute index
470 * \param N attribute size (1..4)
471 * \param T type (GL_FLOAT, GL_DOUBLE, GL_INT, GL_UNSIGNED_INT)
472 * \param C cast type (fi_type or double)
473 * \param V0, V1, v2, V3 attribute value
475 #define ATTR_UNION(A, N, T, C, V0, V1, V2, V3) \
477 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
478 int sz = (sizeof(C) / sizeof(GLfloat)); \
480 assert(sz == 1 || sz == 2); \
482 /* check if attribute size or type is changing */ \
483 if (unlikely(exec->vtx.active_sz[A] != N * sz) || \
484 unlikely(exec->vtx.attrtype[A] != T)) { \
485 vbo_exec_fixup_vertex(ctx, A, N * sz, T); \
488 /* store vertex attribute in vertex buffer */ \
490 C *dest = (C *)exec->vtx.attrptr[A]; \
491 if (N>0) dest[0] = V0; \
492 if (N>1) dest[1] = V1; \
493 if (N>2) dest[2] = V2; \
494 if (N>3) dest[3] = V3; \
495 assert(exec->vtx.attrtype[A] == T); \
499 /* This is a glVertex call */ \
502 if (unlikely((ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) == 0)) { \
503 vbo_exec_begin_vertices(ctx); \
506 if (unlikely(!exec->vtx.buffer_ptr)) { \
507 vbo_exec_vtx_map(exec); \
509 assert(exec->vtx.buffer_ptr); \
511 /* copy 32-bit words */ \
512 for (i = 0; i < exec->vtx.vertex_size; i++) \
513 exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i]; \
515 exec->vtx.buffer_ptr += exec->vtx.vertex_size; \
517 /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \
518 /* something to draw (not just updating a color or texcoord).*/ \
519 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \
521 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
522 vbo_exec_vtx_wrap(exec); \
524 /* we now have accumulated per-vertex attributes */ \
525 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
531 #define ERROR(err) _mesa_error(ctx, err, __func__)
532 #define TAG(x) vbo_##x
534 #include "vbo_attrib_tmp.h"
539 * Execute a glMaterial call. Note that if GL_COLOR_MATERIAL is enabled,
540 * this may be a (partial) no-op.
542 static void GLAPIENTRY
543 vbo_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
545 GLbitfield updateMats
;
546 GET_CURRENT_CONTEXT(ctx
);
548 /* This function should be a no-op when it tries to update material
549 * attributes which are currently tracking glColor via glColorMaterial.
550 * The updateMats var will be a mask of the MAT_BIT_FRONT/BACK_x bits
551 * indicating which material attributes can actually be updated below.
553 if (ctx
->Light
.ColorMaterialEnabled
) {
554 updateMats
= ~ctx
->Light
._ColorMaterialBitmask
;
557 /* GL_COLOR_MATERIAL is disabled so don't skip any material updates */
558 updateMats
= ALL_MATERIAL_BITS
;
561 if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_FRONT
) {
562 updateMats
&= FRONT_MATERIAL_BITS
;
564 else if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_BACK
) {
565 updateMats
&= BACK_MATERIAL_BITS
;
567 else if (face
!= GL_FRONT_AND_BACK
) {
568 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterial(invalid face)");
574 if (updateMats
& MAT_BIT_FRONT_EMISSION
)
575 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_EMISSION
, 4, params
);
576 if (updateMats
& MAT_BIT_BACK_EMISSION
)
577 MAT_ATTR(VBO_ATTRIB_MAT_BACK_EMISSION
, 4, params
);
580 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
581 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
582 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
583 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
586 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
587 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
588 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
589 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
592 if (updateMats
& MAT_BIT_FRONT_SPECULAR
)
593 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SPECULAR
, 4, params
);
594 if (updateMats
& MAT_BIT_BACK_SPECULAR
)
595 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SPECULAR
, 4, params
);
598 if (*params
< 0 || *params
> ctx
->Const
.MaxShininess
) {
599 _mesa_error(ctx
, GL_INVALID_VALUE
,
600 "glMaterial(invalid shininess: %f out range [0, %f])",
601 *params
, ctx
->Const
.MaxShininess
);
604 if (updateMats
& MAT_BIT_FRONT_SHININESS
)
605 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SHININESS
, 1, params
);
606 if (updateMats
& MAT_BIT_BACK_SHININESS
)
607 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SHININESS
, 1, params
);
609 case GL_COLOR_INDEXES
:
610 if (ctx
->API
!= API_OPENGL_COMPAT
) {
611 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
614 if (updateMats
& MAT_BIT_FRONT_INDEXES
)
615 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_INDEXES
, 3, params
);
616 if (updateMats
& MAT_BIT_BACK_INDEXES
)
617 MAT_ATTR(VBO_ATTRIB_MAT_BACK_INDEXES
, 3, params
);
619 case GL_AMBIENT_AND_DIFFUSE
:
620 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
621 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
622 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
623 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
624 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
625 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
626 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
627 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
630 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
637 * Flush (draw) vertices.
638 * \param unmap - leave VBO unmapped after flushing?
641 vbo_exec_FlushVertices_internal(struct vbo_exec_context
*exec
, GLboolean unmap
)
643 if (exec
->vtx
.vert_count
|| unmap
) {
644 vbo_exec_vtx_flush(exec
, unmap
);
647 if (exec
->vtx
.vertex_size
) {
648 vbo_exec_copy_to_current(exec
);
649 vbo_reset_all_attr(exec
);
654 static void GLAPIENTRY
655 vbo_exec_EvalCoord1f(GLfloat u
)
657 GET_CURRENT_CONTEXT(ctx
);
658 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
662 if (exec
->eval
.recalculate_maps
)
663 vbo_exec_eval_update(exec
);
665 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
666 if (exec
->eval
.map1
[i
].map
)
667 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map1
[i
].sz
)
668 vbo_exec_fixup_vertex(ctx
, i
, exec
->eval
.map1
[i
].sz
, GL_FLOAT
);
672 memcpy(exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
673 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
675 vbo_exec_do_EvalCoord1f(exec
, u
);
677 memcpy(exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
678 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
682 static void GLAPIENTRY
683 vbo_exec_EvalCoord2f(GLfloat u
, GLfloat v
)
685 GET_CURRENT_CONTEXT(ctx
);
686 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
690 if (exec
->eval
.recalculate_maps
)
691 vbo_exec_eval_update(exec
);
693 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
694 if (exec
->eval
.map2
[i
].map
)
695 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map2
[i
].sz
)
696 vbo_exec_fixup_vertex(ctx
, i
, exec
->eval
.map2
[i
].sz
, GL_FLOAT
);
699 if (ctx
->Eval
.AutoNormal
)
700 if (exec
->vtx
.active_sz
[VBO_ATTRIB_NORMAL
] != 3)
701 vbo_exec_fixup_vertex(ctx
, VBO_ATTRIB_NORMAL
, 3, GL_FLOAT
);
704 memcpy(exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
705 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
707 vbo_exec_do_EvalCoord2f(exec
, u
, v
);
709 memcpy(exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
710 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
714 static void GLAPIENTRY
715 vbo_exec_EvalCoord1fv(const GLfloat
*u
)
717 vbo_exec_EvalCoord1f(u
[0]);
721 static void GLAPIENTRY
722 vbo_exec_EvalCoord2fv(const GLfloat
*u
)
724 vbo_exec_EvalCoord2f(u
[0], u
[1]);
728 static void GLAPIENTRY
729 vbo_exec_EvalPoint1(GLint i
)
731 GET_CURRENT_CONTEXT(ctx
);
732 GLfloat du
= ((ctx
->Eval
.MapGrid1u2
- ctx
->Eval
.MapGrid1u1
) /
733 (GLfloat
) ctx
->Eval
.MapGrid1un
);
734 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid1u1
;
736 vbo_exec_EvalCoord1f(u
);
740 static void GLAPIENTRY
741 vbo_exec_EvalPoint2(GLint i
, GLint j
)
743 GET_CURRENT_CONTEXT(ctx
);
744 GLfloat du
= ((ctx
->Eval
.MapGrid2u2
- ctx
->Eval
.MapGrid2u1
) /
745 (GLfloat
) ctx
->Eval
.MapGrid2un
);
746 GLfloat dv
= ((ctx
->Eval
.MapGrid2v2
- ctx
->Eval
.MapGrid2v1
) /
747 (GLfloat
) ctx
->Eval
.MapGrid2vn
);
748 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid2u1
;
749 GLfloat v
= j
* dv
+ ctx
->Eval
.MapGrid2v1
;
751 vbo_exec_EvalCoord2f(u
, v
);
756 * Called via glBegin.
758 static void GLAPIENTRY
759 vbo_exec_Begin(GLenum mode
)
761 GET_CURRENT_CONTEXT(ctx
);
762 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
765 if (_mesa_inside_begin_end(ctx
)) {
766 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glBegin");
770 if (!_mesa_valid_prim_mode(ctx
, mode
, "glBegin")) {
774 vbo_draw_method(vbo_context(ctx
), DRAW_BEGIN_END
);
777 _mesa_update_state(ctx
);
779 CALL_Begin(ctx
->Exec
, (mode
));
783 if (!_mesa_valid_to_render(ctx
, "glBegin")) {
787 /* Heuristic: attempt to isolate attributes occurring outside
790 if (exec
->vtx
.vertex_size
&& !exec
->vtx
.attrsz
[0])
791 vbo_exec_FlushVertices_internal(exec
, GL_FALSE
);
793 i
= exec
->vtx
.prim_count
++;
794 exec
->vtx
.prim
[i
].mode
= mode
;
795 exec
->vtx
.prim
[i
].begin
= 1;
796 exec
->vtx
.prim
[i
].end
= 0;
797 exec
->vtx
.prim
[i
].indexed
= 0;
798 exec
->vtx
.prim
[i
].weak
= 0;
799 exec
->vtx
.prim
[i
].pad
= 0;
800 exec
->vtx
.prim
[i
].start
= exec
->vtx
.vert_count
;
801 exec
->vtx
.prim
[i
].count
= 0;
802 exec
->vtx
.prim
[i
].num_instances
= 1;
803 exec
->vtx
.prim
[i
].base_instance
= 0;
804 exec
->vtx
.prim
[i
].is_indirect
= 0;
806 ctx
->Driver
.CurrentExecPrimitive
= mode
;
808 ctx
->Exec
= ctx
->BeginEnd
;
809 /* We may have been called from a display list, in which case we should
810 * leave dlist.c's dispatch table in place.
812 if (ctx
->CurrentClientDispatch
== ctx
->OutsideBeginEnd
) {
813 ctx
->CurrentClientDispatch
= ctx
->BeginEnd
;
814 _glapi_set_dispatch(ctx
->CurrentClientDispatch
);
816 assert(ctx
->CurrentClientDispatch
== ctx
->Save
);
822 * Try to merge / concatenate the two most recent VBO primitives.
825 try_vbo_merge(struct vbo_exec_context
*exec
)
827 struct _mesa_prim
*cur
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
829 assert(exec
->vtx
.prim_count
>= 1);
831 vbo_try_prim_conversion(cur
);
833 if (exec
->vtx
.prim_count
>= 2) {
834 struct _mesa_prim
*prev
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 2];
835 assert(prev
== cur
- 1);
837 if (vbo_can_merge_prims(prev
, cur
)) {
842 vbo_merge_prims(prev
, cur
);
843 exec
->vtx
.prim_count
--; /* drop the last primitive */
852 static void GLAPIENTRY
855 GET_CURRENT_CONTEXT(ctx
);
856 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
858 if (!_mesa_inside_begin_end(ctx
)) {
859 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glEnd");
863 ctx
->Exec
= ctx
->OutsideBeginEnd
;
864 if (ctx
->CurrentClientDispatch
== ctx
->BeginEnd
) {
865 ctx
->CurrentClientDispatch
= ctx
->OutsideBeginEnd
;
866 _glapi_set_dispatch(ctx
->CurrentClientDispatch
);
869 if (exec
->vtx
.prim_count
> 0) {
870 /* close off current primitive */
871 struct _mesa_prim
*last_prim
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
874 last_prim
->count
= exec
->vtx
.vert_count
- last_prim
->start
;
876 /* Special handling for GL_LINE_LOOP */
877 if (last_prim
->mode
== GL_LINE_LOOP
&& last_prim
->begin
== 0) {
878 /* We're finishing drawing a line loop. Append 0th vertex onto
879 * end of vertex buffer so we can draw it as a line strip.
881 const fi_type
*src
= exec
->vtx
.buffer_map
+
882 last_prim
->start
* exec
->vtx
.vertex_size
;
883 fi_type
*dst
= exec
->vtx
.buffer_map
+
884 exec
->vtx
.vert_count
* exec
->vtx
.vertex_size
;
886 /* copy 0th vertex to end of buffer */
887 memcpy(dst
, src
, exec
->vtx
.vertex_size
* sizeof(fi_type
));
889 last_prim
->start
++; /* skip vertex0 */
890 /* note that last_prim->count stays unchanged */
891 last_prim
->mode
= GL_LINE_STRIP
;
893 /* Increment the vertex count so the next primitive doesn't
894 * overwrite the last vertex which we just added.
896 exec
->vtx
.vert_count
++;
897 exec
->vtx
.buffer_ptr
+= exec
->vtx
.vertex_size
;
903 ctx
->Driver
.CurrentExecPrimitive
= PRIM_OUTSIDE_BEGIN_END
;
905 if (exec
->vtx
.prim_count
== VBO_MAX_PRIM
)
906 vbo_exec_vtx_flush(exec
, GL_FALSE
);
908 if (MESA_DEBUG_FLAGS
& DEBUG_ALWAYS_FLUSH
) {
915 * Called via glPrimitiveRestartNV()
917 static void GLAPIENTRY
918 vbo_exec_PrimitiveRestartNV(void)
921 GET_CURRENT_CONTEXT(ctx
);
923 curPrim
= ctx
->Driver
.CurrentExecPrimitive
;
925 if (curPrim
== PRIM_OUTSIDE_BEGIN_END
) {
926 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPrimitiveRestartNV");
930 vbo_exec_Begin(curPrim
);
936 vbo_exec_vtxfmt_init(struct vbo_exec_context
*exec
)
938 struct gl_context
*ctx
= exec
->ctx
;
939 GLvertexformat
*vfmt
= &exec
->vtxfmt
;
941 vfmt
->ArrayElement
= _ae_ArrayElement
;
943 vfmt
->Begin
= vbo_exec_Begin
;
944 vfmt
->End
= vbo_exec_End
;
945 vfmt
->PrimitiveRestartNV
= vbo_exec_PrimitiveRestartNV
;
947 vfmt
->CallList
= _mesa_CallList
;
948 vfmt
->CallLists
= _mesa_CallLists
;
950 vfmt
->EvalCoord1f
= vbo_exec_EvalCoord1f
;
951 vfmt
->EvalCoord1fv
= vbo_exec_EvalCoord1fv
;
952 vfmt
->EvalCoord2f
= vbo_exec_EvalCoord2f
;
953 vfmt
->EvalCoord2fv
= vbo_exec_EvalCoord2fv
;
954 vfmt
->EvalPoint1
= vbo_exec_EvalPoint1
;
955 vfmt
->EvalPoint2
= vbo_exec_EvalPoint2
;
957 /* from attrib_tmp.h:
959 vfmt
->Color3f
= vbo_Color3f
;
960 vfmt
->Color3fv
= vbo_Color3fv
;
961 vfmt
->Color4f
= vbo_Color4f
;
962 vfmt
->Color4fv
= vbo_Color4fv
;
963 vfmt
->FogCoordfEXT
= vbo_FogCoordfEXT
;
964 vfmt
->FogCoordfvEXT
= vbo_FogCoordfvEXT
;
965 vfmt
->MultiTexCoord1fARB
= vbo_MultiTexCoord1f
;
966 vfmt
->MultiTexCoord1fvARB
= vbo_MultiTexCoord1fv
;
967 vfmt
->MultiTexCoord2fARB
= vbo_MultiTexCoord2f
;
968 vfmt
->MultiTexCoord2fvARB
= vbo_MultiTexCoord2fv
;
969 vfmt
->MultiTexCoord3fARB
= vbo_MultiTexCoord3f
;
970 vfmt
->MultiTexCoord3fvARB
= vbo_MultiTexCoord3fv
;
971 vfmt
->MultiTexCoord4fARB
= vbo_MultiTexCoord4f
;
972 vfmt
->MultiTexCoord4fvARB
= vbo_MultiTexCoord4fv
;
973 vfmt
->Normal3f
= vbo_Normal3f
;
974 vfmt
->Normal3fv
= vbo_Normal3fv
;
975 vfmt
->SecondaryColor3fEXT
= vbo_SecondaryColor3fEXT
;
976 vfmt
->SecondaryColor3fvEXT
= vbo_SecondaryColor3fvEXT
;
977 vfmt
->TexCoord1f
= vbo_TexCoord1f
;
978 vfmt
->TexCoord1fv
= vbo_TexCoord1fv
;
979 vfmt
->TexCoord2f
= vbo_TexCoord2f
;
980 vfmt
->TexCoord2fv
= vbo_TexCoord2fv
;
981 vfmt
->TexCoord3f
= vbo_TexCoord3f
;
982 vfmt
->TexCoord3fv
= vbo_TexCoord3fv
;
983 vfmt
->TexCoord4f
= vbo_TexCoord4f
;
984 vfmt
->TexCoord4fv
= vbo_TexCoord4fv
;
985 vfmt
->Vertex2f
= vbo_Vertex2f
;
986 vfmt
->Vertex2fv
= vbo_Vertex2fv
;
987 vfmt
->Vertex3f
= vbo_Vertex3f
;
988 vfmt
->Vertex3fv
= vbo_Vertex3fv
;
989 vfmt
->Vertex4f
= vbo_Vertex4f
;
990 vfmt
->Vertex4fv
= vbo_Vertex4fv
;
992 if (ctx
->API
== API_OPENGLES2
) {
993 vfmt
->VertexAttrib1fARB
= _es_VertexAttrib1f
;
994 vfmt
->VertexAttrib1fvARB
= _es_VertexAttrib1fv
;
995 vfmt
->VertexAttrib2fARB
= _es_VertexAttrib2f
;
996 vfmt
->VertexAttrib2fvARB
= _es_VertexAttrib2fv
;
997 vfmt
->VertexAttrib3fARB
= _es_VertexAttrib3f
;
998 vfmt
->VertexAttrib3fvARB
= _es_VertexAttrib3fv
;
999 vfmt
->VertexAttrib4fARB
= _es_VertexAttrib4f
;
1000 vfmt
->VertexAttrib4fvARB
= _es_VertexAttrib4fv
;
1002 vfmt
->VertexAttrib1fARB
= vbo_VertexAttrib1fARB
;
1003 vfmt
->VertexAttrib1fvARB
= vbo_VertexAttrib1fvARB
;
1004 vfmt
->VertexAttrib2fARB
= vbo_VertexAttrib2fARB
;
1005 vfmt
->VertexAttrib2fvARB
= vbo_VertexAttrib2fvARB
;
1006 vfmt
->VertexAttrib3fARB
= vbo_VertexAttrib3fARB
;
1007 vfmt
->VertexAttrib3fvARB
= vbo_VertexAttrib3fvARB
;
1008 vfmt
->VertexAttrib4fARB
= vbo_VertexAttrib4fARB
;
1009 vfmt
->VertexAttrib4fvARB
= vbo_VertexAttrib4fvARB
;
1012 /* Note that VertexAttrib4fNV is used from dlist.c and api_arrayelt.c so
1013 * they can have a single entrypoint for updating any of the legacy
1016 vfmt
->VertexAttrib1fNV
= vbo_VertexAttrib1fNV
;
1017 vfmt
->VertexAttrib1fvNV
= vbo_VertexAttrib1fvNV
;
1018 vfmt
->VertexAttrib2fNV
= vbo_VertexAttrib2fNV
;
1019 vfmt
->VertexAttrib2fvNV
= vbo_VertexAttrib2fvNV
;
1020 vfmt
->VertexAttrib3fNV
= vbo_VertexAttrib3fNV
;
1021 vfmt
->VertexAttrib3fvNV
= vbo_VertexAttrib3fvNV
;
1022 vfmt
->VertexAttrib4fNV
= vbo_VertexAttrib4fNV
;
1023 vfmt
->VertexAttrib4fvNV
= vbo_VertexAttrib4fvNV
;
1025 /* integer-valued */
1026 vfmt
->VertexAttribI1i
= vbo_VertexAttribI1i
;
1027 vfmt
->VertexAttribI2i
= vbo_VertexAttribI2i
;
1028 vfmt
->VertexAttribI3i
= vbo_VertexAttribI3i
;
1029 vfmt
->VertexAttribI4i
= vbo_VertexAttribI4i
;
1030 vfmt
->VertexAttribI2iv
= vbo_VertexAttribI2iv
;
1031 vfmt
->VertexAttribI3iv
= vbo_VertexAttribI3iv
;
1032 vfmt
->VertexAttribI4iv
= vbo_VertexAttribI4iv
;
1034 /* unsigned integer-valued */
1035 vfmt
->VertexAttribI1ui
= vbo_VertexAttribI1ui
;
1036 vfmt
->VertexAttribI2ui
= vbo_VertexAttribI2ui
;
1037 vfmt
->VertexAttribI3ui
= vbo_VertexAttribI3ui
;
1038 vfmt
->VertexAttribI4ui
= vbo_VertexAttribI4ui
;
1039 vfmt
->VertexAttribI2uiv
= vbo_VertexAttribI2uiv
;
1040 vfmt
->VertexAttribI3uiv
= vbo_VertexAttribI3uiv
;
1041 vfmt
->VertexAttribI4uiv
= vbo_VertexAttribI4uiv
;
1043 vfmt
->Materialfv
= vbo_Materialfv
;
1045 vfmt
->EdgeFlag
= vbo_EdgeFlag
;
1046 vfmt
->Indexf
= vbo_Indexf
;
1047 vfmt
->Indexfv
= vbo_Indexfv
;
1049 /* ARB_vertex_type_2_10_10_10_rev */
1050 vfmt
->VertexP2ui
= vbo_VertexP2ui
;
1051 vfmt
->VertexP2uiv
= vbo_VertexP2uiv
;
1052 vfmt
->VertexP3ui
= vbo_VertexP3ui
;
1053 vfmt
->VertexP3uiv
= vbo_VertexP3uiv
;
1054 vfmt
->VertexP4ui
= vbo_VertexP4ui
;
1055 vfmt
->VertexP4uiv
= vbo_VertexP4uiv
;
1057 vfmt
->TexCoordP1ui
= vbo_TexCoordP1ui
;
1058 vfmt
->TexCoordP1uiv
= vbo_TexCoordP1uiv
;
1059 vfmt
->TexCoordP2ui
= vbo_TexCoordP2ui
;
1060 vfmt
->TexCoordP2uiv
= vbo_TexCoordP2uiv
;
1061 vfmt
->TexCoordP3ui
= vbo_TexCoordP3ui
;
1062 vfmt
->TexCoordP3uiv
= vbo_TexCoordP3uiv
;
1063 vfmt
->TexCoordP4ui
= vbo_TexCoordP4ui
;
1064 vfmt
->TexCoordP4uiv
= vbo_TexCoordP4uiv
;
1066 vfmt
->MultiTexCoordP1ui
= vbo_MultiTexCoordP1ui
;
1067 vfmt
->MultiTexCoordP1uiv
= vbo_MultiTexCoordP1uiv
;
1068 vfmt
->MultiTexCoordP2ui
= vbo_MultiTexCoordP2ui
;
1069 vfmt
->MultiTexCoordP2uiv
= vbo_MultiTexCoordP2uiv
;
1070 vfmt
->MultiTexCoordP3ui
= vbo_MultiTexCoordP3ui
;
1071 vfmt
->MultiTexCoordP3uiv
= vbo_MultiTexCoordP3uiv
;
1072 vfmt
->MultiTexCoordP4ui
= vbo_MultiTexCoordP4ui
;
1073 vfmt
->MultiTexCoordP4uiv
= vbo_MultiTexCoordP4uiv
;
1075 vfmt
->NormalP3ui
= vbo_NormalP3ui
;
1076 vfmt
->NormalP3uiv
= vbo_NormalP3uiv
;
1078 vfmt
->ColorP3ui
= vbo_ColorP3ui
;
1079 vfmt
->ColorP3uiv
= vbo_ColorP3uiv
;
1080 vfmt
->ColorP4ui
= vbo_ColorP4ui
;
1081 vfmt
->ColorP4uiv
= vbo_ColorP4uiv
;
1083 vfmt
->SecondaryColorP3ui
= vbo_SecondaryColorP3ui
;
1084 vfmt
->SecondaryColorP3uiv
= vbo_SecondaryColorP3uiv
;
1086 vfmt
->VertexAttribP1ui
= vbo_VertexAttribP1ui
;
1087 vfmt
->VertexAttribP1uiv
= vbo_VertexAttribP1uiv
;
1088 vfmt
->VertexAttribP2ui
= vbo_VertexAttribP2ui
;
1089 vfmt
->VertexAttribP2uiv
= vbo_VertexAttribP2uiv
;
1090 vfmt
->VertexAttribP3ui
= vbo_VertexAttribP3ui
;
1091 vfmt
->VertexAttribP3uiv
= vbo_VertexAttribP3uiv
;
1092 vfmt
->VertexAttribP4ui
= vbo_VertexAttribP4ui
;
1093 vfmt
->VertexAttribP4uiv
= vbo_VertexAttribP4uiv
;
1095 vfmt
->VertexAttribL1d
= vbo_VertexAttribL1d
;
1096 vfmt
->VertexAttribL2d
= vbo_VertexAttribL2d
;
1097 vfmt
->VertexAttribL3d
= vbo_VertexAttribL3d
;
1098 vfmt
->VertexAttribL4d
= vbo_VertexAttribL4d
;
1100 vfmt
->VertexAttribL1dv
= vbo_VertexAttribL1dv
;
1101 vfmt
->VertexAttribL2dv
= vbo_VertexAttribL2dv
;
1102 vfmt
->VertexAttribL3dv
= vbo_VertexAttribL3dv
;
1103 vfmt
->VertexAttribL4dv
= vbo_VertexAttribL4dv
;
1105 vfmt
->VertexAttribL1ui64ARB
= vbo_VertexAttribL1ui64ARB
;
1106 vfmt
->VertexAttribL1ui64vARB
= vbo_VertexAttribL1ui64vARB
;
1111 * Tell the VBO module to use a real OpenGL vertex buffer object to
1112 * store accumulated immediate-mode vertex data.
1113 * This replaces the malloced buffer which was created in
1114 * vb_exec_vtx_init() below.
1117 vbo_use_buffer_objects(struct gl_context
*ctx
)
1119 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1120 /* Any buffer name but 0 can be used here since this bufferobj won't
1121 * go into the bufferobj hashtable.
1123 GLuint bufName
= IMM_BUFFER_NAME
;
1124 GLenum target
= GL_ARRAY_BUFFER_ARB
;
1125 GLenum usage
= GL_STREAM_DRAW_ARB
;
1126 GLsizei size
= VBO_VERT_BUFFER_SIZE
;
1128 /* Make sure this func is only used once */
1129 assert(exec
->vtx
.bufferobj
== ctx
->Shared
->NullBufferObj
);
1131 _mesa_align_free(exec
->vtx
.buffer_map
);
1132 exec
->vtx
.buffer_map
= NULL
;
1133 exec
->vtx
.buffer_ptr
= NULL
;
1135 /* Allocate a real buffer object now */
1136 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1137 exec
->vtx
.bufferobj
= ctx
->Driver
.NewBufferObject(ctx
, bufName
);
1138 if (!ctx
->Driver
.BufferData(ctx
, target
, size
, NULL
, usage
,
1140 GL_DYNAMIC_STORAGE_BIT
|
1141 GL_CLIENT_STORAGE_BIT
,
1142 exec
->vtx
.bufferobj
)) {
1143 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "VBO allocation");
1149 * If this function is called, all VBO buffers will be unmapped when
1151 * Otherwise, if a simple command like glColor3f() is called and we flush,
1152 * the current VBO may be left mapped.
1155 vbo_always_unmap_buffers(struct gl_context
*ctx
)
1157 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1158 exec
->begin_vertices_flags
|= FLUSH_STORED_VERTICES
;
1163 vbo_exec_vtx_init(struct vbo_exec_context
*exec
)
1165 struct gl_context
*ctx
= exec
->ctx
;
1166 struct vbo_context
*vbo
= vbo_context(ctx
);
1169 /* Allocate a buffer object. Will just reuse this object
1170 * continuously, unless vbo_use_buffer_objects() is called to enable
1173 _mesa_reference_buffer_object(ctx
,
1174 &exec
->vtx
.bufferobj
,
1175 ctx
->Shared
->NullBufferObj
);
1177 assert(!exec
->vtx
.buffer_map
);
1178 exec
->vtx
.buffer_map
= _mesa_align_malloc(VBO_VERT_BUFFER_SIZE
, 64);
1179 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
1181 vbo_exec_vtxfmt_init(exec
);
1182 _mesa_noop_vtxfmt_init(&exec
->vtxfmt_noop
);
1184 exec
->vtx
.enabled
= 0;
1185 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1186 assert(i
< ARRAY_SIZE(exec
->vtx
.attrsz
));
1187 exec
->vtx
.attrsz
[i
] = 0;
1188 assert(i
< ARRAY_SIZE(exec
->vtx
.attrtype
));
1189 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1190 assert(i
< ARRAY_SIZE(exec
->vtx
.active_sz
));
1191 exec
->vtx
.active_sz
[i
] = 0;
1193 for (i
= 0 ; i
< VERT_ATTRIB_MAX
; i
++) {
1194 assert(i
< ARRAY_SIZE(exec
->vtx
.inputs
));
1195 assert(i
< ARRAY_SIZE(exec
->vtx
.arrays
));
1196 exec
->vtx
.inputs
[i
] = &exec
->vtx
.arrays
[i
];
1200 struct gl_vertex_array
*arrays
= exec
->vtx
.arrays
;
1203 memcpy(arrays
, &vbo
->currval
[VBO_ATTRIB_POS
],
1204 VERT_ATTRIB_FF_MAX
* sizeof(arrays
[0]));
1205 for (i
= 0; i
< VERT_ATTRIB_FF_MAX
; ++i
) {
1206 struct gl_vertex_array
*array
;
1207 array
= &arrays
[VERT_ATTRIB_FF(i
)];
1208 array
->BufferObj
= NULL
;
1209 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1210 vbo
->currval
[VBO_ATTRIB_POS
+i
].BufferObj
);
1213 memcpy(arrays
+ VERT_ATTRIB_GENERIC(0),
1214 &vbo
->currval
[VBO_ATTRIB_GENERIC0
],
1215 VERT_ATTRIB_GENERIC_MAX
* sizeof(arrays
[0]));
1217 for (i
= 0; i
< VERT_ATTRIB_GENERIC_MAX
; ++i
) {
1218 struct gl_vertex_array
*array
;
1219 array
= &arrays
[VERT_ATTRIB_GENERIC(i
)];
1220 array
->BufferObj
= NULL
;
1221 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1222 vbo
->currval
[VBO_ATTRIB_GENERIC0
+i
].BufferObj
);
1226 exec
->vtx
.vertex_size
= 0;
1228 exec
->begin_vertices_flags
= FLUSH_UPDATE_CURRENT
;
1233 vbo_exec_vtx_destroy(struct vbo_exec_context
*exec
)
1235 /* using a real VBO for vertex data */
1236 struct gl_context
*ctx
= exec
->ctx
;
1239 /* True VBOs should already be unmapped
1241 if (exec
->vtx
.buffer_map
) {
1242 assert(exec
->vtx
.bufferobj
->Name
== 0 ||
1243 exec
->vtx
.bufferobj
->Name
== IMM_BUFFER_NAME
);
1244 if (exec
->vtx
.bufferobj
->Name
== 0) {
1245 _mesa_align_free(exec
->vtx
.buffer_map
);
1246 exec
->vtx
.buffer_map
= NULL
;
1247 exec
->vtx
.buffer_ptr
= NULL
;
1251 /* Drop any outstanding reference to the vertex buffer
1253 for (i
= 0; i
< ARRAY_SIZE(exec
->vtx
.arrays
); i
++) {
1254 _mesa_reference_buffer_object(ctx
,
1255 &exec
->vtx
.arrays
[i
].BufferObj
,
1259 /* Free the vertex buffer. Unmap first if needed.
1261 if (_mesa_bufferobj_mapped(exec
->vtx
.bufferobj
, MAP_INTERNAL
)) {
1262 ctx
->Driver
.UnmapBuffer(ctx
, exec
->vtx
.bufferobj
, MAP_INTERNAL
);
1264 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1269 * If inside glBegin()/glEnd(), it should assert(0). Otherwise, if
1270 * FLUSH_STORED_VERTICES bit in \p flags is set flushes any buffered
1271 * vertices, if FLUSH_UPDATE_CURRENT bit is set updates
1272 * __struct gl_contextRec::Current and gl_light_attrib::Material
1274 * Note that the default T&L engine never clears the
1275 * FLUSH_UPDATE_CURRENT bit, even after performing the update.
1277 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1280 vbo_exec_FlushVertices(struct gl_context
*ctx
, GLuint flags
)
1282 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1285 /* debug check: make sure we don't get called recursively */
1286 exec
->flush_call_depth
++;
1287 assert(exec
->flush_call_depth
== 1);
1290 if (_mesa_inside_begin_end(ctx
)) {
1291 /* We've had glBegin but not glEnd! */
1293 exec
->flush_call_depth
--;
1294 assert(exec
->flush_call_depth
== 0);
1299 /* Flush (draw), and make sure VBO is left unmapped when done */
1300 vbo_exec_FlushVertices_internal(exec
, GL_TRUE
);
1302 /* Need to do this to ensure vbo_exec_begin_vertices gets called again:
1304 ctx
->Driver
.NeedFlush
&= ~(FLUSH_UPDATE_CURRENT
| flags
);
1307 exec
->flush_call_depth
--;
1308 assert(exec
->flush_call_depth
== 0);
1314 * Reset the vertex attribute by setting its size to zero.
1317 vbo_reset_attr(struct vbo_exec_context
*exec
, GLuint attr
)
1319 exec
->vtx
.attrsz
[attr
] = 0;
1320 exec
->vtx
.attrtype
[attr
] = GL_FLOAT
;
1321 exec
->vtx
.active_sz
[attr
] = 0;
1326 vbo_reset_all_attr(struct vbo_exec_context
*exec
)
1328 while (exec
->vtx
.enabled
) {
1329 const int i
= u_bit_scan64(&exec
->vtx
.enabled
);
1330 vbo_reset_attr(exec
, i
);
1333 exec
->vtx
.vertex_size
= 0;
1338 _es_Color4f(GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
1340 vbo_Color4f(r
, g
, b
, a
);
1345 _es_Normal3f(GLfloat x
, GLfloat y
, GLfloat z
)
1347 vbo_Normal3f(x
, y
, z
);
1352 _es_MultiTexCoord4f(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1354 vbo_MultiTexCoord4f(target
, s
, t
, r
, q
);
1359 _es_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
1361 vbo_Materialfv(face
, pname
, params
);
1366 _es_Materialf(GLenum face
, GLenum pname
, GLfloat param
)
1370 p
[1] = p
[2] = p
[3] = 0.0F
;
1371 vbo_Materialfv(face
, pname
, p
);
1376 * A special version of glVertexAttrib4f that does not treat index 0 as
1380 VertexAttrib4f_nopos(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1382 GET_CURRENT_CONTEXT(ctx
);
1383 if (index
< MAX_VERTEX_GENERIC_ATTRIBS
)
1384 ATTRF(VBO_ATTRIB_GENERIC0
+ index
, 4, x
, y
, z
, w
);
1386 ERROR(GL_INVALID_VALUE
);
1390 _es_VertexAttrib4f(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1392 VertexAttrib4f_nopos(index
, x
, y
, z
, w
);
1397 _es_VertexAttrib1f(GLuint indx
, GLfloat x
)
1399 VertexAttrib4f_nopos(indx
, x
, 0.0f
, 0.0f
, 1.0f
);
1404 _es_VertexAttrib1fv(GLuint indx
, const GLfloat
* values
)
1406 VertexAttrib4f_nopos(indx
, values
[0], 0.0f
, 0.0f
, 1.0f
);
1411 _es_VertexAttrib2f(GLuint indx
, GLfloat x
, GLfloat y
)
1413 VertexAttrib4f_nopos(indx
, x
, y
, 0.0f
, 1.0f
);
1418 _es_VertexAttrib2fv(GLuint indx
, const GLfloat
* values
)
1420 VertexAttrib4f_nopos(indx
, values
[0], values
[1], 0.0f
, 1.0f
);
1425 _es_VertexAttrib3f(GLuint indx
, GLfloat x
, GLfloat y
, GLfloat z
)
1427 VertexAttrib4f_nopos(indx
, x
, y
, z
, 1.0f
);
1432 _es_VertexAttrib3fv(GLuint indx
, const GLfloat
* values
)
1434 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], 1.0f
);
1439 _es_VertexAttrib4fv(GLuint indx
, const GLfloat
* values
)
1441 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], values
[3]);