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_noop.h"
45 #include "main/dispatch.h"
47 #include "vbo_context.h"
54 /** ID/name for immediate-mode VBO */
55 #define IMM_BUFFER_NAME 0xaabbccdd
58 static void reset_attrfv( struct vbo_exec_context
*exec
);
62 * Close off the last primitive, execute the buffer, restart the
65 static void vbo_exec_wrap_buffers( struct vbo_exec_context
*exec
)
67 if (exec
->vtx
.prim_count
== 0) {
68 exec
->vtx
.copied
.nr
= 0;
69 exec
->vtx
.vert_count
= 0;
70 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
73 GLuint last_begin
= exec
->vtx
.prim
[exec
->vtx
.prim_count
-1].begin
;
76 if (exec
->ctx
->Driver
.CurrentExecPrimitive
!= PRIM_OUTSIDE_BEGIN_END
) {
77 GLint i
= exec
->vtx
.prim_count
- 1;
79 exec
->vtx
.prim
[i
].count
= (exec
->vtx
.vert_count
-
80 exec
->vtx
.prim
[i
].start
);
83 last_count
= exec
->vtx
.prim
[exec
->vtx
.prim_count
-1].count
;
85 /* Execute the buffer and save copied vertices.
87 if (exec
->vtx
.vert_count
)
88 vbo_exec_vtx_flush( exec
, GL_FALSE
);
90 exec
->vtx
.prim_count
= 0;
91 exec
->vtx
.copied
.nr
= 0;
94 /* Emit a glBegin to start the new list.
96 assert(exec
->vtx
.prim_count
== 0);
98 if (exec
->ctx
->Driver
.CurrentExecPrimitive
!= PRIM_OUTSIDE_BEGIN_END
) {
99 exec
->vtx
.prim
[0].mode
= exec
->ctx
->Driver
.CurrentExecPrimitive
;
100 exec
->vtx
.prim
[0].start
= 0;
101 exec
->vtx
.prim
[0].count
= 0;
102 exec
->vtx
.prim_count
++;
104 if (exec
->vtx
.copied
.nr
== last_count
)
105 exec
->vtx
.prim
[0].begin
= last_begin
;
112 * Deal with buffer wrapping where provoked by the vertex buffer
113 * filling up, as opposed to upgrade_vertex().
115 void vbo_exec_vtx_wrap( struct vbo_exec_context
*exec
)
117 GLfloat
*data
= exec
->vtx
.copied
.buffer
;
120 /* Run pipeline on current vertices, copy wrapped vertices
121 * to exec->vtx.copied.
123 vbo_exec_wrap_buffers( exec
);
125 /* Copy stored stored vertices to start of new list.
127 assert(exec
->vtx
.max_vert
- exec
->vtx
.vert_count
> exec
->vtx
.copied
.nr
);
129 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
130 memcpy( exec
->vtx
.buffer_ptr
, data
,
131 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
132 exec
->vtx
.buffer_ptr
+= exec
->vtx
.vertex_size
;
133 data
+= exec
->vtx
.vertex_size
;
134 exec
->vtx
.vert_count
++;
137 exec
->vtx
.copied
.nr
= 0;
142 * Copy the active vertex's values to the ctx->Current fields.
144 static void vbo_exec_copy_to_current( struct vbo_exec_context
*exec
)
146 struct gl_context
*ctx
= exec
->ctx
;
147 struct vbo_context
*vbo
= vbo_context(ctx
);
150 for (i
= VBO_ATTRIB_POS
+1 ; i
< VBO_ATTRIB_MAX
; i
++) {
151 if (exec
->vtx
.attrsz
[i
]) {
152 /* Note: the exec->vtx.current[i] pointers point into the
153 * ctx->Current.Attrib and ctx->Light.Material.Attrib arrays.
155 GLfloat
*current
= (GLfloat
*)vbo
->currval
[i
].Ptr
;
160 exec
->vtx
.attrptr
[i
]);
162 if (memcmp(current
, tmp
, sizeof(tmp
)) != 0) {
163 memcpy(current
, tmp
, sizeof(tmp
));
165 /* Given that we explicitly state size here, there is no need
166 * for the COPY_CLEAN above, could just copy 16 bytes and be
167 * done. The only problem is when Mesa accesses ctx->Current
170 vbo
->currval
[i
].Size
= exec
->vtx
.attrsz
[i
];
172 /* This triggers rather too much recalculation of Mesa state
173 * that doesn't get used (eg light positions).
175 if (i
>= VBO_ATTRIB_MAT_FRONT_AMBIENT
&&
176 i
<= VBO_ATTRIB_MAT_BACK_INDEXES
)
177 ctx
->NewState
|= _NEW_LIGHT
;
179 ctx
->NewState
|= _NEW_CURRENT_ATTRIB
;
184 /* Colormaterial -- this kindof sucks.
186 if (ctx
->Light
.ColorMaterialEnabled
&&
187 exec
->vtx
.attrsz
[VBO_ATTRIB_COLOR0
]) {
188 _mesa_update_color_material(ctx
,
189 ctx
->Current
.Attrib
[VBO_ATTRIB_COLOR0
]);
195 * Copy current vertex attribute values into the current vertex.
198 vbo_exec_copy_from_current(struct vbo_exec_context
*exec
)
200 struct gl_context
*ctx
= exec
->ctx
;
201 struct vbo_context
*vbo
= vbo_context(ctx
);
204 for (i
= VBO_ATTRIB_POS
+ 1; i
< VBO_ATTRIB_MAX
; i
++) {
205 const GLfloat
*current
= (GLfloat
*) vbo
->currval
[i
].Ptr
;
206 switch (exec
->vtx
.attrsz
[i
]) {
207 case 4: exec
->vtx
.attrptr
[i
][3] = current
[3];
208 case 3: exec
->vtx
.attrptr
[i
][2] = current
[2];
209 case 2: exec
->vtx
.attrptr
[i
][1] = current
[1];
210 case 1: exec
->vtx
.attrptr
[i
][0] = current
[0];
218 * Flush existing data, set new attrib size, replay copied vertices.
219 * This is called when we transition from a small vertex attribute size
220 * to a larger one. Ex: glTexCoord2f -> glTexCoord4f.
221 * We need to go back over the previous 2-component texcoords and insert
222 * zero and one values.
225 vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context
*exec
,
226 GLuint attr
, GLuint newSize
)
228 struct gl_context
*ctx
= exec
->ctx
;
229 struct vbo_context
*vbo
= vbo_context(ctx
);
230 const GLint lastcount
= exec
->vtx
.vert_count
;
231 GLfloat
*old_attrptr
[VBO_ATTRIB_MAX
];
232 const GLuint old_vtx_size
= exec
->vtx
.vertex_size
; /* floats per vertex */
233 const GLuint oldSize
= exec
->vtx
.attrsz
[attr
];
236 /* Run pipeline on current vertices, copy wrapped vertices
237 * to exec->vtx.copied.
239 vbo_exec_wrap_buffers( exec
);
241 if (unlikely(exec
->vtx
.copied
.nr
)) {
242 /* We're in the middle of a primitive, keep the old vertex
243 * format around to be able to translate the copied vertices to
246 memcpy(old_attrptr
, exec
->vtx
.attrptr
, sizeof(old_attrptr
));
249 if (unlikely(oldSize
)) {
250 /* Do a COPY_TO_CURRENT to ensure back-copying works for the
251 * case when the attribute already exists in the vertex and is
252 * having its size increased.
254 vbo_exec_copy_to_current( exec
);
257 /* Heuristic: Attempt to isolate attributes received outside
258 * begin/end so that they don't bloat the vertices.
260 if (ctx
->Driver
.CurrentExecPrimitive
== PRIM_OUTSIDE_BEGIN_END
&&
261 !oldSize
&& lastcount
> 8 && exec
->vtx
.vertex_size
) {
262 vbo_exec_copy_to_current( exec
);
263 reset_attrfv( exec
);
268 exec
->vtx
.attrsz
[attr
] = newSize
;
269 exec
->vtx
.vertex_size
+= newSize
- oldSize
;
270 exec
->vtx
.max_vert
= ((VBO_VERT_BUFFER_SIZE
- exec
->vtx
.buffer_used
) /
271 (exec
->vtx
.vertex_size
* sizeof(GLfloat
)));
272 exec
->vtx
.vert_count
= 0;
273 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
275 if (unlikely(oldSize
)) {
276 /* Size changed, recalculate all the attrptr[] values
278 GLfloat
*tmp
= exec
->vtx
.vertex
;
280 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
281 if (exec
->vtx
.attrsz
[i
]) {
282 exec
->vtx
.attrptr
[i
] = tmp
;
283 tmp
+= exec
->vtx
.attrsz
[i
];
286 exec
->vtx
.attrptr
[i
] = NULL
; /* will not be dereferenced */
289 /* Copy from current to repopulate the vertex with correct
292 vbo_exec_copy_from_current( exec
);
295 /* Just have to append the new attribute at the end */
296 exec
->vtx
.attrptr
[attr
] = exec
->vtx
.vertex
+
297 exec
->vtx
.vertex_size
- newSize
;
300 /* Replay stored vertices to translate them
301 * to new format here.
303 * -- No need to replay - just copy piecewise
305 if (unlikely(exec
->vtx
.copied
.nr
)) {
306 GLfloat
*data
= exec
->vtx
.copied
.buffer
;
307 GLfloat
*dest
= exec
->vtx
.buffer_ptr
;
310 assert(exec
->vtx
.buffer_ptr
== exec
->vtx
.buffer_map
);
312 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
313 for (j
= 0 ; j
< VBO_ATTRIB_MAX
; j
++) {
314 GLuint sz
= exec
->vtx
.attrsz
[j
];
317 GLint old_offset
= old_attrptr
[j
] - exec
->vtx
.vertex
;
318 GLint new_offset
= exec
->vtx
.attrptr
[j
] - exec
->vtx
.vertex
;
323 COPY_CLEAN_4V(tmp
, oldSize
, data
+ old_offset
);
324 COPY_SZ_4V(dest
+ new_offset
, newSize
, tmp
);
326 GLfloat
*current
= (GLfloat
*)vbo
->currval
[j
].Ptr
;
327 COPY_SZ_4V(dest
+ new_offset
, sz
, current
);
331 COPY_SZ_4V(dest
+ new_offset
, sz
, data
+ old_offset
);
336 data
+= old_vtx_size
;
337 dest
+= exec
->vtx
.vertex_size
;
340 exec
->vtx
.buffer_ptr
= dest
;
341 exec
->vtx
.vert_count
+= exec
->vtx
.copied
.nr
;
342 exec
->vtx
.copied
.nr
= 0;
348 * This is when a vertex attribute transitions to a different size.
349 * For example, we saw a bunch of glTexCoord2f() calls and now we got a
350 * glTexCoord4f() call. We promote the array from size=2 to size=4.
353 vbo_exec_fixup_vertex(struct gl_context
*ctx
, GLuint attr
, GLuint newSize
)
355 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
357 if (newSize
> exec
->vtx
.attrsz
[attr
]) {
358 /* New size is larger. Need to flush existing vertices and get
359 * an enlarged vertex format.
361 vbo_exec_wrap_upgrade_vertex( exec
, attr
, newSize
);
363 else if (newSize
< exec
->vtx
.active_sz
[attr
]) {
364 static const GLfloat id
[4] = { 0, 0, 0, 1 };
367 /* New size is smaller - just need to fill in some
368 * zeros. Don't need to flush or wrap.
370 for (i
= newSize
; i
<= exec
->vtx
.attrsz
[attr
]; i
++)
371 exec
->vtx
.attrptr
[attr
][i
-1] = id
[i
-1];
374 exec
->vtx
.active_sz
[attr
] = newSize
;
376 /* Does setting NeedFlush belong here? Necessitates resetting
377 * vtxfmt on each flush (otherwise flags won't get reset
381 ctx
->Driver
.NeedFlush
|= FLUSH_STORED_VERTICES
;
386 * This macro is used to implement all the glVertex, glColor, glTexCoord,
387 * glVertexAttrib, etc functions.
389 #define ATTR( A, N, V0, V1, V2, V3 ) \
391 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
393 if (unlikely(!(ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT))) \
394 ctx->Driver.BeginVertices( ctx ); \
396 if (unlikely(exec->vtx.active_sz[A] != N)) \
397 vbo_exec_fixup_vertex(ctx, A, N); \
400 GLfloat *dest = exec->vtx.attrptr[A]; \
401 if (N>0) dest[0] = V0; \
402 if (N>1) dest[1] = V1; \
403 if (N>2) dest[2] = V2; \
404 if (N>3) dest[3] = V3; \
408 /* This is a glVertex call */ \
411 for (i = 0; i < exec->vtx.vertex_size; i++) \
412 exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i]; \
414 exec->vtx.buffer_ptr += exec->vtx.vertex_size; \
416 /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \
417 /* something to draw (not just updating a color or texcoord).*/ \
418 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \
420 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
421 vbo_exec_vtx_wrap( exec ); \
426 #define ERROR() _mesa_error( ctx, GL_INVALID_ENUM, __FUNCTION__ )
427 #define TAG(x) vbo_##x
429 #include "vbo_attrib_tmp.h"
435 #if FEATURE_evaluators
437 static void GLAPIENTRY
vbo_exec_EvalCoord1f( GLfloat u
)
439 GET_CURRENT_CONTEXT( ctx
);
440 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
444 if (exec
->eval
.recalculate_maps
)
445 vbo_exec_eval_update( exec
);
447 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
448 if (exec
->eval
.map1
[i
].map
)
449 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map1
[i
].sz
)
450 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map1
[i
].sz
);
455 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
456 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
458 vbo_exec_do_EvalCoord1f( exec
, u
);
460 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
461 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
464 static void GLAPIENTRY
vbo_exec_EvalCoord2f( GLfloat u
, GLfloat v
)
466 GET_CURRENT_CONTEXT( ctx
);
467 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
471 if (exec
->eval
.recalculate_maps
)
472 vbo_exec_eval_update( exec
);
474 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
475 if (exec
->eval
.map2
[i
].map
)
476 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map2
[i
].sz
)
477 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map2
[i
].sz
);
480 if (ctx
->Eval
.AutoNormal
)
481 if (exec
->vtx
.active_sz
[VBO_ATTRIB_NORMAL
] != 3)
482 vbo_exec_fixup_vertex( ctx
, VBO_ATTRIB_NORMAL
, 3 );
485 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
486 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
488 vbo_exec_do_EvalCoord2f( exec
, u
, v
);
490 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
491 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
494 static void GLAPIENTRY
vbo_exec_EvalCoord1fv( const GLfloat
*u
)
496 vbo_exec_EvalCoord1f( u
[0] );
499 static void GLAPIENTRY
vbo_exec_EvalCoord2fv( const GLfloat
*u
)
501 vbo_exec_EvalCoord2f( u
[0], u
[1] );
504 static void GLAPIENTRY
vbo_exec_EvalPoint1( GLint i
)
506 GET_CURRENT_CONTEXT( ctx
);
507 GLfloat du
= ((ctx
->Eval
.MapGrid1u2
- ctx
->Eval
.MapGrid1u1
) /
508 (GLfloat
) ctx
->Eval
.MapGrid1un
);
509 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid1u1
;
511 vbo_exec_EvalCoord1f( u
);
515 static void GLAPIENTRY
vbo_exec_EvalPoint2( GLint i
, GLint j
)
517 GET_CURRENT_CONTEXT( ctx
);
518 GLfloat du
= ((ctx
->Eval
.MapGrid2u2
- ctx
->Eval
.MapGrid2u1
) /
519 (GLfloat
) ctx
->Eval
.MapGrid2un
);
520 GLfloat dv
= ((ctx
->Eval
.MapGrid2v2
- ctx
->Eval
.MapGrid2v1
) /
521 (GLfloat
) ctx
->Eval
.MapGrid2vn
);
522 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid2u1
;
523 GLfloat v
= j
* dv
+ ctx
->Eval
.MapGrid2v1
;
525 vbo_exec_EvalCoord2f( u
, v
);
528 /* use noop eval mesh */
529 #define vbo_exec_EvalMesh1 _mesa_noop_EvalMesh1
530 #define vbo_exec_EvalMesh2 _mesa_noop_EvalMesh2
532 #endif /* FEATURE_evaluators */
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
);
554 * Called via glBegin.
556 static void GLAPIENTRY
vbo_exec_Begin( GLenum mode
)
558 GET_CURRENT_CONTEXT( ctx
);
560 if (ctx
->Driver
.CurrentExecPrimitive
== PRIM_OUTSIDE_BEGIN_END
) {
561 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
565 _mesa_update_state( ctx
);
567 CALL_Begin(ctx
->Exec
, (mode
));
571 if (!_mesa_valid_to_render(ctx
, "glBegin")) {
575 /* Heuristic: attempt to isolate attributes occuring outside
578 if (exec
->vtx
.vertex_size
&& !exec
->vtx
.attrsz
[0])
579 vbo_exec_FlushVertices_internal(exec
, GL_FALSE
);
581 i
= exec
->vtx
.prim_count
++;
582 exec
->vtx
.prim
[i
].mode
= mode
;
583 exec
->vtx
.prim
[i
].begin
= 1;
584 exec
->vtx
.prim
[i
].end
= 0;
585 exec
->vtx
.prim
[i
].indexed
= 0;
586 exec
->vtx
.prim
[i
].weak
= 0;
587 exec
->vtx
.prim
[i
].pad
= 0;
588 exec
->vtx
.prim
[i
].start
= exec
->vtx
.vert_count
;
589 exec
->vtx
.prim
[i
].count
= 0;
590 exec
->vtx
.prim
[i
].num_instances
= 1;
592 ctx
->Driver
.CurrentExecPrimitive
= mode
;
595 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glBegin" );
603 static void GLAPIENTRY
vbo_exec_End( void )
605 GET_CURRENT_CONTEXT( ctx
);
607 if (ctx
->Driver
.CurrentExecPrimitive
!= PRIM_OUTSIDE_BEGIN_END
) {
608 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
609 int idx
= exec
->vtx
.vert_count
;
610 int i
= exec
->vtx
.prim_count
- 1;
612 exec
->vtx
.prim
[i
].end
= 1;
613 exec
->vtx
.prim
[i
].count
= idx
- exec
->vtx
.prim
[i
].start
;
615 ctx
->Driver
.CurrentExecPrimitive
= PRIM_OUTSIDE_BEGIN_END
;
617 if (exec
->vtx
.prim_count
== VBO_MAX_PRIM
)
618 vbo_exec_vtx_flush( exec
, GL_FALSE
);
621 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glEnd" );
626 * Called via glPrimitiveRestartNV()
628 static void GLAPIENTRY
629 vbo_exec_PrimitiveRestartNV(void)
632 GET_CURRENT_CONTEXT( ctx
);
634 curPrim
= ctx
->Driver
.CurrentExecPrimitive
;
636 if (curPrim
== PRIM_OUTSIDE_BEGIN_END
) {
637 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glPrimitiveRestartNV" );
641 vbo_exec_Begin(curPrim
);
647 static void vbo_exec_vtxfmt_init( struct vbo_exec_context
*exec
)
649 GLvertexformat
*vfmt
= &exec
->vtxfmt
;
651 _MESA_INIT_ARRAYELT_VTXFMT(vfmt
, _ae_
);
653 vfmt
->Begin
= vbo_exec_Begin
;
654 vfmt
->End
= vbo_exec_End
;
655 vfmt
->PrimitiveRestartNV
= vbo_exec_PrimitiveRestartNV
;
657 _MESA_INIT_DLIST_VTXFMT(vfmt
, _mesa_
);
658 _MESA_INIT_EVAL_VTXFMT(vfmt
, vbo_exec_
);
660 vfmt
->Rectf
= _mesa_noop_Rectf
;
662 /* from attrib_tmp.h:
664 vfmt
->Color3f
= vbo_Color3f
;
665 vfmt
->Color3fv
= vbo_Color3fv
;
666 vfmt
->Color4f
= vbo_Color4f
;
667 vfmt
->Color4fv
= vbo_Color4fv
;
668 vfmt
->FogCoordfEXT
= vbo_FogCoordfEXT
;
669 vfmt
->FogCoordfvEXT
= vbo_FogCoordfvEXT
;
670 vfmt
->MultiTexCoord1fARB
= vbo_MultiTexCoord1f
;
671 vfmt
->MultiTexCoord1fvARB
= vbo_MultiTexCoord1fv
;
672 vfmt
->MultiTexCoord2fARB
= vbo_MultiTexCoord2f
;
673 vfmt
->MultiTexCoord2fvARB
= vbo_MultiTexCoord2fv
;
674 vfmt
->MultiTexCoord3fARB
= vbo_MultiTexCoord3f
;
675 vfmt
->MultiTexCoord3fvARB
= vbo_MultiTexCoord3fv
;
676 vfmt
->MultiTexCoord4fARB
= vbo_MultiTexCoord4f
;
677 vfmt
->MultiTexCoord4fvARB
= vbo_MultiTexCoord4fv
;
678 vfmt
->Normal3f
= vbo_Normal3f
;
679 vfmt
->Normal3fv
= vbo_Normal3fv
;
680 vfmt
->SecondaryColor3fEXT
= vbo_SecondaryColor3fEXT
;
681 vfmt
->SecondaryColor3fvEXT
= vbo_SecondaryColor3fvEXT
;
682 vfmt
->TexCoord1f
= vbo_TexCoord1f
;
683 vfmt
->TexCoord1fv
= vbo_TexCoord1fv
;
684 vfmt
->TexCoord2f
= vbo_TexCoord2f
;
685 vfmt
->TexCoord2fv
= vbo_TexCoord2fv
;
686 vfmt
->TexCoord3f
= vbo_TexCoord3f
;
687 vfmt
->TexCoord3fv
= vbo_TexCoord3fv
;
688 vfmt
->TexCoord4f
= vbo_TexCoord4f
;
689 vfmt
->TexCoord4fv
= vbo_TexCoord4fv
;
690 vfmt
->Vertex2f
= vbo_Vertex2f
;
691 vfmt
->Vertex2fv
= vbo_Vertex2fv
;
692 vfmt
->Vertex3f
= vbo_Vertex3f
;
693 vfmt
->Vertex3fv
= vbo_Vertex3fv
;
694 vfmt
->Vertex4f
= vbo_Vertex4f
;
695 vfmt
->Vertex4fv
= vbo_Vertex4fv
;
697 vfmt
->VertexAttrib1fARB
= vbo_VertexAttrib1fARB
;
698 vfmt
->VertexAttrib1fvARB
= vbo_VertexAttrib1fvARB
;
699 vfmt
->VertexAttrib2fARB
= vbo_VertexAttrib2fARB
;
700 vfmt
->VertexAttrib2fvARB
= vbo_VertexAttrib2fvARB
;
701 vfmt
->VertexAttrib3fARB
= vbo_VertexAttrib3fARB
;
702 vfmt
->VertexAttrib3fvARB
= vbo_VertexAttrib3fvARB
;
703 vfmt
->VertexAttrib4fARB
= vbo_VertexAttrib4fARB
;
704 vfmt
->VertexAttrib4fvARB
= vbo_VertexAttrib4fvARB
;
706 vfmt
->VertexAttrib1fNV
= vbo_VertexAttrib1fNV
;
707 vfmt
->VertexAttrib1fvNV
= vbo_VertexAttrib1fvNV
;
708 vfmt
->VertexAttrib2fNV
= vbo_VertexAttrib2fNV
;
709 vfmt
->VertexAttrib2fvNV
= vbo_VertexAttrib2fvNV
;
710 vfmt
->VertexAttrib3fNV
= vbo_VertexAttrib3fNV
;
711 vfmt
->VertexAttrib3fvNV
= vbo_VertexAttrib3fvNV
;
712 vfmt
->VertexAttrib4fNV
= vbo_VertexAttrib4fNV
;
713 vfmt
->VertexAttrib4fvNV
= vbo_VertexAttrib4fvNV
;
716 vfmt
->VertexAttribI1i
= vbo_VertexAttribI1i
;
717 vfmt
->VertexAttribI2i
= vbo_VertexAttribI2i
;
718 vfmt
->VertexAttribI3i
= vbo_VertexAttribI3i
;
719 vfmt
->VertexAttribI4i
= vbo_VertexAttribI4i
;
720 vfmt
->VertexAttribI2iv
= vbo_VertexAttribI2iv
;
721 vfmt
->VertexAttribI3iv
= vbo_VertexAttribI3iv
;
722 vfmt
->VertexAttribI4iv
= vbo_VertexAttribI4iv
;
724 /* unsigned integer-valued */
725 vfmt
->VertexAttribI1ui
= vbo_VertexAttribI1ui
;
726 vfmt
->VertexAttribI2ui
= vbo_VertexAttribI2ui
;
727 vfmt
->VertexAttribI3ui
= vbo_VertexAttribI3ui
;
728 vfmt
->VertexAttribI4ui
= vbo_VertexAttribI4ui
;
729 vfmt
->VertexAttribI2uiv
= vbo_VertexAttribI2uiv
;
730 vfmt
->VertexAttribI3uiv
= vbo_VertexAttribI3uiv
;
731 vfmt
->VertexAttribI4uiv
= vbo_VertexAttribI4uiv
;
733 vfmt
->Materialfv
= vbo_Materialfv
;
735 vfmt
->EdgeFlag
= vbo_EdgeFlag
;
736 vfmt
->Indexf
= vbo_Indexf
;
737 vfmt
->Indexfv
= vbo_Indexfv
;
742 #else /* FEATURE_beginend */
745 static void vbo_exec_vtxfmt_init( struct vbo_exec_context
*exec
)
747 /* silence warnings */
752 (void) vbo_FogCoordfEXT
;
753 (void) vbo_FogCoordfvEXT
;
754 (void) vbo_MultiTexCoord1f
;
755 (void) vbo_MultiTexCoord1fv
;
756 (void) vbo_MultiTexCoord2f
;
757 (void) vbo_MultiTexCoord2fv
;
758 (void) vbo_MultiTexCoord3f
;
759 (void) vbo_MultiTexCoord3fv
;
760 (void) vbo_MultiTexCoord4f
;
761 (void) vbo_MultiTexCoord4fv
;
763 (void) vbo_Normal3fv
;
764 (void) vbo_SecondaryColor3fEXT
;
765 (void) vbo_SecondaryColor3fvEXT
;
766 (void) vbo_TexCoord1f
;
767 (void) vbo_TexCoord1fv
;
768 (void) vbo_TexCoord2f
;
769 (void) vbo_TexCoord2fv
;
770 (void) vbo_TexCoord3f
;
771 (void) vbo_TexCoord3fv
;
772 (void) vbo_TexCoord4f
;
773 (void) vbo_TexCoord4fv
;
775 (void) vbo_Vertex2fv
;
777 (void) vbo_Vertex3fv
;
779 (void) vbo_Vertex4fv
;
781 (void) vbo_VertexAttrib1fARB
;
782 (void) vbo_VertexAttrib1fvARB
;
783 (void) vbo_VertexAttrib2fARB
;
784 (void) vbo_VertexAttrib2fvARB
;
785 (void) vbo_VertexAttrib3fARB
;
786 (void) vbo_VertexAttrib3fvARB
;
787 (void) vbo_VertexAttrib4fARB
;
788 (void) vbo_VertexAttrib4fvARB
;
790 (void) vbo_VertexAttrib1fNV
;
791 (void) vbo_VertexAttrib1fvNV
;
792 (void) vbo_VertexAttrib2fNV
;
793 (void) vbo_VertexAttrib2fvNV
;
794 (void) vbo_VertexAttrib3fNV
;
795 (void) vbo_VertexAttrib3fvNV
;
796 (void) vbo_VertexAttrib4fNV
;
797 (void) vbo_VertexAttrib4fvNV
;
799 (void) vbo_Materialfv
;
807 #endif /* FEATURE_beginend */
811 * Tell the VBO module to use a real OpenGL vertex buffer object to
812 * store accumulated immediate-mode vertex data.
813 * This replaces the malloced buffer which was created in
814 * vb_exec_vtx_init() below.
816 void vbo_use_buffer_objects(struct gl_context
*ctx
)
818 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
819 /* Any buffer name but 0 can be used here since this bufferobj won't
820 * go into the bufferobj hashtable.
822 GLuint bufName
= IMM_BUFFER_NAME
;
823 GLenum target
= GL_ARRAY_BUFFER_ARB
;
824 GLenum usage
= GL_STREAM_DRAW_ARB
;
825 GLsizei size
= VBO_VERT_BUFFER_SIZE
;
827 /* Make sure this func is only used once */
828 assert(exec
->vtx
.bufferobj
== ctx
->Shared
->NullBufferObj
);
829 if (exec
->vtx
.buffer_map
) {
830 _mesa_align_free(exec
->vtx
.buffer_map
);
831 exec
->vtx
.buffer_map
= NULL
;
832 exec
->vtx
.buffer_ptr
= NULL
;
835 /* Allocate a real buffer object now */
836 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
837 exec
->vtx
.bufferobj
= ctx
->Driver
.NewBufferObject(ctx
, bufName
, target
);
838 ctx
->Driver
.BufferData(ctx
, target
, size
, NULL
, usage
, exec
->vtx
.bufferobj
);
843 void vbo_exec_vtx_init( struct vbo_exec_context
*exec
)
845 struct gl_context
*ctx
= exec
->ctx
;
846 struct vbo_context
*vbo
= vbo_context(ctx
);
849 /* Allocate a buffer object. Will just reuse this object
850 * continuously, unless vbo_use_buffer_objects() is called to enable
853 _mesa_reference_buffer_object(ctx
,
854 &exec
->vtx
.bufferobj
,
855 ctx
->Shared
->NullBufferObj
);
857 ASSERT(!exec
->vtx
.buffer_map
);
858 exec
->vtx
.buffer_map
= (GLfloat
*)_mesa_align_malloc(VBO_VERT_BUFFER_SIZE
, 64);
859 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
861 vbo_exec_vtxfmt_init( exec
);
863 /* Hook our functions into the dispatch table.
865 _mesa_install_exec_vtxfmt( ctx
, &exec
->vtxfmt
);
867 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
868 ASSERT(i
< Elements(exec
->vtx
.attrsz
));
869 exec
->vtx
.attrsz
[i
] = 0;
870 ASSERT(i
< Elements(exec
->vtx
.active_sz
));
871 exec
->vtx
.active_sz
[i
] = 0;
873 for (i
= 0 ; i
< VERT_ATTRIB_MAX
; i
++) {
874 ASSERT(i
< Elements(exec
->vtx
.inputs
));
875 ASSERT(i
< Elements(exec
->vtx
.arrays
));
876 exec
->vtx
.inputs
[i
] = &exec
->vtx
.arrays
[i
];
880 struct gl_client_array
*arrays
= exec
->vtx
.arrays
;
883 memcpy(arrays
, vbo
->legacy_currval
, 16 * sizeof(arrays
[0]));
884 memcpy(arrays
+ 16, vbo
->generic_currval
, 16 * sizeof(arrays
[0]));
886 for (i
= 0; i
< 16; ++i
) {
887 arrays
[i
].BufferObj
= NULL
;
888 arrays
[i
+ 16].BufferObj
= NULL
;
889 _mesa_reference_buffer_object(ctx
, &arrays
[i
].BufferObj
,
890 vbo
->legacy_currval
[i
].BufferObj
);
891 _mesa_reference_buffer_object(ctx
, &arrays
[i
+ 16].BufferObj
,
892 vbo
->generic_currval
[i
].BufferObj
);
896 exec
->vtx
.vertex_size
= 0;
900 void vbo_exec_vtx_destroy( struct vbo_exec_context
*exec
)
902 /* using a real VBO for vertex data */
903 struct gl_context
*ctx
= exec
->ctx
;
906 /* True VBOs should already be unmapped
908 if (exec
->vtx
.buffer_map
) {
909 ASSERT(exec
->vtx
.bufferobj
->Name
== 0 ||
910 exec
->vtx
.bufferobj
->Name
== IMM_BUFFER_NAME
);
911 if (exec
->vtx
.bufferobj
->Name
== 0) {
912 _mesa_align_free(exec
->vtx
.buffer_map
);
913 exec
->vtx
.buffer_map
= NULL
;
914 exec
->vtx
.buffer_ptr
= NULL
;
918 /* Drop any outstanding reference to the vertex buffer
920 for (i
= 0; i
< Elements(exec
->vtx
.arrays
); i
++) {
921 _mesa_reference_buffer_object(ctx
,
922 &exec
->vtx
.arrays
[i
].BufferObj
,
926 /* Free the vertex buffer. Unmap first if needed.
928 if (_mesa_bufferobj_mapped(exec
->vtx
.bufferobj
)) {
929 ctx
->Driver
.UnmapBuffer(ctx
, GL_ARRAY_BUFFER
, exec
->vtx
.bufferobj
);
931 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
936 * Called upon first glVertex, glColor, glTexCoord, etc.
938 void vbo_exec_BeginVertices( struct gl_context
*ctx
)
940 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
942 vbo_exec_vtx_map( exec
);
944 assert((ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
) == 0);
945 ctx
->Driver
.NeedFlush
|= FLUSH_UPDATE_CURRENT
;
950 * Called via ctx->Driver.FlushVertices()
951 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
953 void vbo_exec_FlushVertices( struct gl_context
*ctx
, GLuint flags
)
955 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
958 /* debug check: make sure we don't get called recursively */
959 exec
->flush_call_depth
++;
960 assert(exec
->flush_call_depth
== 1);
963 if (ctx
->Driver
.CurrentExecPrimitive
!= PRIM_OUTSIDE_BEGIN_END
) {
964 /* We've had glBegin but not glEnd! */
966 exec
->flush_call_depth
--;
967 assert(exec
->flush_call_depth
== 0);
972 /* Flush (draw), and make sure VBO is left unmapped when done */
973 vbo_exec_FlushVertices_internal(exec
, GL_TRUE
);
975 /* Need to do this to ensure BeginVertices gets called again:
977 if (ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
)
978 ctx
->Driver
.NeedFlush
&= ~FLUSH_UPDATE_CURRENT
;
980 ctx
->Driver
.NeedFlush
&= ~flags
;
983 exec
->flush_call_depth
--;
984 assert(exec
->flush_call_depth
== 0);
989 static void reset_attrfv( struct vbo_exec_context
*exec
)
993 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
994 exec
->vtx
.attrsz
[i
] = 0;
995 exec
->vtx
.active_sz
[i
] = 0;
998 exec
->vtx
.vertex_size
= 0;
1003 _es_Color4f(GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
1005 vbo_Color4f(r
, g
, b
, a
);
1010 _es_Normal3f(GLfloat x
, GLfloat y
, GLfloat z
)
1012 vbo_Normal3f(x
, y
, z
);
1017 _es_MultiTexCoord4f(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1019 vbo_MultiTexCoord4f(target
, s
, t
, r
, q
);
1024 _es_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
1026 vbo_Materialfv(face
, pname
, params
);
1031 _es_Materialf(GLenum face
, GLenum pname
, GLfloat param
)
1035 p
[1] = p
[2] = p
[3] = 0.0F
;
1036 vbo_Materialfv(face
, pname
, p
);
1041 * A special version of glVertexAttrib4f that does not treat index 0 as
1045 VertexAttrib4f_nopos(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1047 GET_CURRENT_CONTEXT(ctx
);
1048 if (index
< MAX_VERTEX_GENERIC_ATTRIBS
)
1049 ATTR(VBO_ATTRIB_GENERIC0
+ index
, 4, x
, y
, z
, w
);
1055 _es_VertexAttrib4f(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1057 VertexAttrib4f_nopos(index
, x
, y
, z
, w
);
1062 _es_VertexAttrib1f(GLuint indx
, GLfloat x
)
1064 VertexAttrib4f_nopos(indx
, x
, 0.0f
, 0.0f
, 1.0f
);
1069 _es_VertexAttrib1fv(GLuint indx
, const GLfloat
* values
)
1071 VertexAttrib4f_nopos(indx
, values
[0], 0.0f
, 0.0f
, 1.0f
);
1076 _es_VertexAttrib2f(GLuint indx
, GLfloat x
, GLfloat y
)
1078 VertexAttrib4f_nopos(indx
, x
, y
, 0.0f
, 1.0f
);
1083 _es_VertexAttrib2fv(GLuint indx
, const GLfloat
* values
)
1085 VertexAttrib4f_nopos(indx
, values
[0], values
[1], 0.0f
, 1.0f
);
1090 _es_VertexAttrib3f(GLuint indx
, GLfloat x
, GLfloat y
, GLfloat z
)
1092 VertexAttrib4f_nopos(indx
, x
, y
, z
, 1.0f
);
1097 _es_VertexAttrib3fv(GLuint indx
, const GLfloat
* values
)
1099 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], 1.0f
);
1104 _es_VertexAttrib4fv(GLuint indx
, const GLfloat
* values
)
1106 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], values
[3]);