1 /**************************************************************************
3 Copyright 2002-2008 Tungsten Graphics Inc., Cedar Park, Texas.
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 TUNGSTEN GRAPHICS 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 <keith@tungstengraphics.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 GLfloat
*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
;
164 COPY_CLEAN_4V_TYPE_AS_FLOAT(tmp
,
166 exec
->vtx
.attrptr
[i
],
167 exec
->vtx
.attrtype
[i
]);
169 if (exec
->vtx
.attrtype
[i
] != vbo
->currval
[i
].Type
||
170 memcmp(current
, tmp
, sizeof(tmp
)) != 0) {
171 memcpy(current
, tmp
, sizeof(tmp
));
173 /* Given that we explicitly state size here, there is no need
174 * for the COPY_CLEAN above, could just copy 16 bytes and be
175 * done. The only problem is when Mesa accesses ctx->Current
178 vbo
->currval
[i
].Size
= exec
->vtx
.attrsz
[i
];
179 vbo
->currval
[i
]._ElementSize
= vbo
->currval
[i
].Size
* sizeof(GLfloat
);
180 vbo
->currval
[i
].Type
= exec
->vtx
.attrtype
[i
];
181 vbo
->currval
[i
].Integer
=
182 vbo_attrtype_to_integer_flag(exec
->vtx
.attrtype
[i
]);
184 /* This triggers rather too much recalculation of Mesa state
185 * that doesn't get used (eg light positions).
187 if (i
>= VBO_ATTRIB_MAT_FRONT_AMBIENT
&&
188 i
<= VBO_ATTRIB_MAT_BACK_INDEXES
)
189 ctx
->NewState
|= _NEW_LIGHT
;
191 ctx
->NewState
|= _NEW_CURRENT_ATTRIB
;
196 /* Colormaterial -- this kindof sucks.
198 if (ctx
->Light
.ColorMaterialEnabled
&&
199 exec
->vtx
.attrsz
[VBO_ATTRIB_COLOR0
]) {
200 _mesa_update_color_material(ctx
,
201 ctx
->Current
.Attrib
[VBO_ATTRIB_COLOR0
]);
207 * Copy current vertex attribute values into the current vertex.
210 vbo_exec_copy_from_current(struct vbo_exec_context
*exec
)
212 struct gl_context
*ctx
= exec
->ctx
;
213 struct vbo_context
*vbo
= vbo_context(ctx
);
216 for (i
= VBO_ATTRIB_POS
+ 1; i
< VBO_ATTRIB_MAX
; i
++) {
217 const GLfloat
*current
= (GLfloat
*) vbo
->currval
[i
].Ptr
;
218 switch (exec
->vtx
.attrsz
[i
]) {
219 case 4: exec
->vtx
.attrptr
[i
][3] = current
[3];
220 case 3: exec
->vtx
.attrptr
[i
][2] = current
[2];
221 case 2: exec
->vtx
.attrptr
[i
][1] = current
[1];
222 case 1: exec
->vtx
.attrptr
[i
][0] = current
[0];
230 * Flush existing data, set new attrib size, replay copied vertices.
231 * This is called when we transition from a small vertex attribute size
232 * to a larger one. Ex: glTexCoord2f -> glTexCoord4f.
233 * We need to go back over the previous 2-component texcoords and insert
234 * zero and one values.
237 vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context
*exec
,
238 GLuint attr
, GLuint newSize
)
240 struct gl_context
*ctx
= exec
->ctx
;
241 struct vbo_context
*vbo
= vbo_context(ctx
);
242 const GLint lastcount
= exec
->vtx
.vert_count
;
243 GLfloat
*old_attrptr
[VBO_ATTRIB_MAX
];
244 const GLuint old_vtx_size
= exec
->vtx
.vertex_size
; /* floats per vertex */
245 const GLuint oldSize
= exec
->vtx
.attrsz
[attr
];
248 /* Run pipeline on current vertices, copy wrapped vertices
249 * to exec->vtx.copied.
251 vbo_exec_wrap_buffers( exec
);
253 if (unlikely(exec
->vtx
.copied
.nr
)) {
254 /* We're in the middle of a primitive, keep the old vertex
255 * format around to be able to translate the copied vertices to
258 memcpy(old_attrptr
, exec
->vtx
.attrptr
, sizeof(old_attrptr
));
261 if (unlikely(oldSize
)) {
262 /* Do a COPY_TO_CURRENT to ensure back-copying works for the
263 * case when the attribute already exists in the vertex and is
264 * having its size increased.
266 vbo_exec_copy_to_current( exec
);
269 /* Heuristic: Attempt to isolate attributes received outside
270 * begin/end so that they don't bloat the vertices.
272 if (!_mesa_inside_begin_end(ctx
) &&
273 !oldSize
&& lastcount
> 8 && exec
->vtx
.vertex_size
) {
274 vbo_exec_copy_to_current( exec
);
275 reset_attrfv( exec
);
280 exec
->vtx
.attrsz
[attr
] = newSize
;
281 exec
->vtx
.vertex_size
+= newSize
- oldSize
;
282 exec
->vtx
.max_vert
= ((VBO_VERT_BUFFER_SIZE
- exec
->vtx
.buffer_used
) /
283 (exec
->vtx
.vertex_size
* sizeof(GLfloat
)));
284 exec
->vtx
.vert_count
= 0;
285 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
287 if (unlikely(oldSize
)) {
288 /* Size changed, recalculate all the attrptr[] values
290 GLfloat
*tmp
= exec
->vtx
.vertex
;
292 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
293 if (exec
->vtx
.attrsz
[i
]) {
294 exec
->vtx
.attrptr
[i
] = tmp
;
295 tmp
+= exec
->vtx
.attrsz
[i
];
298 exec
->vtx
.attrptr
[i
] = NULL
; /* will not be dereferenced */
301 /* Copy from current to repopulate the vertex with correct
304 vbo_exec_copy_from_current( exec
);
307 /* Just have to append the new attribute at the end */
308 exec
->vtx
.attrptr
[attr
] = exec
->vtx
.vertex
+
309 exec
->vtx
.vertex_size
- newSize
;
312 /* Replay stored vertices to translate them
313 * to new format here.
315 * -- No need to replay - just copy piecewise
317 if (unlikely(exec
->vtx
.copied
.nr
)) {
318 GLfloat
*data
= exec
->vtx
.copied
.buffer
;
319 GLfloat
*dest
= exec
->vtx
.buffer_ptr
;
322 assert(exec
->vtx
.buffer_ptr
== exec
->vtx
.buffer_map
);
324 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
325 for (j
= 0 ; j
< VBO_ATTRIB_MAX
; j
++) {
326 GLuint sz
= exec
->vtx
.attrsz
[j
];
329 GLint old_offset
= old_attrptr
[j
] - exec
->vtx
.vertex
;
330 GLint new_offset
= exec
->vtx
.attrptr
[j
] - exec
->vtx
.vertex
;
335 COPY_CLEAN_4V_TYPE_AS_FLOAT(tmp
, oldSize
,
337 exec
->vtx
.attrtype
[j
]);
338 COPY_SZ_4V(dest
+ new_offset
, newSize
, tmp
);
340 GLfloat
*current
= (GLfloat
*)vbo
->currval
[j
].Ptr
;
341 COPY_SZ_4V(dest
+ new_offset
, sz
, current
);
345 COPY_SZ_4V(dest
+ new_offset
, sz
, data
+ old_offset
);
350 data
+= old_vtx_size
;
351 dest
+= exec
->vtx
.vertex_size
;
354 exec
->vtx
.buffer_ptr
= dest
;
355 exec
->vtx
.vert_count
+= exec
->vtx
.copied
.nr
;
356 exec
->vtx
.copied
.nr
= 0;
362 * This is when a vertex attribute transitions to a different size.
363 * For example, we saw a bunch of glTexCoord2f() calls and now we got a
364 * glTexCoord4f() call. We promote the array from size=2 to size=4.
367 vbo_exec_fixup_vertex(struct gl_context
*ctx
, GLuint attr
, GLuint newSize
)
369 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
371 if (newSize
> exec
->vtx
.attrsz
[attr
]) {
372 /* New size is larger. Need to flush existing vertices and get
373 * an enlarged vertex format.
375 vbo_exec_wrap_upgrade_vertex( exec
, attr
, newSize
);
377 else if (newSize
< exec
->vtx
.active_sz
[attr
]) {
380 vbo_get_default_vals_as_float(exec
->vtx
.attrtype
[attr
]);
382 /* New size is smaller - just need to fill in some
383 * zeros. Don't need to flush or wrap.
385 for (i
= newSize
; i
<= exec
->vtx
.attrsz
[attr
]; i
++)
386 exec
->vtx
.attrptr
[attr
][i
-1] = id
[i
-1];
389 exec
->vtx
.active_sz
[attr
] = newSize
;
391 /* Does setting NeedFlush belong here? Necessitates resetting
392 * vtxfmt on each flush (otherwise flags won't get reset
396 ctx
->Driver
.NeedFlush
|= FLUSH_STORED_VERTICES
;
401 * This macro is used to implement all the glVertex, glColor, glTexCoord,
402 * glVertexAttrib, etc functions.
404 #define ATTR( A, N, T, V0, V1, V2, V3 ) \
406 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
408 if (unlikely(!(ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT))) \
409 ctx->Driver.BeginVertices( ctx ); \
411 if (unlikely(exec->vtx.active_sz[A] != N)) \
412 vbo_exec_fixup_vertex(ctx, A, N); \
415 GLfloat *dest = exec->vtx.attrptr[A]; \
416 if (N>0) dest[0] = V0; \
417 if (N>1) dest[1] = V1; \
418 if (N>2) dest[2] = V2; \
419 if (N>3) dest[3] = V3; \
420 exec->vtx.attrtype[A] = T; \
424 /* This is a glVertex call */ \
427 for (i = 0; i < exec->vtx.vertex_size; i++) \
428 exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i]; \
430 exec->vtx.buffer_ptr += exec->vtx.vertex_size; \
432 /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \
433 /* something to draw (not just updating a color or texcoord).*/ \
434 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \
436 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
437 vbo_exec_vtx_wrap( exec ); \
442 #define ERROR(err) _mesa_error( ctx, err, __FUNCTION__ )
443 #define TAG(x) vbo_##x
445 #include "vbo_attrib_tmp.h"
450 * Execute a glMaterial call. Note that if GL_COLOR_MATERIAL is enabled,
451 * this may be a (partial) no-op.
453 static void GLAPIENTRY
454 vbo_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
456 GLbitfield updateMats
;
457 GET_CURRENT_CONTEXT(ctx
);
459 /* This function should be a no-op when it tries to update material
460 * attributes which are currently tracking glColor via glColorMaterial.
461 * The updateMats var will be a mask of the MAT_BIT_FRONT/BACK_x bits
462 * indicating which material attributes can actually be updated below.
464 if (ctx
->Light
.ColorMaterialEnabled
) {
465 updateMats
= ~ctx
->Light
._ColorMaterialBitmask
;
468 /* GL_COLOR_MATERIAL is disabled so don't skip any material updates */
469 updateMats
= ALL_MATERIAL_BITS
;
472 if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_FRONT
) {
473 updateMats
&= FRONT_MATERIAL_BITS
;
475 else if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_BACK
) {
476 updateMats
&= BACK_MATERIAL_BITS
;
478 else if (face
!= GL_FRONT_AND_BACK
) {
479 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterial(invalid face)");
485 if (updateMats
& MAT_BIT_FRONT_EMISSION
)
486 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_EMISSION
, 4, params
);
487 if (updateMats
& MAT_BIT_BACK_EMISSION
)
488 MAT_ATTR(VBO_ATTRIB_MAT_BACK_EMISSION
, 4, params
);
491 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
492 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
493 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
494 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
497 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
498 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
499 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
500 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
503 if (updateMats
& MAT_BIT_FRONT_SPECULAR
)
504 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SPECULAR
, 4, params
);
505 if (updateMats
& MAT_BIT_BACK_SPECULAR
)
506 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SPECULAR
, 4, params
);
509 if (*params
< 0 || *params
> ctx
->Const
.MaxShininess
) {
510 _mesa_error(ctx
, GL_INVALID_VALUE
,
511 "glMaterial(invalid shininess: %f out range [0, %f])",
512 *params
, ctx
->Const
.MaxShininess
);
515 if (updateMats
& MAT_BIT_FRONT_SHININESS
)
516 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SHININESS
, 1, params
);
517 if (updateMats
& MAT_BIT_BACK_SHININESS
)
518 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SHININESS
, 1, params
);
520 case GL_COLOR_INDEXES
:
521 if (ctx
->API
!= API_OPENGL_COMPAT
) {
522 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
525 if (updateMats
& MAT_BIT_FRONT_INDEXES
)
526 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_INDEXES
, 3, params
);
527 if (updateMats
& MAT_BIT_BACK_INDEXES
)
528 MAT_ATTR(VBO_ATTRIB_MAT_BACK_INDEXES
, 3, params
);
530 case GL_AMBIENT_AND_DIFFUSE
:
531 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
532 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
533 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
534 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
535 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
536 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
537 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
538 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
541 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
548 * Flush (draw) vertices.
549 * \param unmap - leave VBO unmapped after flushing?
552 vbo_exec_FlushVertices_internal(struct vbo_exec_context
*exec
, GLboolean unmap
)
554 if (exec
->vtx
.vert_count
|| unmap
) {
555 vbo_exec_vtx_flush( exec
, unmap
);
558 if (exec
->vtx
.vertex_size
) {
559 vbo_exec_copy_to_current( exec
);
560 reset_attrfv( exec
);
565 static void GLAPIENTRY
vbo_exec_EvalCoord1f( GLfloat u
)
567 GET_CURRENT_CONTEXT( ctx
);
568 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
572 if (exec
->eval
.recalculate_maps
)
573 vbo_exec_eval_update( exec
);
575 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
576 if (exec
->eval
.map1
[i
].map
)
577 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map1
[i
].sz
)
578 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map1
[i
].sz
);
583 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
584 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
586 vbo_exec_do_EvalCoord1f( exec
, u
);
588 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
589 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
592 static void GLAPIENTRY
vbo_exec_EvalCoord2f( GLfloat u
, GLfloat v
)
594 GET_CURRENT_CONTEXT( ctx
);
595 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
599 if (exec
->eval
.recalculate_maps
)
600 vbo_exec_eval_update( exec
);
602 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
603 if (exec
->eval
.map2
[i
].map
)
604 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map2
[i
].sz
)
605 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map2
[i
].sz
);
608 if (ctx
->Eval
.AutoNormal
)
609 if (exec
->vtx
.active_sz
[VBO_ATTRIB_NORMAL
] != 3)
610 vbo_exec_fixup_vertex( ctx
, VBO_ATTRIB_NORMAL
, 3 );
613 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
614 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
616 vbo_exec_do_EvalCoord2f( exec
, u
, v
);
618 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
619 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
622 static void GLAPIENTRY
vbo_exec_EvalCoord1fv( const GLfloat
*u
)
624 vbo_exec_EvalCoord1f( u
[0] );
627 static void GLAPIENTRY
vbo_exec_EvalCoord2fv( const GLfloat
*u
)
629 vbo_exec_EvalCoord2f( u
[0], u
[1] );
632 static void GLAPIENTRY
vbo_exec_EvalPoint1( GLint i
)
634 GET_CURRENT_CONTEXT( ctx
);
635 GLfloat du
= ((ctx
->Eval
.MapGrid1u2
- ctx
->Eval
.MapGrid1u1
) /
636 (GLfloat
) ctx
->Eval
.MapGrid1un
);
637 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid1u1
;
639 vbo_exec_EvalCoord1f( u
);
643 static void GLAPIENTRY
vbo_exec_EvalPoint2( GLint i
, GLint j
)
645 GET_CURRENT_CONTEXT( ctx
);
646 GLfloat du
= ((ctx
->Eval
.MapGrid2u2
- ctx
->Eval
.MapGrid2u1
) /
647 (GLfloat
) ctx
->Eval
.MapGrid2un
);
648 GLfloat dv
= ((ctx
->Eval
.MapGrid2v2
- ctx
->Eval
.MapGrid2v1
) /
649 (GLfloat
) ctx
->Eval
.MapGrid2vn
);
650 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid2u1
;
651 GLfloat v
= j
* dv
+ ctx
->Eval
.MapGrid2v1
;
653 vbo_exec_EvalCoord2f( u
, v
);
657 static void GLAPIENTRY
658 vbo_exec_EvalMesh1(GLenum mode
, GLint i1
, GLint i2
)
660 GET_CURRENT_CONTEXT(ctx
);
670 prim
= GL_LINE_STRIP
;
673 _mesa_error( ctx
, GL_INVALID_ENUM
, "glEvalMesh1(mode)" );
677 /* No effect if vertex maps disabled.
679 if (!ctx
->Eval
.Map1Vertex4
&&
680 !ctx
->Eval
.Map1Vertex3
)
683 du
= ctx
->Eval
.MapGrid1du
;
684 u
= ctx
->Eval
.MapGrid1u1
+ i1
* du
;
686 CALL_Begin(GET_DISPATCH(), (prim
));
687 for (i
=i1
;i
<=i2
;i
++,u
+=du
) {
688 CALL_EvalCoord1f(GET_DISPATCH(), (u
));
690 CALL_End(GET_DISPATCH(), ());
694 static void GLAPIENTRY
695 vbo_exec_EvalMesh2(GLenum mode
, GLint i1
, GLint i2
, GLint j1
, GLint j2
)
697 GET_CURRENT_CONTEXT(ctx
);
698 GLfloat u
, du
, v
, dv
, v1
, u1
;
707 _mesa_error( ctx
, GL_INVALID_ENUM
, "glEvalMesh2(mode)" );
711 /* No effect if vertex maps disabled.
713 if (!ctx
->Eval
.Map2Vertex4
&&
714 !ctx
->Eval
.Map2Vertex3
)
717 du
= ctx
->Eval
.MapGrid2du
;
718 dv
= ctx
->Eval
.MapGrid2dv
;
719 v1
= ctx
->Eval
.MapGrid2v1
+ j1
* dv
;
720 u1
= ctx
->Eval
.MapGrid2u1
+ i1
* du
;
724 CALL_Begin(GET_DISPATCH(), (GL_POINTS
));
725 for (v
=v1
,j
=j1
;j
<=j2
;j
++,v
+=dv
) {
726 for (u
=u1
,i
=i1
;i
<=i2
;i
++,u
+=du
) {
727 CALL_EvalCoord2f(GET_DISPATCH(), (u
, v
));
730 CALL_End(GET_DISPATCH(), ());
733 for (v
=v1
,j
=j1
;j
<=j2
;j
++,v
+=dv
) {
734 CALL_Begin(GET_DISPATCH(), (GL_LINE_STRIP
));
735 for (u
=u1
,i
=i1
;i
<=i2
;i
++,u
+=du
) {
736 CALL_EvalCoord2f(GET_DISPATCH(), (u
, v
));
738 CALL_End(GET_DISPATCH(), ());
740 for (u
=u1
,i
=i1
;i
<=i2
;i
++,u
+=du
) {
741 CALL_Begin(GET_DISPATCH(), (GL_LINE_STRIP
));
742 for (v
=v1
,j
=j1
;j
<=j2
;j
++,v
+=dv
) {
743 CALL_EvalCoord2f(GET_DISPATCH(), (u
, v
));
745 CALL_End(GET_DISPATCH(), ());
749 for (v
=v1
,j
=j1
;j
<j2
;j
++,v
+=dv
) {
750 CALL_Begin(GET_DISPATCH(), (GL_TRIANGLE_STRIP
));
751 for (u
=u1
,i
=i1
;i
<=i2
;i
++,u
+=du
) {
752 CALL_EvalCoord2f(GET_DISPATCH(), (u
, v
));
753 CALL_EvalCoord2f(GET_DISPATCH(), (u
, v
+dv
));
755 CALL_End(GET_DISPATCH(), ());
763 * Execute a glRectf() function. This is not suitable for GL_COMPILE
764 * modes (as the test for outside begin/end is not compiled),
765 * but may be useful for drivers in circumstances which exclude
766 * display list interactions.
768 * (None of the functions in this file are suitable for GL_COMPILE
771 static void GLAPIENTRY
772 vbo_exec_Rectf(GLfloat x1
, GLfloat y1
, GLfloat x2
, GLfloat y2
)
774 CALL_Begin(GET_DISPATCH(), (GL_QUADS
));
775 CALL_Vertex2f(GET_DISPATCH(), (x1
, y1
));
776 CALL_Vertex2f(GET_DISPATCH(), (x2
, y1
));
777 CALL_Vertex2f(GET_DISPATCH(), (x2
, y2
));
778 CALL_Vertex2f(GET_DISPATCH(), (x1
, y2
));
779 CALL_End(GET_DISPATCH(), ());
784 * Called via glBegin.
786 static void GLAPIENTRY
vbo_exec_Begin( GLenum mode
)
788 GET_CURRENT_CONTEXT( ctx
);
789 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
792 if (_mesa_inside_begin_end(ctx
)) {
793 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glBegin");
797 if (!_mesa_valid_prim_mode(ctx
, mode
, "glBegin")) {
801 vbo_draw_method(vbo_context(ctx
), DRAW_BEGIN_END
);
804 _mesa_update_state( ctx
);
806 CALL_Begin(ctx
->Exec
, (mode
));
810 if (!_mesa_valid_to_render(ctx
, "glBegin")) {
814 /* Heuristic: attempt to isolate attributes occuring outside
817 if (exec
->vtx
.vertex_size
&& !exec
->vtx
.attrsz
[0])
818 vbo_exec_FlushVertices_internal(exec
, GL_FALSE
);
820 i
= exec
->vtx
.prim_count
++;
821 exec
->vtx
.prim
[i
].mode
= mode
;
822 exec
->vtx
.prim
[i
].begin
= 1;
823 exec
->vtx
.prim
[i
].end
= 0;
824 exec
->vtx
.prim
[i
].indexed
= 0;
825 exec
->vtx
.prim
[i
].weak
= 0;
826 exec
->vtx
.prim
[i
].pad
= 0;
827 exec
->vtx
.prim
[i
].start
= exec
->vtx
.vert_count
;
828 exec
->vtx
.prim
[i
].count
= 0;
829 exec
->vtx
.prim
[i
].num_instances
= 1;
830 exec
->vtx
.prim
[i
].base_instance
= 0;
832 ctx
->Driver
.CurrentExecPrimitive
= mode
;
834 ctx
->Exec
= ctx
->BeginEnd
;
835 /* We may have been called from a display list, in which case we should
836 * leave dlist.c's dispatch table in place.
838 if (ctx
->CurrentDispatch
== ctx
->OutsideBeginEnd
) {
839 ctx
->CurrentDispatch
= ctx
->BeginEnd
;
840 _glapi_set_dispatch(ctx
->CurrentDispatch
);
842 assert(ctx
->CurrentDispatch
== ctx
->Save
);
850 static void GLAPIENTRY
vbo_exec_End( void )
852 GET_CURRENT_CONTEXT( ctx
);
853 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
855 if (!_mesa_inside_begin_end(ctx
)) {
856 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glEnd");
860 ctx
->Exec
= ctx
->OutsideBeginEnd
;
861 if (ctx
->CurrentDispatch
== ctx
->BeginEnd
) {
862 ctx
->CurrentDispatch
= ctx
->OutsideBeginEnd
;
863 _glapi_set_dispatch(ctx
->CurrentDispatch
);
866 if (exec
->vtx
.prim_count
> 0) {
867 /* close off current primitive */
868 int idx
= exec
->vtx
.vert_count
;
869 int i
= exec
->vtx
.prim_count
- 1;
871 exec
->vtx
.prim
[i
].end
= 1;
872 exec
->vtx
.prim
[i
].count
= idx
- exec
->vtx
.prim
[i
].start
;
875 ctx
->Driver
.CurrentExecPrimitive
= PRIM_OUTSIDE_BEGIN_END
;
877 if (exec
->vtx
.prim_count
== VBO_MAX_PRIM
)
878 vbo_exec_vtx_flush( exec
, GL_FALSE
);
880 if (MESA_DEBUG_FLAGS
& DEBUG_ALWAYS_FLUSH
) {
887 * Called via glPrimitiveRestartNV()
889 static void GLAPIENTRY
890 vbo_exec_PrimitiveRestartNV(void)
893 GET_CURRENT_CONTEXT( ctx
);
895 curPrim
= ctx
->Driver
.CurrentExecPrimitive
;
897 if (curPrim
== PRIM_OUTSIDE_BEGIN_END
) {
898 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glPrimitiveRestartNV" );
902 vbo_exec_Begin(curPrim
);
908 static void vbo_exec_vtxfmt_init( struct vbo_exec_context
*exec
)
910 struct gl_context
*ctx
= exec
->ctx
;
911 GLvertexformat
*vfmt
= &exec
->vtxfmt
;
913 vfmt
->ArrayElement
= _ae_ArrayElement
;
915 vfmt
->Begin
= vbo_exec_Begin
;
916 vfmt
->End
= vbo_exec_End
;
917 vfmt
->PrimitiveRestartNV
= vbo_exec_PrimitiveRestartNV
;
919 vfmt
->CallList
= _mesa_CallList
;
920 vfmt
->CallLists
= _mesa_CallLists
;
922 vfmt
->EvalCoord1f
= vbo_exec_EvalCoord1f
;
923 vfmt
->EvalCoord1fv
= vbo_exec_EvalCoord1fv
;
924 vfmt
->EvalCoord2f
= vbo_exec_EvalCoord2f
;
925 vfmt
->EvalCoord2fv
= vbo_exec_EvalCoord2fv
;
926 vfmt
->EvalPoint1
= vbo_exec_EvalPoint1
;
927 vfmt
->EvalPoint2
= vbo_exec_EvalPoint2
;
928 vfmt
->EvalMesh1
= vbo_exec_EvalMesh1
;
929 vfmt
->EvalMesh2
= vbo_exec_EvalMesh2
;
931 vfmt
->Rectf
= vbo_exec_Rectf
;
933 /* from attrib_tmp.h:
935 vfmt
->Color3f
= vbo_Color3f
;
936 vfmt
->Color3fv
= vbo_Color3fv
;
937 vfmt
->Color4f
= vbo_Color4f
;
938 vfmt
->Color4fv
= vbo_Color4fv
;
939 vfmt
->FogCoordfEXT
= vbo_FogCoordfEXT
;
940 vfmt
->FogCoordfvEXT
= vbo_FogCoordfvEXT
;
941 vfmt
->MultiTexCoord1fARB
= vbo_MultiTexCoord1f
;
942 vfmt
->MultiTexCoord1fvARB
= vbo_MultiTexCoord1fv
;
943 vfmt
->MultiTexCoord2fARB
= vbo_MultiTexCoord2f
;
944 vfmt
->MultiTexCoord2fvARB
= vbo_MultiTexCoord2fv
;
945 vfmt
->MultiTexCoord3fARB
= vbo_MultiTexCoord3f
;
946 vfmt
->MultiTexCoord3fvARB
= vbo_MultiTexCoord3fv
;
947 vfmt
->MultiTexCoord4fARB
= vbo_MultiTexCoord4f
;
948 vfmt
->MultiTexCoord4fvARB
= vbo_MultiTexCoord4fv
;
949 vfmt
->Normal3f
= vbo_Normal3f
;
950 vfmt
->Normal3fv
= vbo_Normal3fv
;
951 vfmt
->SecondaryColor3fEXT
= vbo_SecondaryColor3fEXT
;
952 vfmt
->SecondaryColor3fvEXT
= vbo_SecondaryColor3fvEXT
;
953 vfmt
->TexCoord1f
= vbo_TexCoord1f
;
954 vfmt
->TexCoord1fv
= vbo_TexCoord1fv
;
955 vfmt
->TexCoord2f
= vbo_TexCoord2f
;
956 vfmt
->TexCoord2fv
= vbo_TexCoord2fv
;
957 vfmt
->TexCoord3f
= vbo_TexCoord3f
;
958 vfmt
->TexCoord3fv
= vbo_TexCoord3fv
;
959 vfmt
->TexCoord4f
= vbo_TexCoord4f
;
960 vfmt
->TexCoord4fv
= vbo_TexCoord4fv
;
961 vfmt
->Vertex2f
= vbo_Vertex2f
;
962 vfmt
->Vertex2fv
= vbo_Vertex2fv
;
963 vfmt
->Vertex3f
= vbo_Vertex3f
;
964 vfmt
->Vertex3fv
= vbo_Vertex3fv
;
965 vfmt
->Vertex4f
= vbo_Vertex4f
;
966 vfmt
->Vertex4fv
= vbo_Vertex4fv
;
968 if (ctx
->API
== API_OPENGLES2
) {
969 vfmt
->VertexAttrib1fARB
= _es_VertexAttrib1f
;
970 vfmt
->VertexAttrib1fvARB
= _es_VertexAttrib1fv
;
971 vfmt
->VertexAttrib2fARB
= _es_VertexAttrib2f
;
972 vfmt
->VertexAttrib2fvARB
= _es_VertexAttrib2fv
;
973 vfmt
->VertexAttrib3fARB
= _es_VertexAttrib3f
;
974 vfmt
->VertexAttrib3fvARB
= _es_VertexAttrib3fv
;
975 vfmt
->VertexAttrib4fARB
= _es_VertexAttrib4f
;
976 vfmt
->VertexAttrib4fvARB
= _es_VertexAttrib4fv
;
978 vfmt
->VertexAttrib1fARB
= vbo_VertexAttrib1fARB
;
979 vfmt
->VertexAttrib1fvARB
= vbo_VertexAttrib1fvARB
;
980 vfmt
->VertexAttrib2fARB
= vbo_VertexAttrib2fARB
;
981 vfmt
->VertexAttrib2fvARB
= vbo_VertexAttrib2fvARB
;
982 vfmt
->VertexAttrib3fARB
= vbo_VertexAttrib3fARB
;
983 vfmt
->VertexAttrib3fvARB
= vbo_VertexAttrib3fvARB
;
984 vfmt
->VertexAttrib4fARB
= vbo_VertexAttrib4fARB
;
985 vfmt
->VertexAttrib4fvARB
= vbo_VertexAttrib4fvARB
;
988 /* Note that VertexAttrib4fNV is used from dlist.c and api_arrayelt.c so
989 * they can have a single entrypoint for updating any of the legacy
992 vfmt
->VertexAttrib1fNV
= vbo_VertexAttrib1fNV
;
993 vfmt
->VertexAttrib1fvNV
= vbo_VertexAttrib1fvNV
;
994 vfmt
->VertexAttrib2fNV
= vbo_VertexAttrib2fNV
;
995 vfmt
->VertexAttrib2fvNV
= vbo_VertexAttrib2fvNV
;
996 vfmt
->VertexAttrib3fNV
= vbo_VertexAttrib3fNV
;
997 vfmt
->VertexAttrib3fvNV
= vbo_VertexAttrib3fvNV
;
998 vfmt
->VertexAttrib4fNV
= vbo_VertexAttrib4fNV
;
999 vfmt
->VertexAttrib4fvNV
= vbo_VertexAttrib4fvNV
;
1001 /* integer-valued */
1002 vfmt
->VertexAttribI1i
= vbo_VertexAttribI1i
;
1003 vfmt
->VertexAttribI2i
= vbo_VertexAttribI2i
;
1004 vfmt
->VertexAttribI3i
= vbo_VertexAttribI3i
;
1005 vfmt
->VertexAttribI4i
= vbo_VertexAttribI4i
;
1006 vfmt
->VertexAttribI2iv
= vbo_VertexAttribI2iv
;
1007 vfmt
->VertexAttribI3iv
= vbo_VertexAttribI3iv
;
1008 vfmt
->VertexAttribI4iv
= vbo_VertexAttribI4iv
;
1010 /* unsigned integer-valued */
1011 vfmt
->VertexAttribI1ui
= vbo_VertexAttribI1ui
;
1012 vfmt
->VertexAttribI2ui
= vbo_VertexAttribI2ui
;
1013 vfmt
->VertexAttribI3ui
= vbo_VertexAttribI3ui
;
1014 vfmt
->VertexAttribI4ui
= vbo_VertexAttribI4ui
;
1015 vfmt
->VertexAttribI2uiv
= vbo_VertexAttribI2uiv
;
1016 vfmt
->VertexAttribI3uiv
= vbo_VertexAttribI3uiv
;
1017 vfmt
->VertexAttribI4uiv
= vbo_VertexAttribI4uiv
;
1019 vfmt
->Materialfv
= vbo_Materialfv
;
1021 vfmt
->EdgeFlag
= vbo_EdgeFlag
;
1022 vfmt
->Indexf
= vbo_Indexf
;
1023 vfmt
->Indexfv
= vbo_Indexfv
;
1025 /* ARB_vertex_type_2_10_10_10_rev */
1026 vfmt
->VertexP2ui
= vbo_VertexP2ui
;
1027 vfmt
->VertexP2uiv
= vbo_VertexP2uiv
;
1028 vfmt
->VertexP3ui
= vbo_VertexP3ui
;
1029 vfmt
->VertexP3uiv
= vbo_VertexP3uiv
;
1030 vfmt
->VertexP4ui
= vbo_VertexP4ui
;
1031 vfmt
->VertexP4uiv
= vbo_VertexP4uiv
;
1033 vfmt
->TexCoordP1ui
= vbo_TexCoordP1ui
;
1034 vfmt
->TexCoordP1uiv
= vbo_TexCoordP1uiv
;
1035 vfmt
->TexCoordP2ui
= vbo_TexCoordP2ui
;
1036 vfmt
->TexCoordP2uiv
= vbo_TexCoordP2uiv
;
1037 vfmt
->TexCoordP3ui
= vbo_TexCoordP3ui
;
1038 vfmt
->TexCoordP3uiv
= vbo_TexCoordP3uiv
;
1039 vfmt
->TexCoordP4ui
= vbo_TexCoordP4ui
;
1040 vfmt
->TexCoordP4uiv
= vbo_TexCoordP4uiv
;
1042 vfmt
->MultiTexCoordP1ui
= vbo_MultiTexCoordP1ui
;
1043 vfmt
->MultiTexCoordP1uiv
= vbo_MultiTexCoordP1uiv
;
1044 vfmt
->MultiTexCoordP2ui
= vbo_MultiTexCoordP2ui
;
1045 vfmt
->MultiTexCoordP2uiv
= vbo_MultiTexCoordP2uiv
;
1046 vfmt
->MultiTexCoordP3ui
= vbo_MultiTexCoordP3ui
;
1047 vfmt
->MultiTexCoordP3uiv
= vbo_MultiTexCoordP3uiv
;
1048 vfmt
->MultiTexCoordP4ui
= vbo_MultiTexCoordP4ui
;
1049 vfmt
->MultiTexCoordP4uiv
= vbo_MultiTexCoordP4uiv
;
1051 vfmt
->NormalP3ui
= vbo_NormalP3ui
;
1052 vfmt
->NormalP3uiv
= vbo_NormalP3uiv
;
1054 vfmt
->ColorP3ui
= vbo_ColorP3ui
;
1055 vfmt
->ColorP3uiv
= vbo_ColorP3uiv
;
1056 vfmt
->ColorP4ui
= vbo_ColorP4ui
;
1057 vfmt
->ColorP4uiv
= vbo_ColorP4uiv
;
1059 vfmt
->SecondaryColorP3ui
= vbo_SecondaryColorP3ui
;
1060 vfmt
->SecondaryColorP3uiv
= vbo_SecondaryColorP3uiv
;
1062 vfmt
->VertexAttribP1ui
= vbo_VertexAttribP1ui
;
1063 vfmt
->VertexAttribP1uiv
= vbo_VertexAttribP1uiv
;
1064 vfmt
->VertexAttribP2ui
= vbo_VertexAttribP2ui
;
1065 vfmt
->VertexAttribP2uiv
= vbo_VertexAttribP2uiv
;
1066 vfmt
->VertexAttribP3ui
= vbo_VertexAttribP3ui
;
1067 vfmt
->VertexAttribP3uiv
= vbo_VertexAttribP3uiv
;
1068 vfmt
->VertexAttribP4ui
= vbo_VertexAttribP4ui
;
1069 vfmt
->VertexAttribP4uiv
= vbo_VertexAttribP4uiv
;
1074 * Tell the VBO module to use a real OpenGL vertex buffer object to
1075 * store accumulated immediate-mode vertex data.
1076 * This replaces the malloced buffer which was created in
1077 * vb_exec_vtx_init() below.
1079 void vbo_use_buffer_objects(struct gl_context
*ctx
)
1081 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1082 /* Any buffer name but 0 can be used here since this bufferobj won't
1083 * go into the bufferobj hashtable.
1085 GLuint bufName
= IMM_BUFFER_NAME
;
1086 GLenum target
= GL_ARRAY_BUFFER_ARB
;
1087 GLenum usage
= GL_STREAM_DRAW_ARB
;
1088 GLsizei size
= VBO_VERT_BUFFER_SIZE
;
1090 /* Make sure this func is only used once */
1091 assert(exec
->vtx
.bufferobj
== ctx
->Shared
->NullBufferObj
);
1092 if (exec
->vtx
.buffer_map
) {
1093 _mesa_align_free(exec
->vtx
.buffer_map
);
1094 exec
->vtx
.buffer_map
= NULL
;
1095 exec
->vtx
.buffer_ptr
= NULL
;
1098 /* Allocate a real buffer object now */
1099 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1100 exec
->vtx
.bufferobj
= ctx
->Driver
.NewBufferObject(ctx
, bufName
, target
);
1101 if (!ctx
->Driver
.BufferData(ctx
, target
, size
, NULL
, usage
, exec
->vtx
.bufferobj
)) {
1102 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "VBO allocation");
1108 * If this function is called, all VBO buffers will be unmapped when
1110 * Otherwise, if a simple command like glColor3f() is called and we flush,
1111 * the current VBO may be left mapped.
1114 vbo_always_unmap_buffers(struct gl_context
*ctx
)
1116 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1117 exec
->begin_vertices_flags
|= FLUSH_STORED_VERTICES
;
1121 void vbo_exec_vtx_init( struct vbo_exec_context
*exec
)
1123 struct gl_context
*ctx
= exec
->ctx
;
1124 struct vbo_context
*vbo
= vbo_context(ctx
);
1127 /* Allocate a buffer object. Will just reuse this object
1128 * continuously, unless vbo_use_buffer_objects() is called to enable
1131 _mesa_reference_buffer_object(ctx
,
1132 &exec
->vtx
.bufferobj
,
1133 ctx
->Shared
->NullBufferObj
);
1135 ASSERT(!exec
->vtx
.buffer_map
);
1136 exec
->vtx
.buffer_map
= _mesa_align_malloc(VBO_VERT_BUFFER_SIZE
, 64);
1137 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
1139 vbo_exec_vtxfmt_init( exec
);
1140 _mesa_noop_vtxfmt_init(&exec
->vtxfmt_noop
);
1142 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1143 ASSERT(i
< Elements(exec
->vtx
.attrsz
));
1144 exec
->vtx
.attrsz
[i
] = 0;
1145 ASSERT(i
< Elements(exec
->vtx
.attrtype
));
1146 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1147 ASSERT(i
< Elements(exec
->vtx
.active_sz
));
1148 exec
->vtx
.active_sz
[i
] = 0;
1150 for (i
= 0 ; i
< VERT_ATTRIB_MAX
; i
++) {
1151 ASSERT(i
< Elements(exec
->vtx
.inputs
));
1152 ASSERT(i
< Elements(exec
->vtx
.arrays
));
1153 exec
->vtx
.inputs
[i
] = &exec
->vtx
.arrays
[i
];
1157 struct gl_client_array
*arrays
= exec
->vtx
.arrays
;
1160 memcpy(arrays
, &vbo
->currval
[VBO_ATTRIB_POS
],
1161 VERT_ATTRIB_FF_MAX
* sizeof(arrays
[0]));
1162 for (i
= 0; i
< VERT_ATTRIB_FF_MAX
; ++i
) {
1163 struct gl_client_array
*array
;
1164 array
= &arrays
[VERT_ATTRIB_FF(i
)];
1165 array
->BufferObj
= NULL
;
1166 _mesa_reference_buffer_object(ctx
, &arrays
->BufferObj
,
1167 vbo
->currval
[VBO_ATTRIB_POS
+i
].BufferObj
);
1170 memcpy(arrays
+ VERT_ATTRIB_GENERIC(0),
1171 &vbo
->currval
[VBO_ATTRIB_GENERIC0
],
1172 VERT_ATTRIB_GENERIC_MAX
* sizeof(arrays
[0]));
1174 for (i
= 0; i
< VERT_ATTRIB_GENERIC_MAX
; ++i
) {
1175 struct gl_client_array
*array
;
1176 array
= &arrays
[VERT_ATTRIB_GENERIC(i
)];
1177 array
->BufferObj
= NULL
;
1178 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1179 vbo
->currval
[VBO_ATTRIB_GENERIC0
+i
].BufferObj
);
1183 exec
->vtx
.vertex_size
= 0;
1185 exec
->begin_vertices_flags
= FLUSH_UPDATE_CURRENT
;
1189 void vbo_exec_vtx_destroy( struct vbo_exec_context
*exec
)
1191 /* using a real VBO for vertex data */
1192 struct gl_context
*ctx
= exec
->ctx
;
1195 /* True VBOs should already be unmapped
1197 if (exec
->vtx
.buffer_map
) {
1198 ASSERT(exec
->vtx
.bufferobj
->Name
== 0 ||
1199 exec
->vtx
.bufferobj
->Name
== IMM_BUFFER_NAME
);
1200 if (exec
->vtx
.bufferobj
->Name
== 0) {
1201 _mesa_align_free(exec
->vtx
.buffer_map
);
1202 exec
->vtx
.buffer_map
= NULL
;
1203 exec
->vtx
.buffer_ptr
= NULL
;
1207 /* Drop any outstanding reference to the vertex buffer
1209 for (i
= 0; i
< Elements(exec
->vtx
.arrays
); i
++) {
1210 _mesa_reference_buffer_object(ctx
,
1211 &exec
->vtx
.arrays
[i
].BufferObj
,
1215 /* Free the vertex buffer. Unmap first if needed.
1217 if (_mesa_bufferobj_mapped(exec
->vtx
.bufferobj
)) {
1218 ctx
->Driver
.UnmapBuffer(ctx
, exec
->vtx
.bufferobj
);
1220 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1225 * Called upon first glVertex, glColor, glTexCoord, etc.
1227 void vbo_exec_BeginVertices( struct gl_context
*ctx
)
1229 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1231 vbo_exec_vtx_map( exec
);
1233 assert((ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
) == 0);
1234 assert(exec
->begin_vertices_flags
);
1236 ctx
->Driver
.NeedFlush
|= exec
->begin_vertices_flags
;
1241 * Called via ctx->Driver.FlushVertices()
1242 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1244 void vbo_exec_FlushVertices( struct gl_context
*ctx
, GLuint flags
)
1246 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1249 /* debug check: make sure we don't get called recursively */
1250 exec
->flush_call_depth
++;
1251 assert(exec
->flush_call_depth
== 1);
1254 if (_mesa_inside_begin_end(ctx
)) {
1255 /* We've had glBegin but not glEnd! */
1257 exec
->flush_call_depth
--;
1258 assert(exec
->flush_call_depth
== 0);
1263 /* Flush (draw), and make sure VBO is left unmapped when done */
1264 vbo_exec_FlushVertices_internal(exec
, GL_TRUE
);
1266 /* Need to do this to ensure BeginVertices gets called again:
1268 ctx
->Driver
.NeedFlush
&= ~(FLUSH_UPDATE_CURRENT
| flags
);
1271 exec
->flush_call_depth
--;
1272 assert(exec
->flush_call_depth
== 0);
1277 static void reset_attrfv( struct vbo_exec_context
*exec
)
1281 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1282 exec
->vtx
.attrsz
[i
] = 0;
1283 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1284 exec
->vtx
.active_sz
[i
] = 0;
1287 exec
->vtx
.vertex_size
= 0;
1292 _es_Color4f(GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
1294 vbo_Color4f(r
, g
, b
, a
);
1299 _es_Normal3f(GLfloat x
, GLfloat y
, GLfloat z
)
1301 vbo_Normal3f(x
, y
, z
);
1306 _es_MultiTexCoord4f(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1308 vbo_MultiTexCoord4f(target
, s
, t
, r
, q
);
1313 _es_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
1315 vbo_Materialfv(face
, pname
, params
);
1320 _es_Materialf(GLenum face
, GLenum pname
, GLfloat param
)
1324 p
[1] = p
[2] = p
[3] = 0.0F
;
1325 vbo_Materialfv(face
, pname
, p
);
1330 * A special version of glVertexAttrib4f that does not treat index 0 as
1334 VertexAttrib4f_nopos(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1336 GET_CURRENT_CONTEXT(ctx
);
1337 if (index
< MAX_VERTEX_GENERIC_ATTRIBS
)
1338 ATTR(VBO_ATTRIB_GENERIC0
+ index
, 4, GL_FLOAT
, x
, y
, z
, w
);
1340 ERROR(GL_INVALID_VALUE
);
1344 _es_VertexAttrib4f(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1346 VertexAttrib4f_nopos(index
, x
, y
, z
, w
);
1351 _es_VertexAttrib1f(GLuint indx
, GLfloat x
)
1353 VertexAttrib4f_nopos(indx
, x
, 0.0f
, 0.0f
, 1.0f
);
1358 _es_VertexAttrib1fv(GLuint indx
, const GLfloat
* values
)
1360 VertexAttrib4f_nopos(indx
, values
[0], 0.0f
, 0.0f
, 1.0f
);
1365 _es_VertexAttrib2f(GLuint indx
, GLfloat x
, GLfloat y
)
1367 VertexAttrib4f_nopos(indx
, x
, y
, 0.0f
, 1.0f
);
1372 _es_VertexAttrib2fv(GLuint indx
, const GLfloat
* values
)
1374 VertexAttrib4f_nopos(indx
, values
[0], values
[1], 0.0f
, 1.0f
);
1379 _es_VertexAttrib3f(GLuint indx
, GLfloat x
, GLfloat y
, GLfloat z
)
1381 VertexAttrib4f_nopos(indx
, x
, y
, z
, 1.0f
);
1386 _es_VertexAttrib3fv(GLuint indx
, const GLfloat
* values
)
1388 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], 1.0f
);
1393 _es_VertexAttrib4fv(GLuint indx
, const GLfloat
* values
)
1395 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], values
[3]);