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"
46 #include "vbo_context.h"
55 /** ID/name for immediate-mode VBO */
56 #define IMM_BUFFER_NAME 0xaabbccdd
59 static void reset_attrfv( struct vbo_exec_context
*exec
);
63 * Close off the last primitive, execute the buffer, restart the
66 static void 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 GLuint last_begin
= exec
->vtx
.prim
[exec
->vtx
.prim_count
-1].begin
;
77 if (_mesa_inside_begin_end(exec
->ctx
)) {
78 GLint i
= exec
->vtx
.prim_count
- 1;
80 exec
->vtx
.prim
[i
].count
= (exec
->vtx
.vert_count
-
81 exec
->vtx
.prim
[i
].start
);
84 last_count
= exec
->vtx
.prim
[exec
->vtx
.prim_count
-1].count
;
86 /* Execute the buffer and save copied vertices.
88 if (exec
->vtx
.vert_count
)
89 vbo_exec_vtx_flush( exec
, GL_FALSE
);
91 exec
->vtx
.prim_count
= 0;
92 exec
->vtx
.copied
.nr
= 0;
95 /* Emit a glBegin to start the new list.
97 assert(exec
->vtx
.prim_count
== 0);
99 if (_mesa_inside_begin_end(exec
->ctx
)) {
100 exec
->vtx
.prim
[0].mode
= exec
->ctx
->Driver
.CurrentExecPrimitive
;
101 exec
->vtx
.prim
[0].start
= 0;
102 exec
->vtx
.prim
[0].count
= 0;
103 exec
->vtx
.prim_count
++;
105 if (exec
->vtx
.copied
.nr
== last_count
)
106 exec
->vtx
.prim
[0].begin
= last_begin
;
113 * Deal with buffer wrapping where provoked by the vertex buffer
114 * filling up, as opposed to upgrade_vertex().
116 void vbo_exec_vtx_wrap( struct vbo_exec_context
*exec
)
118 fi_type
*data
= exec
->vtx
.copied
.buffer
;
121 /* Run pipeline on current vertices, copy wrapped vertices
122 * to exec->vtx.copied.
124 vbo_exec_wrap_buffers( exec
);
126 if (!exec
->vtx
.buffer_ptr
) {
127 /* probably ran out of memory earlier when allocating the VBO */
131 /* Copy stored stored vertices to start of new list.
133 assert(exec
->vtx
.max_vert
- exec
->vtx
.vert_count
> exec
->vtx
.copied
.nr
);
135 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
136 memcpy( exec
->vtx
.buffer_ptr
, data
,
137 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
138 exec
->vtx
.buffer_ptr
+= exec
->vtx
.vertex_size
;
139 data
+= exec
->vtx
.vertex_size
;
140 exec
->vtx
.vert_count
++;
143 exec
->vtx
.copied
.nr
= 0;
148 * Copy the active vertex's values to the ctx->Current fields.
150 static void vbo_exec_copy_to_current( struct vbo_exec_context
*exec
)
152 struct gl_context
*ctx
= exec
->ctx
;
153 struct vbo_context
*vbo
= vbo_context(ctx
);
156 for (i
= VBO_ATTRIB_POS
+1 ; i
< VBO_ATTRIB_MAX
; i
++) {
157 if (exec
->vtx
.attrsz
[i
]) {
158 /* Note: the exec->vtx.current[i] pointers point into the
159 * ctx->Current.Attrib and ctx->Light.Material.Attrib arrays.
161 GLfloat
*current
= (GLfloat
*)vbo
->currval
[i
].Ptr
;
162 fi_type tmp
[8]; /* space for doubles */
163 int dmul
= exec
->vtx
.attrtype
[i
] == GL_DOUBLE
? 2 : 1;
165 if (exec
->vtx
.attrtype
[i
] == GL_DOUBLE
) {
166 memset(tmp
, 0, sizeof(tmp
));
167 memcpy(tmp
, exec
->vtx
.attrptr
[i
], exec
->vtx
.attrsz
[i
] * sizeof(GLfloat
));
169 COPY_CLEAN_4V_TYPE_AS_UNION(tmp
,
171 exec
->vtx
.attrptr
[i
],
172 exec
->vtx
.attrtype
[i
]);
175 if (exec
->vtx
.attrtype
[i
] != vbo
->currval
[i
].Type
||
176 memcmp(current
, tmp
, 4 * sizeof(GLfloat
) * dmul
) != 0) {
177 memcpy(current
, tmp
, 4 * sizeof(GLfloat
) * dmul
);
179 /* Given that we explicitly state size here, there is no need
180 * for the COPY_CLEAN above, could just copy 16 bytes and be
181 * done. The only problem is when Mesa accesses ctx->Current
184 /* Size here is in components - not bytes */
185 vbo
->currval
[i
].Size
= exec
->vtx
.attrsz
[i
] / dmul
;
186 vbo
->currval
[i
]._ElementSize
= vbo
->currval
[i
].Size
* sizeof(GLfloat
) * dmul
;
187 vbo
->currval
[i
].Type
= exec
->vtx
.attrtype
[i
];
188 vbo
->currval
[i
].Integer
=
189 vbo_attrtype_to_integer_flag(exec
->vtx
.attrtype
[i
]);
190 vbo
->currval
[i
].Doubles
=
191 vbo_attrtype_to_double_flag(exec
->vtx
.attrtype
[i
]);
193 /* This triggers rather too much recalculation of Mesa state
194 * that doesn't get used (eg light positions).
196 if (i
>= VBO_ATTRIB_MAT_FRONT_AMBIENT
&&
197 i
<= VBO_ATTRIB_MAT_BACK_INDEXES
)
198 ctx
->NewState
|= _NEW_LIGHT
;
200 ctx
->NewState
|= _NEW_CURRENT_ATTRIB
;
205 /* Colormaterial -- this kindof sucks.
207 if (ctx
->Light
.ColorMaterialEnabled
&&
208 exec
->vtx
.attrsz
[VBO_ATTRIB_COLOR0
]) {
209 _mesa_update_color_material(ctx
,
210 ctx
->Current
.Attrib
[VBO_ATTRIB_COLOR0
]);
216 * Copy current vertex attribute values into the current vertex.
219 vbo_exec_copy_from_current(struct vbo_exec_context
*exec
)
221 struct gl_context
*ctx
= exec
->ctx
;
222 struct vbo_context
*vbo
= vbo_context(ctx
);
225 for (i
= VBO_ATTRIB_POS
+ 1; i
< VBO_ATTRIB_MAX
; i
++) {
226 if (exec
->vtx
.attrtype
[i
] == GL_DOUBLE
) {
227 memcpy(exec
->vtx
.attrptr
[i
], vbo
->currval
[i
].Ptr
, exec
->vtx
.attrsz
[i
] * sizeof(GLfloat
));
229 const fi_type
*current
= (fi_type
*) vbo
->currval
[i
].Ptr
;
230 switch (exec
->vtx
.attrsz
[i
]) {
231 case 4: exec
->vtx
.attrptr
[i
][3] = current
[3];
232 case 3: exec
->vtx
.attrptr
[i
][2] = current
[2];
233 case 2: exec
->vtx
.attrptr
[i
][1] = current
[1];
234 case 1: exec
->vtx
.attrptr
[i
][0] = current
[0];
243 * Flush existing data, set new attrib size, replay copied vertices.
244 * This is called when we transition from a small vertex attribute size
245 * to a larger one. Ex: glTexCoord2f -> glTexCoord4f.
246 * We need to go back over the previous 2-component texcoords and insert
247 * zero and one values.
250 vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context
*exec
,
251 GLuint attr
, GLuint newSize
)
253 struct gl_context
*ctx
= exec
->ctx
;
254 struct vbo_context
*vbo
= vbo_context(ctx
);
255 const GLint lastcount
= exec
->vtx
.vert_count
;
256 fi_type
*old_attrptr
[VBO_ATTRIB_MAX
];
257 const GLuint old_vtx_size
= exec
->vtx
.vertex_size
; /* floats per vertex */
258 const GLuint oldSize
= exec
->vtx
.attrsz
[attr
];
261 /* Run pipeline on current vertices, copy wrapped vertices
262 * to exec->vtx.copied.
264 vbo_exec_wrap_buffers( exec
);
266 if (unlikely(exec
->vtx
.copied
.nr
)) {
267 /* We're in the middle of a primitive, keep the old vertex
268 * format around to be able to translate the copied vertices to
271 memcpy(old_attrptr
, exec
->vtx
.attrptr
, sizeof(old_attrptr
));
274 if (unlikely(oldSize
)) {
275 /* Do a COPY_TO_CURRENT to ensure back-copying works for the
276 * case when the attribute already exists in the vertex and is
277 * having its size increased.
279 vbo_exec_copy_to_current( exec
);
282 /* Heuristic: Attempt to isolate attributes received outside
283 * begin/end so that they don't bloat the vertices.
285 if (!_mesa_inside_begin_end(ctx
) &&
286 !oldSize
&& lastcount
> 8 && exec
->vtx
.vertex_size
) {
287 vbo_exec_copy_to_current( exec
);
288 reset_attrfv( exec
);
293 exec
->vtx
.attrsz
[attr
] = newSize
;
294 exec
->vtx
.vertex_size
+= newSize
- oldSize
;
295 exec
->vtx
.max_vert
= ((VBO_VERT_BUFFER_SIZE
- exec
->vtx
.buffer_used
) /
296 (exec
->vtx
.vertex_size
* sizeof(GLfloat
)));
297 exec
->vtx
.vert_count
= 0;
298 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
300 if (unlikely(oldSize
)) {
301 /* Size changed, recalculate all the attrptr[] values
303 fi_type
*tmp
= exec
->vtx
.vertex
;
305 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
306 if (exec
->vtx
.attrsz
[i
]) {
307 exec
->vtx
.attrptr
[i
] = tmp
;
308 tmp
+= exec
->vtx
.attrsz
[i
];
311 exec
->vtx
.attrptr
[i
] = NULL
; /* will not be dereferenced */
314 /* Copy from current to repopulate the vertex with correct
317 vbo_exec_copy_from_current( exec
);
320 /* Just have to append the new attribute at the end */
321 exec
->vtx
.attrptr
[attr
] = exec
->vtx
.vertex
+
322 exec
->vtx
.vertex_size
- newSize
;
325 /* Replay stored vertices to translate them
326 * to new format here.
328 * -- No need to replay - just copy piecewise
330 if (unlikely(exec
->vtx
.copied
.nr
)) {
331 fi_type
*data
= exec
->vtx
.copied
.buffer
;
332 fi_type
*dest
= exec
->vtx
.buffer_ptr
;
335 assert(exec
->vtx
.buffer_ptr
== exec
->vtx
.buffer_map
);
337 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
338 for (j
= 0 ; j
< VBO_ATTRIB_MAX
; j
++) {
339 GLuint sz
= exec
->vtx
.attrsz
[j
];
342 GLint old_offset
= old_attrptr
[j
] - exec
->vtx
.vertex
;
343 GLint new_offset
= exec
->vtx
.attrptr
[j
] - exec
->vtx
.vertex
;
348 COPY_CLEAN_4V_TYPE_AS_UNION(tmp
, oldSize
,
350 exec
->vtx
.attrtype
[j
]);
351 COPY_SZ_4V(dest
+ new_offset
, newSize
, tmp
);
353 fi_type
*current
= (fi_type
*)vbo
->currval
[j
].Ptr
;
354 COPY_SZ_4V(dest
+ new_offset
, sz
, current
);
358 COPY_SZ_4V(dest
+ new_offset
, sz
, data
+ old_offset
);
363 data
+= old_vtx_size
;
364 dest
+= exec
->vtx
.vertex_size
;
367 exec
->vtx
.buffer_ptr
= dest
;
368 exec
->vtx
.vert_count
+= exec
->vtx
.copied
.nr
;
369 exec
->vtx
.copied
.nr
= 0;
375 * This is when a vertex attribute transitions to a different size.
376 * For example, we saw a bunch of glTexCoord2f() calls and now we got a
377 * glTexCoord4f() call. We promote the array from size=2 to size=4.
380 vbo_exec_fixup_vertex(struct gl_context
*ctx
, GLuint attr
, GLuint newSize
, GLenum newType
)
382 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
384 if (newSize
> exec
->vtx
.attrsz
[attr
] || newType
!= exec
->vtx
.attrtype
[attr
]) {
385 /* New size is larger. Need to flush existing vertices and get
386 * an enlarged vertex format.
388 vbo_exec_wrap_upgrade_vertex( exec
, attr
, newSize
);
390 else if (newSize
< exec
->vtx
.active_sz
[attr
]) {
393 vbo_get_default_vals_as_union(exec
->vtx
.attrtype
[attr
]);
395 /* New size is smaller - just need to fill in some
396 * zeros. Don't need to flush or wrap.
398 for (i
= newSize
; i
<= exec
->vtx
.attrsz
[attr
]; i
++)
399 exec
->vtx
.attrptr
[attr
][i
-1] = id
[i
-1];
402 exec
->vtx
.active_sz
[attr
] = newSize
;
404 /* Does setting NeedFlush belong here? Necessitates resetting
405 * vtxfmt on each flush (otherwise flags won't get reset
409 ctx
->Driver
.NeedFlush
|= FLUSH_STORED_VERTICES
;
414 * This macro is used to implement all the glVertex, glColor, glTexCoord,
415 * glVertexAttrib, etc functions.
416 * \param A attribute index
417 * \param N attribute size (1..4)
418 * \param T type (GL_FLOAT, GL_DOUBLE, GL_INT, GL_UNSIGNED_INT)
419 * \param C cast type (fi_type or double)
420 * \param V0, V1, v2, V3 attribute value
422 #define ATTR_UNION( A, N, T, C, V0, V1, V2, V3 ) \
424 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
425 int sz = (sizeof(C) / sizeof(GLfloat)); \
426 if (unlikely(!(ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT))) { \
427 vbo_exec_BeginVertices(ctx); \
430 /* check if attribute size or type is changing */ \
431 if (unlikely(exec->vtx.active_sz[A] != N * sz) || \
432 unlikely(exec->vtx.attrtype[A] != T)) { \
433 vbo_exec_fixup_vertex(ctx, A, N * sz, T); \
436 /* store vertex attribute in vertex buffer */ \
438 C *dest = (C *)exec->vtx.attrptr[A]; \
439 if (N>0) dest[0] = V0; \
440 if (N>1) dest[1] = V1; \
441 if (N>2) dest[2] = V2; \
442 if (N>3) dest[3] = V3; \
443 exec->vtx.attrtype[A] = T; \
447 /* This is a glVertex call */ \
450 /* copy 32-bit words */ \
451 for (i = 0; i < exec->vtx.vertex_size; i++) \
452 exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i]; \
454 exec->vtx.buffer_ptr += exec->vtx.vertex_size; \
456 /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \
457 /* something to draw (not just updating a color or texcoord).*/ \
458 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \
460 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
461 vbo_exec_vtx_wrap( exec ); \
465 #define ERROR(err) _mesa_error( ctx, err, __func__ )
466 #define TAG(x) vbo_##x
468 #include "vbo_attrib_tmp.h"
473 * Execute a glMaterial call. Note that if GL_COLOR_MATERIAL is enabled,
474 * this may be a (partial) no-op.
476 static void GLAPIENTRY
477 vbo_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
479 GLbitfield updateMats
;
480 GET_CURRENT_CONTEXT(ctx
);
482 /* This function should be a no-op when it tries to update material
483 * attributes which are currently tracking glColor via glColorMaterial.
484 * The updateMats var will be a mask of the MAT_BIT_FRONT/BACK_x bits
485 * indicating which material attributes can actually be updated below.
487 if (ctx
->Light
.ColorMaterialEnabled
) {
488 updateMats
= ~ctx
->Light
._ColorMaterialBitmask
;
491 /* GL_COLOR_MATERIAL is disabled so don't skip any material updates */
492 updateMats
= ALL_MATERIAL_BITS
;
495 if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_FRONT
) {
496 updateMats
&= FRONT_MATERIAL_BITS
;
498 else if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_BACK
) {
499 updateMats
&= BACK_MATERIAL_BITS
;
501 else if (face
!= GL_FRONT_AND_BACK
) {
502 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterial(invalid face)");
508 if (updateMats
& MAT_BIT_FRONT_EMISSION
)
509 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_EMISSION
, 4, params
);
510 if (updateMats
& MAT_BIT_BACK_EMISSION
)
511 MAT_ATTR(VBO_ATTRIB_MAT_BACK_EMISSION
, 4, params
);
514 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
515 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
516 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
517 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
520 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
521 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
522 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
523 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
526 if (updateMats
& MAT_BIT_FRONT_SPECULAR
)
527 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SPECULAR
, 4, params
);
528 if (updateMats
& MAT_BIT_BACK_SPECULAR
)
529 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SPECULAR
, 4, params
);
532 if (*params
< 0 || *params
> ctx
->Const
.MaxShininess
) {
533 _mesa_error(ctx
, GL_INVALID_VALUE
,
534 "glMaterial(invalid shininess: %f out range [0, %f])",
535 *params
, ctx
->Const
.MaxShininess
);
538 if (updateMats
& MAT_BIT_FRONT_SHININESS
)
539 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SHININESS
, 1, params
);
540 if (updateMats
& MAT_BIT_BACK_SHININESS
)
541 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SHININESS
, 1, params
);
543 case GL_COLOR_INDEXES
:
544 if (ctx
->API
!= API_OPENGL_COMPAT
) {
545 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
548 if (updateMats
& MAT_BIT_FRONT_INDEXES
)
549 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_INDEXES
, 3, params
);
550 if (updateMats
& MAT_BIT_BACK_INDEXES
)
551 MAT_ATTR(VBO_ATTRIB_MAT_BACK_INDEXES
, 3, params
);
553 case GL_AMBIENT_AND_DIFFUSE
:
554 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
555 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
556 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
557 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
558 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
559 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
560 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
561 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
564 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
571 * Flush (draw) vertices.
572 * \param unmap - leave VBO unmapped after flushing?
575 vbo_exec_FlushVertices_internal(struct vbo_exec_context
*exec
, GLboolean unmap
)
577 if (exec
->vtx
.vert_count
|| unmap
) {
578 vbo_exec_vtx_flush( exec
, unmap
);
581 if (exec
->vtx
.vertex_size
) {
582 vbo_exec_copy_to_current( exec
);
583 reset_attrfv( exec
);
588 static void GLAPIENTRY
vbo_exec_EvalCoord1f( GLfloat u
)
590 GET_CURRENT_CONTEXT( ctx
);
591 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
595 if (exec
->eval
.recalculate_maps
)
596 vbo_exec_eval_update( exec
);
598 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
599 if (exec
->eval
.map1
[i
].map
)
600 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map1
[i
].sz
)
601 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map1
[i
].sz
, GL_FLOAT
);
606 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
607 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
609 vbo_exec_do_EvalCoord1f( exec
, u
);
611 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
612 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
615 static void GLAPIENTRY
vbo_exec_EvalCoord2f( GLfloat u
, GLfloat v
)
617 GET_CURRENT_CONTEXT( ctx
);
618 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
622 if (exec
->eval
.recalculate_maps
)
623 vbo_exec_eval_update( exec
);
625 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
626 if (exec
->eval
.map2
[i
].map
)
627 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map2
[i
].sz
)
628 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map2
[i
].sz
, GL_FLOAT
);
631 if (ctx
->Eval
.AutoNormal
)
632 if (exec
->vtx
.active_sz
[VBO_ATTRIB_NORMAL
] != 3)
633 vbo_exec_fixup_vertex( ctx
, VBO_ATTRIB_NORMAL
, 3, GL_FLOAT
);
636 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
637 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
639 vbo_exec_do_EvalCoord2f( exec
, u
, v
);
641 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
642 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
645 static void GLAPIENTRY
vbo_exec_EvalCoord1fv( const GLfloat
*u
)
647 vbo_exec_EvalCoord1f( u
[0] );
650 static void GLAPIENTRY
vbo_exec_EvalCoord2fv( const GLfloat
*u
)
652 vbo_exec_EvalCoord2f( u
[0], u
[1] );
655 static void GLAPIENTRY
vbo_exec_EvalPoint1( GLint i
)
657 GET_CURRENT_CONTEXT( ctx
);
658 GLfloat du
= ((ctx
->Eval
.MapGrid1u2
- ctx
->Eval
.MapGrid1u1
) /
659 (GLfloat
) ctx
->Eval
.MapGrid1un
);
660 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid1u1
;
662 vbo_exec_EvalCoord1f( u
);
666 static void GLAPIENTRY
vbo_exec_EvalPoint2( GLint i
, GLint j
)
668 GET_CURRENT_CONTEXT( ctx
);
669 GLfloat du
= ((ctx
->Eval
.MapGrid2u2
- ctx
->Eval
.MapGrid2u1
) /
670 (GLfloat
) ctx
->Eval
.MapGrid2un
);
671 GLfloat dv
= ((ctx
->Eval
.MapGrid2v2
- ctx
->Eval
.MapGrid2v1
) /
672 (GLfloat
) ctx
->Eval
.MapGrid2vn
);
673 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid2u1
;
674 GLfloat v
= j
* dv
+ ctx
->Eval
.MapGrid2v1
;
676 vbo_exec_EvalCoord2f( u
, v
);
681 * Called via glBegin.
683 static void GLAPIENTRY
vbo_exec_Begin( GLenum mode
)
685 GET_CURRENT_CONTEXT( ctx
);
686 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
689 if (_mesa_inside_begin_end(ctx
)) {
690 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glBegin");
694 if (!_mesa_valid_prim_mode(ctx
, mode
, "glBegin")) {
698 vbo_draw_method(vbo_context(ctx
), DRAW_BEGIN_END
);
701 _mesa_update_state( ctx
);
703 CALL_Begin(ctx
->Exec
, (mode
));
707 if (!_mesa_valid_to_render(ctx
, "glBegin")) {
711 /* Heuristic: attempt to isolate attributes occurring outside
714 if (exec
->vtx
.vertex_size
&& !exec
->vtx
.attrsz
[0])
715 vbo_exec_FlushVertices_internal(exec
, GL_FALSE
);
717 i
= exec
->vtx
.prim_count
++;
718 exec
->vtx
.prim
[i
].mode
= mode
;
719 exec
->vtx
.prim
[i
].begin
= 1;
720 exec
->vtx
.prim
[i
].end
= 0;
721 exec
->vtx
.prim
[i
].indexed
= 0;
722 exec
->vtx
.prim
[i
].weak
= 0;
723 exec
->vtx
.prim
[i
].pad
= 0;
724 exec
->vtx
.prim
[i
].start
= exec
->vtx
.vert_count
;
725 exec
->vtx
.prim
[i
].count
= 0;
726 exec
->vtx
.prim
[i
].num_instances
= 1;
727 exec
->vtx
.prim
[i
].base_instance
= 0;
728 exec
->vtx
.prim
[i
].is_indirect
= 0;
730 ctx
->Driver
.CurrentExecPrimitive
= mode
;
732 ctx
->Exec
= ctx
->BeginEnd
;
733 /* We may have been called from a display list, in which case we should
734 * leave dlist.c's dispatch table in place.
736 if (ctx
->CurrentDispatch
== ctx
->OutsideBeginEnd
) {
737 ctx
->CurrentDispatch
= ctx
->BeginEnd
;
738 _glapi_set_dispatch(ctx
->CurrentDispatch
);
740 assert(ctx
->CurrentDispatch
== ctx
->Save
);
746 * Try to merge / concatenate the two most recent VBO primitives.
749 try_vbo_merge(struct vbo_exec_context
*exec
)
751 struct _mesa_prim
*cur
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
753 assert(exec
->vtx
.prim_count
>= 1);
755 vbo_try_prim_conversion(cur
);
757 if (exec
->vtx
.prim_count
>= 2) {
758 struct _mesa_prim
*prev
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 2];
759 assert(prev
== cur
- 1);
761 if (vbo_can_merge_prims(prev
, cur
)) {
766 vbo_merge_prims(prev
, cur
);
767 exec
->vtx
.prim_count
--; /* drop the last primitive */
776 static void GLAPIENTRY
vbo_exec_End( void )
778 GET_CURRENT_CONTEXT( ctx
);
779 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
781 if (!_mesa_inside_begin_end(ctx
)) {
782 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glEnd");
786 ctx
->Exec
= ctx
->OutsideBeginEnd
;
787 if (ctx
->CurrentDispatch
== ctx
->BeginEnd
) {
788 ctx
->CurrentDispatch
= ctx
->OutsideBeginEnd
;
789 _glapi_set_dispatch(ctx
->CurrentDispatch
);
792 if (exec
->vtx
.prim_count
> 0) {
793 /* close off current primitive */
794 int idx
= exec
->vtx
.vert_count
;
795 int i
= exec
->vtx
.prim_count
- 1;
797 exec
->vtx
.prim
[i
].end
= 1;
798 exec
->vtx
.prim
[i
].count
= idx
- exec
->vtx
.prim
[i
].start
;
803 ctx
->Driver
.CurrentExecPrimitive
= PRIM_OUTSIDE_BEGIN_END
;
805 if (exec
->vtx
.prim_count
== VBO_MAX_PRIM
)
806 vbo_exec_vtx_flush( exec
, GL_FALSE
);
808 if (MESA_DEBUG_FLAGS
& DEBUG_ALWAYS_FLUSH
) {
815 * Called via glPrimitiveRestartNV()
817 static void GLAPIENTRY
818 vbo_exec_PrimitiveRestartNV(void)
821 GET_CURRENT_CONTEXT( ctx
);
823 curPrim
= ctx
->Driver
.CurrentExecPrimitive
;
825 if (curPrim
== PRIM_OUTSIDE_BEGIN_END
) {
826 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glPrimitiveRestartNV" );
830 vbo_exec_Begin(curPrim
);
836 static void vbo_exec_vtxfmt_init( struct vbo_exec_context
*exec
)
838 struct gl_context
*ctx
= exec
->ctx
;
839 GLvertexformat
*vfmt
= &exec
->vtxfmt
;
841 vfmt
->ArrayElement
= _ae_ArrayElement
;
843 vfmt
->Begin
= vbo_exec_Begin
;
844 vfmt
->End
= vbo_exec_End
;
845 vfmt
->PrimitiveRestartNV
= vbo_exec_PrimitiveRestartNV
;
847 vfmt
->CallList
= _mesa_CallList
;
848 vfmt
->CallLists
= _mesa_CallLists
;
850 vfmt
->EvalCoord1f
= vbo_exec_EvalCoord1f
;
851 vfmt
->EvalCoord1fv
= vbo_exec_EvalCoord1fv
;
852 vfmt
->EvalCoord2f
= vbo_exec_EvalCoord2f
;
853 vfmt
->EvalCoord2fv
= vbo_exec_EvalCoord2fv
;
854 vfmt
->EvalPoint1
= vbo_exec_EvalPoint1
;
855 vfmt
->EvalPoint2
= vbo_exec_EvalPoint2
;
857 /* from attrib_tmp.h:
859 vfmt
->Color3f
= vbo_Color3f
;
860 vfmt
->Color3fv
= vbo_Color3fv
;
861 vfmt
->Color4f
= vbo_Color4f
;
862 vfmt
->Color4fv
= vbo_Color4fv
;
863 vfmt
->FogCoordfEXT
= vbo_FogCoordfEXT
;
864 vfmt
->FogCoordfvEXT
= vbo_FogCoordfvEXT
;
865 vfmt
->MultiTexCoord1fARB
= vbo_MultiTexCoord1f
;
866 vfmt
->MultiTexCoord1fvARB
= vbo_MultiTexCoord1fv
;
867 vfmt
->MultiTexCoord2fARB
= vbo_MultiTexCoord2f
;
868 vfmt
->MultiTexCoord2fvARB
= vbo_MultiTexCoord2fv
;
869 vfmt
->MultiTexCoord3fARB
= vbo_MultiTexCoord3f
;
870 vfmt
->MultiTexCoord3fvARB
= vbo_MultiTexCoord3fv
;
871 vfmt
->MultiTexCoord4fARB
= vbo_MultiTexCoord4f
;
872 vfmt
->MultiTexCoord4fvARB
= vbo_MultiTexCoord4fv
;
873 vfmt
->Normal3f
= vbo_Normal3f
;
874 vfmt
->Normal3fv
= vbo_Normal3fv
;
875 vfmt
->SecondaryColor3fEXT
= vbo_SecondaryColor3fEXT
;
876 vfmt
->SecondaryColor3fvEXT
= vbo_SecondaryColor3fvEXT
;
877 vfmt
->TexCoord1f
= vbo_TexCoord1f
;
878 vfmt
->TexCoord1fv
= vbo_TexCoord1fv
;
879 vfmt
->TexCoord2f
= vbo_TexCoord2f
;
880 vfmt
->TexCoord2fv
= vbo_TexCoord2fv
;
881 vfmt
->TexCoord3f
= vbo_TexCoord3f
;
882 vfmt
->TexCoord3fv
= vbo_TexCoord3fv
;
883 vfmt
->TexCoord4f
= vbo_TexCoord4f
;
884 vfmt
->TexCoord4fv
= vbo_TexCoord4fv
;
885 vfmt
->Vertex2f
= vbo_Vertex2f
;
886 vfmt
->Vertex2fv
= vbo_Vertex2fv
;
887 vfmt
->Vertex3f
= vbo_Vertex3f
;
888 vfmt
->Vertex3fv
= vbo_Vertex3fv
;
889 vfmt
->Vertex4f
= vbo_Vertex4f
;
890 vfmt
->Vertex4fv
= vbo_Vertex4fv
;
892 if (ctx
->API
== API_OPENGLES2
) {
893 vfmt
->VertexAttrib1fARB
= _es_VertexAttrib1f
;
894 vfmt
->VertexAttrib1fvARB
= _es_VertexAttrib1fv
;
895 vfmt
->VertexAttrib2fARB
= _es_VertexAttrib2f
;
896 vfmt
->VertexAttrib2fvARB
= _es_VertexAttrib2fv
;
897 vfmt
->VertexAttrib3fARB
= _es_VertexAttrib3f
;
898 vfmt
->VertexAttrib3fvARB
= _es_VertexAttrib3fv
;
899 vfmt
->VertexAttrib4fARB
= _es_VertexAttrib4f
;
900 vfmt
->VertexAttrib4fvARB
= _es_VertexAttrib4fv
;
902 vfmt
->VertexAttrib1fARB
= vbo_VertexAttrib1fARB
;
903 vfmt
->VertexAttrib1fvARB
= vbo_VertexAttrib1fvARB
;
904 vfmt
->VertexAttrib2fARB
= vbo_VertexAttrib2fARB
;
905 vfmt
->VertexAttrib2fvARB
= vbo_VertexAttrib2fvARB
;
906 vfmt
->VertexAttrib3fARB
= vbo_VertexAttrib3fARB
;
907 vfmt
->VertexAttrib3fvARB
= vbo_VertexAttrib3fvARB
;
908 vfmt
->VertexAttrib4fARB
= vbo_VertexAttrib4fARB
;
909 vfmt
->VertexAttrib4fvARB
= vbo_VertexAttrib4fvARB
;
912 /* Note that VertexAttrib4fNV is used from dlist.c and api_arrayelt.c so
913 * they can have a single entrypoint for updating any of the legacy
916 vfmt
->VertexAttrib1fNV
= vbo_VertexAttrib1fNV
;
917 vfmt
->VertexAttrib1fvNV
= vbo_VertexAttrib1fvNV
;
918 vfmt
->VertexAttrib2fNV
= vbo_VertexAttrib2fNV
;
919 vfmt
->VertexAttrib2fvNV
= vbo_VertexAttrib2fvNV
;
920 vfmt
->VertexAttrib3fNV
= vbo_VertexAttrib3fNV
;
921 vfmt
->VertexAttrib3fvNV
= vbo_VertexAttrib3fvNV
;
922 vfmt
->VertexAttrib4fNV
= vbo_VertexAttrib4fNV
;
923 vfmt
->VertexAttrib4fvNV
= vbo_VertexAttrib4fvNV
;
926 vfmt
->VertexAttribI1i
= vbo_VertexAttribI1i
;
927 vfmt
->VertexAttribI2i
= vbo_VertexAttribI2i
;
928 vfmt
->VertexAttribI3i
= vbo_VertexAttribI3i
;
929 vfmt
->VertexAttribI4i
= vbo_VertexAttribI4i
;
930 vfmt
->VertexAttribI2iv
= vbo_VertexAttribI2iv
;
931 vfmt
->VertexAttribI3iv
= vbo_VertexAttribI3iv
;
932 vfmt
->VertexAttribI4iv
= vbo_VertexAttribI4iv
;
934 /* unsigned integer-valued */
935 vfmt
->VertexAttribI1ui
= vbo_VertexAttribI1ui
;
936 vfmt
->VertexAttribI2ui
= vbo_VertexAttribI2ui
;
937 vfmt
->VertexAttribI3ui
= vbo_VertexAttribI3ui
;
938 vfmt
->VertexAttribI4ui
= vbo_VertexAttribI4ui
;
939 vfmt
->VertexAttribI2uiv
= vbo_VertexAttribI2uiv
;
940 vfmt
->VertexAttribI3uiv
= vbo_VertexAttribI3uiv
;
941 vfmt
->VertexAttribI4uiv
= vbo_VertexAttribI4uiv
;
943 vfmt
->Materialfv
= vbo_Materialfv
;
945 vfmt
->EdgeFlag
= vbo_EdgeFlag
;
946 vfmt
->Indexf
= vbo_Indexf
;
947 vfmt
->Indexfv
= vbo_Indexfv
;
949 /* ARB_vertex_type_2_10_10_10_rev */
950 vfmt
->VertexP2ui
= vbo_VertexP2ui
;
951 vfmt
->VertexP2uiv
= vbo_VertexP2uiv
;
952 vfmt
->VertexP3ui
= vbo_VertexP3ui
;
953 vfmt
->VertexP3uiv
= vbo_VertexP3uiv
;
954 vfmt
->VertexP4ui
= vbo_VertexP4ui
;
955 vfmt
->VertexP4uiv
= vbo_VertexP4uiv
;
957 vfmt
->TexCoordP1ui
= vbo_TexCoordP1ui
;
958 vfmt
->TexCoordP1uiv
= vbo_TexCoordP1uiv
;
959 vfmt
->TexCoordP2ui
= vbo_TexCoordP2ui
;
960 vfmt
->TexCoordP2uiv
= vbo_TexCoordP2uiv
;
961 vfmt
->TexCoordP3ui
= vbo_TexCoordP3ui
;
962 vfmt
->TexCoordP3uiv
= vbo_TexCoordP3uiv
;
963 vfmt
->TexCoordP4ui
= vbo_TexCoordP4ui
;
964 vfmt
->TexCoordP4uiv
= vbo_TexCoordP4uiv
;
966 vfmt
->MultiTexCoordP1ui
= vbo_MultiTexCoordP1ui
;
967 vfmt
->MultiTexCoordP1uiv
= vbo_MultiTexCoordP1uiv
;
968 vfmt
->MultiTexCoordP2ui
= vbo_MultiTexCoordP2ui
;
969 vfmt
->MultiTexCoordP2uiv
= vbo_MultiTexCoordP2uiv
;
970 vfmt
->MultiTexCoordP3ui
= vbo_MultiTexCoordP3ui
;
971 vfmt
->MultiTexCoordP3uiv
= vbo_MultiTexCoordP3uiv
;
972 vfmt
->MultiTexCoordP4ui
= vbo_MultiTexCoordP4ui
;
973 vfmt
->MultiTexCoordP4uiv
= vbo_MultiTexCoordP4uiv
;
975 vfmt
->NormalP3ui
= vbo_NormalP3ui
;
976 vfmt
->NormalP3uiv
= vbo_NormalP3uiv
;
978 vfmt
->ColorP3ui
= vbo_ColorP3ui
;
979 vfmt
->ColorP3uiv
= vbo_ColorP3uiv
;
980 vfmt
->ColorP4ui
= vbo_ColorP4ui
;
981 vfmt
->ColorP4uiv
= vbo_ColorP4uiv
;
983 vfmt
->SecondaryColorP3ui
= vbo_SecondaryColorP3ui
;
984 vfmt
->SecondaryColorP3uiv
= vbo_SecondaryColorP3uiv
;
986 vfmt
->VertexAttribP1ui
= vbo_VertexAttribP1ui
;
987 vfmt
->VertexAttribP1uiv
= vbo_VertexAttribP1uiv
;
988 vfmt
->VertexAttribP2ui
= vbo_VertexAttribP2ui
;
989 vfmt
->VertexAttribP2uiv
= vbo_VertexAttribP2uiv
;
990 vfmt
->VertexAttribP3ui
= vbo_VertexAttribP3ui
;
991 vfmt
->VertexAttribP3uiv
= vbo_VertexAttribP3uiv
;
992 vfmt
->VertexAttribP4ui
= vbo_VertexAttribP4ui
;
993 vfmt
->VertexAttribP4uiv
= vbo_VertexAttribP4uiv
;
995 vfmt
->VertexAttribL1d
= vbo_VertexAttribL1d
;
996 vfmt
->VertexAttribL2d
= vbo_VertexAttribL2d
;
997 vfmt
->VertexAttribL3d
= vbo_VertexAttribL3d
;
998 vfmt
->VertexAttribL4d
= vbo_VertexAttribL4d
;
1000 vfmt
->VertexAttribL1dv
= vbo_VertexAttribL1dv
;
1001 vfmt
->VertexAttribL2dv
= vbo_VertexAttribL2dv
;
1002 vfmt
->VertexAttribL3dv
= vbo_VertexAttribL3dv
;
1003 vfmt
->VertexAttribL4dv
= vbo_VertexAttribL4dv
;
1008 * Tell the VBO module to use a real OpenGL vertex buffer object to
1009 * store accumulated immediate-mode vertex data.
1010 * This replaces the malloced buffer which was created in
1011 * vb_exec_vtx_init() below.
1013 void vbo_use_buffer_objects(struct gl_context
*ctx
)
1015 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1016 /* Any buffer name but 0 can be used here since this bufferobj won't
1017 * go into the bufferobj hashtable.
1019 GLuint bufName
= IMM_BUFFER_NAME
;
1020 GLenum target
= GL_ARRAY_BUFFER_ARB
;
1021 GLenum usage
= GL_STREAM_DRAW_ARB
;
1022 GLsizei size
= VBO_VERT_BUFFER_SIZE
;
1024 /* Make sure this func is only used once */
1025 assert(exec
->vtx
.bufferobj
== ctx
->Shared
->NullBufferObj
);
1027 _mesa_align_free(exec
->vtx
.buffer_map
);
1028 exec
->vtx
.buffer_map
= NULL
;
1029 exec
->vtx
.buffer_ptr
= NULL
;
1031 /* Allocate a real buffer object now */
1032 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1033 exec
->vtx
.bufferobj
= ctx
->Driver
.NewBufferObject(ctx
, bufName
);
1034 if (!ctx
->Driver
.BufferData(ctx
, target
, size
, NULL
, usage
,
1036 GL_DYNAMIC_STORAGE_BIT
|
1037 GL_CLIENT_STORAGE_BIT
,
1038 exec
->vtx
.bufferobj
)) {
1039 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "VBO allocation");
1045 * If this function is called, all VBO buffers will be unmapped when
1047 * Otherwise, if a simple command like glColor3f() is called and we flush,
1048 * the current VBO may be left mapped.
1051 vbo_always_unmap_buffers(struct gl_context
*ctx
)
1053 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1054 exec
->begin_vertices_flags
|= FLUSH_STORED_VERTICES
;
1058 void vbo_exec_vtx_init( struct vbo_exec_context
*exec
)
1060 struct gl_context
*ctx
= exec
->ctx
;
1061 struct vbo_context
*vbo
= vbo_context(ctx
);
1064 /* Allocate a buffer object. Will just reuse this object
1065 * continuously, unless vbo_use_buffer_objects() is called to enable
1068 _mesa_reference_buffer_object(ctx
,
1069 &exec
->vtx
.bufferobj
,
1070 ctx
->Shared
->NullBufferObj
);
1072 assert(!exec
->vtx
.buffer_map
);
1073 exec
->vtx
.buffer_map
= _mesa_align_malloc(VBO_VERT_BUFFER_SIZE
, 64);
1074 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
1076 vbo_exec_vtxfmt_init( exec
);
1077 _mesa_noop_vtxfmt_init(&exec
->vtxfmt_noop
);
1079 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1080 assert(i
< ARRAY_SIZE(exec
->vtx
.attrsz
));
1081 exec
->vtx
.attrsz
[i
] = 0;
1082 assert(i
< ARRAY_SIZE(exec
->vtx
.attrtype
));
1083 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1084 assert(i
< ARRAY_SIZE(exec
->vtx
.active_sz
));
1085 exec
->vtx
.active_sz
[i
] = 0;
1087 for (i
= 0 ; i
< VERT_ATTRIB_MAX
; i
++) {
1088 assert(i
< ARRAY_SIZE(exec
->vtx
.inputs
));
1089 assert(i
< ARRAY_SIZE(exec
->vtx
.arrays
));
1090 exec
->vtx
.inputs
[i
] = &exec
->vtx
.arrays
[i
];
1094 struct gl_client_array
*arrays
= exec
->vtx
.arrays
;
1097 memcpy(arrays
, &vbo
->currval
[VBO_ATTRIB_POS
],
1098 VERT_ATTRIB_FF_MAX
* sizeof(arrays
[0]));
1099 for (i
= 0; i
< VERT_ATTRIB_FF_MAX
; ++i
) {
1100 struct gl_client_array
*array
;
1101 array
= &arrays
[VERT_ATTRIB_FF(i
)];
1102 array
->BufferObj
= NULL
;
1103 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1104 vbo
->currval
[VBO_ATTRIB_POS
+i
].BufferObj
);
1107 memcpy(arrays
+ VERT_ATTRIB_GENERIC(0),
1108 &vbo
->currval
[VBO_ATTRIB_GENERIC0
],
1109 VERT_ATTRIB_GENERIC_MAX
* sizeof(arrays
[0]));
1111 for (i
= 0; i
< VERT_ATTRIB_GENERIC_MAX
; ++i
) {
1112 struct gl_client_array
*array
;
1113 array
= &arrays
[VERT_ATTRIB_GENERIC(i
)];
1114 array
->BufferObj
= NULL
;
1115 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1116 vbo
->currval
[VBO_ATTRIB_GENERIC0
+i
].BufferObj
);
1120 exec
->vtx
.vertex_size
= 0;
1122 exec
->begin_vertices_flags
= FLUSH_UPDATE_CURRENT
;
1126 void vbo_exec_vtx_destroy( struct vbo_exec_context
*exec
)
1128 /* using a real VBO for vertex data */
1129 struct gl_context
*ctx
= exec
->ctx
;
1132 /* True VBOs should already be unmapped
1134 if (exec
->vtx
.buffer_map
) {
1135 assert(exec
->vtx
.bufferobj
->Name
== 0 ||
1136 exec
->vtx
.bufferobj
->Name
== IMM_BUFFER_NAME
);
1137 if (exec
->vtx
.bufferobj
->Name
== 0) {
1138 _mesa_align_free(exec
->vtx
.buffer_map
);
1139 exec
->vtx
.buffer_map
= NULL
;
1140 exec
->vtx
.buffer_ptr
= NULL
;
1144 /* Drop any outstanding reference to the vertex buffer
1146 for (i
= 0; i
< ARRAY_SIZE(exec
->vtx
.arrays
); i
++) {
1147 _mesa_reference_buffer_object(ctx
,
1148 &exec
->vtx
.arrays
[i
].BufferObj
,
1152 /* Free the vertex buffer. Unmap first if needed.
1154 if (_mesa_bufferobj_mapped(exec
->vtx
.bufferobj
, MAP_INTERNAL
)) {
1155 ctx
->Driver
.UnmapBuffer(ctx
, exec
->vtx
.bufferobj
, MAP_INTERNAL
);
1157 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1162 * Called upon first glVertex, glColor, glTexCoord, etc.
1164 void vbo_exec_BeginVertices( struct gl_context
*ctx
)
1166 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1168 vbo_exec_vtx_map( exec
);
1170 assert((ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
) == 0);
1171 assert(exec
->begin_vertices_flags
);
1173 ctx
->Driver
.NeedFlush
|= exec
->begin_vertices_flags
;
1178 * If inside glBegin()/glEnd(), it should assert(0). Otherwise, if
1179 * FLUSH_STORED_VERTICES bit in \p flags is set flushes any buffered
1180 * vertices, if FLUSH_UPDATE_CURRENT bit is set updates
1181 * __struct gl_contextRec::Current and gl_light_attrib::Material
1183 * Note that the default T&L engine never clears the
1184 * FLUSH_UPDATE_CURRENT bit, even after performing the update.
1186 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1188 void vbo_exec_FlushVertices( struct gl_context
*ctx
, GLuint flags
)
1190 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1193 /* debug check: make sure we don't get called recursively */
1194 exec
->flush_call_depth
++;
1195 assert(exec
->flush_call_depth
== 1);
1198 if (_mesa_inside_begin_end(ctx
)) {
1199 /* We've had glBegin but not glEnd! */
1201 exec
->flush_call_depth
--;
1202 assert(exec
->flush_call_depth
== 0);
1207 /* Flush (draw), and make sure VBO is left unmapped when done */
1208 vbo_exec_FlushVertices_internal(exec
, GL_TRUE
);
1210 /* Need to do this to ensure vbo_exec_BeginVertices gets called again:
1212 ctx
->Driver
.NeedFlush
&= ~(FLUSH_UPDATE_CURRENT
| flags
);
1215 exec
->flush_call_depth
--;
1216 assert(exec
->flush_call_depth
== 0);
1221 static void reset_attrfv( struct vbo_exec_context
*exec
)
1225 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1226 exec
->vtx
.attrsz
[i
] = 0;
1227 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1228 exec
->vtx
.active_sz
[i
] = 0;
1231 exec
->vtx
.vertex_size
= 0;
1236 _es_Color4f(GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
1238 vbo_Color4f(r
, g
, b
, a
);
1243 _es_Normal3f(GLfloat x
, GLfloat y
, GLfloat z
)
1245 vbo_Normal3f(x
, y
, z
);
1250 _es_MultiTexCoord4f(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1252 vbo_MultiTexCoord4f(target
, s
, t
, r
, q
);
1257 _es_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
1259 vbo_Materialfv(face
, pname
, params
);
1264 _es_Materialf(GLenum face
, GLenum pname
, GLfloat param
)
1268 p
[1] = p
[2] = p
[3] = 0.0F
;
1269 vbo_Materialfv(face
, pname
, p
);
1274 * A special version of glVertexAttrib4f that does not treat index 0 as
1278 VertexAttrib4f_nopos(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1280 GET_CURRENT_CONTEXT(ctx
);
1281 if (index
< MAX_VERTEX_GENERIC_ATTRIBS
)
1282 ATTRF(VBO_ATTRIB_GENERIC0
+ index
, 4, x
, y
, z
, w
);
1284 ERROR(GL_INVALID_VALUE
);
1288 _es_VertexAttrib4f(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1290 VertexAttrib4f_nopos(index
, x
, y
, z
, w
);
1295 _es_VertexAttrib1f(GLuint indx
, GLfloat x
)
1297 VertexAttrib4f_nopos(indx
, x
, 0.0f
, 0.0f
, 1.0f
);
1302 _es_VertexAttrib1fv(GLuint indx
, const GLfloat
* values
)
1304 VertexAttrib4f_nopos(indx
, values
[0], 0.0f
, 0.0f
, 1.0f
);
1309 _es_VertexAttrib2f(GLuint indx
, GLfloat x
, GLfloat y
)
1311 VertexAttrib4f_nopos(indx
, x
, y
, 0.0f
, 1.0f
);
1316 _es_VertexAttrib2fv(GLuint indx
, const GLfloat
* values
)
1318 VertexAttrib4f_nopos(indx
, values
[0], values
[1], 0.0f
, 1.0f
);
1323 _es_VertexAttrib3f(GLuint indx
, GLfloat x
, GLfloat y
, GLfloat z
)
1325 VertexAttrib4f_nopos(indx
, x
, y
, z
, 1.0f
);
1330 _es_VertexAttrib3fv(GLuint indx
, const GLfloat
* values
)
1332 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], 1.0f
);
1337 _es_VertexAttrib4fv(GLuint indx
, const GLfloat
* values
)
1339 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], values
[3]);