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/mfeatures.h"
38 #include "main/vtxfmt.h"
39 #include "main/dlist.h"
40 #include "main/eval.h"
41 #include "main/state.h"
42 #include "main/light.h"
43 #include "main/api_arrayelt.h"
44 #include "main/api_validate.h"
45 #include "main/dispatch.h"
47 #include "vbo_context.h"
56 /** ID/name for immediate-mode VBO */
57 #define IMM_BUFFER_NAME 0xaabbccdd
60 static void reset_attrfv( struct vbo_exec_context
*exec
);
64 * Close off the last primitive, execute the buffer, restart the
67 static void vbo_exec_wrap_buffers( struct vbo_exec_context
*exec
)
69 if (exec
->vtx
.prim_count
== 0) {
70 exec
->vtx
.copied
.nr
= 0;
71 exec
->vtx
.vert_count
= 0;
72 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
75 GLuint last_begin
= exec
->vtx
.prim
[exec
->vtx
.prim_count
-1].begin
;
78 if (exec
->ctx
->Driver
.CurrentExecPrimitive
!= PRIM_OUTSIDE_BEGIN_END
) {
79 GLint i
= exec
->vtx
.prim_count
- 1;
81 exec
->vtx
.prim
[i
].count
= (exec
->vtx
.vert_count
-
82 exec
->vtx
.prim
[i
].start
);
85 last_count
= exec
->vtx
.prim
[exec
->vtx
.prim_count
-1].count
;
87 /* Execute the buffer and save copied vertices.
89 if (exec
->vtx
.vert_count
)
90 vbo_exec_vtx_flush( exec
, GL_FALSE
);
92 exec
->vtx
.prim_count
= 0;
93 exec
->vtx
.copied
.nr
= 0;
96 /* Emit a glBegin to start the new list.
98 assert(exec
->vtx
.prim_count
== 0);
100 if (exec
->ctx
->Driver
.CurrentExecPrimitive
!= PRIM_OUTSIDE_BEGIN_END
) {
101 exec
->vtx
.prim
[0].mode
= exec
->ctx
->Driver
.CurrentExecPrimitive
;
102 exec
->vtx
.prim
[0].start
= 0;
103 exec
->vtx
.prim
[0].count
= 0;
104 exec
->vtx
.prim_count
++;
106 if (exec
->vtx
.copied
.nr
== last_count
)
107 exec
->vtx
.prim
[0].begin
= last_begin
;
114 * Deal with buffer wrapping where provoked by the vertex buffer
115 * filling up, as opposed to upgrade_vertex().
117 void vbo_exec_vtx_wrap( struct vbo_exec_context
*exec
)
119 GLfloat
*data
= exec
->vtx
.copied
.buffer
;
122 /* Run pipeline on current vertices, copy wrapped vertices
123 * to exec->vtx.copied.
125 vbo_exec_wrap_buffers( exec
);
127 /* Copy stored stored vertices to start of new list.
129 assert(exec
->vtx
.max_vert
- exec
->vtx
.vert_count
> exec
->vtx
.copied
.nr
);
131 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
132 memcpy( exec
->vtx
.buffer_ptr
, data
,
133 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
134 exec
->vtx
.buffer_ptr
+= exec
->vtx
.vertex_size
;
135 data
+= exec
->vtx
.vertex_size
;
136 exec
->vtx
.vert_count
++;
139 exec
->vtx
.copied
.nr
= 0;
144 * Copy the active vertex's values to the ctx->Current fields.
146 static void vbo_exec_copy_to_current( struct vbo_exec_context
*exec
)
148 struct gl_context
*ctx
= exec
->ctx
;
149 struct vbo_context
*vbo
= vbo_context(ctx
);
152 for (i
= VBO_ATTRIB_POS
+1 ; i
< VBO_ATTRIB_MAX
; i
++) {
153 if (exec
->vtx
.attrsz
[i
]) {
154 /* Note: the exec->vtx.current[i] pointers point into the
155 * ctx->Current.Attrib and ctx->Light.Material.Attrib arrays.
157 GLfloat
*current
= (GLfloat
*)vbo
->currval
[i
].Ptr
;
160 COPY_CLEAN_4V_TYPE_AS_FLOAT(tmp
,
162 exec
->vtx
.attrptr
[i
],
163 exec
->vtx
.attrtype
[i
]);
165 if (exec
->vtx
.attrtype
[i
] != vbo
->currval
[i
].Type
||
166 memcmp(current
, tmp
, sizeof(tmp
)) != 0) {
167 memcpy(current
, tmp
, sizeof(tmp
));
169 /* Given that we explicitly state size here, there is no need
170 * for the COPY_CLEAN above, could just copy 16 bytes and be
171 * done. The only problem is when Mesa accesses ctx->Current
174 vbo
->currval
[i
].Size
= exec
->vtx
.attrsz
[i
];
175 vbo
->currval
[i
]._ElementSize
= vbo
->currval
[i
].Size
* sizeof(GLfloat
);
176 vbo
->currval
[i
].Type
= exec
->vtx
.attrtype
[i
];
177 vbo
->currval
[i
].Integer
=
178 vbo_attrtype_to_integer_flag(exec
->vtx
.attrtype
[i
]);
180 /* This triggers rather too much recalculation of Mesa state
181 * that doesn't get used (eg light positions).
183 if (i
>= VBO_ATTRIB_MAT_FRONT_AMBIENT
&&
184 i
<= VBO_ATTRIB_MAT_BACK_INDEXES
)
185 ctx
->NewState
|= _NEW_LIGHT
;
187 ctx
->NewState
|= _NEW_CURRENT_ATTRIB
;
192 /* Colormaterial -- this kindof sucks.
194 if (ctx
->Light
.ColorMaterialEnabled
&&
195 exec
->vtx
.attrsz
[VBO_ATTRIB_COLOR0
]) {
196 _mesa_update_color_material(ctx
,
197 ctx
->Current
.Attrib
[VBO_ATTRIB_COLOR0
]);
203 * Copy current vertex attribute values into the current vertex.
206 vbo_exec_copy_from_current(struct vbo_exec_context
*exec
)
208 struct gl_context
*ctx
= exec
->ctx
;
209 struct vbo_context
*vbo
= vbo_context(ctx
);
212 for (i
= VBO_ATTRIB_POS
+ 1; i
< VBO_ATTRIB_MAX
; i
++) {
213 const GLfloat
*current
= (GLfloat
*) vbo
->currval
[i
].Ptr
;
214 switch (exec
->vtx
.attrsz
[i
]) {
215 case 4: exec
->vtx
.attrptr
[i
][3] = current
[3];
216 case 3: exec
->vtx
.attrptr
[i
][2] = current
[2];
217 case 2: exec
->vtx
.attrptr
[i
][1] = current
[1];
218 case 1: exec
->vtx
.attrptr
[i
][0] = current
[0];
226 * Flush existing data, set new attrib size, replay copied vertices.
227 * This is called when we transition from a small vertex attribute size
228 * to a larger one. Ex: glTexCoord2f -> glTexCoord4f.
229 * We need to go back over the previous 2-component texcoords and insert
230 * zero and one values.
233 vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context
*exec
,
234 GLuint attr
, GLuint newSize
)
236 struct gl_context
*ctx
= exec
->ctx
;
237 struct vbo_context
*vbo
= vbo_context(ctx
);
238 const GLint lastcount
= exec
->vtx
.vert_count
;
239 GLfloat
*old_attrptr
[VBO_ATTRIB_MAX
];
240 const GLuint old_vtx_size
= exec
->vtx
.vertex_size
; /* floats per vertex */
241 const GLuint oldSize
= exec
->vtx
.attrsz
[attr
];
244 /* Run pipeline on current vertices, copy wrapped vertices
245 * to exec->vtx.copied.
247 vbo_exec_wrap_buffers( exec
);
249 if (unlikely(exec
->vtx
.copied
.nr
)) {
250 /* We're in the middle of a primitive, keep the old vertex
251 * format around to be able to translate the copied vertices to
254 memcpy(old_attrptr
, exec
->vtx
.attrptr
, sizeof(old_attrptr
));
257 if (unlikely(oldSize
)) {
258 /* Do a COPY_TO_CURRENT to ensure back-copying works for the
259 * case when the attribute already exists in the vertex and is
260 * having its size increased.
262 vbo_exec_copy_to_current( exec
);
265 /* Heuristic: Attempt to isolate attributes received outside
266 * begin/end so that they don't bloat the vertices.
268 if (ctx
->Driver
.CurrentExecPrimitive
== PRIM_OUTSIDE_BEGIN_END
&&
269 !oldSize
&& lastcount
> 8 && exec
->vtx
.vertex_size
) {
270 vbo_exec_copy_to_current( exec
);
271 reset_attrfv( exec
);
276 exec
->vtx
.attrsz
[attr
] = newSize
;
277 exec
->vtx
.vertex_size
+= newSize
- oldSize
;
278 exec
->vtx
.max_vert
= ((VBO_VERT_BUFFER_SIZE
- exec
->vtx
.buffer_used
) /
279 (exec
->vtx
.vertex_size
* sizeof(GLfloat
)));
280 exec
->vtx
.vert_count
= 0;
281 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
283 if (unlikely(oldSize
)) {
284 /* Size changed, recalculate all the attrptr[] values
286 GLfloat
*tmp
= exec
->vtx
.vertex
;
288 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
289 if (exec
->vtx
.attrsz
[i
]) {
290 exec
->vtx
.attrptr
[i
] = tmp
;
291 tmp
+= exec
->vtx
.attrsz
[i
];
294 exec
->vtx
.attrptr
[i
] = NULL
; /* will not be dereferenced */
297 /* Copy from current to repopulate the vertex with correct
300 vbo_exec_copy_from_current( exec
);
303 /* Just have to append the new attribute at the end */
304 exec
->vtx
.attrptr
[attr
] = exec
->vtx
.vertex
+
305 exec
->vtx
.vertex_size
- newSize
;
308 /* Replay stored vertices to translate them
309 * to new format here.
311 * -- No need to replay - just copy piecewise
313 if (unlikely(exec
->vtx
.copied
.nr
)) {
314 GLfloat
*data
= exec
->vtx
.copied
.buffer
;
315 GLfloat
*dest
= exec
->vtx
.buffer_ptr
;
318 assert(exec
->vtx
.buffer_ptr
== exec
->vtx
.buffer_map
);
320 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
321 for (j
= 0 ; j
< VBO_ATTRIB_MAX
; j
++) {
322 GLuint sz
= exec
->vtx
.attrsz
[j
];
325 GLint old_offset
= old_attrptr
[j
] - exec
->vtx
.vertex
;
326 GLint new_offset
= exec
->vtx
.attrptr
[j
] - exec
->vtx
.vertex
;
331 COPY_CLEAN_4V_TYPE_AS_FLOAT(tmp
, oldSize
,
333 exec
->vtx
.attrtype
[j
]);
334 COPY_SZ_4V(dest
+ new_offset
, newSize
, tmp
);
336 GLfloat
*current
= (GLfloat
*)vbo
->currval
[j
].Ptr
;
337 COPY_SZ_4V(dest
+ new_offset
, sz
, current
);
341 COPY_SZ_4V(dest
+ new_offset
, sz
, data
+ old_offset
);
346 data
+= old_vtx_size
;
347 dest
+= exec
->vtx
.vertex_size
;
350 exec
->vtx
.buffer_ptr
= dest
;
351 exec
->vtx
.vert_count
+= exec
->vtx
.copied
.nr
;
352 exec
->vtx
.copied
.nr
= 0;
358 * This is when a vertex attribute transitions to a different size.
359 * For example, we saw a bunch of glTexCoord2f() calls and now we got a
360 * glTexCoord4f() call. We promote the array from size=2 to size=4.
363 vbo_exec_fixup_vertex(struct gl_context
*ctx
, GLuint attr
, GLuint newSize
)
365 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
367 if (newSize
> exec
->vtx
.attrsz
[attr
]) {
368 /* New size is larger. Need to flush existing vertices and get
369 * an enlarged vertex format.
371 vbo_exec_wrap_upgrade_vertex( exec
, attr
, newSize
);
373 else if (newSize
< exec
->vtx
.active_sz
[attr
]) {
376 vbo_get_default_vals_as_float(exec
->vtx
.attrtype
[attr
]);
378 /* New size is smaller - just need to fill in some
379 * zeros. Don't need to flush or wrap.
381 for (i
= newSize
; i
<= exec
->vtx
.attrsz
[attr
]; i
++)
382 exec
->vtx
.attrptr
[attr
][i
-1] = id
[i
-1];
385 exec
->vtx
.active_sz
[attr
] = newSize
;
387 /* Does setting NeedFlush belong here? Necessitates resetting
388 * vtxfmt on each flush (otherwise flags won't get reset
392 ctx
->Driver
.NeedFlush
|= FLUSH_STORED_VERTICES
;
397 * This macro is used to implement all the glVertex, glColor, glTexCoord,
398 * glVertexAttrib, etc functions.
400 #define ATTR( A, N, T, V0, V1, V2, V3 ) \
402 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
404 if (unlikely(!(ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT))) \
405 ctx->Driver.BeginVertices( ctx ); \
407 if (unlikely(exec->vtx.active_sz[A] != N)) \
408 vbo_exec_fixup_vertex(ctx, A, N); \
411 GLfloat *dest = exec->vtx.attrptr[A]; \
412 if (N>0) dest[0] = V0; \
413 if (N>1) dest[1] = V1; \
414 if (N>2) dest[2] = V2; \
415 if (N>3) dest[3] = V3; \
416 exec->vtx.attrtype[A] = T; \
420 /* This is a glVertex call */ \
423 for (i = 0; i < exec->vtx.vertex_size; i++) \
424 exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i]; \
426 exec->vtx.buffer_ptr += exec->vtx.vertex_size; \
428 /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \
429 /* something to draw (not just updating a color or texcoord).*/ \
430 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \
432 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
433 vbo_exec_vtx_wrap( exec ); \
438 #define ERROR(err) _mesa_error( ctx, err, __FUNCTION__ )
439 #define TAG(x) vbo_##x
441 #include "vbo_attrib_tmp.h"
446 * Execute a glMaterial call. Note that if GL_COLOR_MATERIAL is enabled,
447 * this may be a (partial) no-op.
449 static void GLAPIENTRY
450 vbo_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
452 GLbitfield updateMats
;
453 GET_CURRENT_CONTEXT(ctx
);
455 /* This function should be a no-op when it tries to update material
456 * attributes which are currently tracking glColor via glColorMaterial.
457 * The updateMats var will be a mask of the MAT_BIT_FRONT/BACK_x bits
458 * indicating which material attributes can actually be updated below.
460 if (ctx
->Light
.ColorMaterialEnabled
) {
461 updateMats
= ~ctx
->Light
._ColorMaterialBitmask
;
464 /* GL_COLOR_MATERIAL is disabled so don't skip any material updates */
465 updateMats
= ALL_MATERIAL_BITS
;
468 if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_FRONT
) {
469 updateMats
&= FRONT_MATERIAL_BITS
;
471 else if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_BACK
) {
472 updateMats
&= BACK_MATERIAL_BITS
;
474 else if (face
!= GL_FRONT_AND_BACK
) {
475 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterial(invalid face)");
481 if (updateMats
& MAT_BIT_FRONT_EMISSION
)
482 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_EMISSION
, 4, params
);
483 if (updateMats
& MAT_BIT_BACK_EMISSION
)
484 MAT_ATTR(VBO_ATTRIB_MAT_BACK_EMISSION
, 4, params
);
487 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
488 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
489 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
490 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
493 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
494 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
495 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
496 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
499 if (updateMats
& MAT_BIT_FRONT_SPECULAR
)
500 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SPECULAR
, 4, params
);
501 if (updateMats
& MAT_BIT_BACK_SPECULAR
)
502 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SPECULAR
, 4, params
);
505 if (*params
< 0 || *params
> ctx
->Const
.MaxShininess
) {
506 _mesa_error(ctx
, GL_INVALID_VALUE
,
507 "glMaterial(invalid shininess: %f out range [0, %f])",
508 *params
, ctx
->Const
.MaxShininess
);
511 if (updateMats
& MAT_BIT_FRONT_SHININESS
)
512 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SHININESS
, 1, params
);
513 if (updateMats
& MAT_BIT_BACK_SHININESS
)
514 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SHININESS
, 1, params
);
516 case GL_COLOR_INDEXES
:
517 if (ctx
->API
!= API_OPENGL_COMPAT
) {
518 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
521 if (updateMats
& MAT_BIT_FRONT_INDEXES
)
522 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_INDEXES
, 3, params
);
523 if (updateMats
& MAT_BIT_BACK_INDEXES
)
524 MAT_ATTR(VBO_ATTRIB_MAT_BACK_INDEXES
, 3, params
);
526 case GL_AMBIENT_AND_DIFFUSE
:
527 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
528 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
529 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
530 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
531 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
532 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
533 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
534 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
537 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
544 * Flush (draw) vertices.
545 * \param unmap - leave VBO unmapped after flushing?
548 vbo_exec_FlushVertices_internal(struct vbo_exec_context
*exec
, GLboolean unmap
)
550 if (exec
->vtx
.vert_count
|| unmap
) {
551 vbo_exec_vtx_flush( exec
, unmap
);
554 if (exec
->vtx
.vertex_size
) {
555 vbo_exec_copy_to_current( exec
);
556 reset_attrfv( exec
);
561 static void GLAPIENTRY
vbo_exec_EvalCoord1f( GLfloat u
)
563 GET_CURRENT_CONTEXT( ctx
);
564 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
568 if (exec
->eval
.recalculate_maps
)
569 vbo_exec_eval_update( exec
);
571 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
572 if (exec
->eval
.map1
[i
].map
)
573 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map1
[i
].sz
)
574 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map1
[i
].sz
);
579 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
580 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
582 vbo_exec_do_EvalCoord1f( exec
, u
);
584 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
585 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
588 static void GLAPIENTRY
vbo_exec_EvalCoord2f( GLfloat u
, GLfloat v
)
590 GET_CURRENT_CONTEXT( ctx
);
591 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
595 if (exec
->eval
.recalculate_maps
)
596 vbo_exec_eval_update( exec
);
598 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
599 if (exec
->eval
.map2
[i
].map
)
600 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map2
[i
].sz
)
601 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map2
[i
].sz
);
604 if (ctx
->Eval
.AutoNormal
)
605 if (exec
->vtx
.active_sz
[VBO_ATTRIB_NORMAL
] != 3)
606 vbo_exec_fixup_vertex( ctx
, VBO_ATTRIB_NORMAL
, 3 );
609 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
610 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
612 vbo_exec_do_EvalCoord2f( exec
, u
, v
);
614 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
615 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
618 static void GLAPIENTRY
vbo_exec_EvalCoord1fv( const GLfloat
*u
)
620 vbo_exec_EvalCoord1f( u
[0] );
623 static void GLAPIENTRY
vbo_exec_EvalCoord2fv( const GLfloat
*u
)
625 vbo_exec_EvalCoord2f( u
[0], u
[1] );
628 static void GLAPIENTRY
vbo_exec_EvalPoint1( GLint i
)
630 GET_CURRENT_CONTEXT( ctx
);
631 GLfloat du
= ((ctx
->Eval
.MapGrid1u2
- ctx
->Eval
.MapGrid1u1
) /
632 (GLfloat
) ctx
->Eval
.MapGrid1un
);
633 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid1u1
;
635 vbo_exec_EvalCoord1f( u
);
639 static void GLAPIENTRY
vbo_exec_EvalPoint2( GLint i
, GLint j
)
641 GET_CURRENT_CONTEXT( ctx
);
642 GLfloat du
= ((ctx
->Eval
.MapGrid2u2
- ctx
->Eval
.MapGrid2u1
) /
643 (GLfloat
) ctx
->Eval
.MapGrid2un
);
644 GLfloat dv
= ((ctx
->Eval
.MapGrid2v2
- ctx
->Eval
.MapGrid2v1
) /
645 (GLfloat
) ctx
->Eval
.MapGrid2vn
);
646 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid2u1
;
647 GLfloat v
= j
* dv
+ ctx
->Eval
.MapGrid2v1
;
649 vbo_exec_EvalCoord2f( u
, v
);
653 static void GLAPIENTRY
654 vbo_exec_EvalMesh1(GLenum mode
, GLint i1
, GLint i2
)
656 GET_CURRENT_CONTEXT(ctx
);
661 ASSERT_OUTSIDE_BEGIN_END(ctx
);
668 prim
= GL_LINE_STRIP
;
671 _mesa_error( ctx
, GL_INVALID_ENUM
, "glEvalMesh1(mode)" );
675 /* No effect if vertex maps disabled.
677 if (!ctx
->Eval
.Map1Vertex4
&&
678 !ctx
->Eval
.Map1Vertex3
)
681 du
= ctx
->Eval
.MapGrid1du
;
682 u
= ctx
->Eval
.MapGrid1u1
+ i1
* du
;
684 CALL_Begin(GET_DISPATCH(), (prim
));
685 for (i
=i1
;i
<=i2
;i
++,u
+=du
) {
686 CALL_EvalCoord1f(GET_DISPATCH(), (u
));
688 CALL_End(GET_DISPATCH(), ());
692 static void GLAPIENTRY
693 vbo_exec_EvalMesh2(GLenum mode
, GLint i1
, GLint i2
, GLint j1
, GLint j2
)
695 GET_CURRENT_CONTEXT(ctx
);
696 GLfloat u
, du
, v
, dv
, v1
, u1
;
699 ASSERT_OUTSIDE_BEGIN_END(ctx
);
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 GET_CURRENT_CONTEXT(ctx
);
775 ASSERT_OUTSIDE_BEGIN_END(ctx
);
777 CALL_Begin(GET_DISPATCH(), (GL_QUADS
));
778 CALL_Vertex2f(GET_DISPATCH(), (x1
, y1
));
779 CALL_Vertex2f(GET_DISPATCH(), (x2
, y1
));
780 CALL_Vertex2f(GET_DISPATCH(), (x2
, y2
));
781 CALL_Vertex2f(GET_DISPATCH(), (x1
, y2
));
782 CALL_End(GET_DISPATCH(), ());
787 * Called via glBegin.
789 static void GLAPIENTRY
vbo_exec_Begin( GLenum mode
)
791 GET_CURRENT_CONTEXT( ctx
);
792 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
795 if (ctx
->Driver
.CurrentExecPrimitive
!= PRIM_OUTSIDE_BEGIN_END
) {
796 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glBegin");
800 if (!_mesa_valid_prim_mode(ctx
, mode
, "glBegin")) {
804 vbo_draw_method(vbo_context(ctx
), DRAW_BEGIN_END
);
807 _mesa_update_state( ctx
);
809 CALL_Begin(ctx
->Exec
, (mode
));
813 if (!_mesa_valid_to_render(ctx
, "glBegin")) {
817 /* Heuristic: attempt to isolate attributes occuring outside
820 if (exec
->vtx
.vertex_size
&& !exec
->vtx
.attrsz
[0])
821 vbo_exec_FlushVertices_internal(exec
, GL_FALSE
);
823 i
= exec
->vtx
.prim_count
++;
824 exec
->vtx
.prim
[i
].mode
= mode
;
825 exec
->vtx
.prim
[i
].begin
= 1;
826 exec
->vtx
.prim
[i
].end
= 0;
827 exec
->vtx
.prim
[i
].indexed
= 0;
828 exec
->vtx
.prim
[i
].weak
= 0;
829 exec
->vtx
.prim
[i
].pad
= 0;
830 exec
->vtx
.prim
[i
].start
= exec
->vtx
.vert_count
;
831 exec
->vtx
.prim
[i
].count
= 0;
832 exec
->vtx
.prim
[i
].num_instances
= 1;
833 exec
->vtx
.prim
[i
].base_instance
= 0;
835 ctx
->Driver
.CurrentExecPrimitive
= mode
;
837 ctx
->Exec
= ctx
->BeginEnd
;
838 /* We may have been called from a display list, in which case we should
839 * leave dlist.c's dispatch table in place.
841 if (ctx
->CurrentDispatch
== ctx
->OutsideBeginEnd
) {
842 ctx
->CurrentDispatch
= ctx
->BeginEnd
;
843 _glapi_set_dispatch(ctx
->CurrentDispatch
);
845 assert(ctx
->CurrentDispatch
== ctx
->Save
);
853 static void GLAPIENTRY
vbo_exec_End( void )
855 GET_CURRENT_CONTEXT( ctx
);
856 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
858 if (ctx
->Driver
.CurrentExecPrimitive
== PRIM_OUTSIDE_BEGIN_END
) {
859 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glEnd");
863 ctx
->Exec
= ctx
->OutsideBeginEnd
;
864 if (ctx
->CurrentDispatch
== ctx
->BeginEnd
) {
865 ctx
->CurrentDispatch
= ctx
->OutsideBeginEnd
;
866 _glapi_set_dispatch(ctx
->CurrentDispatch
);
869 if (exec
->vtx
.prim_count
> 0) {
870 /* close off current primitive */
871 int idx
= exec
->vtx
.vert_count
;
872 int i
= exec
->vtx
.prim_count
- 1;
874 exec
->vtx
.prim
[i
].end
= 1;
875 exec
->vtx
.prim
[i
].count
= idx
- exec
->vtx
.prim
[i
].start
;
878 ctx
->Driver
.CurrentExecPrimitive
= PRIM_OUTSIDE_BEGIN_END
;
880 if (exec
->vtx
.prim_count
== VBO_MAX_PRIM
)
881 vbo_exec_vtx_flush( exec
, GL_FALSE
);
883 if (MESA_DEBUG_FLAGS
& DEBUG_ALWAYS_FLUSH
) {
890 * Called via glPrimitiveRestartNV()
892 static void GLAPIENTRY
893 vbo_exec_PrimitiveRestartNV(void)
896 GET_CURRENT_CONTEXT( ctx
);
898 curPrim
= ctx
->Driver
.CurrentExecPrimitive
;
900 if (curPrim
== PRIM_OUTSIDE_BEGIN_END
) {
901 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glPrimitiveRestartNV" );
905 vbo_exec_Begin(curPrim
);
911 static void vbo_exec_vtxfmt_init( struct vbo_exec_context
*exec
)
913 struct gl_context
*ctx
= exec
->ctx
;
914 GLvertexformat
*vfmt
= &exec
->vtxfmt
;
916 _MESA_INIT_ARRAYELT_VTXFMT(vfmt
, _ae_
);
918 vfmt
->Begin
= vbo_exec_Begin
;
919 vfmt
->End
= vbo_exec_End
;
920 vfmt
->PrimitiveRestartNV
= vbo_exec_PrimitiveRestartNV
;
922 _MESA_INIT_DLIST_VTXFMT(vfmt
, _mesa_
);
923 _MESA_INIT_EVAL_VTXFMT(vfmt
, vbo_exec_
);
925 vfmt
->Rectf
= vbo_exec_Rectf
;
927 /* from attrib_tmp.h:
929 vfmt
->Color3f
= vbo_Color3f
;
930 vfmt
->Color3fv
= vbo_Color3fv
;
931 vfmt
->Color4f
= vbo_Color4f
;
932 vfmt
->Color4fv
= vbo_Color4fv
;
933 vfmt
->FogCoordfEXT
= vbo_FogCoordfEXT
;
934 vfmt
->FogCoordfvEXT
= vbo_FogCoordfvEXT
;
935 vfmt
->MultiTexCoord1fARB
= vbo_MultiTexCoord1f
;
936 vfmt
->MultiTexCoord1fvARB
= vbo_MultiTexCoord1fv
;
937 vfmt
->MultiTexCoord2fARB
= vbo_MultiTexCoord2f
;
938 vfmt
->MultiTexCoord2fvARB
= vbo_MultiTexCoord2fv
;
939 vfmt
->MultiTexCoord3fARB
= vbo_MultiTexCoord3f
;
940 vfmt
->MultiTexCoord3fvARB
= vbo_MultiTexCoord3fv
;
941 vfmt
->MultiTexCoord4fARB
= vbo_MultiTexCoord4f
;
942 vfmt
->MultiTexCoord4fvARB
= vbo_MultiTexCoord4fv
;
943 vfmt
->Normal3f
= vbo_Normal3f
;
944 vfmt
->Normal3fv
= vbo_Normal3fv
;
945 vfmt
->SecondaryColor3fEXT
= vbo_SecondaryColor3fEXT
;
946 vfmt
->SecondaryColor3fvEXT
= vbo_SecondaryColor3fvEXT
;
947 vfmt
->TexCoord1f
= vbo_TexCoord1f
;
948 vfmt
->TexCoord1fv
= vbo_TexCoord1fv
;
949 vfmt
->TexCoord2f
= vbo_TexCoord2f
;
950 vfmt
->TexCoord2fv
= vbo_TexCoord2fv
;
951 vfmt
->TexCoord3f
= vbo_TexCoord3f
;
952 vfmt
->TexCoord3fv
= vbo_TexCoord3fv
;
953 vfmt
->TexCoord4f
= vbo_TexCoord4f
;
954 vfmt
->TexCoord4fv
= vbo_TexCoord4fv
;
955 vfmt
->Vertex2f
= vbo_Vertex2f
;
956 vfmt
->Vertex2fv
= vbo_Vertex2fv
;
957 vfmt
->Vertex3f
= vbo_Vertex3f
;
958 vfmt
->Vertex3fv
= vbo_Vertex3fv
;
959 vfmt
->Vertex4f
= vbo_Vertex4f
;
960 vfmt
->Vertex4fv
= vbo_Vertex4fv
;
962 if (ctx
->API
== API_OPENGLES2
) {
963 vfmt
->VertexAttrib1fARB
= _es_VertexAttrib1f
;
964 vfmt
->VertexAttrib1fvARB
= _es_VertexAttrib1fv
;
965 vfmt
->VertexAttrib2fARB
= _es_VertexAttrib2f
;
966 vfmt
->VertexAttrib2fvARB
= _es_VertexAttrib2fv
;
967 vfmt
->VertexAttrib3fARB
= _es_VertexAttrib3f
;
968 vfmt
->VertexAttrib3fvARB
= _es_VertexAttrib3fv
;
969 vfmt
->VertexAttrib4fARB
= _es_VertexAttrib4f
;
970 vfmt
->VertexAttrib4fvARB
= _es_VertexAttrib4fv
;
972 vfmt
->VertexAttrib1fARB
= vbo_VertexAttrib1fARB
;
973 vfmt
->VertexAttrib1fvARB
= vbo_VertexAttrib1fvARB
;
974 vfmt
->VertexAttrib2fARB
= vbo_VertexAttrib2fARB
;
975 vfmt
->VertexAttrib2fvARB
= vbo_VertexAttrib2fvARB
;
976 vfmt
->VertexAttrib3fARB
= vbo_VertexAttrib3fARB
;
977 vfmt
->VertexAttrib3fvARB
= vbo_VertexAttrib3fvARB
;
978 vfmt
->VertexAttrib4fARB
= vbo_VertexAttrib4fARB
;
979 vfmt
->VertexAttrib4fvARB
= vbo_VertexAttrib4fvARB
;
982 /* Note that VertexAttrib4fNV is used from dlist.c and api_arrayelt.c so
983 * they can have a single entrypoint for updating any of the legacy
986 vfmt
->VertexAttrib1fNV
= vbo_VertexAttrib1fNV
;
987 vfmt
->VertexAttrib1fvNV
= vbo_VertexAttrib1fvNV
;
988 vfmt
->VertexAttrib2fNV
= vbo_VertexAttrib2fNV
;
989 vfmt
->VertexAttrib2fvNV
= vbo_VertexAttrib2fvNV
;
990 vfmt
->VertexAttrib3fNV
= vbo_VertexAttrib3fNV
;
991 vfmt
->VertexAttrib3fvNV
= vbo_VertexAttrib3fvNV
;
992 vfmt
->VertexAttrib4fNV
= vbo_VertexAttrib4fNV
;
993 vfmt
->VertexAttrib4fvNV
= vbo_VertexAttrib4fvNV
;
996 vfmt
->VertexAttribI1i
= vbo_VertexAttribI1i
;
997 vfmt
->VertexAttribI2i
= vbo_VertexAttribI2i
;
998 vfmt
->VertexAttribI3i
= vbo_VertexAttribI3i
;
999 vfmt
->VertexAttribI4i
= vbo_VertexAttribI4i
;
1000 vfmt
->VertexAttribI2iv
= vbo_VertexAttribI2iv
;
1001 vfmt
->VertexAttribI3iv
= vbo_VertexAttribI3iv
;
1002 vfmt
->VertexAttribI4iv
= vbo_VertexAttribI4iv
;
1004 /* unsigned integer-valued */
1005 vfmt
->VertexAttribI1ui
= vbo_VertexAttribI1ui
;
1006 vfmt
->VertexAttribI2ui
= vbo_VertexAttribI2ui
;
1007 vfmt
->VertexAttribI3ui
= vbo_VertexAttribI3ui
;
1008 vfmt
->VertexAttribI4ui
= vbo_VertexAttribI4ui
;
1009 vfmt
->VertexAttribI2uiv
= vbo_VertexAttribI2uiv
;
1010 vfmt
->VertexAttribI3uiv
= vbo_VertexAttribI3uiv
;
1011 vfmt
->VertexAttribI4uiv
= vbo_VertexAttribI4uiv
;
1013 vfmt
->Materialfv
= vbo_Materialfv
;
1015 vfmt
->EdgeFlag
= vbo_EdgeFlag
;
1016 vfmt
->Indexf
= vbo_Indexf
;
1017 vfmt
->Indexfv
= vbo_Indexfv
;
1019 /* ARB_vertex_type_2_10_10_10_rev */
1020 vfmt
->VertexP2ui
= vbo_VertexP2ui
;
1021 vfmt
->VertexP2uiv
= vbo_VertexP2uiv
;
1022 vfmt
->VertexP3ui
= vbo_VertexP3ui
;
1023 vfmt
->VertexP3uiv
= vbo_VertexP3uiv
;
1024 vfmt
->VertexP4ui
= vbo_VertexP4ui
;
1025 vfmt
->VertexP4uiv
= vbo_VertexP4uiv
;
1027 vfmt
->TexCoordP1ui
= vbo_TexCoordP1ui
;
1028 vfmt
->TexCoordP1uiv
= vbo_TexCoordP1uiv
;
1029 vfmt
->TexCoordP2ui
= vbo_TexCoordP2ui
;
1030 vfmt
->TexCoordP2uiv
= vbo_TexCoordP2uiv
;
1031 vfmt
->TexCoordP3ui
= vbo_TexCoordP3ui
;
1032 vfmt
->TexCoordP3uiv
= vbo_TexCoordP3uiv
;
1033 vfmt
->TexCoordP4ui
= vbo_TexCoordP4ui
;
1034 vfmt
->TexCoordP4uiv
= vbo_TexCoordP4uiv
;
1036 vfmt
->MultiTexCoordP1ui
= vbo_MultiTexCoordP1ui
;
1037 vfmt
->MultiTexCoordP1uiv
= vbo_MultiTexCoordP1uiv
;
1038 vfmt
->MultiTexCoordP2ui
= vbo_MultiTexCoordP2ui
;
1039 vfmt
->MultiTexCoordP2uiv
= vbo_MultiTexCoordP2uiv
;
1040 vfmt
->MultiTexCoordP3ui
= vbo_MultiTexCoordP3ui
;
1041 vfmt
->MultiTexCoordP3uiv
= vbo_MultiTexCoordP3uiv
;
1042 vfmt
->MultiTexCoordP4ui
= vbo_MultiTexCoordP4ui
;
1043 vfmt
->MultiTexCoordP4uiv
= vbo_MultiTexCoordP4uiv
;
1045 vfmt
->NormalP3ui
= vbo_NormalP3ui
;
1046 vfmt
->NormalP3uiv
= vbo_NormalP3uiv
;
1048 vfmt
->ColorP3ui
= vbo_ColorP3ui
;
1049 vfmt
->ColorP3uiv
= vbo_ColorP3uiv
;
1050 vfmt
->ColorP4ui
= vbo_ColorP4ui
;
1051 vfmt
->ColorP4uiv
= vbo_ColorP4uiv
;
1053 vfmt
->SecondaryColorP3ui
= vbo_SecondaryColorP3ui
;
1054 vfmt
->SecondaryColorP3uiv
= vbo_SecondaryColorP3uiv
;
1056 vfmt
->VertexAttribP1ui
= vbo_VertexAttribP1ui
;
1057 vfmt
->VertexAttribP1uiv
= vbo_VertexAttribP1uiv
;
1058 vfmt
->VertexAttribP2ui
= vbo_VertexAttribP2ui
;
1059 vfmt
->VertexAttribP2uiv
= vbo_VertexAttribP2uiv
;
1060 vfmt
->VertexAttribP3ui
= vbo_VertexAttribP3ui
;
1061 vfmt
->VertexAttribP3uiv
= vbo_VertexAttribP3uiv
;
1062 vfmt
->VertexAttribP4ui
= vbo_VertexAttribP4ui
;
1063 vfmt
->VertexAttribP4uiv
= vbo_VertexAttribP4uiv
;
1068 * Tell the VBO module to use a real OpenGL vertex buffer object to
1069 * store accumulated immediate-mode vertex data.
1070 * This replaces the malloced buffer which was created in
1071 * vb_exec_vtx_init() below.
1073 void vbo_use_buffer_objects(struct gl_context
*ctx
)
1075 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1076 /* Any buffer name but 0 can be used here since this bufferobj won't
1077 * go into the bufferobj hashtable.
1079 GLuint bufName
= IMM_BUFFER_NAME
;
1080 GLenum target
= GL_ARRAY_BUFFER_ARB
;
1081 GLenum usage
= GL_STREAM_DRAW_ARB
;
1082 GLsizei size
= VBO_VERT_BUFFER_SIZE
;
1084 /* Make sure this func is only used once */
1085 assert(exec
->vtx
.bufferobj
== ctx
->Shared
->NullBufferObj
);
1086 if (exec
->vtx
.buffer_map
) {
1087 _mesa_align_free(exec
->vtx
.buffer_map
);
1088 exec
->vtx
.buffer_map
= NULL
;
1089 exec
->vtx
.buffer_ptr
= NULL
;
1092 /* Allocate a real buffer object now */
1093 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1094 exec
->vtx
.bufferobj
= ctx
->Driver
.NewBufferObject(ctx
, bufName
, target
);
1095 if (!ctx
->Driver
.BufferData(ctx
, target
, size
, NULL
, usage
, exec
->vtx
.bufferobj
)) {
1096 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "VBO allocation");
1102 * If this function is called, all VBO buffers will be unmapped when
1104 * Otherwise, if a simple command like glColor3f() is called and we flush,
1105 * the current VBO may be left mapped.
1108 vbo_always_unmap_buffers(struct gl_context
*ctx
)
1110 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1111 exec
->begin_vertices_flags
|= FLUSH_STORED_VERTICES
;
1115 void vbo_exec_vtx_init( struct vbo_exec_context
*exec
)
1117 struct gl_context
*ctx
= exec
->ctx
;
1118 struct vbo_context
*vbo
= vbo_context(ctx
);
1121 /* Allocate a buffer object. Will just reuse this object
1122 * continuously, unless vbo_use_buffer_objects() is called to enable
1125 _mesa_reference_buffer_object(ctx
,
1126 &exec
->vtx
.bufferobj
,
1127 ctx
->Shared
->NullBufferObj
);
1129 ASSERT(!exec
->vtx
.buffer_map
);
1130 exec
->vtx
.buffer_map
= _mesa_align_malloc(VBO_VERT_BUFFER_SIZE
, 64);
1131 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
1133 vbo_exec_vtxfmt_init( exec
);
1134 _mesa_noop_vtxfmt_init(&exec
->vtxfmt_noop
);
1136 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1137 ASSERT(i
< Elements(exec
->vtx
.attrsz
));
1138 exec
->vtx
.attrsz
[i
] = 0;
1139 ASSERT(i
< Elements(exec
->vtx
.attrtype
));
1140 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1141 ASSERT(i
< Elements(exec
->vtx
.active_sz
));
1142 exec
->vtx
.active_sz
[i
] = 0;
1144 for (i
= 0 ; i
< VERT_ATTRIB_MAX
; i
++) {
1145 ASSERT(i
< Elements(exec
->vtx
.inputs
));
1146 ASSERT(i
< Elements(exec
->vtx
.arrays
));
1147 exec
->vtx
.inputs
[i
] = &exec
->vtx
.arrays
[i
];
1151 struct gl_client_array
*arrays
= exec
->vtx
.arrays
;
1154 memcpy(arrays
, &vbo
->currval
[VBO_ATTRIB_POS
],
1155 VERT_ATTRIB_FF_MAX
* sizeof(arrays
[0]));
1156 for (i
= 0; i
< VERT_ATTRIB_FF_MAX
; ++i
) {
1157 struct gl_client_array
*array
;
1158 array
= &arrays
[VERT_ATTRIB_FF(i
)];
1159 array
->BufferObj
= NULL
;
1160 _mesa_reference_buffer_object(ctx
, &arrays
->BufferObj
,
1161 vbo
->currval
[VBO_ATTRIB_POS
+i
].BufferObj
);
1164 memcpy(arrays
+ VERT_ATTRIB_GENERIC(0),
1165 &vbo
->currval
[VBO_ATTRIB_GENERIC0
],
1166 VERT_ATTRIB_GENERIC_MAX
* sizeof(arrays
[0]));
1168 for (i
= 0; i
< VERT_ATTRIB_GENERIC_MAX
; ++i
) {
1169 struct gl_client_array
*array
;
1170 array
= &arrays
[VERT_ATTRIB_GENERIC(i
)];
1171 array
->BufferObj
= NULL
;
1172 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1173 vbo
->currval
[VBO_ATTRIB_GENERIC0
+i
].BufferObj
);
1177 exec
->vtx
.vertex_size
= 0;
1179 exec
->begin_vertices_flags
= FLUSH_UPDATE_CURRENT
;
1183 void vbo_exec_vtx_destroy( struct vbo_exec_context
*exec
)
1185 /* using a real VBO for vertex data */
1186 struct gl_context
*ctx
= exec
->ctx
;
1189 /* True VBOs should already be unmapped
1191 if (exec
->vtx
.buffer_map
) {
1192 ASSERT(exec
->vtx
.bufferobj
->Name
== 0 ||
1193 exec
->vtx
.bufferobj
->Name
== IMM_BUFFER_NAME
);
1194 if (exec
->vtx
.bufferobj
->Name
== 0) {
1195 _mesa_align_free(exec
->vtx
.buffer_map
);
1196 exec
->vtx
.buffer_map
= NULL
;
1197 exec
->vtx
.buffer_ptr
= NULL
;
1201 /* Drop any outstanding reference to the vertex buffer
1203 for (i
= 0; i
< Elements(exec
->vtx
.arrays
); i
++) {
1204 _mesa_reference_buffer_object(ctx
,
1205 &exec
->vtx
.arrays
[i
].BufferObj
,
1209 /* Free the vertex buffer. Unmap first if needed.
1211 if (_mesa_bufferobj_mapped(exec
->vtx
.bufferobj
)) {
1212 ctx
->Driver
.UnmapBuffer(ctx
, exec
->vtx
.bufferobj
);
1214 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1219 * Called upon first glVertex, glColor, glTexCoord, etc.
1221 void vbo_exec_BeginVertices( struct gl_context
*ctx
)
1223 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1225 vbo_exec_vtx_map( exec
);
1227 assert((ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
) == 0);
1228 assert(exec
->begin_vertices_flags
);
1230 ctx
->Driver
.NeedFlush
|= exec
->begin_vertices_flags
;
1235 * Called via ctx->Driver.FlushVertices()
1236 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1238 void vbo_exec_FlushVertices( struct gl_context
*ctx
, GLuint flags
)
1240 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1243 /* debug check: make sure we don't get called recursively */
1244 exec
->flush_call_depth
++;
1245 assert(exec
->flush_call_depth
== 1);
1248 if (ctx
->Driver
.CurrentExecPrimitive
!= PRIM_OUTSIDE_BEGIN_END
) {
1249 /* We've had glBegin but not glEnd! */
1251 exec
->flush_call_depth
--;
1252 assert(exec
->flush_call_depth
== 0);
1257 /* Flush (draw), and make sure VBO is left unmapped when done */
1258 vbo_exec_FlushVertices_internal(exec
, GL_TRUE
);
1260 /* Need to do this to ensure BeginVertices gets called again:
1262 ctx
->Driver
.NeedFlush
&= ~(FLUSH_UPDATE_CURRENT
| flags
);
1265 exec
->flush_call_depth
--;
1266 assert(exec
->flush_call_depth
== 0);
1271 static void reset_attrfv( struct vbo_exec_context
*exec
)
1275 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1276 exec
->vtx
.attrsz
[i
] = 0;
1277 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1278 exec
->vtx
.active_sz
[i
] = 0;
1281 exec
->vtx
.vertex_size
= 0;
1286 _es_Color4f(GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
1288 vbo_Color4f(r
, g
, b
, a
);
1293 _es_Normal3f(GLfloat x
, GLfloat y
, GLfloat z
)
1295 vbo_Normal3f(x
, y
, z
);
1300 _es_MultiTexCoord4f(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1302 vbo_MultiTexCoord4f(target
, s
, t
, r
, q
);
1307 _es_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
1309 vbo_Materialfv(face
, pname
, params
);
1314 _es_Materialf(GLenum face
, GLenum pname
, GLfloat param
)
1318 p
[1] = p
[2] = p
[3] = 0.0F
;
1319 vbo_Materialfv(face
, pname
, p
);
1324 * A special version of glVertexAttrib4f that does not treat index 0 as
1328 VertexAttrib4f_nopos(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1330 GET_CURRENT_CONTEXT(ctx
);
1331 if (index
< MAX_VERTEX_GENERIC_ATTRIBS
)
1332 ATTR(VBO_ATTRIB_GENERIC0
+ index
, 4, GL_FLOAT
, x
, y
, z
, w
);
1334 ERROR(GL_INVALID_VALUE
);
1338 _es_VertexAttrib4f(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1340 VertexAttrib4f_nopos(index
, x
, y
, z
, w
);
1345 _es_VertexAttrib1f(GLuint indx
, GLfloat x
)
1347 VertexAttrib4f_nopos(indx
, x
, 0.0f
, 0.0f
, 1.0f
);
1352 _es_VertexAttrib1fv(GLuint indx
, const GLfloat
* values
)
1354 VertexAttrib4f_nopos(indx
, values
[0], 0.0f
, 0.0f
, 1.0f
);
1359 _es_VertexAttrib2f(GLuint indx
, GLfloat x
, GLfloat y
)
1361 VertexAttrib4f_nopos(indx
, x
, y
, 0.0f
, 1.0f
);
1366 _es_VertexAttrib2fv(GLuint indx
, const GLfloat
* values
)
1368 VertexAttrib4f_nopos(indx
, values
[0], values
[1], 0.0f
, 1.0f
);
1373 _es_VertexAttrib3f(GLuint indx
, GLfloat x
, GLfloat y
, GLfloat z
)
1375 VertexAttrib4f_nopos(indx
, x
, y
, z
, 1.0f
);
1380 _es_VertexAttrib3fv(GLuint indx
, const GLfloat
* values
)
1382 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], 1.0f
);
1387 _es_VertexAttrib4fv(GLuint indx
, const GLfloat
* values
)
1389 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], values
[3]);