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.
378 * \param newSize size of new vertex (number of 32-bit words).
381 vbo_exec_fixup_vertex(struct gl_context
*ctx
, GLuint attr
,
382 GLuint newSize
, GLenum newType
)
384 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
386 if (newSize
> exec
->vtx
.attrsz
[attr
] ||
387 newType
!= exec
->vtx
.attrtype
[attr
]) {
388 /* New size is larger. Need to flush existing vertices and get
389 * an enlarged vertex format.
391 vbo_exec_wrap_upgrade_vertex( exec
, attr
, newSize
);
393 else if (newSize
< exec
->vtx
.active_sz
[attr
]) {
396 vbo_get_default_vals_as_union(exec
->vtx
.attrtype
[attr
]);
398 /* New size is smaller - just need to fill in some
399 * zeros. Don't need to flush or wrap.
401 for (i
= newSize
; i
<= exec
->vtx
.attrsz
[attr
]; i
++)
402 exec
->vtx
.attrptr
[attr
][i
-1] = id
[i
-1];
405 exec
->vtx
.active_sz
[attr
] = newSize
;
407 /* Does setting NeedFlush belong here? Necessitates resetting
408 * vtxfmt on each flush (otherwise flags won't get reset
412 ctx
->Driver
.NeedFlush
|= FLUSH_STORED_VERTICES
;
417 * This macro is used to implement all the glVertex, glColor, glTexCoord,
418 * glVertexAttrib, etc functions.
419 * \param A attribute index
420 * \param N attribute size (1..4)
421 * \param T type (GL_FLOAT, GL_DOUBLE, GL_INT, GL_UNSIGNED_INT)
422 * \param C cast type (fi_type or double)
423 * \param V0, V1, v2, V3 attribute value
425 #define ATTR_UNION( A, N, T, C, V0, V1, V2, V3 ) \
427 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
428 int sz = (sizeof(C) / sizeof(GLfloat)); \
430 assert(sz == 1 || sz == 2); \
432 if (unlikely(!(ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT))) { \
433 vbo_exec_BeginVertices(ctx); \
436 /* check if attribute size or type is changing */ \
437 if (unlikely(exec->vtx.active_sz[A] != N * sz) || \
438 unlikely(exec->vtx.attrtype[A] != T)) { \
439 vbo_exec_fixup_vertex(ctx, A, N * sz, T); \
442 /* store vertex attribute in vertex buffer */ \
444 C *dest = (C *)exec->vtx.attrptr[A]; \
445 if (N>0) dest[0] = V0; \
446 if (N>1) dest[1] = V1; \
447 if (N>2) dest[2] = V2; \
448 if (N>3) dest[3] = V3; \
449 exec->vtx.attrtype[A] = T; \
453 /* This is a glVertex call */ \
456 /* copy 32-bit words */ \
457 for (i = 0; i < exec->vtx.vertex_size; i++) \
458 exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i]; \
460 exec->vtx.buffer_ptr += exec->vtx.vertex_size; \
462 /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \
463 /* something to draw (not just updating a color or texcoord).*/ \
464 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \
466 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
467 vbo_exec_vtx_wrap( exec ); \
471 #define ERROR(err) _mesa_error( ctx, err, __func__ )
472 #define TAG(x) vbo_##x
474 #include "vbo_attrib_tmp.h"
479 * Execute a glMaterial call. Note that if GL_COLOR_MATERIAL is enabled,
480 * this may be a (partial) no-op.
482 static void GLAPIENTRY
483 vbo_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
485 GLbitfield updateMats
;
486 GET_CURRENT_CONTEXT(ctx
);
488 /* This function should be a no-op when it tries to update material
489 * attributes which are currently tracking glColor via glColorMaterial.
490 * The updateMats var will be a mask of the MAT_BIT_FRONT/BACK_x bits
491 * indicating which material attributes can actually be updated below.
493 if (ctx
->Light
.ColorMaterialEnabled
) {
494 updateMats
= ~ctx
->Light
._ColorMaterialBitmask
;
497 /* GL_COLOR_MATERIAL is disabled so don't skip any material updates */
498 updateMats
= ALL_MATERIAL_BITS
;
501 if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_FRONT
) {
502 updateMats
&= FRONT_MATERIAL_BITS
;
504 else if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_BACK
) {
505 updateMats
&= BACK_MATERIAL_BITS
;
507 else if (face
!= GL_FRONT_AND_BACK
) {
508 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterial(invalid face)");
514 if (updateMats
& MAT_BIT_FRONT_EMISSION
)
515 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_EMISSION
, 4, params
);
516 if (updateMats
& MAT_BIT_BACK_EMISSION
)
517 MAT_ATTR(VBO_ATTRIB_MAT_BACK_EMISSION
, 4, params
);
520 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
521 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
522 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
523 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
526 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
527 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
528 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
529 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
532 if (updateMats
& MAT_BIT_FRONT_SPECULAR
)
533 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SPECULAR
, 4, params
);
534 if (updateMats
& MAT_BIT_BACK_SPECULAR
)
535 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SPECULAR
, 4, params
);
538 if (*params
< 0 || *params
> ctx
->Const
.MaxShininess
) {
539 _mesa_error(ctx
, GL_INVALID_VALUE
,
540 "glMaterial(invalid shininess: %f out range [0, %f])",
541 *params
, ctx
->Const
.MaxShininess
);
544 if (updateMats
& MAT_BIT_FRONT_SHININESS
)
545 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SHININESS
, 1, params
);
546 if (updateMats
& MAT_BIT_BACK_SHININESS
)
547 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SHININESS
, 1, params
);
549 case GL_COLOR_INDEXES
:
550 if (ctx
->API
!= API_OPENGL_COMPAT
) {
551 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
554 if (updateMats
& MAT_BIT_FRONT_INDEXES
)
555 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_INDEXES
, 3, params
);
556 if (updateMats
& MAT_BIT_BACK_INDEXES
)
557 MAT_ATTR(VBO_ATTRIB_MAT_BACK_INDEXES
, 3, params
);
559 case GL_AMBIENT_AND_DIFFUSE
:
560 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
561 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
562 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
563 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
564 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
565 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
566 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
567 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
570 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
577 * Flush (draw) vertices.
578 * \param unmap - leave VBO unmapped after flushing?
581 vbo_exec_FlushVertices_internal(struct vbo_exec_context
*exec
, GLboolean unmap
)
583 if (exec
->vtx
.vert_count
|| unmap
) {
584 vbo_exec_vtx_flush( exec
, unmap
);
587 if (exec
->vtx
.vertex_size
) {
588 vbo_exec_copy_to_current( exec
);
589 reset_attrfv( exec
);
594 static void GLAPIENTRY
vbo_exec_EvalCoord1f( GLfloat u
)
596 GET_CURRENT_CONTEXT( ctx
);
597 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
601 if (exec
->eval
.recalculate_maps
)
602 vbo_exec_eval_update( exec
);
604 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
605 if (exec
->eval
.map1
[i
].map
)
606 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map1
[i
].sz
)
607 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map1
[i
].sz
, GL_FLOAT
);
612 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
613 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
615 vbo_exec_do_EvalCoord1f( exec
, u
);
617 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
618 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
621 static void GLAPIENTRY
vbo_exec_EvalCoord2f( GLfloat u
, GLfloat v
)
623 GET_CURRENT_CONTEXT( ctx
);
624 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
628 if (exec
->eval
.recalculate_maps
)
629 vbo_exec_eval_update( exec
);
631 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
632 if (exec
->eval
.map2
[i
].map
)
633 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map2
[i
].sz
)
634 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map2
[i
].sz
, GL_FLOAT
);
637 if (ctx
->Eval
.AutoNormal
)
638 if (exec
->vtx
.active_sz
[VBO_ATTRIB_NORMAL
] != 3)
639 vbo_exec_fixup_vertex( ctx
, VBO_ATTRIB_NORMAL
, 3, GL_FLOAT
);
642 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
643 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
645 vbo_exec_do_EvalCoord2f( exec
, u
, v
);
647 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
648 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
651 static void GLAPIENTRY
vbo_exec_EvalCoord1fv( const GLfloat
*u
)
653 vbo_exec_EvalCoord1f( u
[0] );
656 static void GLAPIENTRY
vbo_exec_EvalCoord2fv( const GLfloat
*u
)
658 vbo_exec_EvalCoord2f( u
[0], u
[1] );
661 static void GLAPIENTRY
vbo_exec_EvalPoint1( GLint i
)
663 GET_CURRENT_CONTEXT( ctx
);
664 GLfloat du
= ((ctx
->Eval
.MapGrid1u2
- ctx
->Eval
.MapGrid1u1
) /
665 (GLfloat
) ctx
->Eval
.MapGrid1un
);
666 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid1u1
;
668 vbo_exec_EvalCoord1f( u
);
672 static void GLAPIENTRY
vbo_exec_EvalPoint2( GLint i
, GLint j
)
674 GET_CURRENT_CONTEXT( ctx
);
675 GLfloat du
= ((ctx
->Eval
.MapGrid2u2
- ctx
->Eval
.MapGrid2u1
) /
676 (GLfloat
) ctx
->Eval
.MapGrid2un
);
677 GLfloat dv
= ((ctx
->Eval
.MapGrid2v2
- ctx
->Eval
.MapGrid2v1
) /
678 (GLfloat
) ctx
->Eval
.MapGrid2vn
);
679 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid2u1
;
680 GLfloat v
= j
* dv
+ ctx
->Eval
.MapGrid2v1
;
682 vbo_exec_EvalCoord2f( u
, v
);
687 * Called via glBegin.
689 static void GLAPIENTRY
vbo_exec_Begin( GLenum mode
)
691 GET_CURRENT_CONTEXT( ctx
);
692 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
695 if (_mesa_inside_begin_end(ctx
)) {
696 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glBegin");
700 if (!_mesa_valid_prim_mode(ctx
, mode
, "glBegin")) {
704 vbo_draw_method(vbo_context(ctx
), DRAW_BEGIN_END
);
707 _mesa_update_state( ctx
);
709 CALL_Begin(ctx
->Exec
, (mode
));
713 if (!_mesa_valid_to_render(ctx
, "glBegin")) {
717 /* Heuristic: attempt to isolate attributes occurring outside
720 if (exec
->vtx
.vertex_size
&& !exec
->vtx
.attrsz
[0])
721 vbo_exec_FlushVertices_internal(exec
, GL_FALSE
);
723 i
= exec
->vtx
.prim_count
++;
724 exec
->vtx
.prim
[i
].mode
= mode
;
725 exec
->vtx
.prim
[i
].begin
= 1;
726 exec
->vtx
.prim
[i
].end
= 0;
727 exec
->vtx
.prim
[i
].indexed
= 0;
728 exec
->vtx
.prim
[i
].weak
= 0;
729 exec
->vtx
.prim
[i
].pad
= 0;
730 exec
->vtx
.prim
[i
].start
= exec
->vtx
.vert_count
;
731 exec
->vtx
.prim
[i
].count
= 0;
732 exec
->vtx
.prim
[i
].num_instances
= 1;
733 exec
->vtx
.prim
[i
].base_instance
= 0;
734 exec
->vtx
.prim
[i
].is_indirect
= 0;
736 ctx
->Driver
.CurrentExecPrimitive
= mode
;
738 ctx
->Exec
= ctx
->BeginEnd
;
739 /* We may have been called from a display list, in which case we should
740 * leave dlist.c's dispatch table in place.
742 if (ctx
->CurrentDispatch
== ctx
->OutsideBeginEnd
) {
743 ctx
->CurrentDispatch
= ctx
->BeginEnd
;
744 _glapi_set_dispatch(ctx
->CurrentDispatch
);
746 assert(ctx
->CurrentDispatch
== ctx
->Save
);
752 * Try to merge / concatenate the two most recent VBO primitives.
755 try_vbo_merge(struct vbo_exec_context
*exec
)
757 struct _mesa_prim
*cur
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
759 assert(exec
->vtx
.prim_count
>= 1);
761 vbo_try_prim_conversion(cur
);
763 if (exec
->vtx
.prim_count
>= 2) {
764 struct _mesa_prim
*prev
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 2];
765 assert(prev
== cur
- 1);
767 if (vbo_can_merge_prims(prev
, cur
)) {
772 vbo_merge_prims(prev
, cur
);
773 exec
->vtx
.prim_count
--; /* drop the last primitive */
782 static void GLAPIENTRY
vbo_exec_End( void )
784 GET_CURRENT_CONTEXT( ctx
);
785 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
787 if (!_mesa_inside_begin_end(ctx
)) {
788 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glEnd");
792 ctx
->Exec
= ctx
->OutsideBeginEnd
;
793 if (ctx
->CurrentDispatch
== ctx
->BeginEnd
) {
794 ctx
->CurrentDispatch
= ctx
->OutsideBeginEnd
;
795 _glapi_set_dispatch(ctx
->CurrentDispatch
);
798 if (exec
->vtx
.prim_count
> 0) {
799 /* close off current primitive */
800 int idx
= exec
->vtx
.vert_count
;
801 int i
= exec
->vtx
.prim_count
- 1;
803 exec
->vtx
.prim
[i
].end
= 1;
804 exec
->vtx
.prim
[i
].count
= idx
- exec
->vtx
.prim
[i
].start
;
809 ctx
->Driver
.CurrentExecPrimitive
= PRIM_OUTSIDE_BEGIN_END
;
811 if (exec
->vtx
.prim_count
== VBO_MAX_PRIM
)
812 vbo_exec_vtx_flush( exec
, GL_FALSE
);
814 if (MESA_DEBUG_FLAGS
& DEBUG_ALWAYS_FLUSH
) {
821 * Called via glPrimitiveRestartNV()
823 static void GLAPIENTRY
824 vbo_exec_PrimitiveRestartNV(void)
827 GET_CURRENT_CONTEXT( ctx
);
829 curPrim
= ctx
->Driver
.CurrentExecPrimitive
;
831 if (curPrim
== PRIM_OUTSIDE_BEGIN_END
) {
832 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glPrimitiveRestartNV" );
836 vbo_exec_Begin(curPrim
);
842 static void vbo_exec_vtxfmt_init( struct vbo_exec_context
*exec
)
844 struct gl_context
*ctx
= exec
->ctx
;
845 GLvertexformat
*vfmt
= &exec
->vtxfmt
;
847 vfmt
->ArrayElement
= _ae_ArrayElement
;
849 vfmt
->Begin
= vbo_exec_Begin
;
850 vfmt
->End
= vbo_exec_End
;
851 vfmt
->PrimitiveRestartNV
= vbo_exec_PrimitiveRestartNV
;
853 vfmt
->CallList
= _mesa_CallList
;
854 vfmt
->CallLists
= _mesa_CallLists
;
856 vfmt
->EvalCoord1f
= vbo_exec_EvalCoord1f
;
857 vfmt
->EvalCoord1fv
= vbo_exec_EvalCoord1fv
;
858 vfmt
->EvalCoord2f
= vbo_exec_EvalCoord2f
;
859 vfmt
->EvalCoord2fv
= vbo_exec_EvalCoord2fv
;
860 vfmt
->EvalPoint1
= vbo_exec_EvalPoint1
;
861 vfmt
->EvalPoint2
= vbo_exec_EvalPoint2
;
863 /* from attrib_tmp.h:
865 vfmt
->Color3f
= vbo_Color3f
;
866 vfmt
->Color3fv
= vbo_Color3fv
;
867 vfmt
->Color4f
= vbo_Color4f
;
868 vfmt
->Color4fv
= vbo_Color4fv
;
869 vfmt
->FogCoordfEXT
= vbo_FogCoordfEXT
;
870 vfmt
->FogCoordfvEXT
= vbo_FogCoordfvEXT
;
871 vfmt
->MultiTexCoord1fARB
= vbo_MultiTexCoord1f
;
872 vfmt
->MultiTexCoord1fvARB
= vbo_MultiTexCoord1fv
;
873 vfmt
->MultiTexCoord2fARB
= vbo_MultiTexCoord2f
;
874 vfmt
->MultiTexCoord2fvARB
= vbo_MultiTexCoord2fv
;
875 vfmt
->MultiTexCoord3fARB
= vbo_MultiTexCoord3f
;
876 vfmt
->MultiTexCoord3fvARB
= vbo_MultiTexCoord3fv
;
877 vfmt
->MultiTexCoord4fARB
= vbo_MultiTexCoord4f
;
878 vfmt
->MultiTexCoord4fvARB
= vbo_MultiTexCoord4fv
;
879 vfmt
->Normal3f
= vbo_Normal3f
;
880 vfmt
->Normal3fv
= vbo_Normal3fv
;
881 vfmt
->SecondaryColor3fEXT
= vbo_SecondaryColor3fEXT
;
882 vfmt
->SecondaryColor3fvEXT
= vbo_SecondaryColor3fvEXT
;
883 vfmt
->TexCoord1f
= vbo_TexCoord1f
;
884 vfmt
->TexCoord1fv
= vbo_TexCoord1fv
;
885 vfmt
->TexCoord2f
= vbo_TexCoord2f
;
886 vfmt
->TexCoord2fv
= vbo_TexCoord2fv
;
887 vfmt
->TexCoord3f
= vbo_TexCoord3f
;
888 vfmt
->TexCoord3fv
= vbo_TexCoord3fv
;
889 vfmt
->TexCoord4f
= vbo_TexCoord4f
;
890 vfmt
->TexCoord4fv
= vbo_TexCoord4fv
;
891 vfmt
->Vertex2f
= vbo_Vertex2f
;
892 vfmt
->Vertex2fv
= vbo_Vertex2fv
;
893 vfmt
->Vertex3f
= vbo_Vertex3f
;
894 vfmt
->Vertex3fv
= vbo_Vertex3fv
;
895 vfmt
->Vertex4f
= vbo_Vertex4f
;
896 vfmt
->Vertex4fv
= vbo_Vertex4fv
;
898 if (ctx
->API
== API_OPENGLES2
) {
899 vfmt
->VertexAttrib1fARB
= _es_VertexAttrib1f
;
900 vfmt
->VertexAttrib1fvARB
= _es_VertexAttrib1fv
;
901 vfmt
->VertexAttrib2fARB
= _es_VertexAttrib2f
;
902 vfmt
->VertexAttrib2fvARB
= _es_VertexAttrib2fv
;
903 vfmt
->VertexAttrib3fARB
= _es_VertexAttrib3f
;
904 vfmt
->VertexAttrib3fvARB
= _es_VertexAttrib3fv
;
905 vfmt
->VertexAttrib4fARB
= _es_VertexAttrib4f
;
906 vfmt
->VertexAttrib4fvARB
= _es_VertexAttrib4fv
;
908 vfmt
->VertexAttrib1fARB
= vbo_VertexAttrib1fARB
;
909 vfmt
->VertexAttrib1fvARB
= vbo_VertexAttrib1fvARB
;
910 vfmt
->VertexAttrib2fARB
= vbo_VertexAttrib2fARB
;
911 vfmt
->VertexAttrib2fvARB
= vbo_VertexAttrib2fvARB
;
912 vfmt
->VertexAttrib3fARB
= vbo_VertexAttrib3fARB
;
913 vfmt
->VertexAttrib3fvARB
= vbo_VertexAttrib3fvARB
;
914 vfmt
->VertexAttrib4fARB
= vbo_VertexAttrib4fARB
;
915 vfmt
->VertexAttrib4fvARB
= vbo_VertexAttrib4fvARB
;
918 /* Note that VertexAttrib4fNV is used from dlist.c and api_arrayelt.c so
919 * they can have a single entrypoint for updating any of the legacy
922 vfmt
->VertexAttrib1fNV
= vbo_VertexAttrib1fNV
;
923 vfmt
->VertexAttrib1fvNV
= vbo_VertexAttrib1fvNV
;
924 vfmt
->VertexAttrib2fNV
= vbo_VertexAttrib2fNV
;
925 vfmt
->VertexAttrib2fvNV
= vbo_VertexAttrib2fvNV
;
926 vfmt
->VertexAttrib3fNV
= vbo_VertexAttrib3fNV
;
927 vfmt
->VertexAttrib3fvNV
= vbo_VertexAttrib3fvNV
;
928 vfmt
->VertexAttrib4fNV
= vbo_VertexAttrib4fNV
;
929 vfmt
->VertexAttrib4fvNV
= vbo_VertexAttrib4fvNV
;
932 vfmt
->VertexAttribI1i
= vbo_VertexAttribI1i
;
933 vfmt
->VertexAttribI2i
= vbo_VertexAttribI2i
;
934 vfmt
->VertexAttribI3i
= vbo_VertexAttribI3i
;
935 vfmt
->VertexAttribI4i
= vbo_VertexAttribI4i
;
936 vfmt
->VertexAttribI2iv
= vbo_VertexAttribI2iv
;
937 vfmt
->VertexAttribI3iv
= vbo_VertexAttribI3iv
;
938 vfmt
->VertexAttribI4iv
= vbo_VertexAttribI4iv
;
940 /* unsigned integer-valued */
941 vfmt
->VertexAttribI1ui
= vbo_VertexAttribI1ui
;
942 vfmt
->VertexAttribI2ui
= vbo_VertexAttribI2ui
;
943 vfmt
->VertexAttribI3ui
= vbo_VertexAttribI3ui
;
944 vfmt
->VertexAttribI4ui
= vbo_VertexAttribI4ui
;
945 vfmt
->VertexAttribI2uiv
= vbo_VertexAttribI2uiv
;
946 vfmt
->VertexAttribI3uiv
= vbo_VertexAttribI3uiv
;
947 vfmt
->VertexAttribI4uiv
= vbo_VertexAttribI4uiv
;
949 vfmt
->Materialfv
= vbo_Materialfv
;
951 vfmt
->EdgeFlag
= vbo_EdgeFlag
;
952 vfmt
->Indexf
= vbo_Indexf
;
953 vfmt
->Indexfv
= vbo_Indexfv
;
955 /* ARB_vertex_type_2_10_10_10_rev */
956 vfmt
->VertexP2ui
= vbo_VertexP2ui
;
957 vfmt
->VertexP2uiv
= vbo_VertexP2uiv
;
958 vfmt
->VertexP3ui
= vbo_VertexP3ui
;
959 vfmt
->VertexP3uiv
= vbo_VertexP3uiv
;
960 vfmt
->VertexP4ui
= vbo_VertexP4ui
;
961 vfmt
->VertexP4uiv
= vbo_VertexP4uiv
;
963 vfmt
->TexCoordP1ui
= vbo_TexCoordP1ui
;
964 vfmt
->TexCoordP1uiv
= vbo_TexCoordP1uiv
;
965 vfmt
->TexCoordP2ui
= vbo_TexCoordP2ui
;
966 vfmt
->TexCoordP2uiv
= vbo_TexCoordP2uiv
;
967 vfmt
->TexCoordP3ui
= vbo_TexCoordP3ui
;
968 vfmt
->TexCoordP3uiv
= vbo_TexCoordP3uiv
;
969 vfmt
->TexCoordP4ui
= vbo_TexCoordP4ui
;
970 vfmt
->TexCoordP4uiv
= vbo_TexCoordP4uiv
;
972 vfmt
->MultiTexCoordP1ui
= vbo_MultiTexCoordP1ui
;
973 vfmt
->MultiTexCoordP1uiv
= vbo_MultiTexCoordP1uiv
;
974 vfmt
->MultiTexCoordP2ui
= vbo_MultiTexCoordP2ui
;
975 vfmt
->MultiTexCoordP2uiv
= vbo_MultiTexCoordP2uiv
;
976 vfmt
->MultiTexCoordP3ui
= vbo_MultiTexCoordP3ui
;
977 vfmt
->MultiTexCoordP3uiv
= vbo_MultiTexCoordP3uiv
;
978 vfmt
->MultiTexCoordP4ui
= vbo_MultiTexCoordP4ui
;
979 vfmt
->MultiTexCoordP4uiv
= vbo_MultiTexCoordP4uiv
;
981 vfmt
->NormalP3ui
= vbo_NormalP3ui
;
982 vfmt
->NormalP3uiv
= vbo_NormalP3uiv
;
984 vfmt
->ColorP3ui
= vbo_ColorP3ui
;
985 vfmt
->ColorP3uiv
= vbo_ColorP3uiv
;
986 vfmt
->ColorP4ui
= vbo_ColorP4ui
;
987 vfmt
->ColorP4uiv
= vbo_ColorP4uiv
;
989 vfmt
->SecondaryColorP3ui
= vbo_SecondaryColorP3ui
;
990 vfmt
->SecondaryColorP3uiv
= vbo_SecondaryColorP3uiv
;
992 vfmt
->VertexAttribP1ui
= vbo_VertexAttribP1ui
;
993 vfmt
->VertexAttribP1uiv
= vbo_VertexAttribP1uiv
;
994 vfmt
->VertexAttribP2ui
= vbo_VertexAttribP2ui
;
995 vfmt
->VertexAttribP2uiv
= vbo_VertexAttribP2uiv
;
996 vfmt
->VertexAttribP3ui
= vbo_VertexAttribP3ui
;
997 vfmt
->VertexAttribP3uiv
= vbo_VertexAttribP3uiv
;
998 vfmt
->VertexAttribP4ui
= vbo_VertexAttribP4ui
;
999 vfmt
->VertexAttribP4uiv
= vbo_VertexAttribP4uiv
;
1001 vfmt
->VertexAttribL1d
= vbo_VertexAttribL1d
;
1002 vfmt
->VertexAttribL2d
= vbo_VertexAttribL2d
;
1003 vfmt
->VertexAttribL3d
= vbo_VertexAttribL3d
;
1004 vfmt
->VertexAttribL4d
= vbo_VertexAttribL4d
;
1006 vfmt
->VertexAttribL1dv
= vbo_VertexAttribL1dv
;
1007 vfmt
->VertexAttribL2dv
= vbo_VertexAttribL2dv
;
1008 vfmt
->VertexAttribL3dv
= vbo_VertexAttribL3dv
;
1009 vfmt
->VertexAttribL4dv
= vbo_VertexAttribL4dv
;
1014 * Tell the VBO module to use a real OpenGL vertex buffer object to
1015 * store accumulated immediate-mode vertex data.
1016 * This replaces the malloced buffer which was created in
1017 * vb_exec_vtx_init() below.
1019 void vbo_use_buffer_objects(struct gl_context
*ctx
)
1021 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1022 /* Any buffer name but 0 can be used here since this bufferobj won't
1023 * go into the bufferobj hashtable.
1025 GLuint bufName
= IMM_BUFFER_NAME
;
1026 GLenum target
= GL_ARRAY_BUFFER_ARB
;
1027 GLenum usage
= GL_STREAM_DRAW_ARB
;
1028 GLsizei size
= VBO_VERT_BUFFER_SIZE
;
1030 /* Make sure this func is only used once */
1031 assert(exec
->vtx
.bufferobj
== ctx
->Shared
->NullBufferObj
);
1033 _mesa_align_free(exec
->vtx
.buffer_map
);
1034 exec
->vtx
.buffer_map
= NULL
;
1035 exec
->vtx
.buffer_ptr
= NULL
;
1037 /* Allocate a real buffer object now */
1038 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1039 exec
->vtx
.bufferobj
= ctx
->Driver
.NewBufferObject(ctx
, bufName
);
1040 if (!ctx
->Driver
.BufferData(ctx
, target
, size
, NULL
, usage
,
1042 GL_DYNAMIC_STORAGE_BIT
|
1043 GL_CLIENT_STORAGE_BIT
,
1044 exec
->vtx
.bufferobj
)) {
1045 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "VBO allocation");
1051 * If this function is called, all VBO buffers will be unmapped when
1053 * Otherwise, if a simple command like glColor3f() is called and we flush,
1054 * the current VBO may be left mapped.
1057 vbo_always_unmap_buffers(struct gl_context
*ctx
)
1059 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1060 exec
->begin_vertices_flags
|= FLUSH_STORED_VERTICES
;
1064 void vbo_exec_vtx_init( struct vbo_exec_context
*exec
)
1066 struct gl_context
*ctx
= exec
->ctx
;
1067 struct vbo_context
*vbo
= vbo_context(ctx
);
1070 /* Allocate a buffer object. Will just reuse this object
1071 * continuously, unless vbo_use_buffer_objects() is called to enable
1074 _mesa_reference_buffer_object(ctx
,
1075 &exec
->vtx
.bufferobj
,
1076 ctx
->Shared
->NullBufferObj
);
1078 assert(!exec
->vtx
.buffer_map
);
1079 exec
->vtx
.buffer_map
= _mesa_align_malloc(VBO_VERT_BUFFER_SIZE
, 64);
1080 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
1082 vbo_exec_vtxfmt_init( exec
);
1083 _mesa_noop_vtxfmt_init(&exec
->vtxfmt_noop
);
1085 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1086 assert(i
< ARRAY_SIZE(exec
->vtx
.attrsz
));
1087 exec
->vtx
.attrsz
[i
] = 0;
1088 assert(i
< ARRAY_SIZE(exec
->vtx
.attrtype
));
1089 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1090 assert(i
< ARRAY_SIZE(exec
->vtx
.active_sz
));
1091 exec
->vtx
.active_sz
[i
] = 0;
1093 for (i
= 0 ; i
< VERT_ATTRIB_MAX
; i
++) {
1094 assert(i
< ARRAY_SIZE(exec
->vtx
.inputs
));
1095 assert(i
< ARRAY_SIZE(exec
->vtx
.arrays
));
1096 exec
->vtx
.inputs
[i
] = &exec
->vtx
.arrays
[i
];
1100 struct gl_client_array
*arrays
= exec
->vtx
.arrays
;
1103 memcpy(arrays
, &vbo
->currval
[VBO_ATTRIB_POS
],
1104 VERT_ATTRIB_FF_MAX
* sizeof(arrays
[0]));
1105 for (i
= 0; i
< VERT_ATTRIB_FF_MAX
; ++i
) {
1106 struct gl_client_array
*array
;
1107 array
= &arrays
[VERT_ATTRIB_FF(i
)];
1108 array
->BufferObj
= NULL
;
1109 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1110 vbo
->currval
[VBO_ATTRIB_POS
+i
].BufferObj
);
1113 memcpy(arrays
+ VERT_ATTRIB_GENERIC(0),
1114 &vbo
->currval
[VBO_ATTRIB_GENERIC0
],
1115 VERT_ATTRIB_GENERIC_MAX
* sizeof(arrays
[0]));
1117 for (i
= 0; i
< VERT_ATTRIB_GENERIC_MAX
; ++i
) {
1118 struct gl_client_array
*array
;
1119 array
= &arrays
[VERT_ATTRIB_GENERIC(i
)];
1120 array
->BufferObj
= NULL
;
1121 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1122 vbo
->currval
[VBO_ATTRIB_GENERIC0
+i
].BufferObj
);
1126 exec
->vtx
.vertex_size
= 0;
1128 exec
->begin_vertices_flags
= FLUSH_UPDATE_CURRENT
;
1132 void vbo_exec_vtx_destroy( struct vbo_exec_context
*exec
)
1134 /* using a real VBO for vertex data */
1135 struct gl_context
*ctx
= exec
->ctx
;
1138 /* True VBOs should already be unmapped
1140 if (exec
->vtx
.buffer_map
) {
1141 assert(exec
->vtx
.bufferobj
->Name
== 0 ||
1142 exec
->vtx
.bufferobj
->Name
== IMM_BUFFER_NAME
);
1143 if (exec
->vtx
.bufferobj
->Name
== 0) {
1144 _mesa_align_free(exec
->vtx
.buffer_map
);
1145 exec
->vtx
.buffer_map
= NULL
;
1146 exec
->vtx
.buffer_ptr
= NULL
;
1150 /* Drop any outstanding reference to the vertex buffer
1152 for (i
= 0; i
< ARRAY_SIZE(exec
->vtx
.arrays
); i
++) {
1153 _mesa_reference_buffer_object(ctx
,
1154 &exec
->vtx
.arrays
[i
].BufferObj
,
1158 /* Free the vertex buffer. Unmap first if needed.
1160 if (_mesa_bufferobj_mapped(exec
->vtx
.bufferobj
, MAP_INTERNAL
)) {
1161 ctx
->Driver
.UnmapBuffer(ctx
, exec
->vtx
.bufferobj
, MAP_INTERNAL
);
1163 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1168 * Called upon first glVertex, glColor, glTexCoord, etc.
1170 void vbo_exec_BeginVertices( struct gl_context
*ctx
)
1172 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1174 vbo_exec_vtx_map( exec
);
1176 assert((ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
) == 0);
1177 assert(exec
->begin_vertices_flags
);
1179 ctx
->Driver
.NeedFlush
|= exec
->begin_vertices_flags
;
1184 * If inside glBegin()/glEnd(), it should assert(0). Otherwise, if
1185 * FLUSH_STORED_VERTICES bit in \p flags is set flushes any buffered
1186 * vertices, if FLUSH_UPDATE_CURRENT bit is set updates
1187 * __struct gl_contextRec::Current and gl_light_attrib::Material
1189 * Note that the default T&L engine never clears the
1190 * FLUSH_UPDATE_CURRENT bit, even after performing the update.
1192 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1194 void vbo_exec_FlushVertices( struct gl_context
*ctx
, GLuint flags
)
1196 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1199 /* debug check: make sure we don't get called recursively */
1200 exec
->flush_call_depth
++;
1201 assert(exec
->flush_call_depth
== 1);
1204 if (_mesa_inside_begin_end(ctx
)) {
1205 /* We've had glBegin but not glEnd! */
1207 exec
->flush_call_depth
--;
1208 assert(exec
->flush_call_depth
== 0);
1213 /* Flush (draw), and make sure VBO is left unmapped when done */
1214 vbo_exec_FlushVertices_internal(exec
, GL_TRUE
);
1216 /* Need to do this to ensure vbo_exec_BeginVertices gets called again:
1218 ctx
->Driver
.NeedFlush
&= ~(FLUSH_UPDATE_CURRENT
| flags
);
1221 exec
->flush_call_depth
--;
1222 assert(exec
->flush_call_depth
== 0);
1227 static void reset_attrfv( struct vbo_exec_context
*exec
)
1231 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1232 exec
->vtx
.attrsz
[i
] = 0;
1233 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1234 exec
->vtx
.active_sz
[i
] = 0;
1237 exec
->vtx
.vertex_size
= 0;
1242 _es_Color4f(GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
1244 vbo_Color4f(r
, g
, b
, a
);
1249 _es_Normal3f(GLfloat x
, GLfloat y
, GLfloat z
)
1251 vbo_Normal3f(x
, y
, z
);
1256 _es_MultiTexCoord4f(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1258 vbo_MultiTexCoord4f(target
, s
, t
, r
, q
);
1263 _es_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
1265 vbo_Materialfv(face
, pname
, params
);
1270 _es_Materialf(GLenum face
, GLenum pname
, GLfloat param
)
1274 p
[1] = p
[2] = p
[3] = 0.0F
;
1275 vbo_Materialfv(face
, pname
, p
);
1280 * A special version of glVertexAttrib4f that does not treat index 0 as
1284 VertexAttrib4f_nopos(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1286 GET_CURRENT_CONTEXT(ctx
);
1287 if (index
< MAX_VERTEX_GENERIC_ATTRIBS
)
1288 ATTRF(VBO_ATTRIB_GENERIC0
+ index
, 4, x
, y
, z
, w
);
1290 ERROR(GL_INVALID_VALUE
);
1294 _es_VertexAttrib4f(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1296 VertexAttrib4f_nopos(index
, x
, y
, z
, w
);
1301 _es_VertexAttrib1f(GLuint indx
, GLfloat x
)
1303 VertexAttrib4f_nopos(indx
, x
, 0.0f
, 0.0f
, 1.0f
);
1308 _es_VertexAttrib1fv(GLuint indx
, const GLfloat
* values
)
1310 VertexAttrib4f_nopos(indx
, values
[0], 0.0f
, 0.0f
, 1.0f
);
1315 _es_VertexAttrib2f(GLuint indx
, GLfloat x
, GLfloat y
)
1317 VertexAttrib4f_nopos(indx
, x
, y
, 0.0f
, 1.0f
);
1322 _es_VertexAttrib2fv(GLuint indx
, const GLfloat
* values
)
1324 VertexAttrib4f_nopos(indx
, values
[0], values
[1], 0.0f
, 1.0f
);
1329 _es_VertexAttrib3f(GLuint indx
, GLfloat x
, GLfloat y
, GLfloat z
)
1331 VertexAttrib4f_nopos(indx
, x
, y
, z
, 1.0f
);
1336 _es_VertexAttrib3fv(GLuint indx
, const GLfloat
* values
)
1338 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], 1.0f
);
1343 _es_VertexAttrib4fv(GLuint indx
, const GLfloat
* values
)
1345 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], values
[3]);