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
;
162 exec
->vtx
.attrptr
[i
]);
164 if (memcmp(current
, tmp
, sizeof(tmp
)) != 0) {
165 memcpy(current
, tmp
, sizeof(tmp
));
167 /* Given that we explicitly state size here, there is no need
168 * for the COPY_CLEAN above, could just copy 16 bytes and be
169 * done. The only problem is when Mesa accesses ctx->Current
172 vbo
->currval
[i
].Size
= exec
->vtx
.attrsz
[i
];
173 assert(vbo
->currval
[i
].Type
== GL_FLOAT
);
174 vbo
->currval
[i
]._ElementSize
= vbo
->currval
[i
].Size
* sizeof(GLfloat
);
176 /* This triggers rather too much recalculation of Mesa state
177 * that doesn't get used (eg light positions).
179 if (i
>= VBO_ATTRIB_MAT_FRONT_AMBIENT
&&
180 i
<= VBO_ATTRIB_MAT_BACK_INDEXES
)
181 ctx
->NewState
|= _NEW_LIGHT
;
183 ctx
->NewState
|= _NEW_CURRENT_ATTRIB
;
188 /* Colormaterial -- this kindof sucks.
190 if (ctx
->Light
.ColorMaterialEnabled
&&
191 exec
->vtx
.attrsz
[VBO_ATTRIB_COLOR0
]) {
192 _mesa_update_color_material(ctx
,
193 ctx
->Current
.Attrib
[VBO_ATTRIB_COLOR0
]);
199 * Copy current vertex attribute values into the current vertex.
202 vbo_exec_copy_from_current(struct vbo_exec_context
*exec
)
204 struct gl_context
*ctx
= exec
->ctx
;
205 struct vbo_context
*vbo
= vbo_context(ctx
);
208 for (i
= VBO_ATTRIB_POS
+ 1; i
< VBO_ATTRIB_MAX
; i
++) {
209 const GLfloat
*current
= (GLfloat
*) vbo
->currval
[i
].Ptr
;
210 switch (exec
->vtx
.attrsz
[i
]) {
211 case 4: exec
->vtx
.attrptr
[i
][3] = current
[3];
212 case 3: exec
->vtx
.attrptr
[i
][2] = current
[2];
213 case 2: exec
->vtx
.attrptr
[i
][1] = current
[1];
214 case 1: exec
->vtx
.attrptr
[i
][0] = current
[0];
222 * Flush existing data, set new attrib size, replay copied vertices.
223 * This is called when we transition from a small vertex attribute size
224 * to a larger one. Ex: glTexCoord2f -> glTexCoord4f.
225 * We need to go back over the previous 2-component texcoords and insert
226 * zero and one values.
229 vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context
*exec
,
230 GLuint attr
, GLuint newSize
)
232 struct gl_context
*ctx
= exec
->ctx
;
233 struct vbo_context
*vbo
= vbo_context(ctx
);
234 const GLint lastcount
= exec
->vtx
.vert_count
;
235 GLfloat
*old_attrptr
[VBO_ATTRIB_MAX
];
236 const GLuint old_vtx_size
= exec
->vtx
.vertex_size
; /* floats per vertex */
237 const GLuint oldSize
= exec
->vtx
.attrsz
[attr
];
240 /* Run pipeline on current vertices, copy wrapped vertices
241 * to exec->vtx.copied.
243 vbo_exec_wrap_buffers( exec
);
245 if (unlikely(exec
->vtx
.copied
.nr
)) {
246 /* We're in the middle of a primitive, keep the old vertex
247 * format around to be able to translate the copied vertices to
250 memcpy(old_attrptr
, exec
->vtx
.attrptr
, sizeof(old_attrptr
));
253 if (unlikely(oldSize
)) {
254 /* Do a COPY_TO_CURRENT to ensure back-copying works for the
255 * case when the attribute already exists in the vertex and is
256 * having its size increased.
258 vbo_exec_copy_to_current( exec
);
261 /* Heuristic: Attempt to isolate attributes received outside
262 * begin/end so that they don't bloat the vertices.
264 if (ctx
->Driver
.CurrentExecPrimitive
== PRIM_OUTSIDE_BEGIN_END
&&
265 !oldSize
&& lastcount
> 8 && exec
->vtx
.vertex_size
) {
266 vbo_exec_copy_to_current( exec
);
267 reset_attrfv( exec
);
272 exec
->vtx
.attrsz
[attr
] = newSize
;
273 exec
->vtx
.vertex_size
+= newSize
- oldSize
;
274 exec
->vtx
.max_vert
= ((VBO_VERT_BUFFER_SIZE
- exec
->vtx
.buffer_used
) /
275 (exec
->vtx
.vertex_size
* sizeof(GLfloat
)));
276 exec
->vtx
.vert_count
= 0;
277 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
279 if (unlikely(oldSize
)) {
280 /* Size changed, recalculate all the attrptr[] values
282 GLfloat
*tmp
= exec
->vtx
.vertex
;
284 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
285 if (exec
->vtx
.attrsz
[i
]) {
286 exec
->vtx
.attrptr
[i
] = tmp
;
287 tmp
+= exec
->vtx
.attrsz
[i
];
290 exec
->vtx
.attrptr
[i
] = NULL
; /* will not be dereferenced */
293 /* Copy from current to repopulate the vertex with correct
296 vbo_exec_copy_from_current( exec
);
299 /* Just have to append the new attribute at the end */
300 exec
->vtx
.attrptr
[attr
] = exec
->vtx
.vertex
+
301 exec
->vtx
.vertex_size
- newSize
;
304 /* Replay stored vertices to translate them
305 * to new format here.
307 * -- No need to replay - just copy piecewise
309 if (unlikely(exec
->vtx
.copied
.nr
)) {
310 GLfloat
*data
= exec
->vtx
.copied
.buffer
;
311 GLfloat
*dest
= exec
->vtx
.buffer_ptr
;
314 assert(exec
->vtx
.buffer_ptr
== exec
->vtx
.buffer_map
);
316 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
317 for (j
= 0 ; j
< VBO_ATTRIB_MAX
; j
++) {
318 GLuint sz
= exec
->vtx
.attrsz
[j
];
321 GLint old_offset
= old_attrptr
[j
] - exec
->vtx
.vertex
;
322 GLint new_offset
= exec
->vtx
.attrptr
[j
] - exec
->vtx
.vertex
;
327 COPY_CLEAN_4V(tmp
, oldSize
, data
+ old_offset
);
328 COPY_SZ_4V(dest
+ new_offset
, newSize
, tmp
);
330 GLfloat
*current
= (GLfloat
*)vbo
->currval
[j
].Ptr
;
331 COPY_SZ_4V(dest
+ new_offset
, sz
, current
);
335 COPY_SZ_4V(dest
+ new_offset
, sz
, data
+ old_offset
);
340 data
+= old_vtx_size
;
341 dest
+= exec
->vtx
.vertex_size
;
344 exec
->vtx
.buffer_ptr
= dest
;
345 exec
->vtx
.vert_count
+= exec
->vtx
.copied
.nr
;
346 exec
->vtx
.copied
.nr
= 0;
352 * This is when a vertex attribute transitions to a different size.
353 * For example, we saw a bunch of glTexCoord2f() calls and now we got a
354 * glTexCoord4f() call. We promote the array from size=2 to size=4.
357 vbo_exec_fixup_vertex(struct gl_context
*ctx
, GLuint attr
, GLuint newSize
)
359 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
361 if (newSize
> exec
->vtx
.attrsz
[attr
]) {
362 /* New size is larger. Need to flush existing vertices and get
363 * an enlarged vertex format.
365 vbo_exec_wrap_upgrade_vertex( exec
, attr
, newSize
);
367 else if (newSize
< exec
->vtx
.active_sz
[attr
]) {
368 static const GLfloat id
[4] = { 0, 0, 0, 1 };
371 /* New size is smaller - just need to fill in some
372 * zeros. Don't need to flush or wrap.
374 for (i
= newSize
; i
<= exec
->vtx
.attrsz
[attr
]; i
++)
375 exec
->vtx
.attrptr
[attr
][i
-1] = id
[i
-1];
378 exec
->vtx
.active_sz
[attr
] = newSize
;
380 /* Does setting NeedFlush belong here? Necessitates resetting
381 * vtxfmt on each flush (otherwise flags won't get reset
385 ctx
->Driver
.NeedFlush
|= FLUSH_STORED_VERTICES
;
390 * This macro is used to implement all the glVertex, glColor, glTexCoord,
391 * glVertexAttrib, etc functions.
393 #define ATTR( A, N, V0, V1, V2, V3 ) \
395 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
397 if (unlikely(!(ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT))) \
398 ctx->Driver.BeginVertices( ctx ); \
400 if (unlikely(exec->vtx.active_sz[A] != N)) \
401 vbo_exec_fixup_vertex(ctx, A, N); \
404 GLfloat *dest = exec->vtx.attrptr[A]; \
405 if (N>0) dest[0] = V0; \
406 if (N>1) dest[1] = V1; \
407 if (N>2) dest[2] = V2; \
408 if (N>3) dest[3] = V3; \
412 /* This is a glVertex call */ \
415 for (i = 0; i < exec->vtx.vertex_size; i++) \
416 exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i]; \
418 exec->vtx.buffer_ptr += exec->vtx.vertex_size; \
420 /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \
421 /* something to draw (not just updating a color or texcoord).*/ \
422 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \
424 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
425 vbo_exec_vtx_wrap( exec ); \
430 #define ERROR(err) _mesa_error( ctx, err, __FUNCTION__ )
431 #define TAG(x) vbo_##x
433 #include "vbo_attrib_tmp.h"
438 * Execute a glMaterial call. Note that if GL_COLOR_MATERIAL is enabled,
439 * this may be a (partial) no-op.
441 static void GLAPIENTRY
442 vbo_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
444 GLbitfield updateMats
;
445 GET_CURRENT_CONTEXT(ctx
);
447 /* This function should be a no-op when it tries to update material
448 * attributes which are currently tracking glColor via glColorMaterial.
449 * The updateMats var will be a mask of the MAT_BIT_FRONT/BACK_x bits
450 * indicating which material attributes can actually be updated below.
452 if (ctx
->Light
.ColorMaterialEnabled
) {
453 updateMats
= ~ctx
->Light
._ColorMaterialBitmask
;
456 /* GL_COLOR_MATERIAL is disabled so don't skip any material updates */
457 updateMats
= ALL_MATERIAL_BITS
;
460 if (ctx
->API
== API_OPENGL
&& face
== GL_FRONT
) {
461 updateMats
&= FRONT_MATERIAL_BITS
;
463 else if (ctx
->API
== API_OPENGL
&& face
== GL_BACK
) {
464 updateMats
&= BACK_MATERIAL_BITS
;
466 else if (face
!= GL_FRONT_AND_BACK
) {
467 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterial(invalid face)");
473 if (updateMats
& MAT_BIT_FRONT_EMISSION
)
474 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_EMISSION
, 4, params
);
475 if (updateMats
& MAT_BIT_BACK_EMISSION
)
476 MAT_ATTR(VBO_ATTRIB_MAT_BACK_EMISSION
, 4, params
);
479 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
480 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
481 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
482 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
485 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
486 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
487 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
488 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
491 if (updateMats
& MAT_BIT_FRONT_SPECULAR
)
492 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SPECULAR
, 4, params
);
493 if (updateMats
& MAT_BIT_BACK_SPECULAR
)
494 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SPECULAR
, 4, params
);
497 if (*params
< 0 || *params
> ctx
->Const
.MaxShininess
) {
498 _mesa_error(ctx
, GL_INVALID_VALUE
,
499 "glMaterial(invalid shininess: %f out range [0, %f])",
500 *params
, ctx
->Const
.MaxShininess
);
503 if (updateMats
& MAT_BIT_FRONT_SHININESS
)
504 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SHININESS
, 1, params
);
505 if (updateMats
& MAT_BIT_BACK_SHININESS
)
506 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SHININESS
, 1, params
);
508 case GL_COLOR_INDEXES
:
509 if (ctx
->API
!= API_OPENGL
) {
510 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
513 if (updateMats
& MAT_BIT_FRONT_INDEXES
)
514 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_INDEXES
, 3, params
);
515 if (updateMats
& MAT_BIT_BACK_INDEXES
)
516 MAT_ATTR(VBO_ATTRIB_MAT_BACK_INDEXES
, 3, params
);
518 case GL_AMBIENT_AND_DIFFUSE
:
519 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
520 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
521 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
522 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
523 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
524 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
525 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
526 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
529 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
536 * Flush (draw) vertices.
537 * \param unmap - leave VBO unmapped after flushing?
540 vbo_exec_FlushVertices_internal(struct vbo_exec_context
*exec
, GLboolean unmap
)
542 if (exec
->vtx
.vert_count
|| unmap
) {
543 vbo_exec_vtx_flush( exec
, unmap
);
546 if (exec
->vtx
.vertex_size
) {
547 vbo_exec_copy_to_current( exec
);
548 reset_attrfv( exec
);
556 #if FEATURE_evaluators
558 static void GLAPIENTRY
vbo_exec_EvalCoord1f( GLfloat u
)
560 GET_CURRENT_CONTEXT( ctx
);
561 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
565 if (exec
->eval
.recalculate_maps
)
566 vbo_exec_eval_update( exec
);
568 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
569 if (exec
->eval
.map1
[i
].map
)
570 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map1
[i
].sz
)
571 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map1
[i
].sz
);
576 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
577 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
579 vbo_exec_do_EvalCoord1f( exec
, u
);
581 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
582 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
585 static void GLAPIENTRY
vbo_exec_EvalCoord2f( GLfloat u
, GLfloat v
)
587 GET_CURRENT_CONTEXT( ctx
);
588 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
592 if (exec
->eval
.recalculate_maps
)
593 vbo_exec_eval_update( exec
);
595 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
596 if (exec
->eval
.map2
[i
].map
)
597 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map2
[i
].sz
)
598 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map2
[i
].sz
);
601 if (ctx
->Eval
.AutoNormal
)
602 if (exec
->vtx
.active_sz
[VBO_ATTRIB_NORMAL
] != 3)
603 vbo_exec_fixup_vertex( ctx
, VBO_ATTRIB_NORMAL
, 3 );
606 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
607 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
609 vbo_exec_do_EvalCoord2f( exec
, u
, v
);
611 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
612 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
615 static void GLAPIENTRY
vbo_exec_EvalCoord1fv( const GLfloat
*u
)
617 vbo_exec_EvalCoord1f( u
[0] );
620 static void GLAPIENTRY
vbo_exec_EvalCoord2fv( const GLfloat
*u
)
622 vbo_exec_EvalCoord2f( u
[0], u
[1] );
625 static void GLAPIENTRY
vbo_exec_EvalPoint1( GLint i
)
627 GET_CURRENT_CONTEXT( ctx
);
628 GLfloat du
= ((ctx
->Eval
.MapGrid1u2
- ctx
->Eval
.MapGrid1u1
) /
629 (GLfloat
) ctx
->Eval
.MapGrid1un
);
630 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid1u1
;
632 vbo_exec_EvalCoord1f( u
);
636 static void GLAPIENTRY
vbo_exec_EvalPoint2( GLint i
, GLint j
)
638 GET_CURRENT_CONTEXT( ctx
);
639 GLfloat du
= ((ctx
->Eval
.MapGrid2u2
- ctx
->Eval
.MapGrid2u1
) /
640 (GLfloat
) ctx
->Eval
.MapGrid2un
);
641 GLfloat dv
= ((ctx
->Eval
.MapGrid2v2
- ctx
->Eval
.MapGrid2v1
) /
642 (GLfloat
) ctx
->Eval
.MapGrid2vn
);
643 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid2u1
;
644 GLfloat v
= j
* dv
+ ctx
->Eval
.MapGrid2v1
;
646 vbo_exec_EvalCoord2f( u
, v
);
650 static void GLAPIENTRY
651 vbo_exec_EvalMesh1(GLenum mode
, GLint i1
, GLint i2
)
653 GET_CURRENT_CONTEXT(ctx
);
658 ASSERT_OUTSIDE_BEGIN_END(ctx
);
665 prim
= GL_LINE_STRIP
;
668 _mesa_error( ctx
, GL_INVALID_ENUM
, "glEvalMesh1(mode)" );
672 /* No effect if vertex maps disabled.
674 if (!ctx
->Eval
.Map1Vertex4
&&
675 !ctx
->Eval
.Map1Vertex3
&&
676 !(ctx
->VertexProgram
._Enabled
&& ctx
->Eval
.Map1Attrib
[VERT_ATTRIB_POS
]))
679 du
= ctx
->Eval
.MapGrid1du
;
680 u
= ctx
->Eval
.MapGrid1u1
+ i1
* du
;
682 CALL_Begin(GET_DISPATCH(), (prim
));
683 for (i
=i1
;i
<=i2
;i
++,u
+=du
) {
684 CALL_EvalCoord1f(GET_DISPATCH(), (u
));
686 CALL_End(GET_DISPATCH(), ());
690 static void GLAPIENTRY
691 vbo_exec_EvalMesh2(GLenum mode
, GLint i1
, GLint i2
, GLint j1
, GLint j2
)
693 GET_CURRENT_CONTEXT(ctx
);
694 GLfloat u
, du
, v
, dv
, v1
, u1
;
697 ASSERT_OUTSIDE_BEGIN_END(ctx
);
705 _mesa_error( ctx
, GL_INVALID_ENUM
, "glEvalMesh2(mode)" );
709 /* No effect if vertex maps disabled.
711 if (!ctx
->Eval
.Map2Vertex4
&&
712 !ctx
->Eval
.Map2Vertex3
&&
713 !(ctx
->VertexProgram
._Enabled
&& ctx
->Eval
.Map2Attrib
[VERT_ATTRIB_POS
]))
716 du
= ctx
->Eval
.MapGrid2du
;
717 dv
= ctx
->Eval
.MapGrid2dv
;
718 v1
= ctx
->Eval
.MapGrid2v1
+ j1
* dv
;
719 u1
= ctx
->Eval
.MapGrid2u1
+ i1
* du
;
723 CALL_Begin(GET_DISPATCH(), (GL_POINTS
));
724 for (v
=v1
,j
=j1
;j
<=j2
;j
++,v
+=dv
) {
725 for (u
=u1
,i
=i1
;i
<=i2
;i
++,u
+=du
) {
726 CALL_EvalCoord2f(GET_DISPATCH(), (u
, v
));
729 CALL_End(GET_DISPATCH(), ());
732 for (v
=v1
,j
=j1
;j
<=j2
;j
++,v
+=dv
) {
733 CALL_Begin(GET_DISPATCH(), (GL_LINE_STRIP
));
734 for (u
=u1
,i
=i1
;i
<=i2
;i
++,u
+=du
) {
735 CALL_EvalCoord2f(GET_DISPATCH(), (u
, v
));
737 CALL_End(GET_DISPATCH(), ());
739 for (u
=u1
,i
=i1
;i
<=i2
;i
++,u
+=du
) {
740 CALL_Begin(GET_DISPATCH(), (GL_LINE_STRIP
));
741 for (v
=v1
,j
=j1
;j
<=j2
;j
++,v
+=dv
) {
742 CALL_EvalCoord2f(GET_DISPATCH(), (u
, v
));
744 CALL_End(GET_DISPATCH(), ());
748 for (v
=v1
,j
=j1
;j
<j2
;j
++,v
+=dv
) {
749 CALL_Begin(GET_DISPATCH(), (GL_TRIANGLE_STRIP
));
750 for (u
=u1
,i
=i1
;i
<=i2
;i
++,u
+=du
) {
751 CALL_EvalCoord2f(GET_DISPATCH(), (u
, v
));
752 CALL_EvalCoord2f(GET_DISPATCH(), (u
, v
+dv
));
754 CALL_End(GET_DISPATCH(), ());
760 #endif /* FEATURE_evaluators */
764 * Execute a glRectf() function. This is not suitable for GL_COMPILE
765 * modes (as the test for outside begin/end is not compiled),
766 * but may be useful for drivers in circumstances which exclude
767 * display list interactions.
769 * (None of the functions in this file are suitable for GL_COMPILE
772 static void GLAPIENTRY
773 vbo_exec_Rectf(GLfloat x1
, GLfloat y1
, GLfloat x2
, GLfloat y2
)
775 GET_CURRENT_CONTEXT(ctx
);
776 ASSERT_OUTSIDE_BEGIN_END(ctx
);
778 CALL_Begin(GET_DISPATCH(), (GL_QUADS
));
779 CALL_Vertex2f(GET_DISPATCH(), (x1
, y1
));
780 CALL_Vertex2f(GET_DISPATCH(), (x2
, y1
));
781 CALL_Vertex2f(GET_DISPATCH(), (x2
, y2
));
782 CALL_Vertex2f(GET_DISPATCH(), (x1
, y2
));
783 CALL_End(GET_DISPATCH(), ());
788 * Called via glBegin.
790 static void GLAPIENTRY
vbo_exec_Begin( GLenum mode
)
792 GET_CURRENT_CONTEXT( ctx
);
794 if (ctx
->Driver
.CurrentExecPrimitive
== PRIM_OUTSIDE_BEGIN_END
) {
795 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
798 if (!_mesa_valid_prim_mode(ctx
, mode
, "glBegin")) {
802 vbo_draw_method(vbo_context(ctx
), DRAW_BEGIN_END
);
804 if (ctx
->Driver
.PrepareExecBegin
)
805 ctx
->Driver
.PrepareExecBegin(ctx
);
808 _mesa_update_state( ctx
);
810 CALL_Begin(ctx
->Exec
, (mode
));
814 if (!_mesa_valid_to_render(ctx
, "glBegin")) {
818 /* Heuristic: attempt to isolate attributes occuring outside
821 if (exec
->vtx
.vertex_size
&& !exec
->vtx
.attrsz
[0])
822 vbo_exec_FlushVertices_internal(exec
, GL_FALSE
);
824 i
= exec
->vtx
.prim_count
++;
825 exec
->vtx
.prim
[i
].mode
= mode
;
826 exec
->vtx
.prim
[i
].begin
= 1;
827 exec
->vtx
.prim
[i
].end
= 0;
828 exec
->vtx
.prim
[i
].indexed
= 0;
829 exec
->vtx
.prim
[i
].weak
= 0;
830 exec
->vtx
.prim
[i
].pad
= 0;
831 exec
->vtx
.prim
[i
].start
= exec
->vtx
.vert_count
;
832 exec
->vtx
.prim
[i
].count
= 0;
833 exec
->vtx
.prim
[i
].num_instances
= 1;
834 exec
->vtx
.prim
[i
].base_instance
= 0;
836 ctx
->Driver
.CurrentExecPrimitive
= mode
;
839 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glBegin" );
847 static void GLAPIENTRY
vbo_exec_End( void )
849 GET_CURRENT_CONTEXT( ctx
);
851 if (ctx
->Driver
.CurrentExecPrimitive
!= PRIM_OUTSIDE_BEGIN_END
) {
852 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
854 if (exec
->vtx
.prim_count
> 0) {
855 /* close off current primitive */
856 int idx
= exec
->vtx
.vert_count
;
857 int i
= exec
->vtx
.prim_count
- 1;
859 exec
->vtx
.prim
[i
].end
= 1;
860 exec
->vtx
.prim
[i
].count
= idx
- exec
->vtx
.prim
[i
].start
;
863 ctx
->Driver
.CurrentExecPrimitive
= PRIM_OUTSIDE_BEGIN_END
;
865 if (exec
->vtx
.prim_count
== VBO_MAX_PRIM
)
866 vbo_exec_vtx_flush( exec
, GL_FALSE
);
869 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glEnd" );
871 if (MESA_DEBUG_FLAGS
& DEBUG_ALWAYS_FLUSH
) {
878 * Called via glPrimitiveRestartNV()
880 static void GLAPIENTRY
881 vbo_exec_PrimitiveRestartNV(void)
884 GET_CURRENT_CONTEXT( ctx
);
886 curPrim
= ctx
->Driver
.CurrentExecPrimitive
;
888 if (curPrim
== PRIM_OUTSIDE_BEGIN_END
) {
889 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glPrimitiveRestartNV" );
893 vbo_exec_Begin(curPrim
);
899 static void vbo_exec_vtxfmt_init( struct vbo_exec_context
*exec
)
901 struct gl_context
*ctx
= exec
->ctx
;
902 GLvertexformat
*vfmt
= &exec
->vtxfmt
;
904 _MESA_INIT_ARRAYELT_VTXFMT(vfmt
, _ae_
);
906 vfmt
->Begin
= vbo_exec_Begin
;
907 vfmt
->End
= vbo_exec_End
;
908 vfmt
->PrimitiveRestartNV
= vbo_exec_PrimitiveRestartNV
;
910 _MESA_INIT_DLIST_VTXFMT(vfmt
, _mesa_
);
911 _MESA_INIT_EVAL_VTXFMT(vfmt
, vbo_exec_
);
913 vfmt
->Rectf
= vbo_exec_Rectf
;
915 /* from attrib_tmp.h:
917 vfmt
->Color3f
= vbo_Color3f
;
918 vfmt
->Color3fv
= vbo_Color3fv
;
919 vfmt
->Color4f
= vbo_Color4f
;
920 vfmt
->Color4fv
= vbo_Color4fv
;
921 vfmt
->FogCoordfEXT
= vbo_FogCoordfEXT
;
922 vfmt
->FogCoordfvEXT
= vbo_FogCoordfvEXT
;
923 vfmt
->MultiTexCoord1fARB
= vbo_MultiTexCoord1f
;
924 vfmt
->MultiTexCoord1fvARB
= vbo_MultiTexCoord1fv
;
925 vfmt
->MultiTexCoord2fARB
= vbo_MultiTexCoord2f
;
926 vfmt
->MultiTexCoord2fvARB
= vbo_MultiTexCoord2fv
;
927 vfmt
->MultiTexCoord3fARB
= vbo_MultiTexCoord3f
;
928 vfmt
->MultiTexCoord3fvARB
= vbo_MultiTexCoord3fv
;
929 vfmt
->MultiTexCoord4fARB
= vbo_MultiTexCoord4f
;
930 vfmt
->MultiTexCoord4fvARB
= vbo_MultiTexCoord4fv
;
931 vfmt
->Normal3f
= vbo_Normal3f
;
932 vfmt
->Normal3fv
= vbo_Normal3fv
;
933 vfmt
->SecondaryColor3fEXT
= vbo_SecondaryColor3fEXT
;
934 vfmt
->SecondaryColor3fvEXT
= vbo_SecondaryColor3fvEXT
;
935 vfmt
->TexCoord1f
= vbo_TexCoord1f
;
936 vfmt
->TexCoord1fv
= vbo_TexCoord1fv
;
937 vfmt
->TexCoord2f
= vbo_TexCoord2f
;
938 vfmt
->TexCoord2fv
= vbo_TexCoord2fv
;
939 vfmt
->TexCoord3f
= vbo_TexCoord3f
;
940 vfmt
->TexCoord3fv
= vbo_TexCoord3fv
;
941 vfmt
->TexCoord4f
= vbo_TexCoord4f
;
942 vfmt
->TexCoord4fv
= vbo_TexCoord4fv
;
943 vfmt
->Vertex2f
= vbo_Vertex2f
;
944 vfmt
->Vertex2fv
= vbo_Vertex2fv
;
945 vfmt
->Vertex3f
= vbo_Vertex3f
;
946 vfmt
->Vertex3fv
= vbo_Vertex3fv
;
947 vfmt
->Vertex4f
= vbo_Vertex4f
;
948 vfmt
->Vertex4fv
= vbo_Vertex4fv
;
950 if (ctx
->API
== API_OPENGLES2
) {
951 vfmt
->VertexAttrib1fARB
= _es_VertexAttrib1f
;
952 vfmt
->VertexAttrib1fvARB
= _es_VertexAttrib1fv
;
953 vfmt
->VertexAttrib2fARB
= _es_VertexAttrib2f
;
954 vfmt
->VertexAttrib2fvARB
= _es_VertexAttrib2fv
;
955 vfmt
->VertexAttrib3fARB
= _es_VertexAttrib3f
;
956 vfmt
->VertexAttrib3fvARB
= _es_VertexAttrib3fv
;
957 vfmt
->VertexAttrib4fARB
= _es_VertexAttrib4f
;
958 vfmt
->VertexAttrib4fvARB
= _es_VertexAttrib4fv
;
960 vfmt
->VertexAttrib1fARB
= vbo_VertexAttrib1fARB
;
961 vfmt
->VertexAttrib1fvARB
= vbo_VertexAttrib1fvARB
;
962 vfmt
->VertexAttrib2fARB
= vbo_VertexAttrib2fARB
;
963 vfmt
->VertexAttrib2fvARB
= vbo_VertexAttrib2fvARB
;
964 vfmt
->VertexAttrib3fARB
= vbo_VertexAttrib3fARB
;
965 vfmt
->VertexAttrib3fvARB
= vbo_VertexAttrib3fvARB
;
966 vfmt
->VertexAttrib4fARB
= vbo_VertexAttrib4fARB
;
967 vfmt
->VertexAttrib4fvARB
= vbo_VertexAttrib4fvARB
;
970 vfmt
->VertexAttrib1fNV
= vbo_VertexAttrib1fNV
;
971 vfmt
->VertexAttrib1fvNV
= vbo_VertexAttrib1fvNV
;
972 vfmt
->VertexAttrib2fNV
= vbo_VertexAttrib2fNV
;
973 vfmt
->VertexAttrib2fvNV
= vbo_VertexAttrib2fvNV
;
974 vfmt
->VertexAttrib3fNV
= vbo_VertexAttrib3fNV
;
975 vfmt
->VertexAttrib3fvNV
= vbo_VertexAttrib3fvNV
;
976 vfmt
->VertexAttrib4fNV
= vbo_VertexAttrib4fNV
;
977 vfmt
->VertexAttrib4fvNV
= vbo_VertexAttrib4fvNV
;
980 vfmt
->VertexAttribI1i
= vbo_VertexAttribI1i
;
981 vfmt
->VertexAttribI2i
= vbo_VertexAttribI2i
;
982 vfmt
->VertexAttribI3i
= vbo_VertexAttribI3i
;
983 vfmt
->VertexAttribI4i
= vbo_VertexAttribI4i
;
984 vfmt
->VertexAttribI2iv
= vbo_VertexAttribI2iv
;
985 vfmt
->VertexAttribI3iv
= vbo_VertexAttribI3iv
;
986 vfmt
->VertexAttribI4iv
= vbo_VertexAttribI4iv
;
988 /* unsigned integer-valued */
989 vfmt
->VertexAttribI1ui
= vbo_VertexAttribI1ui
;
990 vfmt
->VertexAttribI2ui
= vbo_VertexAttribI2ui
;
991 vfmt
->VertexAttribI3ui
= vbo_VertexAttribI3ui
;
992 vfmt
->VertexAttribI4ui
= vbo_VertexAttribI4ui
;
993 vfmt
->VertexAttribI2uiv
= vbo_VertexAttribI2uiv
;
994 vfmt
->VertexAttribI3uiv
= vbo_VertexAttribI3uiv
;
995 vfmt
->VertexAttribI4uiv
= vbo_VertexAttribI4uiv
;
997 vfmt
->Materialfv
= vbo_Materialfv
;
999 vfmt
->EdgeFlag
= vbo_EdgeFlag
;
1000 vfmt
->Indexf
= vbo_Indexf
;
1001 vfmt
->Indexfv
= vbo_Indexfv
;
1003 /* ARB_vertex_type_2_10_10_10_rev */
1004 vfmt
->VertexP2ui
= vbo_VertexP2ui
;
1005 vfmt
->VertexP2uiv
= vbo_VertexP2uiv
;
1006 vfmt
->VertexP3ui
= vbo_VertexP3ui
;
1007 vfmt
->VertexP3uiv
= vbo_VertexP3uiv
;
1008 vfmt
->VertexP4ui
= vbo_VertexP4ui
;
1009 vfmt
->VertexP4uiv
= vbo_VertexP4uiv
;
1011 vfmt
->TexCoordP1ui
= vbo_TexCoordP1ui
;
1012 vfmt
->TexCoordP1uiv
= vbo_TexCoordP1uiv
;
1013 vfmt
->TexCoordP2ui
= vbo_TexCoordP2ui
;
1014 vfmt
->TexCoordP2uiv
= vbo_TexCoordP2uiv
;
1015 vfmt
->TexCoordP3ui
= vbo_TexCoordP3ui
;
1016 vfmt
->TexCoordP3uiv
= vbo_TexCoordP3uiv
;
1017 vfmt
->TexCoordP4ui
= vbo_TexCoordP4ui
;
1018 vfmt
->TexCoordP4uiv
= vbo_TexCoordP4uiv
;
1020 vfmt
->MultiTexCoordP1ui
= vbo_MultiTexCoordP1ui
;
1021 vfmt
->MultiTexCoordP1uiv
= vbo_MultiTexCoordP1uiv
;
1022 vfmt
->MultiTexCoordP2ui
= vbo_MultiTexCoordP2ui
;
1023 vfmt
->MultiTexCoordP2uiv
= vbo_MultiTexCoordP2uiv
;
1024 vfmt
->MultiTexCoordP3ui
= vbo_MultiTexCoordP3ui
;
1025 vfmt
->MultiTexCoordP3uiv
= vbo_MultiTexCoordP3uiv
;
1026 vfmt
->MultiTexCoordP4ui
= vbo_MultiTexCoordP4ui
;
1027 vfmt
->MultiTexCoordP4uiv
= vbo_MultiTexCoordP4uiv
;
1029 vfmt
->NormalP3ui
= vbo_NormalP3ui
;
1030 vfmt
->NormalP3uiv
= vbo_NormalP3uiv
;
1032 vfmt
->ColorP3ui
= vbo_ColorP3ui
;
1033 vfmt
->ColorP3uiv
= vbo_ColorP3uiv
;
1034 vfmt
->ColorP4ui
= vbo_ColorP4ui
;
1035 vfmt
->ColorP4uiv
= vbo_ColorP4uiv
;
1037 vfmt
->SecondaryColorP3ui
= vbo_SecondaryColorP3ui
;
1038 vfmt
->SecondaryColorP3uiv
= vbo_SecondaryColorP3uiv
;
1040 vfmt
->VertexAttribP1ui
= vbo_VertexAttribP1ui
;
1041 vfmt
->VertexAttribP1uiv
= vbo_VertexAttribP1uiv
;
1042 vfmt
->VertexAttribP2ui
= vbo_VertexAttribP2ui
;
1043 vfmt
->VertexAttribP2uiv
= vbo_VertexAttribP2uiv
;
1044 vfmt
->VertexAttribP3ui
= vbo_VertexAttribP3ui
;
1045 vfmt
->VertexAttribP3uiv
= vbo_VertexAttribP3uiv
;
1046 vfmt
->VertexAttribP4ui
= vbo_VertexAttribP4ui
;
1047 vfmt
->VertexAttribP4uiv
= vbo_VertexAttribP4uiv
;
1051 #else /* FEATURE_beginend */
1054 static void vbo_exec_vtxfmt_init( struct vbo_exec_context
*exec
)
1056 /* silence warnings */
1058 (void) vbo_Color3fv
;
1060 (void) vbo_Color4fv
;
1061 (void) vbo_FogCoordfEXT
;
1062 (void) vbo_FogCoordfvEXT
;
1063 (void) vbo_MultiTexCoord1f
;
1064 (void) vbo_MultiTexCoord1fv
;
1065 (void) vbo_MultiTexCoord2f
;
1066 (void) vbo_MultiTexCoord2fv
;
1067 (void) vbo_MultiTexCoord3f
;
1068 (void) vbo_MultiTexCoord3fv
;
1069 (void) vbo_MultiTexCoord4f
;
1070 (void) vbo_MultiTexCoord4fv
;
1071 (void) vbo_Normal3f
;
1072 (void) vbo_Normal3fv
;
1073 (void) vbo_SecondaryColor3fEXT
;
1074 (void) vbo_SecondaryColor3fvEXT
;
1075 (void) vbo_TexCoord1f
;
1076 (void) vbo_TexCoord1fv
;
1077 (void) vbo_TexCoord2f
;
1078 (void) vbo_TexCoord2fv
;
1079 (void) vbo_TexCoord3f
;
1080 (void) vbo_TexCoord3fv
;
1081 (void) vbo_TexCoord4f
;
1082 (void) vbo_TexCoord4fv
;
1083 (void) vbo_Vertex2f
;
1084 (void) vbo_Vertex2fv
;
1085 (void) vbo_Vertex3f
;
1086 (void) vbo_Vertex3fv
;
1087 (void) vbo_Vertex4f
;
1088 (void) vbo_Vertex4fv
;
1090 (void) vbo_VertexAttrib1fARB
;
1091 (void) vbo_VertexAttrib1fvARB
;
1092 (void) vbo_VertexAttrib2fARB
;
1093 (void) vbo_VertexAttrib2fvARB
;
1094 (void) vbo_VertexAttrib3fARB
;
1095 (void) vbo_VertexAttrib3fvARB
;
1096 (void) vbo_VertexAttrib4fARB
;
1097 (void) vbo_VertexAttrib4fvARB
;
1099 (void) vbo_VertexAttrib1fNV
;
1100 (void) vbo_VertexAttrib1fvNV
;
1101 (void) vbo_VertexAttrib2fNV
;
1102 (void) vbo_VertexAttrib2fvNV
;
1103 (void) vbo_VertexAttrib3fNV
;
1104 (void) vbo_VertexAttrib3fvNV
;
1105 (void) vbo_VertexAttrib4fNV
;
1106 (void) vbo_VertexAttrib4fvNV
;
1108 (void) vbo_Materialfv
;
1110 (void) vbo_EdgeFlag
;
1116 #endif /* FEATURE_beginend */
1120 * Tell the VBO module to use a real OpenGL vertex buffer object to
1121 * store accumulated immediate-mode vertex data.
1122 * This replaces the malloced buffer which was created in
1123 * vb_exec_vtx_init() below.
1125 void vbo_use_buffer_objects(struct gl_context
*ctx
)
1127 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1128 /* Any buffer name but 0 can be used here since this bufferobj won't
1129 * go into the bufferobj hashtable.
1131 GLuint bufName
= IMM_BUFFER_NAME
;
1132 GLenum target
= GL_ARRAY_BUFFER_ARB
;
1133 GLenum usage
= GL_STREAM_DRAW_ARB
;
1134 GLsizei size
= VBO_VERT_BUFFER_SIZE
;
1136 /* Make sure this func is only used once */
1137 assert(exec
->vtx
.bufferobj
== ctx
->Shared
->NullBufferObj
);
1138 if (exec
->vtx
.buffer_map
) {
1139 _mesa_align_free(exec
->vtx
.buffer_map
);
1140 exec
->vtx
.buffer_map
= NULL
;
1141 exec
->vtx
.buffer_ptr
= NULL
;
1144 /* Allocate a real buffer object now */
1145 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1146 exec
->vtx
.bufferobj
= ctx
->Driver
.NewBufferObject(ctx
, bufName
, target
);
1147 if (!ctx
->Driver
.BufferData(ctx
, target
, size
, NULL
, usage
, exec
->vtx
.bufferobj
)) {
1148 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "VBO allocation");
1154 * If this function is called, all VBO buffers will be unmapped when
1156 * Otherwise, if a simple command like glColor3f() is called and we flush,
1157 * the current VBO may be left mapped.
1160 vbo_always_unmap_buffers(struct gl_context
*ctx
)
1162 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1163 exec
->begin_vertices_flags
|= FLUSH_STORED_VERTICES
;
1167 void vbo_exec_vtx_init( struct vbo_exec_context
*exec
)
1169 struct gl_context
*ctx
= exec
->ctx
;
1170 struct vbo_context
*vbo
= vbo_context(ctx
);
1173 /* Allocate a buffer object. Will just reuse this object
1174 * continuously, unless vbo_use_buffer_objects() is called to enable
1177 _mesa_reference_buffer_object(ctx
,
1178 &exec
->vtx
.bufferobj
,
1179 ctx
->Shared
->NullBufferObj
);
1181 ASSERT(!exec
->vtx
.buffer_map
);
1182 exec
->vtx
.buffer_map
= _mesa_align_malloc(VBO_VERT_BUFFER_SIZE
, 64);
1183 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
1185 vbo_exec_vtxfmt_init( exec
);
1186 _mesa_noop_vtxfmt_init(&exec
->vtxfmt_noop
);
1188 /* Hook our functions into the dispatch table.
1190 _mesa_install_exec_vtxfmt( ctx
, &exec
->vtxfmt
);
1192 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1193 ASSERT(i
< Elements(exec
->vtx
.attrsz
));
1194 exec
->vtx
.attrsz
[i
] = 0;
1195 ASSERT(i
< Elements(exec
->vtx
.active_sz
));
1196 exec
->vtx
.active_sz
[i
] = 0;
1198 for (i
= 0 ; i
< VERT_ATTRIB_MAX
; i
++) {
1199 ASSERT(i
< Elements(exec
->vtx
.inputs
));
1200 ASSERT(i
< Elements(exec
->vtx
.arrays
));
1201 exec
->vtx
.inputs
[i
] = &exec
->vtx
.arrays
[i
];
1205 struct gl_client_array
*arrays
= exec
->vtx
.arrays
;
1208 memcpy(arrays
, &vbo
->currval
[VBO_ATTRIB_POS
],
1209 VERT_ATTRIB_FF_MAX
* sizeof(arrays
[0]));
1210 for (i
= 0; i
< VERT_ATTRIB_FF_MAX
; ++i
) {
1211 struct gl_client_array
*array
;
1212 array
= &arrays
[VERT_ATTRIB_FF(i
)];
1213 array
->BufferObj
= NULL
;
1214 _mesa_reference_buffer_object(ctx
, &arrays
->BufferObj
,
1215 vbo
->currval
[VBO_ATTRIB_POS
+i
].BufferObj
);
1218 memcpy(arrays
+ VERT_ATTRIB_GENERIC(0),
1219 &vbo
->currval
[VBO_ATTRIB_GENERIC0
],
1220 VERT_ATTRIB_GENERIC_MAX
* sizeof(arrays
[0]));
1222 for (i
= 0; i
< VERT_ATTRIB_GENERIC_MAX
; ++i
) {
1223 struct gl_client_array
*array
;
1224 array
= &arrays
[VERT_ATTRIB_GENERIC(i
)];
1225 array
->BufferObj
= NULL
;
1226 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1227 vbo
->currval
[VBO_ATTRIB_GENERIC0
+i
].BufferObj
);
1231 exec
->vtx
.vertex_size
= 0;
1233 exec
->begin_vertices_flags
= FLUSH_UPDATE_CURRENT
;
1237 void vbo_exec_vtx_destroy( struct vbo_exec_context
*exec
)
1239 /* using a real VBO for vertex data */
1240 struct gl_context
*ctx
= exec
->ctx
;
1243 /* True VBOs should already be unmapped
1245 if (exec
->vtx
.buffer_map
) {
1246 ASSERT(exec
->vtx
.bufferobj
->Name
== 0 ||
1247 exec
->vtx
.bufferobj
->Name
== IMM_BUFFER_NAME
);
1248 if (exec
->vtx
.bufferobj
->Name
== 0) {
1249 _mesa_align_free(exec
->vtx
.buffer_map
);
1250 exec
->vtx
.buffer_map
= NULL
;
1251 exec
->vtx
.buffer_ptr
= NULL
;
1255 /* Drop any outstanding reference to the vertex buffer
1257 for (i
= 0; i
< Elements(exec
->vtx
.arrays
); i
++) {
1258 _mesa_reference_buffer_object(ctx
,
1259 &exec
->vtx
.arrays
[i
].BufferObj
,
1263 /* Free the vertex buffer. Unmap first if needed.
1265 if (_mesa_bufferobj_mapped(exec
->vtx
.bufferobj
)) {
1266 ctx
->Driver
.UnmapBuffer(ctx
, exec
->vtx
.bufferobj
);
1268 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1273 * Called upon first glVertex, glColor, glTexCoord, etc.
1275 void vbo_exec_BeginVertices( struct gl_context
*ctx
)
1277 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1279 vbo_exec_vtx_map( exec
);
1281 assert((ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
) == 0);
1282 assert(exec
->begin_vertices_flags
);
1284 ctx
->Driver
.NeedFlush
|= exec
->begin_vertices_flags
;
1289 * Called via ctx->Driver.FlushVertices()
1290 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1292 void vbo_exec_FlushVertices( struct gl_context
*ctx
, GLuint flags
)
1294 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1297 /* debug check: make sure we don't get called recursively */
1298 exec
->flush_call_depth
++;
1299 assert(exec
->flush_call_depth
== 1);
1302 if (ctx
->Driver
.CurrentExecPrimitive
!= PRIM_OUTSIDE_BEGIN_END
) {
1303 /* We've had glBegin but not glEnd! */
1305 exec
->flush_call_depth
--;
1306 assert(exec
->flush_call_depth
== 0);
1311 /* Flush (draw), and make sure VBO is left unmapped when done */
1312 vbo_exec_FlushVertices_internal(exec
, GL_TRUE
);
1314 /* Need to do this to ensure BeginVertices gets called again:
1316 ctx
->Driver
.NeedFlush
&= ~(FLUSH_UPDATE_CURRENT
| flags
);
1319 exec
->flush_call_depth
--;
1320 assert(exec
->flush_call_depth
== 0);
1325 static void reset_attrfv( struct vbo_exec_context
*exec
)
1329 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1330 exec
->vtx
.attrsz
[i
] = 0;
1331 exec
->vtx
.active_sz
[i
] = 0;
1334 exec
->vtx
.vertex_size
= 0;
1339 _es_Color4f(GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
1341 vbo_Color4f(r
, g
, b
, a
);
1346 _es_Normal3f(GLfloat x
, GLfloat y
, GLfloat z
)
1348 vbo_Normal3f(x
, y
, z
);
1353 _es_MultiTexCoord4f(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1355 vbo_MultiTexCoord4f(target
, s
, t
, r
, q
);
1360 _es_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
1362 vbo_Materialfv(face
, pname
, params
);
1367 _es_Materialf(GLenum face
, GLenum pname
, GLfloat param
)
1371 p
[1] = p
[2] = p
[3] = 0.0F
;
1372 vbo_Materialfv(face
, pname
, p
);
1377 * A special version of glVertexAttrib4f that does not treat index 0 as
1381 VertexAttrib4f_nopos(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1383 GET_CURRENT_CONTEXT(ctx
);
1384 if (index
< MAX_VERTEX_GENERIC_ATTRIBS
)
1385 ATTR(VBO_ATTRIB_GENERIC0
+ index
, 4, x
, y
, z
, w
);
1387 ERROR(GL_INVALID_VALUE
);
1391 _es_VertexAttrib4f(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1393 VertexAttrib4f_nopos(index
, x
, y
, z
, w
);
1398 _es_VertexAttrib1f(GLuint indx
, GLfloat x
)
1400 VertexAttrib4f_nopos(indx
, x
, 0.0f
, 0.0f
, 1.0f
);
1405 _es_VertexAttrib1fv(GLuint indx
, const GLfloat
* values
)
1407 VertexAttrib4f_nopos(indx
, values
[0], 0.0f
, 0.0f
, 1.0f
);
1412 _es_VertexAttrib2f(GLuint indx
, GLfloat x
, GLfloat y
)
1414 VertexAttrib4f_nopos(indx
, x
, y
, 0.0f
, 1.0f
);
1419 _es_VertexAttrib2fv(GLuint indx
, const GLfloat
* values
)
1421 VertexAttrib4f_nopos(indx
, values
[0], values
[1], 0.0f
, 1.0f
);
1426 _es_VertexAttrib3f(GLuint indx
, GLfloat x
, GLfloat y
, GLfloat z
)
1428 VertexAttrib4f_nopos(indx
, x
, y
, z
, 1.0f
);
1433 _es_VertexAttrib3fv(GLuint indx
, const GLfloat
* values
)
1435 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], 1.0f
);
1440 _es_VertexAttrib4fv(GLuint indx
, const GLfloat
* values
)
1442 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], values
[3]);