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)); \
427 assert(sz == 1 || sz == 2); \
429 if (unlikely(!(ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT))) { \
430 vbo_exec_BeginVertices(ctx); \
433 /* check if attribute size or type is changing */ \
434 if (unlikely(exec->vtx.active_sz[A] != N * sz) || \
435 unlikely(exec->vtx.attrtype[A] != T)) { \
436 vbo_exec_fixup_vertex(ctx, A, N * sz, T); \
439 /* store vertex attribute in vertex buffer */ \
441 C *dest = (C *)exec->vtx.attrptr[A]; \
442 if (N>0) dest[0] = V0; \
443 if (N>1) dest[1] = V1; \
444 if (N>2) dest[2] = V2; \
445 if (N>3) dest[3] = V3; \
446 exec->vtx.attrtype[A] = T; \
450 /* This is a glVertex call */ \
453 /* copy 32-bit words */ \
454 for (i = 0; i < exec->vtx.vertex_size; i++) \
455 exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i]; \
457 exec->vtx.buffer_ptr += exec->vtx.vertex_size; \
459 /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \
460 /* something to draw (not just updating a color or texcoord).*/ \
461 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \
463 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
464 vbo_exec_vtx_wrap( exec ); \
468 #define ERROR(err) _mesa_error( ctx, err, __func__ )
469 #define TAG(x) vbo_##x
471 #include "vbo_attrib_tmp.h"
476 * Execute a glMaterial call. Note that if GL_COLOR_MATERIAL is enabled,
477 * this may be a (partial) no-op.
479 static void GLAPIENTRY
480 vbo_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
482 GLbitfield updateMats
;
483 GET_CURRENT_CONTEXT(ctx
);
485 /* This function should be a no-op when it tries to update material
486 * attributes which are currently tracking glColor via glColorMaterial.
487 * The updateMats var will be a mask of the MAT_BIT_FRONT/BACK_x bits
488 * indicating which material attributes can actually be updated below.
490 if (ctx
->Light
.ColorMaterialEnabled
) {
491 updateMats
= ~ctx
->Light
._ColorMaterialBitmask
;
494 /* GL_COLOR_MATERIAL is disabled so don't skip any material updates */
495 updateMats
= ALL_MATERIAL_BITS
;
498 if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_FRONT
) {
499 updateMats
&= FRONT_MATERIAL_BITS
;
501 else if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_BACK
) {
502 updateMats
&= BACK_MATERIAL_BITS
;
504 else if (face
!= GL_FRONT_AND_BACK
) {
505 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterial(invalid face)");
511 if (updateMats
& MAT_BIT_FRONT_EMISSION
)
512 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_EMISSION
, 4, params
);
513 if (updateMats
& MAT_BIT_BACK_EMISSION
)
514 MAT_ATTR(VBO_ATTRIB_MAT_BACK_EMISSION
, 4, params
);
517 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
518 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
519 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
520 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
523 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
524 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
525 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
526 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
529 if (updateMats
& MAT_BIT_FRONT_SPECULAR
)
530 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SPECULAR
, 4, params
);
531 if (updateMats
& MAT_BIT_BACK_SPECULAR
)
532 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SPECULAR
, 4, params
);
535 if (*params
< 0 || *params
> ctx
->Const
.MaxShininess
) {
536 _mesa_error(ctx
, GL_INVALID_VALUE
,
537 "glMaterial(invalid shininess: %f out range [0, %f])",
538 *params
, ctx
->Const
.MaxShininess
);
541 if (updateMats
& MAT_BIT_FRONT_SHININESS
)
542 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SHININESS
, 1, params
);
543 if (updateMats
& MAT_BIT_BACK_SHININESS
)
544 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SHININESS
, 1, params
);
546 case GL_COLOR_INDEXES
:
547 if (ctx
->API
!= API_OPENGL_COMPAT
) {
548 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
551 if (updateMats
& MAT_BIT_FRONT_INDEXES
)
552 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_INDEXES
, 3, params
);
553 if (updateMats
& MAT_BIT_BACK_INDEXES
)
554 MAT_ATTR(VBO_ATTRIB_MAT_BACK_INDEXES
, 3, params
);
556 case GL_AMBIENT_AND_DIFFUSE
:
557 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
558 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
559 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
560 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
561 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
562 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
563 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
564 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
567 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
574 * Flush (draw) vertices.
575 * \param unmap - leave VBO unmapped after flushing?
578 vbo_exec_FlushVertices_internal(struct vbo_exec_context
*exec
, GLboolean unmap
)
580 if (exec
->vtx
.vert_count
|| unmap
) {
581 vbo_exec_vtx_flush( exec
, unmap
);
584 if (exec
->vtx
.vertex_size
) {
585 vbo_exec_copy_to_current( exec
);
586 reset_attrfv( exec
);
591 static void GLAPIENTRY
vbo_exec_EvalCoord1f( GLfloat u
)
593 GET_CURRENT_CONTEXT( ctx
);
594 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
598 if (exec
->eval
.recalculate_maps
)
599 vbo_exec_eval_update( exec
);
601 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
602 if (exec
->eval
.map1
[i
].map
)
603 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map1
[i
].sz
)
604 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map1
[i
].sz
, GL_FLOAT
);
609 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
610 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
612 vbo_exec_do_EvalCoord1f( exec
, u
);
614 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
615 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
618 static void GLAPIENTRY
vbo_exec_EvalCoord2f( GLfloat u
, GLfloat v
)
620 GET_CURRENT_CONTEXT( ctx
);
621 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
625 if (exec
->eval
.recalculate_maps
)
626 vbo_exec_eval_update( exec
);
628 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
629 if (exec
->eval
.map2
[i
].map
)
630 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map2
[i
].sz
)
631 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map2
[i
].sz
, GL_FLOAT
);
634 if (ctx
->Eval
.AutoNormal
)
635 if (exec
->vtx
.active_sz
[VBO_ATTRIB_NORMAL
] != 3)
636 vbo_exec_fixup_vertex( ctx
, VBO_ATTRIB_NORMAL
, 3, GL_FLOAT
);
639 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
640 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
642 vbo_exec_do_EvalCoord2f( exec
, u
, v
);
644 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
645 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
648 static void GLAPIENTRY
vbo_exec_EvalCoord1fv( const GLfloat
*u
)
650 vbo_exec_EvalCoord1f( u
[0] );
653 static void GLAPIENTRY
vbo_exec_EvalCoord2fv( const GLfloat
*u
)
655 vbo_exec_EvalCoord2f( u
[0], u
[1] );
658 static void GLAPIENTRY
vbo_exec_EvalPoint1( GLint i
)
660 GET_CURRENT_CONTEXT( ctx
);
661 GLfloat du
= ((ctx
->Eval
.MapGrid1u2
- ctx
->Eval
.MapGrid1u1
) /
662 (GLfloat
) ctx
->Eval
.MapGrid1un
);
663 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid1u1
;
665 vbo_exec_EvalCoord1f( u
);
669 static void GLAPIENTRY
vbo_exec_EvalPoint2( GLint i
, GLint j
)
671 GET_CURRENT_CONTEXT( ctx
);
672 GLfloat du
= ((ctx
->Eval
.MapGrid2u2
- ctx
->Eval
.MapGrid2u1
) /
673 (GLfloat
) ctx
->Eval
.MapGrid2un
);
674 GLfloat dv
= ((ctx
->Eval
.MapGrid2v2
- ctx
->Eval
.MapGrid2v1
) /
675 (GLfloat
) ctx
->Eval
.MapGrid2vn
);
676 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid2u1
;
677 GLfloat v
= j
* dv
+ ctx
->Eval
.MapGrid2v1
;
679 vbo_exec_EvalCoord2f( u
, v
);
684 * Called via glBegin.
686 static void GLAPIENTRY
vbo_exec_Begin( GLenum mode
)
688 GET_CURRENT_CONTEXT( ctx
);
689 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
692 if (_mesa_inside_begin_end(ctx
)) {
693 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glBegin");
697 if (!_mesa_valid_prim_mode(ctx
, mode
, "glBegin")) {
701 vbo_draw_method(vbo_context(ctx
), DRAW_BEGIN_END
);
704 _mesa_update_state( ctx
);
706 CALL_Begin(ctx
->Exec
, (mode
));
710 if (!_mesa_valid_to_render(ctx
, "glBegin")) {
714 /* Heuristic: attempt to isolate attributes occurring outside
717 if (exec
->vtx
.vertex_size
&& !exec
->vtx
.attrsz
[0])
718 vbo_exec_FlushVertices_internal(exec
, GL_FALSE
);
720 i
= exec
->vtx
.prim_count
++;
721 exec
->vtx
.prim
[i
].mode
= mode
;
722 exec
->vtx
.prim
[i
].begin
= 1;
723 exec
->vtx
.prim
[i
].end
= 0;
724 exec
->vtx
.prim
[i
].indexed
= 0;
725 exec
->vtx
.prim
[i
].weak
= 0;
726 exec
->vtx
.prim
[i
].pad
= 0;
727 exec
->vtx
.prim
[i
].start
= exec
->vtx
.vert_count
;
728 exec
->vtx
.prim
[i
].count
= 0;
729 exec
->vtx
.prim
[i
].num_instances
= 1;
730 exec
->vtx
.prim
[i
].base_instance
= 0;
731 exec
->vtx
.prim
[i
].is_indirect
= 0;
733 ctx
->Driver
.CurrentExecPrimitive
= mode
;
735 ctx
->Exec
= ctx
->BeginEnd
;
736 /* We may have been called from a display list, in which case we should
737 * leave dlist.c's dispatch table in place.
739 if (ctx
->CurrentDispatch
== ctx
->OutsideBeginEnd
) {
740 ctx
->CurrentDispatch
= ctx
->BeginEnd
;
741 _glapi_set_dispatch(ctx
->CurrentDispatch
);
743 assert(ctx
->CurrentDispatch
== ctx
->Save
);
749 * Try to merge / concatenate the two most recent VBO primitives.
752 try_vbo_merge(struct vbo_exec_context
*exec
)
754 struct _mesa_prim
*cur
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
756 assert(exec
->vtx
.prim_count
>= 1);
758 vbo_try_prim_conversion(cur
);
760 if (exec
->vtx
.prim_count
>= 2) {
761 struct _mesa_prim
*prev
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 2];
762 assert(prev
== cur
- 1);
764 if (vbo_can_merge_prims(prev
, cur
)) {
769 vbo_merge_prims(prev
, cur
);
770 exec
->vtx
.prim_count
--; /* drop the last primitive */
779 static void GLAPIENTRY
vbo_exec_End( void )
781 GET_CURRENT_CONTEXT( ctx
);
782 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
784 if (!_mesa_inside_begin_end(ctx
)) {
785 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glEnd");
789 ctx
->Exec
= ctx
->OutsideBeginEnd
;
790 if (ctx
->CurrentDispatch
== ctx
->BeginEnd
) {
791 ctx
->CurrentDispatch
= ctx
->OutsideBeginEnd
;
792 _glapi_set_dispatch(ctx
->CurrentDispatch
);
795 if (exec
->vtx
.prim_count
> 0) {
796 /* close off current primitive */
797 int idx
= exec
->vtx
.vert_count
;
798 int i
= exec
->vtx
.prim_count
- 1;
800 exec
->vtx
.prim
[i
].end
= 1;
801 exec
->vtx
.prim
[i
].count
= idx
- exec
->vtx
.prim
[i
].start
;
806 ctx
->Driver
.CurrentExecPrimitive
= PRIM_OUTSIDE_BEGIN_END
;
808 if (exec
->vtx
.prim_count
== VBO_MAX_PRIM
)
809 vbo_exec_vtx_flush( exec
, GL_FALSE
);
811 if (MESA_DEBUG_FLAGS
& DEBUG_ALWAYS_FLUSH
) {
818 * Called via glPrimitiveRestartNV()
820 static void GLAPIENTRY
821 vbo_exec_PrimitiveRestartNV(void)
824 GET_CURRENT_CONTEXT( ctx
);
826 curPrim
= ctx
->Driver
.CurrentExecPrimitive
;
828 if (curPrim
== PRIM_OUTSIDE_BEGIN_END
) {
829 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glPrimitiveRestartNV" );
833 vbo_exec_Begin(curPrim
);
839 static void vbo_exec_vtxfmt_init( struct vbo_exec_context
*exec
)
841 struct gl_context
*ctx
= exec
->ctx
;
842 GLvertexformat
*vfmt
= &exec
->vtxfmt
;
844 vfmt
->ArrayElement
= _ae_ArrayElement
;
846 vfmt
->Begin
= vbo_exec_Begin
;
847 vfmt
->End
= vbo_exec_End
;
848 vfmt
->PrimitiveRestartNV
= vbo_exec_PrimitiveRestartNV
;
850 vfmt
->CallList
= _mesa_CallList
;
851 vfmt
->CallLists
= _mesa_CallLists
;
853 vfmt
->EvalCoord1f
= vbo_exec_EvalCoord1f
;
854 vfmt
->EvalCoord1fv
= vbo_exec_EvalCoord1fv
;
855 vfmt
->EvalCoord2f
= vbo_exec_EvalCoord2f
;
856 vfmt
->EvalCoord2fv
= vbo_exec_EvalCoord2fv
;
857 vfmt
->EvalPoint1
= vbo_exec_EvalPoint1
;
858 vfmt
->EvalPoint2
= vbo_exec_EvalPoint2
;
860 /* from attrib_tmp.h:
862 vfmt
->Color3f
= vbo_Color3f
;
863 vfmt
->Color3fv
= vbo_Color3fv
;
864 vfmt
->Color4f
= vbo_Color4f
;
865 vfmt
->Color4fv
= vbo_Color4fv
;
866 vfmt
->FogCoordfEXT
= vbo_FogCoordfEXT
;
867 vfmt
->FogCoordfvEXT
= vbo_FogCoordfvEXT
;
868 vfmt
->MultiTexCoord1fARB
= vbo_MultiTexCoord1f
;
869 vfmt
->MultiTexCoord1fvARB
= vbo_MultiTexCoord1fv
;
870 vfmt
->MultiTexCoord2fARB
= vbo_MultiTexCoord2f
;
871 vfmt
->MultiTexCoord2fvARB
= vbo_MultiTexCoord2fv
;
872 vfmt
->MultiTexCoord3fARB
= vbo_MultiTexCoord3f
;
873 vfmt
->MultiTexCoord3fvARB
= vbo_MultiTexCoord3fv
;
874 vfmt
->MultiTexCoord4fARB
= vbo_MultiTexCoord4f
;
875 vfmt
->MultiTexCoord4fvARB
= vbo_MultiTexCoord4fv
;
876 vfmt
->Normal3f
= vbo_Normal3f
;
877 vfmt
->Normal3fv
= vbo_Normal3fv
;
878 vfmt
->SecondaryColor3fEXT
= vbo_SecondaryColor3fEXT
;
879 vfmt
->SecondaryColor3fvEXT
= vbo_SecondaryColor3fvEXT
;
880 vfmt
->TexCoord1f
= vbo_TexCoord1f
;
881 vfmt
->TexCoord1fv
= vbo_TexCoord1fv
;
882 vfmt
->TexCoord2f
= vbo_TexCoord2f
;
883 vfmt
->TexCoord2fv
= vbo_TexCoord2fv
;
884 vfmt
->TexCoord3f
= vbo_TexCoord3f
;
885 vfmt
->TexCoord3fv
= vbo_TexCoord3fv
;
886 vfmt
->TexCoord4f
= vbo_TexCoord4f
;
887 vfmt
->TexCoord4fv
= vbo_TexCoord4fv
;
888 vfmt
->Vertex2f
= vbo_Vertex2f
;
889 vfmt
->Vertex2fv
= vbo_Vertex2fv
;
890 vfmt
->Vertex3f
= vbo_Vertex3f
;
891 vfmt
->Vertex3fv
= vbo_Vertex3fv
;
892 vfmt
->Vertex4f
= vbo_Vertex4f
;
893 vfmt
->Vertex4fv
= vbo_Vertex4fv
;
895 if (ctx
->API
== API_OPENGLES2
) {
896 vfmt
->VertexAttrib1fARB
= _es_VertexAttrib1f
;
897 vfmt
->VertexAttrib1fvARB
= _es_VertexAttrib1fv
;
898 vfmt
->VertexAttrib2fARB
= _es_VertexAttrib2f
;
899 vfmt
->VertexAttrib2fvARB
= _es_VertexAttrib2fv
;
900 vfmt
->VertexAttrib3fARB
= _es_VertexAttrib3f
;
901 vfmt
->VertexAttrib3fvARB
= _es_VertexAttrib3fv
;
902 vfmt
->VertexAttrib4fARB
= _es_VertexAttrib4f
;
903 vfmt
->VertexAttrib4fvARB
= _es_VertexAttrib4fv
;
905 vfmt
->VertexAttrib1fARB
= vbo_VertexAttrib1fARB
;
906 vfmt
->VertexAttrib1fvARB
= vbo_VertexAttrib1fvARB
;
907 vfmt
->VertexAttrib2fARB
= vbo_VertexAttrib2fARB
;
908 vfmt
->VertexAttrib2fvARB
= vbo_VertexAttrib2fvARB
;
909 vfmt
->VertexAttrib3fARB
= vbo_VertexAttrib3fARB
;
910 vfmt
->VertexAttrib3fvARB
= vbo_VertexAttrib3fvARB
;
911 vfmt
->VertexAttrib4fARB
= vbo_VertexAttrib4fARB
;
912 vfmt
->VertexAttrib4fvARB
= vbo_VertexAttrib4fvARB
;
915 /* Note that VertexAttrib4fNV is used from dlist.c and api_arrayelt.c so
916 * they can have a single entrypoint for updating any of the legacy
919 vfmt
->VertexAttrib1fNV
= vbo_VertexAttrib1fNV
;
920 vfmt
->VertexAttrib1fvNV
= vbo_VertexAttrib1fvNV
;
921 vfmt
->VertexAttrib2fNV
= vbo_VertexAttrib2fNV
;
922 vfmt
->VertexAttrib2fvNV
= vbo_VertexAttrib2fvNV
;
923 vfmt
->VertexAttrib3fNV
= vbo_VertexAttrib3fNV
;
924 vfmt
->VertexAttrib3fvNV
= vbo_VertexAttrib3fvNV
;
925 vfmt
->VertexAttrib4fNV
= vbo_VertexAttrib4fNV
;
926 vfmt
->VertexAttrib4fvNV
= vbo_VertexAttrib4fvNV
;
929 vfmt
->VertexAttribI1i
= vbo_VertexAttribI1i
;
930 vfmt
->VertexAttribI2i
= vbo_VertexAttribI2i
;
931 vfmt
->VertexAttribI3i
= vbo_VertexAttribI3i
;
932 vfmt
->VertexAttribI4i
= vbo_VertexAttribI4i
;
933 vfmt
->VertexAttribI2iv
= vbo_VertexAttribI2iv
;
934 vfmt
->VertexAttribI3iv
= vbo_VertexAttribI3iv
;
935 vfmt
->VertexAttribI4iv
= vbo_VertexAttribI4iv
;
937 /* unsigned integer-valued */
938 vfmt
->VertexAttribI1ui
= vbo_VertexAttribI1ui
;
939 vfmt
->VertexAttribI2ui
= vbo_VertexAttribI2ui
;
940 vfmt
->VertexAttribI3ui
= vbo_VertexAttribI3ui
;
941 vfmt
->VertexAttribI4ui
= vbo_VertexAttribI4ui
;
942 vfmt
->VertexAttribI2uiv
= vbo_VertexAttribI2uiv
;
943 vfmt
->VertexAttribI3uiv
= vbo_VertexAttribI3uiv
;
944 vfmt
->VertexAttribI4uiv
= vbo_VertexAttribI4uiv
;
946 vfmt
->Materialfv
= vbo_Materialfv
;
948 vfmt
->EdgeFlag
= vbo_EdgeFlag
;
949 vfmt
->Indexf
= vbo_Indexf
;
950 vfmt
->Indexfv
= vbo_Indexfv
;
952 /* ARB_vertex_type_2_10_10_10_rev */
953 vfmt
->VertexP2ui
= vbo_VertexP2ui
;
954 vfmt
->VertexP2uiv
= vbo_VertexP2uiv
;
955 vfmt
->VertexP3ui
= vbo_VertexP3ui
;
956 vfmt
->VertexP3uiv
= vbo_VertexP3uiv
;
957 vfmt
->VertexP4ui
= vbo_VertexP4ui
;
958 vfmt
->VertexP4uiv
= vbo_VertexP4uiv
;
960 vfmt
->TexCoordP1ui
= vbo_TexCoordP1ui
;
961 vfmt
->TexCoordP1uiv
= vbo_TexCoordP1uiv
;
962 vfmt
->TexCoordP2ui
= vbo_TexCoordP2ui
;
963 vfmt
->TexCoordP2uiv
= vbo_TexCoordP2uiv
;
964 vfmt
->TexCoordP3ui
= vbo_TexCoordP3ui
;
965 vfmt
->TexCoordP3uiv
= vbo_TexCoordP3uiv
;
966 vfmt
->TexCoordP4ui
= vbo_TexCoordP4ui
;
967 vfmt
->TexCoordP4uiv
= vbo_TexCoordP4uiv
;
969 vfmt
->MultiTexCoordP1ui
= vbo_MultiTexCoordP1ui
;
970 vfmt
->MultiTexCoordP1uiv
= vbo_MultiTexCoordP1uiv
;
971 vfmt
->MultiTexCoordP2ui
= vbo_MultiTexCoordP2ui
;
972 vfmt
->MultiTexCoordP2uiv
= vbo_MultiTexCoordP2uiv
;
973 vfmt
->MultiTexCoordP3ui
= vbo_MultiTexCoordP3ui
;
974 vfmt
->MultiTexCoordP3uiv
= vbo_MultiTexCoordP3uiv
;
975 vfmt
->MultiTexCoordP4ui
= vbo_MultiTexCoordP4ui
;
976 vfmt
->MultiTexCoordP4uiv
= vbo_MultiTexCoordP4uiv
;
978 vfmt
->NormalP3ui
= vbo_NormalP3ui
;
979 vfmt
->NormalP3uiv
= vbo_NormalP3uiv
;
981 vfmt
->ColorP3ui
= vbo_ColorP3ui
;
982 vfmt
->ColorP3uiv
= vbo_ColorP3uiv
;
983 vfmt
->ColorP4ui
= vbo_ColorP4ui
;
984 vfmt
->ColorP4uiv
= vbo_ColorP4uiv
;
986 vfmt
->SecondaryColorP3ui
= vbo_SecondaryColorP3ui
;
987 vfmt
->SecondaryColorP3uiv
= vbo_SecondaryColorP3uiv
;
989 vfmt
->VertexAttribP1ui
= vbo_VertexAttribP1ui
;
990 vfmt
->VertexAttribP1uiv
= vbo_VertexAttribP1uiv
;
991 vfmt
->VertexAttribP2ui
= vbo_VertexAttribP2ui
;
992 vfmt
->VertexAttribP2uiv
= vbo_VertexAttribP2uiv
;
993 vfmt
->VertexAttribP3ui
= vbo_VertexAttribP3ui
;
994 vfmt
->VertexAttribP3uiv
= vbo_VertexAttribP3uiv
;
995 vfmt
->VertexAttribP4ui
= vbo_VertexAttribP4ui
;
996 vfmt
->VertexAttribP4uiv
= vbo_VertexAttribP4uiv
;
998 vfmt
->VertexAttribL1d
= vbo_VertexAttribL1d
;
999 vfmt
->VertexAttribL2d
= vbo_VertexAttribL2d
;
1000 vfmt
->VertexAttribL3d
= vbo_VertexAttribL3d
;
1001 vfmt
->VertexAttribL4d
= vbo_VertexAttribL4d
;
1003 vfmt
->VertexAttribL1dv
= vbo_VertexAttribL1dv
;
1004 vfmt
->VertexAttribL2dv
= vbo_VertexAttribL2dv
;
1005 vfmt
->VertexAttribL3dv
= vbo_VertexAttribL3dv
;
1006 vfmt
->VertexAttribL4dv
= vbo_VertexAttribL4dv
;
1011 * Tell the VBO module to use a real OpenGL vertex buffer object to
1012 * store accumulated immediate-mode vertex data.
1013 * This replaces the malloced buffer which was created in
1014 * vb_exec_vtx_init() below.
1016 void vbo_use_buffer_objects(struct gl_context
*ctx
)
1018 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1019 /* Any buffer name but 0 can be used here since this bufferobj won't
1020 * go into the bufferobj hashtable.
1022 GLuint bufName
= IMM_BUFFER_NAME
;
1023 GLenum target
= GL_ARRAY_BUFFER_ARB
;
1024 GLenum usage
= GL_STREAM_DRAW_ARB
;
1025 GLsizei size
= VBO_VERT_BUFFER_SIZE
;
1027 /* Make sure this func is only used once */
1028 assert(exec
->vtx
.bufferobj
== ctx
->Shared
->NullBufferObj
);
1030 _mesa_align_free(exec
->vtx
.buffer_map
);
1031 exec
->vtx
.buffer_map
= NULL
;
1032 exec
->vtx
.buffer_ptr
= NULL
;
1034 /* Allocate a real buffer object now */
1035 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1036 exec
->vtx
.bufferobj
= ctx
->Driver
.NewBufferObject(ctx
, bufName
);
1037 if (!ctx
->Driver
.BufferData(ctx
, target
, size
, NULL
, usage
,
1039 GL_DYNAMIC_STORAGE_BIT
|
1040 GL_CLIENT_STORAGE_BIT
,
1041 exec
->vtx
.bufferobj
)) {
1042 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "VBO allocation");
1048 * If this function is called, all VBO buffers will be unmapped when
1050 * Otherwise, if a simple command like glColor3f() is called and we flush,
1051 * the current VBO may be left mapped.
1054 vbo_always_unmap_buffers(struct gl_context
*ctx
)
1056 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1057 exec
->begin_vertices_flags
|= FLUSH_STORED_VERTICES
;
1061 void vbo_exec_vtx_init( struct vbo_exec_context
*exec
)
1063 struct gl_context
*ctx
= exec
->ctx
;
1064 struct vbo_context
*vbo
= vbo_context(ctx
);
1067 /* Allocate a buffer object. Will just reuse this object
1068 * continuously, unless vbo_use_buffer_objects() is called to enable
1071 _mesa_reference_buffer_object(ctx
,
1072 &exec
->vtx
.bufferobj
,
1073 ctx
->Shared
->NullBufferObj
);
1075 assert(!exec
->vtx
.buffer_map
);
1076 exec
->vtx
.buffer_map
= _mesa_align_malloc(VBO_VERT_BUFFER_SIZE
, 64);
1077 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
1079 vbo_exec_vtxfmt_init( exec
);
1080 _mesa_noop_vtxfmt_init(&exec
->vtxfmt_noop
);
1082 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1083 assert(i
< ARRAY_SIZE(exec
->vtx
.attrsz
));
1084 exec
->vtx
.attrsz
[i
] = 0;
1085 assert(i
< ARRAY_SIZE(exec
->vtx
.attrtype
));
1086 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1087 assert(i
< ARRAY_SIZE(exec
->vtx
.active_sz
));
1088 exec
->vtx
.active_sz
[i
] = 0;
1090 for (i
= 0 ; i
< VERT_ATTRIB_MAX
; i
++) {
1091 assert(i
< ARRAY_SIZE(exec
->vtx
.inputs
));
1092 assert(i
< ARRAY_SIZE(exec
->vtx
.arrays
));
1093 exec
->vtx
.inputs
[i
] = &exec
->vtx
.arrays
[i
];
1097 struct gl_client_array
*arrays
= exec
->vtx
.arrays
;
1100 memcpy(arrays
, &vbo
->currval
[VBO_ATTRIB_POS
],
1101 VERT_ATTRIB_FF_MAX
* sizeof(arrays
[0]));
1102 for (i
= 0; i
< VERT_ATTRIB_FF_MAX
; ++i
) {
1103 struct gl_client_array
*array
;
1104 array
= &arrays
[VERT_ATTRIB_FF(i
)];
1105 array
->BufferObj
= NULL
;
1106 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1107 vbo
->currval
[VBO_ATTRIB_POS
+i
].BufferObj
);
1110 memcpy(arrays
+ VERT_ATTRIB_GENERIC(0),
1111 &vbo
->currval
[VBO_ATTRIB_GENERIC0
],
1112 VERT_ATTRIB_GENERIC_MAX
* sizeof(arrays
[0]));
1114 for (i
= 0; i
< VERT_ATTRIB_GENERIC_MAX
; ++i
) {
1115 struct gl_client_array
*array
;
1116 array
= &arrays
[VERT_ATTRIB_GENERIC(i
)];
1117 array
->BufferObj
= NULL
;
1118 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1119 vbo
->currval
[VBO_ATTRIB_GENERIC0
+i
].BufferObj
);
1123 exec
->vtx
.vertex_size
= 0;
1125 exec
->begin_vertices_flags
= FLUSH_UPDATE_CURRENT
;
1129 void vbo_exec_vtx_destroy( struct vbo_exec_context
*exec
)
1131 /* using a real VBO for vertex data */
1132 struct gl_context
*ctx
= exec
->ctx
;
1135 /* True VBOs should already be unmapped
1137 if (exec
->vtx
.buffer_map
) {
1138 assert(exec
->vtx
.bufferobj
->Name
== 0 ||
1139 exec
->vtx
.bufferobj
->Name
== IMM_BUFFER_NAME
);
1140 if (exec
->vtx
.bufferobj
->Name
== 0) {
1141 _mesa_align_free(exec
->vtx
.buffer_map
);
1142 exec
->vtx
.buffer_map
= NULL
;
1143 exec
->vtx
.buffer_ptr
= NULL
;
1147 /* Drop any outstanding reference to the vertex buffer
1149 for (i
= 0; i
< ARRAY_SIZE(exec
->vtx
.arrays
); i
++) {
1150 _mesa_reference_buffer_object(ctx
,
1151 &exec
->vtx
.arrays
[i
].BufferObj
,
1155 /* Free the vertex buffer. Unmap first if needed.
1157 if (_mesa_bufferobj_mapped(exec
->vtx
.bufferobj
, MAP_INTERNAL
)) {
1158 ctx
->Driver
.UnmapBuffer(ctx
, exec
->vtx
.bufferobj
, MAP_INTERNAL
);
1160 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1165 * Called upon first glVertex, glColor, glTexCoord, etc.
1167 void vbo_exec_BeginVertices( struct gl_context
*ctx
)
1169 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1171 vbo_exec_vtx_map( exec
);
1173 assert((ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
) == 0);
1174 assert(exec
->begin_vertices_flags
);
1176 ctx
->Driver
.NeedFlush
|= exec
->begin_vertices_flags
;
1181 * If inside glBegin()/glEnd(), it should assert(0). Otherwise, if
1182 * FLUSH_STORED_VERTICES bit in \p flags is set flushes any buffered
1183 * vertices, if FLUSH_UPDATE_CURRENT bit is set updates
1184 * __struct gl_contextRec::Current and gl_light_attrib::Material
1186 * Note that the default T&L engine never clears the
1187 * FLUSH_UPDATE_CURRENT bit, even after performing the update.
1189 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1191 void vbo_exec_FlushVertices( struct gl_context
*ctx
, GLuint flags
)
1193 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1196 /* debug check: make sure we don't get called recursively */
1197 exec
->flush_call_depth
++;
1198 assert(exec
->flush_call_depth
== 1);
1201 if (_mesa_inside_begin_end(ctx
)) {
1202 /* We've had glBegin but not glEnd! */
1204 exec
->flush_call_depth
--;
1205 assert(exec
->flush_call_depth
== 0);
1210 /* Flush (draw), and make sure VBO is left unmapped when done */
1211 vbo_exec_FlushVertices_internal(exec
, GL_TRUE
);
1213 /* Need to do this to ensure vbo_exec_BeginVertices gets called again:
1215 ctx
->Driver
.NeedFlush
&= ~(FLUSH_UPDATE_CURRENT
| flags
);
1218 exec
->flush_call_depth
--;
1219 assert(exec
->flush_call_depth
== 0);
1224 static void reset_attrfv( struct vbo_exec_context
*exec
)
1228 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1229 exec
->vtx
.attrsz
[i
] = 0;
1230 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1231 exec
->vtx
.active_sz
[i
] = 0;
1234 exec
->vtx
.vertex_size
= 0;
1239 _es_Color4f(GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
1241 vbo_Color4f(r
, g
, b
, a
);
1246 _es_Normal3f(GLfloat x
, GLfloat y
, GLfloat z
)
1248 vbo_Normal3f(x
, y
, z
);
1253 _es_MultiTexCoord4f(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1255 vbo_MultiTexCoord4f(target
, s
, t
, r
, q
);
1260 _es_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
1262 vbo_Materialfv(face
, pname
, params
);
1267 _es_Materialf(GLenum face
, GLenum pname
, GLfloat param
)
1271 p
[1] = p
[2] = p
[3] = 0.0F
;
1272 vbo_Materialfv(face
, pname
, p
);
1277 * A special version of glVertexAttrib4f that does not treat index 0 as
1281 VertexAttrib4f_nopos(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1283 GET_CURRENT_CONTEXT(ctx
);
1284 if (index
< MAX_VERTEX_GENERIC_ATTRIBS
)
1285 ATTRF(VBO_ATTRIB_GENERIC0
+ index
, 4, x
, y
, z
, w
);
1287 ERROR(GL_INVALID_VALUE
);
1291 _es_VertexAttrib4f(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1293 VertexAttrib4f_nopos(index
, x
, y
, z
, w
);
1298 _es_VertexAttrib1f(GLuint indx
, GLfloat x
)
1300 VertexAttrib4f_nopos(indx
, x
, 0.0f
, 0.0f
, 1.0f
);
1305 _es_VertexAttrib1fv(GLuint indx
, const GLfloat
* values
)
1307 VertexAttrib4f_nopos(indx
, values
[0], 0.0f
, 0.0f
, 1.0f
);
1312 _es_VertexAttrib2f(GLuint indx
, GLfloat x
, GLfloat y
)
1314 VertexAttrib4f_nopos(indx
, x
, y
, 0.0f
, 1.0f
);
1319 _es_VertexAttrib2fv(GLuint indx
, const GLfloat
* values
)
1321 VertexAttrib4f_nopos(indx
, values
[0], values
[1], 0.0f
, 1.0f
);
1326 _es_VertexAttrib3f(GLuint indx
, GLfloat x
, GLfloat y
, GLfloat z
)
1328 VertexAttrib4f_nopos(indx
, x
, y
, z
, 1.0f
);
1333 _es_VertexAttrib3fv(GLuint indx
, const GLfloat
* values
)
1335 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], 1.0f
);
1340 _es_VertexAttrib4fv(GLuint indx
, const GLfloat
* values
)
1342 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], values
[3]);