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().
117 vbo_exec_vtx_wrap(struct vbo_exec_context
*exec
)
119 fi_type
*data
= exec
->vtx
.copied
.buffer
;
122 /* Run pipeline on current vertices, copy wrapped vertices
123 * to exec->vtx.copied.
125 vbo_exec_wrap_buffers( exec
);
127 if (!exec
->vtx
.buffer_ptr
) {
128 /* probably ran out of memory earlier when allocating the VBO */
132 /* Copy stored stored vertices to start of new list.
134 assert(exec
->vtx
.max_vert
- exec
->vtx
.vert_count
> exec
->vtx
.copied
.nr
);
136 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
137 memcpy( exec
->vtx
.buffer_ptr
, data
,
138 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
139 exec
->vtx
.buffer_ptr
+= exec
->vtx
.vertex_size
;
140 data
+= exec
->vtx
.vertex_size
;
141 exec
->vtx
.vert_count
++;
144 exec
->vtx
.copied
.nr
= 0;
149 * Copy the active vertex's values to the ctx->Current fields.
151 static void vbo_exec_copy_to_current( struct vbo_exec_context
*exec
)
153 struct gl_context
*ctx
= exec
->ctx
;
154 struct vbo_context
*vbo
= vbo_context(ctx
);
157 for (i
= VBO_ATTRIB_POS
+1 ; i
< VBO_ATTRIB_MAX
; i
++) {
158 if (exec
->vtx
.attrsz
[i
]) {
159 /* Note: the exec->vtx.current[i] pointers point into the
160 * ctx->Current.Attrib and ctx->Light.Material.Attrib arrays.
162 GLfloat
*current
= (GLfloat
*)vbo
->currval
[i
].Ptr
;
163 fi_type tmp
[8]; /* space for doubles */
164 int dmul
= exec
->vtx
.attrtype
[i
] == GL_DOUBLE
? 2 : 1;
166 if (exec
->vtx
.attrtype
[i
] == GL_DOUBLE
) {
167 memset(tmp
, 0, sizeof(tmp
));
168 memcpy(tmp
, exec
->vtx
.attrptr
[i
], exec
->vtx
.attrsz
[i
] * sizeof(GLfloat
));
170 COPY_CLEAN_4V_TYPE_AS_UNION(tmp
,
172 exec
->vtx
.attrptr
[i
],
173 exec
->vtx
.attrtype
[i
]);
176 if (exec
->vtx
.attrtype
[i
] != vbo
->currval
[i
].Type
||
177 memcmp(current
, tmp
, 4 * sizeof(GLfloat
) * dmul
) != 0) {
178 memcpy(current
, tmp
, 4 * sizeof(GLfloat
) * dmul
);
180 /* Given that we explicitly state size here, there is no need
181 * for the COPY_CLEAN above, could just copy 16 bytes and be
182 * done. The only problem is when Mesa accesses ctx->Current
185 /* Size here is in components - not bytes */
186 vbo
->currval
[i
].Size
= exec
->vtx
.attrsz
[i
] / dmul
;
187 vbo
->currval
[i
]._ElementSize
= vbo
->currval
[i
].Size
* sizeof(GLfloat
) * dmul
;
188 vbo
->currval
[i
].Type
= exec
->vtx
.attrtype
[i
];
189 vbo
->currval
[i
].Integer
=
190 vbo_attrtype_to_integer_flag(exec
->vtx
.attrtype
[i
]);
191 vbo
->currval
[i
].Doubles
=
192 vbo_attrtype_to_double_flag(exec
->vtx
.attrtype
[i
]);
194 /* This triggers rather too much recalculation of Mesa state
195 * that doesn't get used (eg light positions).
197 if (i
>= VBO_ATTRIB_MAT_FRONT_AMBIENT
&&
198 i
<= VBO_ATTRIB_MAT_BACK_INDEXES
)
199 ctx
->NewState
|= _NEW_LIGHT
;
201 ctx
->NewState
|= _NEW_CURRENT_ATTRIB
;
206 /* Colormaterial -- this kindof sucks.
208 if (ctx
->Light
.ColorMaterialEnabled
&&
209 exec
->vtx
.attrsz
[VBO_ATTRIB_COLOR0
]) {
210 _mesa_update_color_material(ctx
,
211 ctx
->Current
.Attrib
[VBO_ATTRIB_COLOR0
]);
217 * Copy current vertex attribute values into the current vertex.
220 vbo_exec_copy_from_current(struct vbo_exec_context
*exec
)
222 struct gl_context
*ctx
= exec
->ctx
;
223 struct vbo_context
*vbo
= vbo_context(ctx
);
226 for (i
= VBO_ATTRIB_POS
+ 1; i
< VBO_ATTRIB_MAX
; i
++) {
227 if (exec
->vtx
.attrtype
[i
] == GL_DOUBLE
) {
228 memcpy(exec
->vtx
.attrptr
[i
], vbo
->currval
[i
].Ptr
, exec
->vtx
.attrsz
[i
] * sizeof(GLfloat
));
230 const fi_type
*current
= (fi_type
*) vbo
->currval
[i
].Ptr
;
231 switch (exec
->vtx
.attrsz
[i
]) {
232 case 4: exec
->vtx
.attrptr
[i
][3] = current
[3];
233 case 3: exec
->vtx
.attrptr
[i
][2] = current
[2];
234 case 2: exec
->vtx
.attrptr
[i
][1] = current
[1];
235 case 1: exec
->vtx
.attrptr
[i
][0] = current
[0];
244 * Flush existing data, set new attrib size, replay copied vertices.
245 * This is called when we transition from a small vertex attribute size
246 * to a larger one. Ex: glTexCoord2f -> glTexCoord4f.
247 * We need to go back over the previous 2-component texcoords and insert
248 * zero and one values.
251 vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context
*exec
,
252 GLuint attr
, GLuint newSize
)
254 struct gl_context
*ctx
= exec
->ctx
;
255 struct vbo_context
*vbo
= vbo_context(ctx
);
256 const GLint lastcount
= exec
->vtx
.vert_count
;
257 fi_type
*old_attrptr
[VBO_ATTRIB_MAX
];
258 const GLuint old_vtx_size
= exec
->vtx
.vertex_size
; /* floats per vertex */
259 const GLuint oldSize
= exec
->vtx
.attrsz
[attr
];
262 /* Run pipeline on current vertices, copy wrapped vertices
263 * to exec->vtx.copied.
265 vbo_exec_wrap_buffers( exec
);
267 if (unlikely(exec
->vtx
.copied
.nr
)) {
268 /* We're in the middle of a primitive, keep the old vertex
269 * format around to be able to translate the copied vertices to
272 memcpy(old_attrptr
, exec
->vtx
.attrptr
, sizeof(old_attrptr
));
275 if (unlikely(oldSize
)) {
276 /* Do a COPY_TO_CURRENT to ensure back-copying works for the
277 * case when the attribute already exists in the vertex and is
278 * having its size increased.
280 vbo_exec_copy_to_current( exec
);
283 /* Heuristic: Attempt to isolate attributes received outside
284 * begin/end so that they don't bloat the vertices.
286 if (!_mesa_inside_begin_end(ctx
) &&
287 !oldSize
&& lastcount
> 8 && exec
->vtx
.vertex_size
) {
288 vbo_exec_copy_to_current( exec
);
289 reset_attrfv( exec
);
294 exec
->vtx
.attrsz
[attr
] = newSize
;
295 exec
->vtx
.vertex_size
+= newSize
- oldSize
;
296 exec
->vtx
.max_vert
= ((VBO_VERT_BUFFER_SIZE
- exec
->vtx
.buffer_used
) /
297 (exec
->vtx
.vertex_size
* sizeof(GLfloat
)));
298 exec
->vtx
.vert_count
= 0;
299 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
301 if (unlikely(oldSize
)) {
302 /* Size changed, recalculate all the attrptr[] values
304 fi_type
*tmp
= exec
->vtx
.vertex
;
306 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
307 if (exec
->vtx
.attrsz
[i
]) {
308 exec
->vtx
.attrptr
[i
] = tmp
;
309 tmp
+= exec
->vtx
.attrsz
[i
];
312 exec
->vtx
.attrptr
[i
] = NULL
; /* will not be dereferenced */
315 /* Copy from current to repopulate the vertex with correct
318 vbo_exec_copy_from_current( exec
);
321 /* Just have to append the new attribute at the end */
322 exec
->vtx
.attrptr
[attr
] = exec
->vtx
.vertex
+
323 exec
->vtx
.vertex_size
- newSize
;
326 /* Replay stored vertices to translate them
327 * to new format here.
329 * -- No need to replay - just copy piecewise
331 if (unlikely(exec
->vtx
.copied
.nr
)) {
332 fi_type
*data
= exec
->vtx
.copied
.buffer
;
333 fi_type
*dest
= exec
->vtx
.buffer_ptr
;
336 assert(exec
->vtx
.buffer_ptr
== exec
->vtx
.buffer_map
);
338 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
339 for (j
= 0 ; j
< VBO_ATTRIB_MAX
; j
++) {
340 GLuint sz
= exec
->vtx
.attrsz
[j
];
343 GLint old_offset
= old_attrptr
[j
] - exec
->vtx
.vertex
;
344 GLint new_offset
= exec
->vtx
.attrptr
[j
] - exec
->vtx
.vertex
;
349 COPY_CLEAN_4V_TYPE_AS_UNION(tmp
, oldSize
,
351 exec
->vtx
.attrtype
[j
]);
352 COPY_SZ_4V(dest
+ new_offset
, newSize
, tmp
);
354 fi_type
*current
= (fi_type
*)vbo
->currval
[j
].Ptr
;
355 COPY_SZ_4V(dest
+ new_offset
, sz
, current
);
359 COPY_SZ_4V(dest
+ new_offset
, sz
, data
+ old_offset
);
364 data
+= old_vtx_size
;
365 dest
+= exec
->vtx
.vertex_size
;
368 exec
->vtx
.buffer_ptr
= dest
;
369 exec
->vtx
.vert_count
+= exec
->vtx
.copied
.nr
;
370 exec
->vtx
.copied
.nr
= 0;
376 * This is when a vertex attribute transitions to a different size.
377 * For example, we saw a bunch of glTexCoord2f() calls and now we got a
378 * glTexCoord4f() call. We promote the array from size=2 to size=4.
379 * \param newSize size of new vertex (number of 32-bit words).
382 vbo_exec_fixup_vertex(struct gl_context
*ctx
, GLuint attr
,
383 GLuint newSize
, GLenum newType
)
385 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
387 if (newSize
> exec
->vtx
.attrsz
[attr
] ||
388 newType
!= exec
->vtx
.attrtype
[attr
]) {
389 /* New size is larger. Need to flush existing vertices and get
390 * an enlarged vertex format.
392 vbo_exec_wrap_upgrade_vertex( exec
, attr
, newSize
);
394 else if (newSize
< exec
->vtx
.active_sz
[attr
]) {
397 vbo_get_default_vals_as_union(exec
->vtx
.attrtype
[attr
]);
399 /* New size is smaller - just need to fill in some
400 * zeros. Don't need to flush or wrap.
402 for (i
= newSize
; i
<= exec
->vtx
.attrsz
[attr
]; i
++)
403 exec
->vtx
.attrptr
[attr
][i
-1] = id
[i
-1];
406 exec
->vtx
.active_sz
[attr
] = newSize
;
408 /* Does setting NeedFlush belong here? Necessitates resetting
409 * vtxfmt on each flush (otherwise flags won't get reset
413 ctx
->Driver
.NeedFlush
|= FLUSH_STORED_VERTICES
;
418 * Called upon first glVertex, glColor, glTexCoord, etc.
421 vbo_exec_begin_vertices(struct gl_context
*ctx
)
423 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
425 vbo_exec_vtx_map( exec
);
427 assert((ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
) == 0);
428 assert(exec
->begin_vertices_flags
);
430 ctx
->Driver
.NeedFlush
|= exec
->begin_vertices_flags
;
435 * This macro is used to implement all the glVertex, glColor, glTexCoord,
436 * glVertexAttrib, etc functions.
437 * \param A attribute index
438 * \param N attribute size (1..4)
439 * \param T type (GL_FLOAT, GL_DOUBLE, GL_INT, GL_UNSIGNED_INT)
440 * \param C cast type (fi_type or double)
441 * \param V0, V1, v2, V3 attribute value
443 #define ATTR_UNION( A, N, T, C, V0, V1, V2, V3 ) \
445 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
446 int sz = (sizeof(C) / sizeof(GLfloat)); \
448 assert(sz == 1 || sz == 2); \
450 /* check if attribute size or type is changing */ \
451 if (unlikely(exec->vtx.active_sz[A] != N * sz) || \
452 unlikely(exec->vtx.attrtype[A] != T)) { \
453 vbo_exec_fixup_vertex(ctx, A, N * sz, T); \
456 /* store vertex attribute in vertex buffer */ \
458 C *dest = (C *)exec->vtx.attrptr[A]; \
459 if (N>0) dest[0] = V0; \
460 if (N>1) dest[1] = V1; \
461 if (N>2) dest[2] = V2; \
462 if (N>3) dest[3] = V3; \
463 exec->vtx.attrtype[A] = T; \
467 /* This is a glVertex call */ \
470 if (unlikely((ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) == 0)) { \
471 vbo_exec_begin_vertices(ctx); \
474 if (unlikely(!exec->vtx.buffer_ptr)) { \
475 vbo_exec_vtx_map(exec); \
477 assert(exec->vtx.buffer_ptr); \
479 /* copy 32-bit words */ \
480 for (i = 0; i < exec->vtx.vertex_size; i++) \
481 exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i]; \
483 exec->vtx.buffer_ptr += exec->vtx.vertex_size; \
485 /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \
486 /* something to draw (not just updating a color or texcoord).*/ \
487 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \
489 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
490 vbo_exec_vtx_wrap( exec ); \
492 /* we now have accumulated per-vertex attributes */ \
493 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
497 #define ERROR(err) _mesa_error( ctx, err, __func__ )
498 #define TAG(x) vbo_##x
500 #include "vbo_attrib_tmp.h"
505 * Execute a glMaterial call. Note that if GL_COLOR_MATERIAL is enabled,
506 * this may be a (partial) no-op.
508 static void GLAPIENTRY
509 vbo_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
511 GLbitfield updateMats
;
512 GET_CURRENT_CONTEXT(ctx
);
514 /* This function should be a no-op when it tries to update material
515 * attributes which are currently tracking glColor via glColorMaterial.
516 * The updateMats var will be a mask of the MAT_BIT_FRONT/BACK_x bits
517 * indicating which material attributes can actually be updated below.
519 if (ctx
->Light
.ColorMaterialEnabled
) {
520 updateMats
= ~ctx
->Light
._ColorMaterialBitmask
;
523 /* GL_COLOR_MATERIAL is disabled so don't skip any material updates */
524 updateMats
= ALL_MATERIAL_BITS
;
527 if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_FRONT
) {
528 updateMats
&= FRONT_MATERIAL_BITS
;
530 else if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_BACK
) {
531 updateMats
&= BACK_MATERIAL_BITS
;
533 else if (face
!= GL_FRONT_AND_BACK
) {
534 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterial(invalid face)");
540 if (updateMats
& MAT_BIT_FRONT_EMISSION
)
541 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_EMISSION
, 4, params
);
542 if (updateMats
& MAT_BIT_BACK_EMISSION
)
543 MAT_ATTR(VBO_ATTRIB_MAT_BACK_EMISSION
, 4, params
);
546 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
547 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
548 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
549 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
552 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
553 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
554 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
555 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
558 if (updateMats
& MAT_BIT_FRONT_SPECULAR
)
559 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SPECULAR
, 4, params
);
560 if (updateMats
& MAT_BIT_BACK_SPECULAR
)
561 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SPECULAR
, 4, params
);
564 if (*params
< 0 || *params
> ctx
->Const
.MaxShininess
) {
565 _mesa_error(ctx
, GL_INVALID_VALUE
,
566 "glMaterial(invalid shininess: %f out range [0, %f])",
567 *params
, ctx
->Const
.MaxShininess
);
570 if (updateMats
& MAT_BIT_FRONT_SHININESS
)
571 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SHININESS
, 1, params
);
572 if (updateMats
& MAT_BIT_BACK_SHININESS
)
573 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SHININESS
, 1, params
);
575 case GL_COLOR_INDEXES
:
576 if (ctx
->API
!= API_OPENGL_COMPAT
) {
577 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
580 if (updateMats
& MAT_BIT_FRONT_INDEXES
)
581 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_INDEXES
, 3, params
);
582 if (updateMats
& MAT_BIT_BACK_INDEXES
)
583 MAT_ATTR(VBO_ATTRIB_MAT_BACK_INDEXES
, 3, params
);
585 case GL_AMBIENT_AND_DIFFUSE
:
586 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
587 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
588 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
589 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
590 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
591 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
592 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
593 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
596 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
603 * Flush (draw) vertices.
604 * \param unmap - leave VBO unmapped after flushing?
607 vbo_exec_FlushVertices_internal(struct vbo_exec_context
*exec
, GLboolean unmap
)
609 if (exec
->vtx
.vert_count
|| unmap
) {
610 vbo_exec_vtx_flush( exec
, unmap
);
613 if (exec
->vtx
.vertex_size
) {
614 vbo_exec_copy_to_current( exec
);
615 reset_attrfv( exec
);
620 static void GLAPIENTRY
vbo_exec_EvalCoord1f( GLfloat u
)
622 GET_CURRENT_CONTEXT( ctx
);
623 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
627 if (exec
->eval
.recalculate_maps
)
628 vbo_exec_eval_update( exec
);
630 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
631 if (exec
->eval
.map1
[i
].map
)
632 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map1
[i
].sz
)
633 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map1
[i
].sz
, GL_FLOAT
);
638 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
639 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
641 vbo_exec_do_EvalCoord1f( exec
, u
);
643 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
644 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
647 static void GLAPIENTRY
vbo_exec_EvalCoord2f( GLfloat u
, GLfloat v
)
649 GET_CURRENT_CONTEXT( ctx
);
650 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
654 if (exec
->eval
.recalculate_maps
)
655 vbo_exec_eval_update( exec
);
657 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
658 if (exec
->eval
.map2
[i
].map
)
659 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map2
[i
].sz
)
660 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map2
[i
].sz
, GL_FLOAT
);
663 if (ctx
->Eval
.AutoNormal
)
664 if (exec
->vtx
.active_sz
[VBO_ATTRIB_NORMAL
] != 3)
665 vbo_exec_fixup_vertex( ctx
, VBO_ATTRIB_NORMAL
, 3, GL_FLOAT
);
668 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
669 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
671 vbo_exec_do_EvalCoord2f( exec
, u
, v
);
673 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
674 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
677 static void GLAPIENTRY
vbo_exec_EvalCoord1fv( const GLfloat
*u
)
679 vbo_exec_EvalCoord1f( u
[0] );
682 static void GLAPIENTRY
vbo_exec_EvalCoord2fv( const GLfloat
*u
)
684 vbo_exec_EvalCoord2f( u
[0], u
[1] );
687 static void GLAPIENTRY
vbo_exec_EvalPoint1( GLint i
)
689 GET_CURRENT_CONTEXT( ctx
);
690 GLfloat du
= ((ctx
->Eval
.MapGrid1u2
- ctx
->Eval
.MapGrid1u1
) /
691 (GLfloat
) ctx
->Eval
.MapGrid1un
);
692 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid1u1
;
694 vbo_exec_EvalCoord1f( u
);
698 static void GLAPIENTRY
vbo_exec_EvalPoint2( GLint i
, GLint j
)
700 GET_CURRENT_CONTEXT( ctx
);
701 GLfloat du
= ((ctx
->Eval
.MapGrid2u2
- ctx
->Eval
.MapGrid2u1
) /
702 (GLfloat
) ctx
->Eval
.MapGrid2un
);
703 GLfloat dv
= ((ctx
->Eval
.MapGrid2v2
- ctx
->Eval
.MapGrid2v1
) /
704 (GLfloat
) ctx
->Eval
.MapGrid2vn
);
705 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid2u1
;
706 GLfloat v
= j
* dv
+ ctx
->Eval
.MapGrid2v1
;
708 vbo_exec_EvalCoord2f( u
, v
);
713 * Called via glBegin.
715 static void GLAPIENTRY
vbo_exec_Begin( GLenum mode
)
717 GET_CURRENT_CONTEXT( ctx
);
718 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
721 if (_mesa_inside_begin_end(ctx
)) {
722 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glBegin");
726 if (!_mesa_valid_prim_mode(ctx
, mode
, "glBegin")) {
730 vbo_draw_method(vbo_context(ctx
), DRAW_BEGIN_END
);
733 _mesa_update_state( ctx
);
735 CALL_Begin(ctx
->Exec
, (mode
));
739 if (!_mesa_valid_to_render(ctx
, "glBegin")) {
743 /* Heuristic: attempt to isolate attributes occurring outside
746 if (exec
->vtx
.vertex_size
&& !exec
->vtx
.attrsz
[0])
747 vbo_exec_FlushVertices_internal(exec
, GL_FALSE
);
749 i
= exec
->vtx
.prim_count
++;
750 exec
->vtx
.prim
[i
].mode
= mode
;
751 exec
->vtx
.prim
[i
].begin
= 1;
752 exec
->vtx
.prim
[i
].end
= 0;
753 exec
->vtx
.prim
[i
].indexed
= 0;
754 exec
->vtx
.prim
[i
].weak
= 0;
755 exec
->vtx
.prim
[i
].pad
= 0;
756 exec
->vtx
.prim
[i
].start
= exec
->vtx
.vert_count
;
757 exec
->vtx
.prim
[i
].count
= 0;
758 exec
->vtx
.prim
[i
].num_instances
= 1;
759 exec
->vtx
.prim
[i
].base_instance
= 0;
760 exec
->vtx
.prim
[i
].is_indirect
= 0;
762 ctx
->Driver
.CurrentExecPrimitive
= mode
;
764 ctx
->Exec
= ctx
->BeginEnd
;
765 /* We may have been called from a display list, in which case we should
766 * leave dlist.c's dispatch table in place.
768 if (ctx
->CurrentDispatch
== ctx
->OutsideBeginEnd
) {
769 ctx
->CurrentDispatch
= ctx
->BeginEnd
;
770 _glapi_set_dispatch(ctx
->CurrentDispatch
);
772 assert(ctx
->CurrentDispatch
== ctx
->Save
);
778 * Try to merge / concatenate the two most recent VBO primitives.
781 try_vbo_merge(struct vbo_exec_context
*exec
)
783 struct _mesa_prim
*cur
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
785 assert(exec
->vtx
.prim_count
>= 1);
787 vbo_try_prim_conversion(cur
);
789 if (exec
->vtx
.prim_count
>= 2) {
790 struct _mesa_prim
*prev
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 2];
791 assert(prev
== cur
- 1);
793 if (vbo_can_merge_prims(prev
, cur
)) {
798 vbo_merge_prims(prev
, cur
);
799 exec
->vtx
.prim_count
--; /* drop the last primitive */
808 static void GLAPIENTRY
vbo_exec_End( void )
810 GET_CURRENT_CONTEXT( ctx
);
811 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
813 if (!_mesa_inside_begin_end(ctx
)) {
814 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glEnd");
818 ctx
->Exec
= ctx
->OutsideBeginEnd
;
819 if (ctx
->CurrentDispatch
== ctx
->BeginEnd
) {
820 ctx
->CurrentDispatch
= ctx
->OutsideBeginEnd
;
821 _glapi_set_dispatch(ctx
->CurrentDispatch
);
824 if (exec
->vtx
.prim_count
> 0) {
825 /* close off current primitive */
826 int idx
= exec
->vtx
.vert_count
;
827 int i
= exec
->vtx
.prim_count
- 1;
829 exec
->vtx
.prim
[i
].end
= 1;
830 exec
->vtx
.prim
[i
].count
= idx
- exec
->vtx
.prim
[i
].start
;
835 ctx
->Driver
.CurrentExecPrimitive
= PRIM_OUTSIDE_BEGIN_END
;
837 if (exec
->vtx
.prim_count
== VBO_MAX_PRIM
)
838 vbo_exec_vtx_flush( exec
, GL_FALSE
);
840 if (MESA_DEBUG_FLAGS
& DEBUG_ALWAYS_FLUSH
) {
847 * Called via glPrimitiveRestartNV()
849 static void GLAPIENTRY
850 vbo_exec_PrimitiveRestartNV(void)
853 GET_CURRENT_CONTEXT( ctx
);
855 curPrim
= ctx
->Driver
.CurrentExecPrimitive
;
857 if (curPrim
== PRIM_OUTSIDE_BEGIN_END
) {
858 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glPrimitiveRestartNV" );
862 vbo_exec_Begin(curPrim
);
868 static void vbo_exec_vtxfmt_init( struct vbo_exec_context
*exec
)
870 struct gl_context
*ctx
= exec
->ctx
;
871 GLvertexformat
*vfmt
= &exec
->vtxfmt
;
873 vfmt
->ArrayElement
= _ae_ArrayElement
;
875 vfmt
->Begin
= vbo_exec_Begin
;
876 vfmt
->End
= vbo_exec_End
;
877 vfmt
->PrimitiveRestartNV
= vbo_exec_PrimitiveRestartNV
;
879 vfmt
->CallList
= _mesa_CallList
;
880 vfmt
->CallLists
= _mesa_CallLists
;
882 vfmt
->EvalCoord1f
= vbo_exec_EvalCoord1f
;
883 vfmt
->EvalCoord1fv
= vbo_exec_EvalCoord1fv
;
884 vfmt
->EvalCoord2f
= vbo_exec_EvalCoord2f
;
885 vfmt
->EvalCoord2fv
= vbo_exec_EvalCoord2fv
;
886 vfmt
->EvalPoint1
= vbo_exec_EvalPoint1
;
887 vfmt
->EvalPoint2
= vbo_exec_EvalPoint2
;
889 /* from attrib_tmp.h:
891 vfmt
->Color3f
= vbo_Color3f
;
892 vfmt
->Color3fv
= vbo_Color3fv
;
893 vfmt
->Color4f
= vbo_Color4f
;
894 vfmt
->Color4fv
= vbo_Color4fv
;
895 vfmt
->FogCoordfEXT
= vbo_FogCoordfEXT
;
896 vfmt
->FogCoordfvEXT
= vbo_FogCoordfvEXT
;
897 vfmt
->MultiTexCoord1fARB
= vbo_MultiTexCoord1f
;
898 vfmt
->MultiTexCoord1fvARB
= vbo_MultiTexCoord1fv
;
899 vfmt
->MultiTexCoord2fARB
= vbo_MultiTexCoord2f
;
900 vfmt
->MultiTexCoord2fvARB
= vbo_MultiTexCoord2fv
;
901 vfmt
->MultiTexCoord3fARB
= vbo_MultiTexCoord3f
;
902 vfmt
->MultiTexCoord3fvARB
= vbo_MultiTexCoord3fv
;
903 vfmt
->MultiTexCoord4fARB
= vbo_MultiTexCoord4f
;
904 vfmt
->MultiTexCoord4fvARB
= vbo_MultiTexCoord4fv
;
905 vfmt
->Normal3f
= vbo_Normal3f
;
906 vfmt
->Normal3fv
= vbo_Normal3fv
;
907 vfmt
->SecondaryColor3fEXT
= vbo_SecondaryColor3fEXT
;
908 vfmt
->SecondaryColor3fvEXT
= vbo_SecondaryColor3fvEXT
;
909 vfmt
->TexCoord1f
= vbo_TexCoord1f
;
910 vfmt
->TexCoord1fv
= vbo_TexCoord1fv
;
911 vfmt
->TexCoord2f
= vbo_TexCoord2f
;
912 vfmt
->TexCoord2fv
= vbo_TexCoord2fv
;
913 vfmt
->TexCoord3f
= vbo_TexCoord3f
;
914 vfmt
->TexCoord3fv
= vbo_TexCoord3fv
;
915 vfmt
->TexCoord4f
= vbo_TexCoord4f
;
916 vfmt
->TexCoord4fv
= vbo_TexCoord4fv
;
917 vfmt
->Vertex2f
= vbo_Vertex2f
;
918 vfmt
->Vertex2fv
= vbo_Vertex2fv
;
919 vfmt
->Vertex3f
= vbo_Vertex3f
;
920 vfmt
->Vertex3fv
= vbo_Vertex3fv
;
921 vfmt
->Vertex4f
= vbo_Vertex4f
;
922 vfmt
->Vertex4fv
= vbo_Vertex4fv
;
924 if (ctx
->API
== API_OPENGLES2
) {
925 vfmt
->VertexAttrib1fARB
= _es_VertexAttrib1f
;
926 vfmt
->VertexAttrib1fvARB
= _es_VertexAttrib1fv
;
927 vfmt
->VertexAttrib2fARB
= _es_VertexAttrib2f
;
928 vfmt
->VertexAttrib2fvARB
= _es_VertexAttrib2fv
;
929 vfmt
->VertexAttrib3fARB
= _es_VertexAttrib3f
;
930 vfmt
->VertexAttrib3fvARB
= _es_VertexAttrib3fv
;
931 vfmt
->VertexAttrib4fARB
= _es_VertexAttrib4f
;
932 vfmt
->VertexAttrib4fvARB
= _es_VertexAttrib4fv
;
934 vfmt
->VertexAttrib1fARB
= vbo_VertexAttrib1fARB
;
935 vfmt
->VertexAttrib1fvARB
= vbo_VertexAttrib1fvARB
;
936 vfmt
->VertexAttrib2fARB
= vbo_VertexAttrib2fARB
;
937 vfmt
->VertexAttrib2fvARB
= vbo_VertexAttrib2fvARB
;
938 vfmt
->VertexAttrib3fARB
= vbo_VertexAttrib3fARB
;
939 vfmt
->VertexAttrib3fvARB
= vbo_VertexAttrib3fvARB
;
940 vfmt
->VertexAttrib4fARB
= vbo_VertexAttrib4fARB
;
941 vfmt
->VertexAttrib4fvARB
= vbo_VertexAttrib4fvARB
;
944 /* Note that VertexAttrib4fNV is used from dlist.c and api_arrayelt.c so
945 * they can have a single entrypoint for updating any of the legacy
948 vfmt
->VertexAttrib1fNV
= vbo_VertexAttrib1fNV
;
949 vfmt
->VertexAttrib1fvNV
= vbo_VertexAttrib1fvNV
;
950 vfmt
->VertexAttrib2fNV
= vbo_VertexAttrib2fNV
;
951 vfmt
->VertexAttrib2fvNV
= vbo_VertexAttrib2fvNV
;
952 vfmt
->VertexAttrib3fNV
= vbo_VertexAttrib3fNV
;
953 vfmt
->VertexAttrib3fvNV
= vbo_VertexAttrib3fvNV
;
954 vfmt
->VertexAttrib4fNV
= vbo_VertexAttrib4fNV
;
955 vfmt
->VertexAttrib4fvNV
= vbo_VertexAttrib4fvNV
;
958 vfmt
->VertexAttribI1i
= vbo_VertexAttribI1i
;
959 vfmt
->VertexAttribI2i
= vbo_VertexAttribI2i
;
960 vfmt
->VertexAttribI3i
= vbo_VertexAttribI3i
;
961 vfmt
->VertexAttribI4i
= vbo_VertexAttribI4i
;
962 vfmt
->VertexAttribI2iv
= vbo_VertexAttribI2iv
;
963 vfmt
->VertexAttribI3iv
= vbo_VertexAttribI3iv
;
964 vfmt
->VertexAttribI4iv
= vbo_VertexAttribI4iv
;
966 /* unsigned integer-valued */
967 vfmt
->VertexAttribI1ui
= vbo_VertexAttribI1ui
;
968 vfmt
->VertexAttribI2ui
= vbo_VertexAttribI2ui
;
969 vfmt
->VertexAttribI3ui
= vbo_VertexAttribI3ui
;
970 vfmt
->VertexAttribI4ui
= vbo_VertexAttribI4ui
;
971 vfmt
->VertexAttribI2uiv
= vbo_VertexAttribI2uiv
;
972 vfmt
->VertexAttribI3uiv
= vbo_VertexAttribI3uiv
;
973 vfmt
->VertexAttribI4uiv
= vbo_VertexAttribI4uiv
;
975 vfmt
->Materialfv
= vbo_Materialfv
;
977 vfmt
->EdgeFlag
= vbo_EdgeFlag
;
978 vfmt
->Indexf
= vbo_Indexf
;
979 vfmt
->Indexfv
= vbo_Indexfv
;
981 /* ARB_vertex_type_2_10_10_10_rev */
982 vfmt
->VertexP2ui
= vbo_VertexP2ui
;
983 vfmt
->VertexP2uiv
= vbo_VertexP2uiv
;
984 vfmt
->VertexP3ui
= vbo_VertexP3ui
;
985 vfmt
->VertexP3uiv
= vbo_VertexP3uiv
;
986 vfmt
->VertexP4ui
= vbo_VertexP4ui
;
987 vfmt
->VertexP4uiv
= vbo_VertexP4uiv
;
989 vfmt
->TexCoordP1ui
= vbo_TexCoordP1ui
;
990 vfmt
->TexCoordP1uiv
= vbo_TexCoordP1uiv
;
991 vfmt
->TexCoordP2ui
= vbo_TexCoordP2ui
;
992 vfmt
->TexCoordP2uiv
= vbo_TexCoordP2uiv
;
993 vfmt
->TexCoordP3ui
= vbo_TexCoordP3ui
;
994 vfmt
->TexCoordP3uiv
= vbo_TexCoordP3uiv
;
995 vfmt
->TexCoordP4ui
= vbo_TexCoordP4ui
;
996 vfmt
->TexCoordP4uiv
= vbo_TexCoordP4uiv
;
998 vfmt
->MultiTexCoordP1ui
= vbo_MultiTexCoordP1ui
;
999 vfmt
->MultiTexCoordP1uiv
= vbo_MultiTexCoordP1uiv
;
1000 vfmt
->MultiTexCoordP2ui
= vbo_MultiTexCoordP2ui
;
1001 vfmt
->MultiTexCoordP2uiv
= vbo_MultiTexCoordP2uiv
;
1002 vfmt
->MultiTexCoordP3ui
= vbo_MultiTexCoordP3ui
;
1003 vfmt
->MultiTexCoordP3uiv
= vbo_MultiTexCoordP3uiv
;
1004 vfmt
->MultiTexCoordP4ui
= vbo_MultiTexCoordP4ui
;
1005 vfmt
->MultiTexCoordP4uiv
= vbo_MultiTexCoordP4uiv
;
1007 vfmt
->NormalP3ui
= vbo_NormalP3ui
;
1008 vfmt
->NormalP3uiv
= vbo_NormalP3uiv
;
1010 vfmt
->ColorP3ui
= vbo_ColorP3ui
;
1011 vfmt
->ColorP3uiv
= vbo_ColorP3uiv
;
1012 vfmt
->ColorP4ui
= vbo_ColorP4ui
;
1013 vfmt
->ColorP4uiv
= vbo_ColorP4uiv
;
1015 vfmt
->SecondaryColorP3ui
= vbo_SecondaryColorP3ui
;
1016 vfmt
->SecondaryColorP3uiv
= vbo_SecondaryColorP3uiv
;
1018 vfmt
->VertexAttribP1ui
= vbo_VertexAttribP1ui
;
1019 vfmt
->VertexAttribP1uiv
= vbo_VertexAttribP1uiv
;
1020 vfmt
->VertexAttribP2ui
= vbo_VertexAttribP2ui
;
1021 vfmt
->VertexAttribP2uiv
= vbo_VertexAttribP2uiv
;
1022 vfmt
->VertexAttribP3ui
= vbo_VertexAttribP3ui
;
1023 vfmt
->VertexAttribP3uiv
= vbo_VertexAttribP3uiv
;
1024 vfmt
->VertexAttribP4ui
= vbo_VertexAttribP4ui
;
1025 vfmt
->VertexAttribP4uiv
= vbo_VertexAttribP4uiv
;
1027 vfmt
->VertexAttribL1d
= vbo_VertexAttribL1d
;
1028 vfmt
->VertexAttribL2d
= vbo_VertexAttribL2d
;
1029 vfmt
->VertexAttribL3d
= vbo_VertexAttribL3d
;
1030 vfmt
->VertexAttribL4d
= vbo_VertexAttribL4d
;
1032 vfmt
->VertexAttribL1dv
= vbo_VertexAttribL1dv
;
1033 vfmt
->VertexAttribL2dv
= vbo_VertexAttribL2dv
;
1034 vfmt
->VertexAttribL3dv
= vbo_VertexAttribL3dv
;
1035 vfmt
->VertexAttribL4dv
= vbo_VertexAttribL4dv
;
1040 * Tell the VBO module to use a real OpenGL vertex buffer object to
1041 * store accumulated immediate-mode vertex data.
1042 * This replaces the malloced buffer which was created in
1043 * vb_exec_vtx_init() below.
1045 void vbo_use_buffer_objects(struct gl_context
*ctx
)
1047 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1048 /* Any buffer name but 0 can be used here since this bufferobj won't
1049 * go into the bufferobj hashtable.
1051 GLuint bufName
= IMM_BUFFER_NAME
;
1052 GLenum target
= GL_ARRAY_BUFFER_ARB
;
1053 GLenum usage
= GL_STREAM_DRAW_ARB
;
1054 GLsizei size
= VBO_VERT_BUFFER_SIZE
;
1056 /* Make sure this func is only used once */
1057 assert(exec
->vtx
.bufferobj
== ctx
->Shared
->NullBufferObj
);
1059 _mesa_align_free(exec
->vtx
.buffer_map
);
1060 exec
->vtx
.buffer_map
= NULL
;
1061 exec
->vtx
.buffer_ptr
= NULL
;
1063 /* Allocate a real buffer object now */
1064 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1065 exec
->vtx
.bufferobj
= ctx
->Driver
.NewBufferObject(ctx
, bufName
);
1066 if (!ctx
->Driver
.BufferData(ctx
, target
, size
, NULL
, usage
,
1068 GL_DYNAMIC_STORAGE_BIT
|
1069 GL_CLIENT_STORAGE_BIT
,
1070 exec
->vtx
.bufferobj
)) {
1071 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "VBO allocation");
1077 * If this function is called, all VBO buffers will be unmapped when
1079 * Otherwise, if a simple command like glColor3f() is called and we flush,
1080 * the current VBO may be left mapped.
1083 vbo_always_unmap_buffers(struct gl_context
*ctx
)
1085 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1086 exec
->begin_vertices_flags
|= FLUSH_STORED_VERTICES
;
1090 void vbo_exec_vtx_init( struct vbo_exec_context
*exec
)
1092 struct gl_context
*ctx
= exec
->ctx
;
1093 struct vbo_context
*vbo
= vbo_context(ctx
);
1096 /* Allocate a buffer object. Will just reuse this object
1097 * continuously, unless vbo_use_buffer_objects() is called to enable
1100 _mesa_reference_buffer_object(ctx
,
1101 &exec
->vtx
.bufferobj
,
1102 ctx
->Shared
->NullBufferObj
);
1104 assert(!exec
->vtx
.buffer_map
);
1105 exec
->vtx
.buffer_map
= _mesa_align_malloc(VBO_VERT_BUFFER_SIZE
, 64);
1106 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
1108 vbo_exec_vtxfmt_init( exec
);
1109 _mesa_noop_vtxfmt_init(&exec
->vtxfmt_noop
);
1111 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1112 assert(i
< ARRAY_SIZE(exec
->vtx
.attrsz
));
1113 exec
->vtx
.attrsz
[i
] = 0;
1114 assert(i
< ARRAY_SIZE(exec
->vtx
.attrtype
));
1115 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1116 assert(i
< ARRAY_SIZE(exec
->vtx
.active_sz
));
1117 exec
->vtx
.active_sz
[i
] = 0;
1119 for (i
= 0 ; i
< VERT_ATTRIB_MAX
; i
++) {
1120 assert(i
< ARRAY_SIZE(exec
->vtx
.inputs
));
1121 assert(i
< ARRAY_SIZE(exec
->vtx
.arrays
));
1122 exec
->vtx
.inputs
[i
] = &exec
->vtx
.arrays
[i
];
1126 struct gl_client_array
*arrays
= exec
->vtx
.arrays
;
1129 memcpy(arrays
, &vbo
->currval
[VBO_ATTRIB_POS
],
1130 VERT_ATTRIB_FF_MAX
* sizeof(arrays
[0]));
1131 for (i
= 0; i
< VERT_ATTRIB_FF_MAX
; ++i
) {
1132 struct gl_client_array
*array
;
1133 array
= &arrays
[VERT_ATTRIB_FF(i
)];
1134 array
->BufferObj
= NULL
;
1135 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1136 vbo
->currval
[VBO_ATTRIB_POS
+i
].BufferObj
);
1139 memcpy(arrays
+ VERT_ATTRIB_GENERIC(0),
1140 &vbo
->currval
[VBO_ATTRIB_GENERIC0
],
1141 VERT_ATTRIB_GENERIC_MAX
* sizeof(arrays
[0]));
1143 for (i
= 0; i
< VERT_ATTRIB_GENERIC_MAX
; ++i
) {
1144 struct gl_client_array
*array
;
1145 array
= &arrays
[VERT_ATTRIB_GENERIC(i
)];
1146 array
->BufferObj
= NULL
;
1147 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1148 vbo
->currval
[VBO_ATTRIB_GENERIC0
+i
].BufferObj
);
1152 exec
->vtx
.vertex_size
= 0;
1154 exec
->begin_vertices_flags
= FLUSH_UPDATE_CURRENT
;
1158 void vbo_exec_vtx_destroy( struct vbo_exec_context
*exec
)
1160 /* using a real VBO for vertex data */
1161 struct gl_context
*ctx
= exec
->ctx
;
1164 /* True VBOs should already be unmapped
1166 if (exec
->vtx
.buffer_map
) {
1167 assert(exec
->vtx
.bufferobj
->Name
== 0 ||
1168 exec
->vtx
.bufferobj
->Name
== IMM_BUFFER_NAME
);
1169 if (exec
->vtx
.bufferobj
->Name
== 0) {
1170 _mesa_align_free(exec
->vtx
.buffer_map
);
1171 exec
->vtx
.buffer_map
= NULL
;
1172 exec
->vtx
.buffer_ptr
= NULL
;
1176 /* Drop any outstanding reference to the vertex buffer
1178 for (i
= 0; i
< ARRAY_SIZE(exec
->vtx
.arrays
); i
++) {
1179 _mesa_reference_buffer_object(ctx
,
1180 &exec
->vtx
.arrays
[i
].BufferObj
,
1184 /* Free the vertex buffer. Unmap first if needed.
1186 if (_mesa_bufferobj_mapped(exec
->vtx
.bufferobj
, MAP_INTERNAL
)) {
1187 ctx
->Driver
.UnmapBuffer(ctx
, exec
->vtx
.bufferobj
, MAP_INTERNAL
);
1189 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1194 * If inside glBegin()/glEnd(), it should assert(0). Otherwise, if
1195 * FLUSH_STORED_VERTICES bit in \p flags is set flushes any buffered
1196 * vertices, if FLUSH_UPDATE_CURRENT bit is set updates
1197 * __struct gl_contextRec::Current and gl_light_attrib::Material
1199 * Note that the default T&L engine never clears the
1200 * FLUSH_UPDATE_CURRENT bit, even after performing the update.
1202 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1204 void vbo_exec_FlushVertices( struct gl_context
*ctx
, GLuint flags
)
1206 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1209 /* debug check: make sure we don't get called recursively */
1210 exec
->flush_call_depth
++;
1211 assert(exec
->flush_call_depth
== 1);
1214 if (_mesa_inside_begin_end(ctx
)) {
1215 /* We've had glBegin but not glEnd! */
1217 exec
->flush_call_depth
--;
1218 assert(exec
->flush_call_depth
== 0);
1223 /* Flush (draw), and make sure VBO is left unmapped when done */
1224 vbo_exec_FlushVertices_internal(exec
, GL_TRUE
);
1226 /* Need to do this to ensure vbo_exec_begin_vertices gets called again:
1228 ctx
->Driver
.NeedFlush
&= ~(FLUSH_UPDATE_CURRENT
| flags
);
1231 exec
->flush_call_depth
--;
1232 assert(exec
->flush_call_depth
== 0);
1237 static void reset_attrfv( struct vbo_exec_context
*exec
)
1241 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1242 exec
->vtx
.attrsz
[i
] = 0;
1243 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1244 exec
->vtx
.active_sz
[i
] = 0;
1247 exec
->vtx
.vertex_size
= 0;
1252 _es_Color4f(GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
1254 vbo_Color4f(r
, g
, b
, a
);
1259 _es_Normal3f(GLfloat x
, GLfloat y
, GLfloat z
)
1261 vbo_Normal3f(x
, y
, z
);
1266 _es_MultiTexCoord4f(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1268 vbo_MultiTexCoord4f(target
, s
, t
, r
, q
);
1273 _es_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
1275 vbo_Materialfv(face
, pname
, params
);
1280 _es_Materialf(GLenum face
, GLenum pname
, GLfloat param
)
1284 p
[1] = p
[2] = p
[3] = 0.0F
;
1285 vbo_Materialfv(face
, pname
, p
);
1290 * A special version of glVertexAttrib4f that does not treat index 0 as
1294 VertexAttrib4f_nopos(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1296 GET_CURRENT_CONTEXT(ctx
);
1297 if (index
< MAX_VERTEX_GENERIC_ATTRIBS
)
1298 ATTRF(VBO_ATTRIB_GENERIC0
+ index
, 4, x
, y
, z
, w
);
1300 ERROR(GL_INVALID_VALUE
);
1304 _es_VertexAttrib4f(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1306 VertexAttrib4f_nopos(index
, x
, y
, z
, w
);
1311 _es_VertexAttrib1f(GLuint indx
, GLfloat x
)
1313 VertexAttrib4f_nopos(indx
, x
, 0.0f
, 0.0f
, 1.0f
);
1318 _es_VertexAttrib1fv(GLuint indx
, const GLfloat
* values
)
1320 VertexAttrib4f_nopos(indx
, values
[0], 0.0f
, 0.0f
, 1.0f
);
1325 _es_VertexAttrib2f(GLuint indx
, GLfloat x
, GLfloat y
)
1327 VertexAttrib4f_nopos(indx
, x
, y
, 0.0f
, 1.0f
);
1332 _es_VertexAttrib2fv(GLuint indx
, const GLfloat
* values
)
1334 VertexAttrib4f_nopos(indx
, values
[0], values
[1], 0.0f
, 1.0f
);
1339 _es_VertexAttrib3f(GLuint indx
, GLfloat x
, GLfloat y
, GLfloat z
)
1341 VertexAttrib4f_nopos(indx
, x
, y
, z
, 1.0f
);
1346 _es_VertexAttrib3fv(GLuint indx
, const GLfloat
* values
)
1348 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], 1.0f
);
1353 _es_VertexAttrib4fv(GLuint indx
, const GLfloat
* values
)
1355 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], values
[3]);