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"
56 /** ID/name for immediate-mode VBO */
57 #define IMM_BUFFER_NAME 0xaabbccdd
61 vbo_reset_all_attr(struct vbo_exec_context
*exec
);
65 * Close off the last primitive, execute the buffer, restart the
66 * primitive. This is called when we fill a vertex buffer before
69 static void vbo_exec_wrap_buffers( struct vbo_exec_context
*exec
)
71 if (exec
->vtx
.prim_count
== 0) {
72 exec
->vtx
.copied
.nr
= 0;
73 exec
->vtx
.vert_count
= 0;
74 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
77 struct _mesa_prim
*last_prim
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
78 const GLuint last_begin
= last_prim
->begin
;
81 if (_mesa_inside_begin_end(exec
->ctx
)) {
82 last_prim
->count
= exec
->vtx
.vert_count
- last_prim
->start
;
85 last_count
= last_prim
->count
;
87 /* Special handling for wrapping GL_LINE_LOOP */
88 if (last_prim
->mode
== GL_LINE_LOOP
&&
91 /* draw this section of the incomplete line loop as a line strip */
92 last_prim
->mode
= GL_LINE_STRIP
;
93 if (!last_prim
->begin
) {
94 /* This is not the first section of the line loop, so don't
95 * draw the 0th vertex. We're saving it until we draw the
96 * very last section of the loop.
103 /* Execute the buffer and save copied vertices.
105 if (exec
->vtx
.vert_count
)
106 vbo_exec_vtx_flush( exec
, GL_FALSE
);
108 exec
->vtx
.prim_count
= 0;
109 exec
->vtx
.copied
.nr
= 0;
112 /* Emit a glBegin to start the new list.
114 assert(exec
->vtx
.prim_count
== 0);
116 if (_mesa_inside_begin_end(exec
->ctx
)) {
117 exec
->vtx
.prim
[0].mode
= exec
->ctx
->Driver
.CurrentExecPrimitive
;
118 exec
->vtx
.prim
[0].begin
= 0;
119 exec
->vtx
.prim
[0].end
= 0;
120 exec
->vtx
.prim
[0].start
= 0;
121 exec
->vtx
.prim
[0].count
= 0;
122 exec
->vtx
.prim_count
++;
124 if (exec
->vtx
.copied
.nr
== last_count
)
125 exec
->vtx
.prim
[0].begin
= last_begin
;
132 * Deal with buffer wrapping where provoked by the vertex buffer
133 * filling up, as opposed to upgrade_vertex().
136 vbo_exec_vtx_wrap(struct vbo_exec_context
*exec
)
138 unsigned numComponents
;
140 /* Run pipeline on current vertices, copy wrapped vertices
141 * to exec->vtx.copied.
143 vbo_exec_wrap_buffers( exec
);
145 if (!exec
->vtx
.buffer_ptr
) {
146 /* probably ran out of memory earlier when allocating the VBO */
150 /* Copy stored stored vertices to start of new list.
152 assert(exec
->vtx
.max_vert
- exec
->vtx
.vert_count
> exec
->vtx
.copied
.nr
);
154 numComponents
= exec
->vtx
.copied
.nr
* exec
->vtx
.vertex_size
;
155 memcpy(exec
->vtx
.buffer_ptr
,
156 exec
->vtx
.copied
.buffer
,
157 numComponents
* sizeof(fi_type
));
158 exec
->vtx
.buffer_ptr
+= numComponents
;
159 exec
->vtx
.vert_count
+= exec
->vtx
.copied
.nr
;
161 exec
->vtx
.copied
.nr
= 0;
166 * Copy the active vertex's values to the ctx->Current fields.
168 static void vbo_exec_copy_to_current( struct vbo_exec_context
*exec
)
170 struct gl_context
*ctx
= exec
->ctx
;
171 struct vbo_context
*vbo
= vbo_context(ctx
);
172 GLbitfield64 enabled
= exec
->vtx
.enabled
& (~BITFIELD64_BIT(VBO_ATTRIB_POS
));
175 const int i
= u_bit_scan64(&enabled
);
177 /* Note: the exec->vtx.current[i] pointers point into the
178 * ctx->Current.Attrib and ctx->Light.Material.Attrib arrays.
180 GLfloat
*current
= (GLfloat
*)vbo
->currval
[i
].Ptr
;
181 fi_type tmp
[8]; /* space for doubles */
182 int dmul
= exec
->vtx
.attrtype
[i
] == GL_DOUBLE
? 2 : 1;
184 assert(exec
->vtx
.attrsz
[i
]);
186 if (exec
->vtx
.attrtype
[i
] == GL_DOUBLE
) {
187 memset(tmp
, 0, sizeof(tmp
));
188 memcpy(tmp
, exec
->vtx
.attrptr
[i
], exec
->vtx
.attrsz
[i
] * sizeof(GLfloat
));
190 COPY_CLEAN_4V_TYPE_AS_UNION(tmp
,
192 exec
->vtx
.attrptr
[i
],
193 exec
->vtx
.attrtype
[i
]);
196 if (exec
->vtx
.attrtype
[i
] != vbo
->currval
[i
].Type
||
197 memcmp(current
, tmp
, 4 * sizeof(GLfloat
) * dmul
) != 0) {
198 memcpy(current
, tmp
, 4 * sizeof(GLfloat
) * dmul
);
200 /* Given that we explicitly state size here, there is no need
201 * for the COPY_CLEAN above, could just copy 16 bytes and be
202 * done. The only problem is when Mesa accesses ctx->Current
205 /* Size here is in components - not bytes */
206 vbo
->currval
[i
].Size
= exec
->vtx
.attrsz
[i
] / dmul
;
207 vbo
->currval
[i
]._ElementSize
= vbo
->currval
[i
].Size
* sizeof(GLfloat
) * dmul
;
208 vbo
->currval
[i
].Type
= exec
->vtx
.attrtype
[i
];
209 vbo
->currval
[i
].Integer
=
210 vbo_attrtype_to_integer_flag(exec
->vtx
.attrtype
[i
]);
211 vbo
->currval
[i
].Doubles
=
212 vbo_attrtype_to_double_flag(exec
->vtx
.attrtype
[i
]);
214 /* This triggers rather too much recalculation of Mesa state
215 * that doesn't get used (eg light positions).
217 if (i
>= VBO_ATTRIB_MAT_FRONT_AMBIENT
&&
218 i
<= VBO_ATTRIB_MAT_BACK_INDEXES
)
219 ctx
->NewState
|= _NEW_LIGHT
;
221 ctx
->NewState
|= _NEW_CURRENT_ATTRIB
;
225 /* Colormaterial -- this kindof sucks.
227 if (ctx
->Light
.ColorMaterialEnabled
&&
228 exec
->vtx
.attrsz
[VBO_ATTRIB_COLOR0
]) {
229 _mesa_update_color_material(ctx
,
230 ctx
->Current
.Attrib
[VBO_ATTRIB_COLOR0
]);
236 * Copy current vertex attribute values into the current vertex.
239 vbo_exec_copy_from_current(struct vbo_exec_context
*exec
)
241 struct gl_context
*ctx
= exec
->ctx
;
242 struct vbo_context
*vbo
= vbo_context(ctx
);
245 for (i
= VBO_ATTRIB_POS
+ 1; i
< VBO_ATTRIB_MAX
; i
++) {
246 if (exec
->vtx
.attrtype
[i
] == GL_DOUBLE
) {
247 memcpy(exec
->vtx
.attrptr
[i
], vbo
->currval
[i
].Ptr
, exec
->vtx
.attrsz
[i
] * sizeof(GLfloat
));
249 const fi_type
*current
= (fi_type
*) vbo
->currval
[i
].Ptr
;
250 switch (exec
->vtx
.attrsz
[i
]) {
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.
270 vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context
*exec
,
271 GLuint attr
, GLuint newSize
)
273 struct gl_context
*ctx
= exec
->ctx
;
274 struct vbo_context
*vbo
= vbo_context(ctx
);
275 const GLint lastcount
= exec
->vtx
.vert_count
;
276 fi_type
*old_attrptr
[VBO_ATTRIB_MAX
];
277 const GLuint old_vtx_size
= exec
->vtx
.vertex_size
; /* floats per vertex */
278 const GLuint oldSize
= exec
->vtx
.attrsz
[attr
];
281 /* Run pipeline on current vertices, copy wrapped vertices
282 * to exec->vtx.copied.
284 vbo_exec_wrap_buffers( exec
);
286 if (unlikely(exec
->vtx
.copied
.nr
)) {
287 /* We're in the middle of a primitive, keep the old vertex
288 * format around to be able to translate the copied vertices to
291 memcpy(old_attrptr
, exec
->vtx
.attrptr
, sizeof(old_attrptr
));
294 if (unlikely(oldSize
)) {
295 /* Do a COPY_TO_CURRENT to ensure back-copying works for the
296 * case when the attribute already exists in the vertex and is
297 * having its size increased.
299 vbo_exec_copy_to_current( exec
);
302 /* Heuristic: Attempt to isolate attributes received outside
303 * begin/end so that they don't bloat the vertices.
305 if (!_mesa_inside_begin_end(ctx
) &&
306 !oldSize
&& lastcount
> 8 && exec
->vtx
.vertex_size
) {
307 vbo_exec_copy_to_current( exec
);
308 vbo_reset_all_attr(exec
);
313 exec
->vtx
.attrsz
[attr
] = newSize
;
314 exec
->vtx
.vertex_size
+= newSize
- oldSize
;
315 exec
->vtx
.max_vert
= vbo_compute_max_verts(exec
);
316 exec
->vtx
.vert_count
= 0;
317 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
318 exec
->vtx
.enabled
|= BITFIELD64_BIT(attr
);
320 if (unlikely(oldSize
)) {
321 /* Size changed, recalculate all the attrptr[] values
323 fi_type
*tmp
= exec
->vtx
.vertex
;
325 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
326 if (exec
->vtx
.attrsz
[i
]) {
327 exec
->vtx
.attrptr
[i
] = tmp
;
328 tmp
+= exec
->vtx
.attrsz
[i
];
331 exec
->vtx
.attrptr
[i
] = NULL
; /* will not be dereferenced */
334 /* Copy from current to repopulate the vertex with correct
337 vbo_exec_copy_from_current( exec
);
340 /* Just have to append the new attribute at the end */
341 exec
->vtx
.attrptr
[attr
] = exec
->vtx
.vertex
+
342 exec
->vtx
.vertex_size
- newSize
;
345 /* Replay stored vertices to translate them
346 * to new format here.
348 * -- No need to replay - just copy piecewise
350 if (unlikely(exec
->vtx
.copied
.nr
)) {
351 fi_type
*data
= exec
->vtx
.copied
.buffer
;
352 fi_type
*dest
= exec
->vtx
.buffer_ptr
;
354 assert(exec
->vtx
.buffer_ptr
== exec
->vtx
.buffer_map
);
356 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
357 GLbitfield64 enabled
= exec
->vtx
.enabled
;
359 const int j
= u_bit_scan64(&enabled
);
360 GLuint sz
= exec
->vtx
.attrsz
[j
];
361 GLint old_offset
= old_attrptr
[j
] - exec
->vtx
.vertex
;
362 GLint new_offset
= exec
->vtx
.attrptr
[j
] - exec
->vtx
.vertex
;
369 COPY_CLEAN_4V_TYPE_AS_UNION(tmp
, oldSize
,
371 exec
->vtx
.attrtype
[j
]);
372 COPY_SZ_4V(dest
+ new_offset
, newSize
, tmp
);
374 fi_type
*current
= (fi_type
*)vbo
->currval
[j
].Ptr
;
375 COPY_SZ_4V(dest
+ new_offset
, sz
, current
);
379 COPY_SZ_4V(dest
+ new_offset
, sz
, data
+ old_offset
);
383 data
+= old_vtx_size
;
384 dest
+= exec
->vtx
.vertex_size
;
387 exec
->vtx
.buffer_ptr
= dest
;
388 exec
->vtx
.vert_count
+= exec
->vtx
.copied
.nr
;
389 exec
->vtx
.copied
.nr
= 0;
395 * This is when a vertex attribute transitions to a different size.
396 * For example, we saw a bunch of glTexCoord2f() calls and now we got a
397 * glTexCoord4f() call. We promote the array from size=2 to size=4.
398 * \param newSize size of new vertex (number of 32-bit words).
401 vbo_exec_fixup_vertex(struct gl_context
*ctx
, GLuint attr
,
402 GLuint newSize
, GLenum newType
)
404 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
406 if (newSize
> exec
->vtx
.attrsz
[attr
] ||
407 newType
!= exec
->vtx
.attrtype
[attr
]) {
408 /* New size is larger. Need to flush existing vertices and get
409 * an enlarged vertex format.
411 vbo_exec_wrap_upgrade_vertex( exec
, attr
, newSize
);
413 else if (newSize
< exec
->vtx
.active_sz
[attr
]) {
416 vbo_get_default_vals_as_union(exec
->vtx
.attrtype
[attr
]);
418 /* New size is smaller - just need to fill in some
419 * zeros. Don't need to flush or wrap.
421 for (i
= newSize
; i
<= exec
->vtx
.attrsz
[attr
]; i
++)
422 exec
->vtx
.attrptr
[attr
][i
-1] = id
[i
-1];
425 exec
->vtx
.active_sz
[attr
] = newSize
;
426 exec
->vtx
.attrtype
[attr
] = newType
;
428 /* Does setting NeedFlush belong here? Necessitates resetting
429 * vtxfmt on each flush (otherwise flags won't get reset
433 ctx
->Driver
.NeedFlush
|= FLUSH_STORED_VERTICES
;
438 * Called upon first glVertex, glColor, glTexCoord, etc.
441 vbo_exec_begin_vertices(struct gl_context
*ctx
)
443 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
445 vbo_exec_vtx_map( exec
);
447 assert((ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
) == 0);
448 assert(exec
->begin_vertices_flags
);
450 ctx
->Driver
.NeedFlush
|= exec
->begin_vertices_flags
;
455 * This macro is used to implement all the glVertex, glColor, glTexCoord,
456 * glVertexAttrib, etc functions.
457 * \param A attribute index
458 * \param N attribute size (1..4)
459 * \param T type (GL_FLOAT, GL_DOUBLE, GL_INT, GL_UNSIGNED_INT)
460 * \param C cast type (fi_type or double)
461 * \param V0, V1, v2, V3 attribute value
463 #define ATTR_UNION( A, N, T, C, V0, V1, V2, V3 ) \
465 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
466 int sz = (sizeof(C) / sizeof(GLfloat)); \
468 assert(sz == 1 || sz == 2); \
470 /* check if attribute size or type is changing */ \
471 if (unlikely(exec->vtx.active_sz[A] != N * sz) || \
472 unlikely(exec->vtx.attrtype[A] != T)) { \
473 vbo_exec_fixup_vertex(ctx, A, N * sz, T); \
476 /* store vertex attribute in vertex buffer */ \
478 C *dest = (C *)exec->vtx.attrptr[A]; \
479 if (N>0) dest[0] = V0; \
480 if (N>1) dest[1] = V1; \
481 if (N>2) dest[2] = V2; \
482 if (N>3) dest[3] = V3; \
483 assert(exec->vtx.attrtype[A] == T); \
487 /* This is a glVertex call */ \
490 if (unlikely((ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) == 0)) { \
491 vbo_exec_begin_vertices(ctx); \
494 if (unlikely(!exec->vtx.buffer_ptr)) { \
495 vbo_exec_vtx_map(exec); \
497 assert(exec->vtx.buffer_ptr); \
499 /* copy 32-bit words */ \
500 for (i = 0; i < exec->vtx.vertex_size; i++) \
501 exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i]; \
503 exec->vtx.buffer_ptr += exec->vtx.vertex_size; \
505 /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \
506 /* something to draw (not just updating a color or texcoord).*/ \
507 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \
509 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
510 vbo_exec_vtx_wrap( exec ); \
512 /* we now have accumulated per-vertex attributes */ \
513 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
517 #define ERROR(err) _mesa_error( ctx, err, __func__ )
518 #define TAG(x) vbo_##x
520 #include "vbo_attrib_tmp.h"
525 * Execute a glMaterial call. Note that if GL_COLOR_MATERIAL is enabled,
526 * this may be a (partial) no-op.
528 static void GLAPIENTRY
529 vbo_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
531 GLbitfield updateMats
;
532 GET_CURRENT_CONTEXT(ctx
);
534 /* This function should be a no-op when it tries to update material
535 * attributes which are currently tracking glColor via glColorMaterial.
536 * The updateMats var will be a mask of the MAT_BIT_FRONT/BACK_x bits
537 * indicating which material attributes can actually be updated below.
539 if (ctx
->Light
.ColorMaterialEnabled
) {
540 updateMats
= ~ctx
->Light
._ColorMaterialBitmask
;
543 /* GL_COLOR_MATERIAL is disabled so don't skip any material updates */
544 updateMats
= ALL_MATERIAL_BITS
;
547 if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_FRONT
) {
548 updateMats
&= FRONT_MATERIAL_BITS
;
550 else if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_BACK
) {
551 updateMats
&= BACK_MATERIAL_BITS
;
553 else if (face
!= GL_FRONT_AND_BACK
) {
554 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterial(invalid face)");
560 if (updateMats
& MAT_BIT_FRONT_EMISSION
)
561 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_EMISSION
, 4, params
);
562 if (updateMats
& MAT_BIT_BACK_EMISSION
)
563 MAT_ATTR(VBO_ATTRIB_MAT_BACK_EMISSION
, 4, params
);
566 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
567 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
568 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
569 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
572 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
573 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
574 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
575 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
578 if (updateMats
& MAT_BIT_FRONT_SPECULAR
)
579 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SPECULAR
, 4, params
);
580 if (updateMats
& MAT_BIT_BACK_SPECULAR
)
581 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SPECULAR
, 4, params
);
584 if (*params
< 0 || *params
> ctx
->Const
.MaxShininess
) {
585 _mesa_error(ctx
, GL_INVALID_VALUE
,
586 "glMaterial(invalid shininess: %f out range [0, %f])",
587 *params
, ctx
->Const
.MaxShininess
);
590 if (updateMats
& MAT_BIT_FRONT_SHININESS
)
591 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SHININESS
, 1, params
);
592 if (updateMats
& MAT_BIT_BACK_SHININESS
)
593 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SHININESS
, 1, params
);
595 case GL_COLOR_INDEXES
:
596 if (ctx
->API
!= API_OPENGL_COMPAT
) {
597 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
600 if (updateMats
& MAT_BIT_FRONT_INDEXES
)
601 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_INDEXES
, 3, params
);
602 if (updateMats
& MAT_BIT_BACK_INDEXES
)
603 MAT_ATTR(VBO_ATTRIB_MAT_BACK_INDEXES
, 3, params
);
605 case GL_AMBIENT_AND_DIFFUSE
:
606 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
607 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_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_AMBIENT
)
611 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
612 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
613 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
616 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
623 * Flush (draw) vertices.
624 * \param unmap - leave VBO unmapped after flushing?
627 vbo_exec_FlushVertices_internal(struct vbo_exec_context
*exec
, GLboolean unmap
)
629 if (exec
->vtx
.vert_count
|| unmap
) {
630 vbo_exec_vtx_flush( exec
, unmap
);
633 if (exec
->vtx
.vertex_size
) {
634 vbo_exec_copy_to_current( exec
);
635 vbo_reset_all_attr(exec
);
640 static void GLAPIENTRY
vbo_exec_EvalCoord1f( GLfloat u
)
642 GET_CURRENT_CONTEXT( ctx
);
643 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
647 if (exec
->eval
.recalculate_maps
)
648 vbo_exec_eval_update( exec
);
650 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
651 if (exec
->eval
.map1
[i
].map
)
652 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map1
[i
].sz
)
653 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map1
[i
].sz
, GL_FLOAT
);
658 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
659 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
661 vbo_exec_do_EvalCoord1f( exec
, u
);
663 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
664 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
667 static void GLAPIENTRY
vbo_exec_EvalCoord2f( GLfloat u
, GLfloat v
)
669 GET_CURRENT_CONTEXT( ctx
);
670 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
674 if (exec
->eval
.recalculate_maps
)
675 vbo_exec_eval_update( exec
);
677 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
678 if (exec
->eval
.map2
[i
].map
)
679 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map2
[i
].sz
)
680 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map2
[i
].sz
, GL_FLOAT
);
683 if (ctx
->Eval
.AutoNormal
)
684 if (exec
->vtx
.active_sz
[VBO_ATTRIB_NORMAL
] != 3)
685 vbo_exec_fixup_vertex( ctx
, VBO_ATTRIB_NORMAL
, 3, GL_FLOAT
);
688 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
689 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
691 vbo_exec_do_EvalCoord2f( exec
, u
, v
);
693 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
694 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
697 static void GLAPIENTRY
vbo_exec_EvalCoord1fv( const GLfloat
*u
)
699 vbo_exec_EvalCoord1f( u
[0] );
702 static void GLAPIENTRY
vbo_exec_EvalCoord2fv( const GLfloat
*u
)
704 vbo_exec_EvalCoord2f( u
[0], u
[1] );
707 static void GLAPIENTRY
vbo_exec_EvalPoint1( GLint i
)
709 GET_CURRENT_CONTEXT( ctx
);
710 GLfloat du
= ((ctx
->Eval
.MapGrid1u2
- ctx
->Eval
.MapGrid1u1
) /
711 (GLfloat
) ctx
->Eval
.MapGrid1un
);
712 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid1u1
;
714 vbo_exec_EvalCoord1f( u
);
718 static void GLAPIENTRY
vbo_exec_EvalPoint2( GLint i
, GLint j
)
720 GET_CURRENT_CONTEXT( ctx
);
721 GLfloat du
= ((ctx
->Eval
.MapGrid2u2
- ctx
->Eval
.MapGrid2u1
) /
722 (GLfloat
) ctx
->Eval
.MapGrid2un
);
723 GLfloat dv
= ((ctx
->Eval
.MapGrid2v2
- ctx
->Eval
.MapGrid2v1
) /
724 (GLfloat
) ctx
->Eval
.MapGrid2vn
);
725 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid2u1
;
726 GLfloat v
= j
* dv
+ ctx
->Eval
.MapGrid2v1
;
728 vbo_exec_EvalCoord2f( u
, v
);
733 * Called via glBegin.
735 static void GLAPIENTRY
vbo_exec_Begin( GLenum mode
)
737 GET_CURRENT_CONTEXT( ctx
);
738 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
741 if (_mesa_inside_begin_end(ctx
)) {
742 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glBegin");
746 if (!_mesa_valid_prim_mode(ctx
, mode
, "glBegin")) {
750 vbo_draw_method(vbo_context(ctx
), DRAW_BEGIN_END
);
753 _mesa_update_state( ctx
);
755 CALL_Begin(ctx
->Exec
, (mode
));
759 if (!_mesa_valid_to_render(ctx
, "glBegin")) {
763 /* Heuristic: attempt to isolate attributes occurring outside
766 if (exec
->vtx
.vertex_size
&& !exec
->vtx
.attrsz
[0])
767 vbo_exec_FlushVertices_internal(exec
, GL_FALSE
);
769 i
= exec
->vtx
.prim_count
++;
770 exec
->vtx
.prim
[i
].mode
= mode
;
771 exec
->vtx
.prim
[i
].begin
= 1;
772 exec
->vtx
.prim
[i
].end
= 0;
773 exec
->vtx
.prim
[i
].indexed
= 0;
774 exec
->vtx
.prim
[i
].weak
= 0;
775 exec
->vtx
.prim
[i
].pad
= 0;
776 exec
->vtx
.prim
[i
].start
= exec
->vtx
.vert_count
;
777 exec
->vtx
.prim
[i
].count
= 0;
778 exec
->vtx
.prim
[i
].num_instances
= 1;
779 exec
->vtx
.prim
[i
].base_instance
= 0;
780 exec
->vtx
.prim
[i
].is_indirect
= 0;
782 ctx
->Driver
.CurrentExecPrimitive
= mode
;
784 ctx
->Exec
= ctx
->BeginEnd
;
785 /* We may have been called from a display list, in which case we should
786 * leave dlist.c's dispatch table in place.
788 if (ctx
->CurrentDispatch
== ctx
->OutsideBeginEnd
) {
789 ctx
->CurrentDispatch
= ctx
->BeginEnd
;
790 _glapi_set_dispatch(ctx
->CurrentDispatch
);
792 assert(ctx
->CurrentDispatch
== ctx
->Save
);
798 * Try to merge / concatenate the two most recent VBO primitives.
801 try_vbo_merge(struct vbo_exec_context
*exec
)
803 struct _mesa_prim
*cur
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
805 assert(exec
->vtx
.prim_count
>= 1);
807 vbo_try_prim_conversion(cur
);
809 if (exec
->vtx
.prim_count
>= 2) {
810 struct _mesa_prim
*prev
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 2];
811 assert(prev
== cur
- 1);
813 if (vbo_can_merge_prims(prev
, cur
)) {
818 vbo_merge_prims(prev
, cur
);
819 exec
->vtx
.prim_count
--; /* drop the last primitive */
828 static void GLAPIENTRY
vbo_exec_End( void )
830 GET_CURRENT_CONTEXT( ctx
);
831 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
833 if (!_mesa_inside_begin_end(ctx
)) {
834 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glEnd");
838 ctx
->Exec
= ctx
->OutsideBeginEnd
;
839 if (ctx
->CurrentDispatch
== ctx
->BeginEnd
) {
840 ctx
->CurrentDispatch
= ctx
->OutsideBeginEnd
;
841 _glapi_set_dispatch(ctx
->CurrentDispatch
);
844 if (exec
->vtx
.prim_count
> 0) {
845 /* close off current primitive */
846 struct _mesa_prim
*last_prim
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
849 last_prim
->count
= exec
->vtx
.vert_count
- last_prim
->start
;
851 /* Special handling for GL_LINE_LOOP */
852 if (last_prim
->mode
== GL_LINE_LOOP
&& last_prim
->begin
== 0) {
853 /* We're finishing drawing a line loop. Append 0th vertex onto
854 * end of vertex buffer so we can draw it as a line strip.
856 const fi_type
*src
= exec
->vtx
.buffer_map
+
857 last_prim
->start
* exec
->vtx
.vertex_size
;
858 fi_type
*dst
= exec
->vtx
.buffer_map
+
859 exec
->vtx
.vert_count
* exec
->vtx
.vertex_size
;
861 /* copy 0th vertex to end of buffer */
862 memcpy(dst
, src
, exec
->vtx
.vertex_size
* sizeof(fi_type
));
864 last_prim
->start
++; /* skip vertex0 */
865 /* note that last_prim->count stays unchanged */
866 last_prim
->mode
= GL_LINE_STRIP
;
868 /* Increment the vertex count so the next primitive doesn't
869 * overwrite the last vertex which we just added.
871 exec
->vtx
.vert_count
++;
872 exec
->vtx
.buffer_ptr
+= exec
->vtx
.vertex_size
;
878 ctx
->Driver
.CurrentExecPrimitive
= PRIM_OUTSIDE_BEGIN_END
;
880 if (exec
->vtx
.prim_count
== VBO_MAX_PRIM
)
881 vbo_exec_vtx_flush( exec
, GL_FALSE
);
883 if (MESA_DEBUG_FLAGS
& DEBUG_ALWAYS_FLUSH
) {
890 * Called via glPrimitiveRestartNV()
892 static void GLAPIENTRY
893 vbo_exec_PrimitiveRestartNV(void)
896 GET_CURRENT_CONTEXT( ctx
);
898 curPrim
= ctx
->Driver
.CurrentExecPrimitive
;
900 if (curPrim
== PRIM_OUTSIDE_BEGIN_END
) {
901 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glPrimitiveRestartNV" );
905 vbo_exec_Begin(curPrim
);
911 static void vbo_exec_vtxfmt_init( struct vbo_exec_context
*exec
)
913 struct gl_context
*ctx
= exec
->ctx
;
914 GLvertexformat
*vfmt
= &exec
->vtxfmt
;
916 vfmt
->ArrayElement
= _ae_ArrayElement
;
918 vfmt
->Begin
= vbo_exec_Begin
;
919 vfmt
->End
= vbo_exec_End
;
920 vfmt
->PrimitiveRestartNV
= vbo_exec_PrimitiveRestartNV
;
922 vfmt
->CallList
= _mesa_CallList
;
923 vfmt
->CallLists
= _mesa_CallLists
;
925 vfmt
->EvalCoord1f
= vbo_exec_EvalCoord1f
;
926 vfmt
->EvalCoord1fv
= vbo_exec_EvalCoord1fv
;
927 vfmt
->EvalCoord2f
= vbo_exec_EvalCoord2f
;
928 vfmt
->EvalCoord2fv
= vbo_exec_EvalCoord2fv
;
929 vfmt
->EvalPoint1
= vbo_exec_EvalPoint1
;
930 vfmt
->EvalPoint2
= vbo_exec_EvalPoint2
;
932 /* from attrib_tmp.h:
934 vfmt
->Color3f
= vbo_Color3f
;
935 vfmt
->Color3fv
= vbo_Color3fv
;
936 vfmt
->Color4f
= vbo_Color4f
;
937 vfmt
->Color4fv
= vbo_Color4fv
;
938 vfmt
->FogCoordfEXT
= vbo_FogCoordfEXT
;
939 vfmt
->FogCoordfvEXT
= vbo_FogCoordfvEXT
;
940 vfmt
->MultiTexCoord1fARB
= vbo_MultiTexCoord1f
;
941 vfmt
->MultiTexCoord1fvARB
= vbo_MultiTexCoord1fv
;
942 vfmt
->MultiTexCoord2fARB
= vbo_MultiTexCoord2f
;
943 vfmt
->MultiTexCoord2fvARB
= vbo_MultiTexCoord2fv
;
944 vfmt
->MultiTexCoord3fARB
= vbo_MultiTexCoord3f
;
945 vfmt
->MultiTexCoord3fvARB
= vbo_MultiTexCoord3fv
;
946 vfmt
->MultiTexCoord4fARB
= vbo_MultiTexCoord4f
;
947 vfmt
->MultiTexCoord4fvARB
= vbo_MultiTexCoord4fv
;
948 vfmt
->Normal3f
= vbo_Normal3f
;
949 vfmt
->Normal3fv
= vbo_Normal3fv
;
950 vfmt
->SecondaryColor3fEXT
= vbo_SecondaryColor3fEXT
;
951 vfmt
->SecondaryColor3fvEXT
= vbo_SecondaryColor3fvEXT
;
952 vfmt
->TexCoord1f
= vbo_TexCoord1f
;
953 vfmt
->TexCoord1fv
= vbo_TexCoord1fv
;
954 vfmt
->TexCoord2f
= vbo_TexCoord2f
;
955 vfmt
->TexCoord2fv
= vbo_TexCoord2fv
;
956 vfmt
->TexCoord3f
= vbo_TexCoord3f
;
957 vfmt
->TexCoord3fv
= vbo_TexCoord3fv
;
958 vfmt
->TexCoord4f
= vbo_TexCoord4f
;
959 vfmt
->TexCoord4fv
= vbo_TexCoord4fv
;
960 vfmt
->Vertex2f
= vbo_Vertex2f
;
961 vfmt
->Vertex2fv
= vbo_Vertex2fv
;
962 vfmt
->Vertex3f
= vbo_Vertex3f
;
963 vfmt
->Vertex3fv
= vbo_Vertex3fv
;
964 vfmt
->Vertex4f
= vbo_Vertex4f
;
965 vfmt
->Vertex4fv
= vbo_Vertex4fv
;
967 if (ctx
->API
== API_OPENGLES2
) {
968 vfmt
->VertexAttrib1fARB
= _es_VertexAttrib1f
;
969 vfmt
->VertexAttrib1fvARB
= _es_VertexAttrib1fv
;
970 vfmt
->VertexAttrib2fARB
= _es_VertexAttrib2f
;
971 vfmt
->VertexAttrib2fvARB
= _es_VertexAttrib2fv
;
972 vfmt
->VertexAttrib3fARB
= _es_VertexAttrib3f
;
973 vfmt
->VertexAttrib3fvARB
= _es_VertexAttrib3fv
;
974 vfmt
->VertexAttrib4fARB
= _es_VertexAttrib4f
;
975 vfmt
->VertexAttrib4fvARB
= _es_VertexAttrib4fv
;
977 vfmt
->VertexAttrib1fARB
= vbo_VertexAttrib1fARB
;
978 vfmt
->VertexAttrib1fvARB
= vbo_VertexAttrib1fvARB
;
979 vfmt
->VertexAttrib2fARB
= vbo_VertexAttrib2fARB
;
980 vfmt
->VertexAttrib2fvARB
= vbo_VertexAttrib2fvARB
;
981 vfmt
->VertexAttrib3fARB
= vbo_VertexAttrib3fARB
;
982 vfmt
->VertexAttrib3fvARB
= vbo_VertexAttrib3fvARB
;
983 vfmt
->VertexAttrib4fARB
= vbo_VertexAttrib4fARB
;
984 vfmt
->VertexAttrib4fvARB
= vbo_VertexAttrib4fvARB
;
987 /* Note that VertexAttrib4fNV is used from dlist.c and api_arrayelt.c so
988 * they can have a single entrypoint for updating any of the legacy
991 vfmt
->VertexAttrib1fNV
= vbo_VertexAttrib1fNV
;
992 vfmt
->VertexAttrib1fvNV
= vbo_VertexAttrib1fvNV
;
993 vfmt
->VertexAttrib2fNV
= vbo_VertexAttrib2fNV
;
994 vfmt
->VertexAttrib2fvNV
= vbo_VertexAttrib2fvNV
;
995 vfmt
->VertexAttrib3fNV
= vbo_VertexAttrib3fNV
;
996 vfmt
->VertexAttrib3fvNV
= vbo_VertexAttrib3fvNV
;
997 vfmt
->VertexAttrib4fNV
= vbo_VertexAttrib4fNV
;
998 vfmt
->VertexAttrib4fvNV
= vbo_VertexAttrib4fvNV
;
1000 /* integer-valued */
1001 vfmt
->VertexAttribI1i
= vbo_VertexAttribI1i
;
1002 vfmt
->VertexAttribI2i
= vbo_VertexAttribI2i
;
1003 vfmt
->VertexAttribI3i
= vbo_VertexAttribI3i
;
1004 vfmt
->VertexAttribI4i
= vbo_VertexAttribI4i
;
1005 vfmt
->VertexAttribI2iv
= vbo_VertexAttribI2iv
;
1006 vfmt
->VertexAttribI3iv
= vbo_VertexAttribI3iv
;
1007 vfmt
->VertexAttribI4iv
= vbo_VertexAttribI4iv
;
1009 /* unsigned integer-valued */
1010 vfmt
->VertexAttribI1ui
= vbo_VertexAttribI1ui
;
1011 vfmt
->VertexAttribI2ui
= vbo_VertexAttribI2ui
;
1012 vfmt
->VertexAttribI3ui
= vbo_VertexAttribI3ui
;
1013 vfmt
->VertexAttribI4ui
= vbo_VertexAttribI4ui
;
1014 vfmt
->VertexAttribI2uiv
= vbo_VertexAttribI2uiv
;
1015 vfmt
->VertexAttribI3uiv
= vbo_VertexAttribI3uiv
;
1016 vfmt
->VertexAttribI4uiv
= vbo_VertexAttribI4uiv
;
1018 vfmt
->Materialfv
= vbo_Materialfv
;
1020 vfmt
->EdgeFlag
= vbo_EdgeFlag
;
1021 vfmt
->Indexf
= vbo_Indexf
;
1022 vfmt
->Indexfv
= vbo_Indexfv
;
1024 /* ARB_vertex_type_2_10_10_10_rev */
1025 vfmt
->VertexP2ui
= vbo_VertexP2ui
;
1026 vfmt
->VertexP2uiv
= vbo_VertexP2uiv
;
1027 vfmt
->VertexP3ui
= vbo_VertexP3ui
;
1028 vfmt
->VertexP3uiv
= vbo_VertexP3uiv
;
1029 vfmt
->VertexP4ui
= vbo_VertexP4ui
;
1030 vfmt
->VertexP4uiv
= vbo_VertexP4uiv
;
1032 vfmt
->TexCoordP1ui
= vbo_TexCoordP1ui
;
1033 vfmt
->TexCoordP1uiv
= vbo_TexCoordP1uiv
;
1034 vfmt
->TexCoordP2ui
= vbo_TexCoordP2ui
;
1035 vfmt
->TexCoordP2uiv
= vbo_TexCoordP2uiv
;
1036 vfmt
->TexCoordP3ui
= vbo_TexCoordP3ui
;
1037 vfmt
->TexCoordP3uiv
= vbo_TexCoordP3uiv
;
1038 vfmt
->TexCoordP4ui
= vbo_TexCoordP4ui
;
1039 vfmt
->TexCoordP4uiv
= vbo_TexCoordP4uiv
;
1041 vfmt
->MultiTexCoordP1ui
= vbo_MultiTexCoordP1ui
;
1042 vfmt
->MultiTexCoordP1uiv
= vbo_MultiTexCoordP1uiv
;
1043 vfmt
->MultiTexCoordP2ui
= vbo_MultiTexCoordP2ui
;
1044 vfmt
->MultiTexCoordP2uiv
= vbo_MultiTexCoordP2uiv
;
1045 vfmt
->MultiTexCoordP3ui
= vbo_MultiTexCoordP3ui
;
1046 vfmt
->MultiTexCoordP3uiv
= vbo_MultiTexCoordP3uiv
;
1047 vfmt
->MultiTexCoordP4ui
= vbo_MultiTexCoordP4ui
;
1048 vfmt
->MultiTexCoordP4uiv
= vbo_MultiTexCoordP4uiv
;
1050 vfmt
->NormalP3ui
= vbo_NormalP3ui
;
1051 vfmt
->NormalP3uiv
= vbo_NormalP3uiv
;
1053 vfmt
->ColorP3ui
= vbo_ColorP3ui
;
1054 vfmt
->ColorP3uiv
= vbo_ColorP3uiv
;
1055 vfmt
->ColorP4ui
= vbo_ColorP4ui
;
1056 vfmt
->ColorP4uiv
= vbo_ColorP4uiv
;
1058 vfmt
->SecondaryColorP3ui
= vbo_SecondaryColorP3ui
;
1059 vfmt
->SecondaryColorP3uiv
= vbo_SecondaryColorP3uiv
;
1061 vfmt
->VertexAttribP1ui
= vbo_VertexAttribP1ui
;
1062 vfmt
->VertexAttribP1uiv
= vbo_VertexAttribP1uiv
;
1063 vfmt
->VertexAttribP2ui
= vbo_VertexAttribP2ui
;
1064 vfmt
->VertexAttribP2uiv
= vbo_VertexAttribP2uiv
;
1065 vfmt
->VertexAttribP3ui
= vbo_VertexAttribP3ui
;
1066 vfmt
->VertexAttribP3uiv
= vbo_VertexAttribP3uiv
;
1067 vfmt
->VertexAttribP4ui
= vbo_VertexAttribP4ui
;
1068 vfmt
->VertexAttribP4uiv
= vbo_VertexAttribP4uiv
;
1070 vfmt
->VertexAttribL1d
= vbo_VertexAttribL1d
;
1071 vfmt
->VertexAttribL2d
= vbo_VertexAttribL2d
;
1072 vfmt
->VertexAttribL3d
= vbo_VertexAttribL3d
;
1073 vfmt
->VertexAttribL4d
= vbo_VertexAttribL4d
;
1075 vfmt
->VertexAttribL1dv
= vbo_VertexAttribL1dv
;
1076 vfmt
->VertexAttribL2dv
= vbo_VertexAttribL2dv
;
1077 vfmt
->VertexAttribL3dv
= vbo_VertexAttribL3dv
;
1078 vfmt
->VertexAttribL4dv
= vbo_VertexAttribL4dv
;
1083 * Tell the VBO module to use a real OpenGL vertex buffer object to
1084 * store accumulated immediate-mode vertex data.
1085 * This replaces the malloced buffer which was created in
1086 * vb_exec_vtx_init() below.
1088 void vbo_use_buffer_objects(struct gl_context
*ctx
)
1090 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1091 /* Any buffer name but 0 can be used here since this bufferobj won't
1092 * go into the bufferobj hashtable.
1094 GLuint bufName
= IMM_BUFFER_NAME
;
1095 GLenum target
= GL_ARRAY_BUFFER_ARB
;
1096 GLenum usage
= GL_STREAM_DRAW_ARB
;
1097 GLsizei size
= VBO_VERT_BUFFER_SIZE
;
1099 /* Make sure this func is only used once */
1100 assert(exec
->vtx
.bufferobj
== ctx
->Shared
->NullBufferObj
);
1102 _mesa_align_free(exec
->vtx
.buffer_map
);
1103 exec
->vtx
.buffer_map
= NULL
;
1104 exec
->vtx
.buffer_ptr
= NULL
;
1106 /* Allocate a real buffer object now */
1107 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1108 exec
->vtx
.bufferobj
= ctx
->Driver
.NewBufferObject(ctx
, bufName
);
1109 if (!ctx
->Driver
.BufferData(ctx
, target
, size
, NULL
, usage
,
1111 GL_DYNAMIC_STORAGE_BIT
|
1112 GL_CLIENT_STORAGE_BIT
,
1113 exec
->vtx
.bufferobj
)) {
1114 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "VBO allocation");
1120 * If this function is called, all VBO buffers will be unmapped when
1122 * Otherwise, if a simple command like glColor3f() is called and we flush,
1123 * the current VBO may be left mapped.
1126 vbo_always_unmap_buffers(struct gl_context
*ctx
)
1128 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1129 exec
->begin_vertices_flags
|= FLUSH_STORED_VERTICES
;
1133 void vbo_exec_vtx_init( struct vbo_exec_context
*exec
)
1135 struct gl_context
*ctx
= exec
->ctx
;
1136 struct vbo_context
*vbo
= vbo_context(ctx
);
1139 /* Allocate a buffer object. Will just reuse this object
1140 * continuously, unless vbo_use_buffer_objects() is called to enable
1143 _mesa_reference_buffer_object(ctx
,
1144 &exec
->vtx
.bufferobj
,
1145 ctx
->Shared
->NullBufferObj
);
1147 assert(!exec
->vtx
.buffer_map
);
1148 exec
->vtx
.buffer_map
= _mesa_align_malloc(VBO_VERT_BUFFER_SIZE
, 64);
1149 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
1151 vbo_exec_vtxfmt_init( exec
);
1152 _mesa_noop_vtxfmt_init(&exec
->vtxfmt_noop
);
1154 exec
->vtx
.enabled
= 0;
1155 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1156 assert(i
< ARRAY_SIZE(exec
->vtx
.attrsz
));
1157 exec
->vtx
.attrsz
[i
] = 0;
1158 assert(i
< ARRAY_SIZE(exec
->vtx
.attrtype
));
1159 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1160 assert(i
< ARRAY_SIZE(exec
->vtx
.active_sz
));
1161 exec
->vtx
.active_sz
[i
] = 0;
1163 for (i
= 0 ; i
< VERT_ATTRIB_MAX
; i
++) {
1164 assert(i
< ARRAY_SIZE(exec
->vtx
.inputs
));
1165 assert(i
< ARRAY_SIZE(exec
->vtx
.arrays
));
1166 exec
->vtx
.inputs
[i
] = &exec
->vtx
.arrays
[i
];
1170 struct gl_client_array
*arrays
= exec
->vtx
.arrays
;
1173 memcpy(arrays
, &vbo
->currval
[VBO_ATTRIB_POS
],
1174 VERT_ATTRIB_FF_MAX
* sizeof(arrays
[0]));
1175 for (i
= 0; i
< VERT_ATTRIB_FF_MAX
; ++i
) {
1176 struct gl_client_array
*array
;
1177 array
= &arrays
[VERT_ATTRIB_FF(i
)];
1178 array
->BufferObj
= NULL
;
1179 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1180 vbo
->currval
[VBO_ATTRIB_POS
+i
].BufferObj
);
1183 memcpy(arrays
+ VERT_ATTRIB_GENERIC(0),
1184 &vbo
->currval
[VBO_ATTRIB_GENERIC0
],
1185 VERT_ATTRIB_GENERIC_MAX
* sizeof(arrays
[0]));
1187 for (i
= 0; i
< VERT_ATTRIB_GENERIC_MAX
; ++i
) {
1188 struct gl_client_array
*array
;
1189 array
= &arrays
[VERT_ATTRIB_GENERIC(i
)];
1190 array
->BufferObj
= NULL
;
1191 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1192 vbo
->currval
[VBO_ATTRIB_GENERIC0
+i
].BufferObj
);
1196 exec
->vtx
.vertex_size
= 0;
1198 exec
->begin_vertices_flags
= FLUSH_UPDATE_CURRENT
;
1202 void vbo_exec_vtx_destroy( struct vbo_exec_context
*exec
)
1204 /* using a real VBO for vertex data */
1205 struct gl_context
*ctx
= exec
->ctx
;
1208 /* True VBOs should already be unmapped
1210 if (exec
->vtx
.buffer_map
) {
1211 assert(exec
->vtx
.bufferobj
->Name
== 0 ||
1212 exec
->vtx
.bufferobj
->Name
== IMM_BUFFER_NAME
);
1213 if (exec
->vtx
.bufferobj
->Name
== 0) {
1214 _mesa_align_free(exec
->vtx
.buffer_map
);
1215 exec
->vtx
.buffer_map
= NULL
;
1216 exec
->vtx
.buffer_ptr
= NULL
;
1220 /* Drop any outstanding reference to the vertex buffer
1222 for (i
= 0; i
< ARRAY_SIZE(exec
->vtx
.arrays
); i
++) {
1223 _mesa_reference_buffer_object(ctx
,
1224 &exec
->vtx
.arrays
[i
].BufferObj
,
1228 /* Free the vertex buffer. Unmap first if needed.
1230 if (_mesa_bufferobj_mapped(exec
->vtx
.bufferobj
, MAP_INTERNAL
)) {
1231 ctx
->Driver
.UnmapBuffer(ctx
, exec
->vtx
.bufferobj
, MAP_INTERNAL
);
1233 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1238 * If inside glBegin()/glEnd(), it should assert(0). Otherwise, if
1239 * FLUSH_STORED_VERTICES bit in \p flags is set flushes any buffered
1240 * vertices, if FLUSH_UPDATE_CURRENT bit is set updates
1241 * __struct gl_contextRec::Current and gl_light_attrib::Material
1243 * Note that the default T&L engine never clears the
1244 * FLUSH_UPDATE_CURRENT bit, even after performing the update.
1246 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1248 void vbo_exec_FlushVertices( struct gl_context
*ctx
, GLuint flags
)
1250 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1253 /* debug check: make sure we don't get called recursively */
1254 exec
->flush_call_depth
++;
1255 assert(exec
->flush_call_depth
== 1);
1258 if (_mesa_inside_begin_end(ctx
)) {
1259 /* We've had glBegin but not glEnd! */
1261 exec
->flush_call_depth
--;
1262 assert(exec
->flush_call_depth
== 0);
1267 /* Flush (draw), and make sure VBO is left unmapped when done */
1268 vbo_exec_FlushVertices_internal(exec
, GL_TRUE
);
1270 /* Need to do this to ensure vbo_exec_begin_vertices gets called again:
1272 ctx
->Driver
.NeedFlush
&= ~(FLUSH_UPDATE_CURRENT
| flags
);
1275 exec
->flush_call_depth
--;
1276 assert(exec
->flush_call_depth
== 0);
1281 * Reset the vertex attribute by setting its size to zero.
1284 vbo_reset_attr(struct vbo_exec_context
*exec
, GLuint attr
)
1286 exec
->vtx
.attrsz
[attr
] = 0;
1287 exec
->vtx
.attrtype
[attr
] = GL_FLOAT
;
1288 exec
->vtx
.active_sz
[attr
] = 0;
1292 vbo_reset_all_attr(struct vbo_exec_context
*exec
)
1294 while (exec
->vtx
.enabled
) {
1295 const int i
= u_bit_scan64(&exec
->vtx
.enabled
);
1296 vbo_reset_attr(exec
, i
);
1299 exec
->vtx
.vertex_size
= 0;
1304 _es_Color4f(GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
1306 vbo_Color4f(r
, g
, b
, a
);
1311 _es_Normal3f(GLfloat x
, GLfloat y
, GLfloat z
)
1313 vbo_Normal3f(x
, y
, z
);
1318 _es_MultiTexCoord4f(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1320 vbo_MultiTexCoord4f(target
, s
, t
, r
, q
);
1325 _es_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
1327 vbo_Materialfv(face
, pname
, params
);
1332 _es_Materialf(GLenum face
, GLenum pname
, GLfloat param
)
1336 p
[1] = p
[2] = p
[3] = 0.0F
;
1337 vbo_Materialfv(face
, pname
, p
);
1342 * A special version of glVertexAttrib4f that does not treat index 0 as
1346 VertexAttrib4f_nopos(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1348 GET_CURRENT_CONTEXT(ctx
);
1349 if (index
< MAX_VERTEX_GENERIC_ATTRIBS
)
1350 ATTRF(VBO_ATTRIB_GENERIC0
+ index
, 4, x
, y
, z
, w
);
1352 ERROR(GL_INVALID_VALUE
);
1356 _es_VertexAttrib4f(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1358 VertexAttrib4f_nopos(index
, x
, y
, z
, w
);
1363 _es_VertexAttrib1f(GLuint indx
, GLfloat x
)
1365 VertexAttrib4f_nopos(indx
, x
, 0.0f
, 0.0f
, 1.0f
);
1370 _es_VertexAttrib1fv(GLuint indx
, const GLfloat
* values
)
1372 VertexAttrib4f_nopos(indx
, values
[0], 0.0f
, 0.0f
, 1.0f
);
1377 _es_VertexAttrib2f(GLuint indx
, GLfloat x
, GLfloat y
)
1379 VertexAttrib4f_nopos(indx
, x
, y
, 0.0f
, 1.0f
);
1384 _es_VertexAttrib2fv(GLuint indx
, const GLfloat
* values
)
1386 VertexAttrib4f_nopos(indx
, values
[0], values
[1], 0.0f
, 1.0f
);
1391 _es_VertexAttrib3f(GLuint indx
, GLfloat x
, GLfloat y
, GLfloat z
)
1393 VertexAttrib4f_nopos(indx
, x
, y
, z
, 1.0f
);
1398 _es_VertexAttrib3fv(GLuint indx
, const GLfloat
* values
)
1400 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], 1.0f
);
1405 _es_VertexAttrib4fv(GLuint indx
, const GLfloat
* values
)
1407 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], values
[3]);