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.
417 #define ATTR_UNION( A, N, T, C, V0, V1, V2, V3 ) \
419 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
420 int sz = (sizeof(C) / sizeof(GLfloat)); \
421 if (unlikely(!(ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT))) \
422 ctx->Driver.BeginVertices( ctx ); \
424 if (unlikely(exec->vtx.active_sz[A] != N * sz) || \
425 unlikely(exec->vtx.attrtype[A] != T)) \
426 vbo_exec_fixup_vertex(ctx, A, N * sz, T); \
429 C *dest = (C *)exec->vtx.attrptr[A]; \
430 if (N>0) dest[0] = V0; \
431 if (N>1) dest[1] = V1; \
432 if (N>2) dest[2] = V2; \
433 if (N>3) dest[3] = V3; \
434 exec->vtx.attrtype[A] = T; \
438 /* This is a glVertex call */ \
441 for (i = 0; i < exec->vtx.vertex_size; i++) \
442 exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i]; \
444 exec->vtx.buffer_ptr += exec->vtx.vertex_size; \
446 /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \
447 /* something to draw (not just updating a color or texcoord).*/ \
448 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \
450 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
451 vbo_exec_vtx_wrap( exec ); \
455 #define ERROR(err) _mesa_error( ctx, err, __func__ )
456 #define TAG(x) vbo_##x
458 #include "vbo_attrib_tmp.h"
463 * Execute a glMaterial call. Note that if GL_COLOR_MATERIAL is enabled,
464 * this may be a (partial) no-op.
466 static void GLAPIENTRY
467 vbo_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
469 GLbitfield updateMats
;
470 GET_CURRENT_CONTEXT(ctx
);
472 /* This function should be a no-op when it tries to update material
473 * attributes which are currently tracking glColor via glColorMaterial.
474 * The updateMats var will be a mask of the MAT_BIT_FRONT/BACK_x bits
475 * indicating which material attributes can actually be updated below.
477 if (ctx
->Light
.ColorMaterialEnabled
) {
478 updateMats
= ~ctx
->Light
._ColorMaterialBitmask
;
481 /* GL_COLOR_MATERIAL is disabled so don't skip any material updates */
482 updateMats
= ALL_MATERIAL_BITS
;
485 if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_FRONT
) {
486 updateMats
&= FRONT_MATERIAL_BITS
;
488 else if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_BACK
) {
489 updateMats
&= BACK_MATERIAL_BITS
;
491 else if (face
!= GL_FRONT_AND_BACK
) {
492 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterial(invalid face)");
498 if (updateMats
& MAT_BIT_FRONT_EMISSION
)
499 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_EMISSION
, 4, params
);
500 if (updateMats
& MAT_BIT_BACK_EMISSION
)
501 MAT_ATTR(VBO_ATTRIB_MAT_BACK_EMISSION
, 4, params
);
504 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
505 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
506 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
507 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
510 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
511 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
512 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
513 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
516 if (updateMats
& MAT_BIT_FRONT_SPECULAR
)
517 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SPECULAR
, 4, params
);
518 if (updateMats
& MAT_BIT_BACK_SPECULAR
)
519 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SPECULAR
, 4, params
);
522 if (*params
< 0 || *params
> ctx
->Const
.MaxShininess
) {
523 _mesa_error(ctx
, GL_INVALID_VALUE
,
524 "glMaterial(invalid shininess: %f out range [0, %f])",
525 *params
, ctx
->Const
.MaxShininess
);
528 if (updateMats
& MAT_BIT_FRONT_SHININESS
)
529 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SHININESS
, 1, params
);
530 if (updateMats
& MAT_BIT_BACK_SHININESS
)
531 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SHININESS
, 1, params
);
533 case GL_COLOR_INDEXES
:
534 if (ctx
->API
!= API_OPENGL_COMPAT
) {
535 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
538 if (updateMats
& MAT_BIT_FRONT_INDEXES
)
539 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_INDEXES
, 3, params
);
540 if (updateMats
& MAT_BIT_BACK_INDEXES
)
541 MAT_ATTR(VBO_ATTRIB_MAT_BACK_INDEXES
, 3, params
);
543 case GL_AMBIENT_AND_DIFFUSE
:
544 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
545 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
546 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
547 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
548 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
549 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
550 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
551 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
554 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
561 * Flush (draw) vertices.
562 * \param unmap - leave VBO unmapped after flushing?
565 vbo_exec_FlushVertices_internal(struct vbo_exec_context
*exec
, GLboolean unmap
)
567 if (exec
->vtx
.vert_count
|| unmap
) {
568 vbo_exec_vtx_flush( exec
, unmap
);
571 if (exec
->vtx
.vertex_size
) {
572 vbo_exec_copy_to_current( exec
);
573 reset_attrfv( exec
);
578 static void GLAPIENTRY
vbo_exec_EvalCoord1f( GLfloat u
)
580 GET_CURRENT_CONTEXT( ctx
);
581 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
585 if (exec
->eval
.recalculate_maps
)
586 vbo_exec_eval_update( exec
);
588 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
589 if (exec
->eval
.map1
[i
].map
)
590 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map1
[i
].sz
)
591 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map1
[i
].sz
, GL_FLOAT
);
596 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
597 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
599 vbo_exec_do_EvalCoord1f( exec
, u
);
601 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
602 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
605 static void GLAPIENTRY
vbo_exec_EvalCoord2f( GLfloat u
, GLfloat v
)
607 GET_CURRENT_CONTEXT( ctx
);
608 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
612 if (exec
->eval
.recalculate_maps
)
613 vbo_exec_eval_update( exec
);
615 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
616 if (exec
->eval
.map2
[i
].map
)
617 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map2
[i
].sz
)
618 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map2
[i
].sz
, GL_FLOAT
);
621 if (ctx
->Eval
.AutoNormal
)
622 if (exec
->vtx
.active_sz
[VBO_ATTRIB_NORMAL
] != 3)
623 vbo_exec_fixup_vertex( ctx
, VBO_ATTRIB_NORMAL
, 3, GL_FLOAT
);
626 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
627 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
629 vbo_exec_do_EvalCoord2f( exec
, u
, v
);
631 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
632 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
635 static void GLAPIENTRY
vbo_exec_EvalCoord1fv( const GLfloat
*u
)
637 vbo_exec_EvalCoord1f( u
[0] );
640 static void GLAPIENTRY
vbo_exec_EvalCoord2fv( const GLfloat
*u
)
642 vbo_exec_EvalCoord2f( u
[0], u
[1] );
645 static void GLAPIENTRY
vbo_exec_EvalPoint1( GLint i
)
647 GET_CURRENT_CONTEXT( ctx
);
648 GLfloat du
= ((ctx
->Eval
.MapGrid1u2
- ctx
->Eval
.MapGrid1u1
) /
649 (GLfloat
) ctx
->Eval
.MapGrid1un
);
650 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid1u1
;
652 vbo_exec_EvalCoord1f( u
);
656 static void GLAPIENTRY
vbo_exec_EvalPoint2( GLint i
, GLint j
)
658 GET_CURRENT_CONTEXT( ctx
);
659 GLfloat du
= ((ctx
->Eval
.MapGrid2u2
- ctx
->Eval
.MapGrid2u1
) /
660 (GLfloat
) ctx
->Eval
.MapGrid2un
);
661 GLfloat dv
= ((ctx
->Eval
.MapGrid2v2
- ctx
->Eval
.MapGrid2v1
) /
662 (GLfloat
) ctx
->Eval
.MapGrid2vn
);
663 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid2u1
;
664 GLfloat v
= j
* dv
+ ctx
->Eval
.MapGrid2v1
;
666 vbo_exec_EvalCoord2f( u
, v
);
671 * Called via glBegin.
673 static void GLAPIENTRY
vbo_exec_Begin( GLenum mode
)
675 GET_CURRENT_CONTEXT( ctx
);
676 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
679 if (_mesa_inside_begin_end(ctx
)) {
680 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glBegin");
684 if (!_mesa_valid_prim_mode(ctx
, mode
, "glBegin")) {
688 vbo_draw_method(vbo_context(ctx
), DRAW_BEGIN_END
);
691 _mesa_update_state( ctx
);
693 CALL_Begin(ctx
->Exec
, (mode
));
697 if (!_mesa_valid_to_render(ctx
, "glBegin")) {
701 /* Heuristic: attempt to isolate attributes occurring outside
704 if (exec
->vtx
.vertex_size
&& !exec
->vtx
.attrsz
[0])
705 vbo_exec_FlushVertices_internal(exec
, GL_FALSE
);
707 i
= exec
->vtx
.prim_count
++;
708 exec
->vtx
.prim
[i
].mode
= mode
;
709 exec
->vtx
.prim
[i
].begin
= 1;
710 exec
->vtx
.prim
[i
].end
= 0;
711 exec
->vtx
.prim
[i
].indexed
= 0;
712 exec
->vtx
.prim
[i
].weak
= 0;
713 exec
->vtx
.prim
[i
].pad
= 0;
714 exec
->vtx
.prim
[i
].start
= exec
->vtx
.vert_count
;
715 exec
->vtx
.prim
[i
].count
= 0;
716 exec
->vtx
.prim
[i
].num_instances
= 1;
717 exec
->vtx
.prim
[i
].base_instance
= 0;
718 exec
->vtx
.prim
[i
].is_indirect
= 0;
720 ctx
->Driver
.CurrentExecPrimitive
= mode
;
722 ctx
->Exec
= ctx
->BeginEnd
;
723 /* We may have been called from a display list, in which case we should
724 * leave dlist.c's dispatch table in place.
726 if (ctx
->CurrentDispatch
== ctx
->OutsideBeginEnd
) {
727 ctx
->CurrentDispatch
= ctx
->BeginEnd
;
728 _glapi_set_dispatch(ctx
->CurrentDispatch
);
730 assert(ctx
->CurrentDispatch
== ctx
->Save
);
736 * Try to merge / concatenate the two most recent VBO primitives.
739 try_vbo_merge(struct vbo_exec_context
*exec
)
741 struct _mesa_prim
*cur
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
743 assert(exec
->vtx
.prim_count
>= 1);
745 vbo_try_prim_conversion(cur
);
747 if (exec
->vtx
.prim_count
>= 2) {
748 struct _mesa_prim
*prev
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 2];
749 assert(prev
== cur
- 1);
751 if (vbo_can_merge_prims(prev
, cur
)) {
756 vbo_merge_prims(prev
, cur
);
757 exec
->vtx
.prim_count
--; /* drop the last primitive */
766 static void GLAPIENTRY
vbo_exec_End( void )
768 GET_CURRENT_CONTEXT( ctx
);
769 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
771 if (!_mesa_inside_begin_end(ctx
)) {
772 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glEnd");
776 ctx
->Exec
= ctx
->OutsideBeginEnd
;
777 if (ctx
->CurrentDispatch
== ctx
->BeginEnd
) {
778 ctx
->CurrentDispatch
= ctx
->OutsideBeginEnd
;
779 _glapi_set_dispatch(ctx
->CurrentDispatch
);
782 if (exec
->vtx
.prim_count
> 0) {
783 /* close off current primitive */
784 int idx
= exec
->vtx
.vert_count
;
785 int i
= exec
->vtx
.prim_count
- 1;
787 exec
->vtx
.prim
[i
].end
= 1;
788 exec
->vtx
.prim
[i
].count
= idx
- exec
->vtx
.prim
[i
].start
;
793 ctx
->Driver
.CurrentExecPrimitive
= PRIM_OUTSIDE_BEGIN_END
;
795 if (exec
->vtx
.prim_count
== VBO_MAX_PRIM
)
796 vbo_exec_vtx_flush( exec
, GL_FALSE
);
798 if (MESA_DEBUG_FLAGS
& DEBUG_ALWAYS_FLUSH
) {
805 * Called via glPrimitiveRestartNV()
807 static void GLAPIENTRY
808 vbo_exec_PrimitiveRestartNV(void)
811 GET_CURRENT_CONTEXT( ctx
);
813 curPrim
= ctx
->Driver
.CurrentExecPrimitive
;
815 if (curPrim
== PRIM_OUTSIDE_BEGIN_END
) {
816 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glPrimitiveRestartNV" );
820 vbo_exec_Begin(curPrim
);
826 static void vbo_exec_vtxfmt_init( struct vbo_exec_context
*exec
)
828 struct gl_context
*ctx
= exec
->ctx
;
829 GLvertexformat
*vfmt
= &exec
->vtxfmt
;
831 vfmt
->ArrayElement
= _ae_ArrayElement
;
833 vfmt
->Begin
= vbo_exec_Begin
;
834 vfmt
->End
= vbo_exec_End
;
835 vfmt
->PrimitiveRestartNV
= vbo_exec_PrimitiveRestartNV
;
837 vfmt
->CallList
= _mesa_CallList
;
838 vfmt
->CallLists
= _mesa_CallLists
;
840 vfmt
->EvalCoord1f
= vbo_exec_EvalCoord1f
;
841 vfmt
->EvalCoord1fv
= vbo_exec_EvalCoord1fv
;
842 vfmt
->EvalCoord2f
= vbo_exec_EvalCoord2f
;
843 vfmt
->EvalCoord2fv
= vbo_exec_EvalCoord2fv
;
844 vfmt
->EvalPoint1
= vbo_exec_EvalPoint1
;
845 vfmt
->EvalPoint2
= vbo_exec_EvalPoint2
;
847 /* from attrib_tmp.h:
849 vfmt
->Color3f
= vbo_Color3f
;
850 vfmt
->Color3fv
= vbo_Color3fv
;
851 vfmt
->Color4f
= vbo_Color4f
;
852 vfmt
->Color4fv
= vbo_Color4fv
;
853 vfmt
->FogCoordfEXT
= vbo_FogCoordfEXT
;
854 vfmt
->FogCoordfvEXT
= vbo_FogCoordfvEXT
;
855 vfmt
->MultiTexCoord1fARB
= vbo_MultiTexCoord1f
;
856 vfmt
->MultiTexCoord1fvARB
= vbo_MultiTexCoord1fv
;
857 vfmt
->MultiTexCoord2fARB
= vbo_MultiTexCoord2f
;
858 vfmt
->MultiTexCoord2fvARB
= vbo_MultiTexCoord2fv
;
859 vfmt
->MultiTexCoord3fARB
= vbo_MultiTexCoord3f
;
860 vfmt
->MultiTexCoord3fvARB
= vbo_MultiTexCoord3fv
;
861 vfmt
->MultiTexCoord4fARB
= vbo_MultiTexCoord4f
;
862 vfmt
->MultiTexCoord4fvARB
= vbo_MultiTexCoord4fv
;
863 vfmt
->Normal3f
= vbo_Normal3f
;
864 vfmt
->Normal3fv
= vbo_Normal3fv
;
865 vfmt
->SecondaryColor3fEXT
= vbo_SecondaryColor3fEXT
;
866 vfmt
->SecondaryColor3fvEXT
= vbo_SecondaryColor3fvEXT
;
867 vfmt
->TexCoord1f
= vbo_TexCoord1f
;
868 vfmt
->TexCoord1fv
= vbo_TexCoord1fv
;
869 vfmt
->TexCoord2f
= vbo_TexCoord2f
;
870 vfmt
->TexCoord2fv
= vbo_TexCoord2fv
;
871 vfmt
->TexCoord3f
= vbo_TexCoord3f
;
872 vfmt
->TexCoord3fv
= vbo_TexCoord3fv
;
873 vfmt
->TexCoord4f
= vbo_TexCoord4f
;
874 vfmt
->TexCoord4fv
= vbo_TexCoord4fv
;
875 vfmt
->Vertex2f
= vbo_Vertex2f
;
876 vfmt
->Vertex2fv
= vbo_Vertex2fv
;
877 vfmt
->Vertex3f
= vbo_Vertex3f
;
878 vfmt
->Vertex3fv
= vbo_Vertex3fv
;
879 vfmt
->Vertex4f
= vbo_Vertex4f
;
880 vfmt
->Vertex4fv
= vbo_Vertex4fv
;
882 if (ctx
->API
== API_OPENGLES2
) {
883 vfmt
->VertexAttrib1fARB
= _es_VertexAttrib1f
;
884 vfmt
->VertexAttrib1fvARB
= _es_VertexAttrib1fv
;
885 vfmt
->VertexAttrib2fARB
= _es_VertexAttrib2f
;
886 vfmt
->VertexAttrib2fvARB
= _es_VertexAttrib2fv
;
887 vfmt
->VertexAttrib3fARB
= _es_VertexAttrib3f
;
888 vfmt
->VertexAttrib3fvARB
= _es_VertexAttrib3fv
;
889 vfmt
->VertexAttrib4fARB
= _es_VertexAttrib4f
;
890 vfmt
->VertexAttrib4fvARB
= _es_VertexAttrib4fv
;
892 vfmt
->VertexAttrib1fARB
= vbo_VertexAttrib1fARB
;
893 vfmt
->VertexAttrib1fvARB
= vbo_VertexAttrib1fvARB
;
894 vfmt
->VertexAttrib2fARB
= vbo_VertexAttrib2fARB
;
895 vfmt
->VertexAttrib2fvARB
= vbo_VertexAttrib2fvARB
;
896 vfmt
->VertexAttrib3fARB
= vbo_VertexAttrib3fARB
;
897 vfmt
->VertexAttrib3fvARB
= vbo_VertexAttrib3fvARB
;
898 vfmt
->VertexAttrib4fARB
= vbo_VertexAttrib4fARB
;
899 vfmt
->VertexAttrib4fvARB
= vbo_VertexAttrib4fvARB
;
902 /* Note that VertexAttrib4fNV is used from dlist.c and api_arrayelt.c so
903 * they can have a single entrypoint for updating any of the legacy
906 vfmt
->VertexAttrib1fNV
= vbo_VertexAttrib1fNV
;
907 vfmt
->VertexAttrib1fvNV
= vbo_VertexAttrib1fvNV
;
908 vfmt
->VertexAttrib2fNV
= vbo_VertexAttrib2fNV
;
909 vfmt
->VertexAttrib2fvNV
= vbo_VertexAttrib2fvNV
;
910 vfmt
->VertexAttrib3fNV
= vbo_VertexAttrib3fNV
;
911 vfmt
->VertexAttrib3fvNV
= vbo_VertexAttrib3fvNV
;
912 vfmt
->VertexAttrib4fNV
= vbo_VertexAttrib4fNV
;
913 vfmt
->VertexAttrib4fvNV
= vbo_VertexAttrib4fvNV
;
916 vfmt
->VertexAttribI1i
= vbo_VertexAttribI1i
;
917 vfmt
->VertexAttribI2i
= vbo_VertexAttribI2i
;
918 vfmt
->VertexAttribI3i
= vbo_VertexAttribI3i
;
919 vfmt
->VertexAttribI4i
= vbo_VertexAttribI4i
;
920 vfmt
->VertexAttribI2iv
= vbo_VertexAttribI2iv
;
921 vfmt
->VertexAttribI3iv
= vbo_VertexAttribI3iv
;
922 vfmt
->VertexAttribI4iv
= vbo_VertexAttribI4iv
;
924 /* unsigned integer-valued */
925 vfmt
->VertexAttribI1ui
= vbo_VertexAttribI1ui
;
926 vfmt
->VertexAttribI2ui
= vbo_VertexAttribI2ui
;
927 vfmt
->VertexAttribI3ui
= vbo_VertexAttribI3ui
;
928 vfmt
->VertexAttribI4ui
= vbo_VertexAttribI4ui
;
929 vfmt
->VertexAttribI2uiv
= vbo_VertexAttribI2uiv
;
930 vfmt
->VertexAttribI3uiv
= vbo_VertexAttribI3uiv
;
931 vfmt
->VertexAttribI4uiv
= vbo_VertexAttribI4uiv
;
933 vfmt
->Materialfv
= vbo_Materialfv
;
935 vfmt
->EdgeFlag
= vbo_EdgeFlag
;
936 vfmt
->Indexf
= vbo_Indexf
;
937 vfmt
->Indexfv
= vbo_Indexfv
;
939 /* ARB_vertex_type_2_10_10_10_rev */
940 vfmt
->VertexP2ui
= vbo_VertexP2ui
;
941 vfmt
->VertexP2uiv
= vbo_VertexP2uiv
;
942 vfmt
->VertexP3ui
= vbo_VertexP3ui
;
943 vfmt
->VertexP3uiv
= vbo_VertexP3uiv
;
944 vfmt
->VertexP4ui
= vbo_VertexP4ui
;
945 vfmt
->VertexP4uiv
= vbo_VertexP4uiv
;
947 vfmt
->TexCoordP1ui
= vbo_TexCoordP1ui
;
948 vfmt
->TexCoordP1uiv
= vbo_TexCoordP1uiv
;
949 vfmt
->TexCoordP2ui
= vbo_TexCoordP2ui
;
950 vfmt
->TexCoordP2uiv
= vbo_TexCoordP2uiv
;
951 vfmt
->TexCoordP3ui
= vbo_TexCoordP3ui
;
952 vfmt
->TexCoordP3uiv
= vbo_TexCoordP3uiv
;
953 vfmt
->TexCoordP4ui
= vbo_TexCoordP4ui
;
954 vfmt
->TexCoordP4uiv
= vbo_TexCoordP4uiv
;
956 vfmt
->MultiTexCoordP1ui
= vbo_MultiTexCoordP1ui
;
957 vfmt
->MultiTexCoordP1uiv
= vbo_MultiTexCoordP1uiv
;
958 vfmt
->MultiTexCoordP2ui
= vbo_MultiTexCoordP2ui
;
959 vfmt
->MultiTexCoordP2uiv
= vbo_MultiTexCoordP2uiv
;
960 vfmt
->MultiTexCoordP3ui
= vbo_MultiTexCoordP3ui
;
961 vfmt
->MultiTexCoordP3uiv
= vbo_MultiTexCoordP3uiv
;
962 vfmt
->MultiTexCoordP4ui
= vbo_MultiTexCoordP4ui
;
963 vfmt
->MultiTexCoordP4uiv
= vbo_MultiTexCoordP4uiv
;
965 vfmt
->NormalP3ui
= vbo_NormalP3ui
;
966 vfmt
->NormalP3uiv
= vbo_NormalP3uiv
;
968 vfmt
->ColorP3ui
= vbo_ColorP3ui
;
969 vfmt
->ColorP3uiv
= vbo_ColorP3uiv
;
970 vfmt
->ColorP4ui
= vbo_ColorP4ui
;
971 vfmt
->ColorP4uiv
= vbo_ColorP4uiv
;
973 vfmt
->SecondaryColorP3ui
= vbo_SecondaryColorP3ui
;
974 vfmt
->SecondaryColorP3uiv
= vbo_SecondaryColorP3uiv
;
976 vfmt
->VertexAttribP1ui
= vbo_VertexAttribP1ui
;
977 vfmt
->VertexAttribP1uiv
= vbo_VertexAttribP1uiv
;
978 vfmt
->VertexAttribP2ui
= vbo_VertexAttribP2ui
;
979 vfmt
->VertexAttribP2uiv
= vbo_VertexAttribP2uiv
;
980 vfmt
->VertexAttribP3ui
= vbo_VertexAttribP3ui
;
981 vfmt
->VertexAttribP3uiv
= vbo_VertexAttribP3uiv
;
982 vfmt
->VertexAttribP4ui
= vbo_VertexAttribP4ui
;
983 vfmt
->VertexAttribP4uiv
= vbo_VertexAttribP4uiv
;
985 vfmt
->VertexAttribL1d
= vbo_VertexAttribL1d
;
986 vfmt
->VertexAttribL2d
= vbo_VertexAttribL2d
;
987 vfmt
->VertexAttribL3d
= vbo_VertexAttribL3d
;
988 vfmt
->VertexAttribL4d
= vbo_VertexAttribL4d
;
990 vfmt
->VertexAttribL1dv
= vbo_VertexAttribL1dv
;
991 vfmt
->VertexAttribL2dv
= vbo_VertexAttribL2dv
;
992 vfmt
->VertexAttribL3dv
= vbo_VertexAttribL3dv
;
993 vfmt
->VertexAttribL4dv
= vbo_VertexAttribL4dv
;
998 * Tell the VBO module to use a real OpenGL vertex buffer object to
999 * store accumulated immediate-mode vertex data.
1000 * This replaces the malloced buffer which was created in
1001 * vb_exec_vtx_init() below.
1003 void vbo_use_buffer_objects(struct gl_context
*ctx
)
1005 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1006 /* Any buffer name but 0 can be used here since this bufferobj won't
1007 * go into the bufferobj hashtable.
1009 GLuint bufName
= IMM_BUFFER_NAME
;
1010 GLenum target
= GL_ARRAY_BUFFER_ARB
;
1011 GLenum usage
= GL_STREAM_DRAW_ARB
;
1012 GLsizei size
= VBO_VERT_BUFFER_SIZE
;
1014 /* Make sure this func is only used once */
1015 assert(exec
->vtx
.bufferobj
== ctx
->Shared
->NullBufferObj
);
1017 _mesa_align_free(exec
->vtx
.buffer_map
);
1018 exec
->vtx
.buffer_map
= NULL
;
1019 exec
->vtx
.buffer_ptr
= NULL
;
1021 /* Allocate a real buffer object now */
1022 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1023 exec
->vtx
.bufferobj
= ctx
->Driver
.NewBufferObject(ctx
, bufName
);
1024 if (!ctx
->Driver
.BufferData(ctx
, target
, size
, NULL
, usage
,
1026 GL_DYNAMIC_STORAGE_BIT
|
1027 GL_CLIENT_STORAGE_BIT
,
1028 exec
->vtx
.bufferobj
)) {
1029 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "VBO allocation");
1035 * If this function is called, all VBO buffers will be unmapped when
1037 * Otherwise, if a simple command like glColor3f() is called and we flush,
1038 * the current VBO may be left mapped.
1041 vbo_always_unmap_buffers(struct gl_context
*ctx
)
1043 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1044 exec
->begin_vertices_flags
|= FLUSH_STORED_VERTICES
;
1048 void vbo_exec_vtx_init( struct vbo_exec_context
*exec
)
1050 struct gl_context
*ctx
= exec
->ctx
;
1051 struct vbo_context
*vbo
= vbo_context(ctx
);
1054 /* Allocate a buffer object. Will just reuse this object
1055 * continuously, unless vbo_use_buffer_objects() is called to enable
1058 _mesa_reference_buffer_object(ctx
,
1059 &exec
->vtx
.bufferobj
,
1060 ctx
->Shared
->NullBufferObj
);
1062 assert(!exec
->vtx
.buffer_map
);
1063 exec
->vtx
.buffer_map
= _mesa_align_malloc(VBO_VERT_BUFFER_SIZE
, 64);
1064 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
1066 vbo_exec_vtxfmt_init( exec
);
1067 _mesa_noop_vtxfmt_init(&exec
->vtxfmt_noop
);
1069 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1070 assert(i
< ARRAY_SIZE(exec
->vtx
.attrsz
));
1071 exec
->vtx
.attrsz
[i
] = 0;
1072 assert(i
< ARRAY_SIZE(exec
->vtx
.attrtype
));
1073 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1074 assert(i
< ARRAY_SIZE(exec
->vtx
.active_sz
));
1075 exec
->vtx
.active_sz
[i
] = 0;
1077 for (i
= 0 ; i
< VERT_ATTRIB_MAX
; i
++) {
1078 assert(i
< ARRAY_SIZE(exec
->vtx
.inputs
));
1079 assert(i
< ARRAY_SIZE(exec
->vtx
.arrays
));
1080 exec
->vtx
.inputs
[i
] = &exec
->vtx
.arrays
[i
];
1084 struct gl_client_array
*arrays
= exec
->vtx
.arrays
;
1087 memcpy(arrays
, &vbo
->currval
[VBO_ATTRIB_POS
],
1088 VERT_ATTRIB_FF_MAX
* sizeof(arrays
[0]));
1089 for (i
= 0; i
< VERT_ATTRIB_FF_MAX
; ++i
) {
1090 struct gl_client_array
*array
;
1091 array
= &arrays
[VERT_ATTRIB_FF(i
)];
1092 array
->BufferObj
= NULL
;
1093 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1094 vbo
->currval
[VBO_ATTRIB_POS
+i
].BufferObj
);
1097 memcpy(arrays
+ VERT_ATTRIB_GENERIC(0),
1098 &vbo
->currval
[VBO_ATTRIB_GENERIC0
],
1099 VERT_ATTRIB_GENERIC_MAX
* sizeof(arrays
[0]));
1101 for (i
= 0; i
< VERT_ATTRIB_GENERIC_MAX
; ++i
) {
1102 struct gl_client_array
*array
;
1103 array
= &arrays
[VERT_ATTRIB_GENERIC(i
)];
1104 array
->BufferObj
= NULL
;
1105 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1106 vbo
->currval
[VBO_ATTRIB_GENERIC0
+i
].BufferObj
);
1110 exec
->vtx
.vertex_size
= 0;
1112 exec
->begin_vertices_flags
= FLUSH_UPDATE_CURRENT
;
1116 void vbo_exec_vtx_destroy( struct vbo_exec_context
*exec
)
1118 /* using a real VBO for vertex data */
1119 struct gl_context
*ctx
= exec
->ctx
;
1122 /* True VBOs should already be unmapped
1124 if (exec
->vtx
.buffer_map
) {
1125 assert(exec
->vtx
.bufferobj
->Name
== 0 ||
1126 exec
->vtx
.bufferobj
->Name
== IMM_BUFFER_NAME
);
1127 if (exec
->vtx
.bufferobj
->Name
== 0) {
1128 _mesa_align_free(exec
->vtx
.buffer_map
);
1129 exec
->vtx
.buffer_map
= NULL
;
1130 exec
->vtx
.buffer_ptr
= NULL
;
1134 /* Drop any outstanding reference to the vertex buffer
1136 for (i
= 0; i
< ARRAY_SIZE(exec
->vtx
.arrays
); i
++) {
1137 _mesa_reference_buffer_object(ctx
,
1138 &exec
->vtx
.arrays
[i
].BufferObj
,
1142 /* Free the vertex buffer. Unmap first if needed.
1144 if (_mesa_bufferobj_mapped(exec
->vtx
.bufferobj
, MAP_INTERNAL
)) {
1145 ctx
->Driver
.UnmapBuffer(ctx
, exec
->vtx
.bufferobj
, MAP_INTERNAL
);
1147 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1152 * Called upon first glVertex, glColor, glTexCoord, etc.
1154 void vbo_exec_BeginVertices( struct gl_context
*ctx
)
1156 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1158 vbo_exec_vtx_map( exec
);
1160 assert((ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
) == 0);
1161 assert(exec
->begin_vertices_flags
);
1163 ctx
->Driver
.NeedFlush
|= exec
->begin_vertices_flags
;
1168 * Called via ctx->Driver.FlushVertices()
1169 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1171 void vbo_exec_FlushVertices( struct gl_context
*ctx
, GLuint flags
)
1173 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1176 /* debug check: make sure we don't get called recursively */
1177 exec
->flush_call_depth
++;
1178 assert(exec
->flush_call_depth
== 1);
1181 if (_mesa_inside_begin_end(ctx
)) {
1182 /* We've had glBegin but not glEnd! */
1184 exec
->flush_call_depth
--;
1185 assert(exec
->flush_call_depth
== 0);
1190 /* Flush (draw), and make sure VBO is left unmapped when done */
1191 vbo_exec_FlushVertices_internal(exec
, GL_TRUE
);
1193 /* Need to do this to ensure BeginVertices gets called again:
1195 ctx
->Driver
.NeedFlush
&= ~(FLUSH_UPDATE_CURRENT
| flags
);
1198 exec
->flush_call_depth
--;
1199 assert(exec
->flush_call_depth
== 0);
1204 static void reset_attrfv( struct vbo_exec_context
*exec
)
1208 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1209 exec
->vtx
.attrsz
[i
] = 0;
1210 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1211 exec
->vtx
.active_sz
[i
] = 0;
1214 exec
->vtx
.vertex_size
= 0;
1219 _es_Color4f(GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
1221 vbo_Color4f(r
, g
, b
, a
);
1226 _es_Normal3f(GLfloat x
, GLfloat y
, GLfloat z
)
1228 vbo_Normal3f(x
, y
, z
);
1233 _es_MultiTexCoord4f(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1235 vbo_MultiTexCoord4f(target
, s
, t
, r
, q
);
1240 _es_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
1242 vbo_Materialfv(face
, pname
, params
);
1247 _es_Materialf(GLenum face
, GLenum pname
, GLfloat param
)
1251 p
[1] = p
[2] = p
[3] = 0.0F
;
1252 vbo_Materialfv(face
, pname
, p
);
1257 * A special version of glVertexAttrib4f that does not treat index 0 as
1261 VertexAttrib4f_nopos(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1263 GET_CURRENT_CONTEXT(ctx
);
1264 if (index
< MAX_VERTEX_GENERIC_ATTRIBS
)
1265 ATTRF(VBO_ATTRIB_GENERIC0
+ index
, 4, x
, y
, z
, w
);
1267 ERROR(GL_INVALID_VALUE
);
1271 _es_VertexAttrib4f(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1273 VertexAttrib4f_nopos(index
, x
, y
, z
, w
);
1278 _es_VertexAttrib1f(GLuint indx
, GLfloat x
)
1280 VertexAttrib4f_nopos(indx
, x
, 0.0f
, 0.0f
, 1.0f
);
1285 _es_VertexAttrib1fv(GLuint indx
, const GLfloat
* values
)
1287 VertexAttrib4f_nopos(indx
, values
[0], 0.0f
, 0.0f
, 1.0f
);
1292 _es_VertexAttrib2f(GLuint indx
, GLfloat x
, GLfloat y
)
1294 VertexAttrib4f_nopos(indx
, x
, y
, 0.0f
, 1.0f
);
1299 _es_VertexAttrib2fv(GLuint indx
, const GLfloat
* values
)
1301 VertexAttrib4f_nopos(indx
, values
[0], values
[1], 0.0f
, 1.0f
);
1306 _es_VertexAttrib3f(GLuint indx
, GLfloat x
, GLfloat y
, GLfloat z
)
1308 VertexAttrib4f_nopos(indx
, x
, y
, z
, 1.0f
);
1313 _es_VertexAttrib3fv(GLuint indx
, const GLfloat
* values
)
1315 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], 1.0f
);
1320 _es_VertexAttrib4fv(GLuint indx
, const GLfloat
* values
)
1322 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], values
[3]);