1 /**************************************************************************
3 Copyright 2002-2008 Tungsten Graphics Inc., Cedar Park, Texas.
7 Permission is hereby granted, free of charge, to any person obtaining a
8 copy of this software and associated documentation files (the "Software"),
9 to deal in the Software without restriction, including without limitation
10 on the rights to use, copy, modify, merge, publish, distribute, sub
11 license, and/or sell copies of the Software, and to permit persons to whom
12 the Software is furnished to do so, subject to the following conditions:
14 The above copyright notice and this permission notice (including the next
15 paragraph) shall be included in all copies or substantial portions of the
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
21 TUNGSTEN GRAPHICS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
22 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
23 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
24 USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
30 * Keith Whitwell <keith@tungstengraphics.com>
33 #include "main/glheader.h"
34 #include "main/bufferobj.h"
35 #include "main/context.h"
36 #include "main/macros.h"
37 #include "main/vtxfmt.h"
38 #include "main/dlist.h"
39 #include "main/eval.h"
40 #include "main/state.h"
41 #include "main/light.h"
42 #include "main/api_arrayelt.h"
43 #include "main/api_noop.h"
44 #include "main/dispatch.h"
46 #include "vbo_context.h"
53 /** ID/name for immediate-mode VBO */
54 #define IMM_BUFFER_NAME 0xaabbccdd
57 static void reset_attrfv( struct vbo_exec_context
*exec
);
61 * Close off the last primitive, execute the buffer, restart the
64 static void vbo_exec_wrap_buffers( struct vbo_exec_context
*exec
)
66 if (exec
->vtx
.prim_count
== 0) {
67 exec
->vtx
.copied
.nr
= 0;
68 exec
->vtx
.vert_count
= 0;
69 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
72 GLuint last_begin
= exec
->vtx
.prim
[exec
->vtx
.prim_count
-1].begin
;
75 if (exec
->ctx
->Driver
.CurrentExecPrimitive
!= PRIM_OUTSIDE_BEGIN_END
) {
76 GLint i
= exec
->vtx
.prim_count
- 1;
78 exec
->vtx
.prim
[i
].count
= (exec
->vtx
.vert_count
-
79 exec
->vtx
.prim
[i
].start
);
82 last_count
= exec
->vtx
.prim
[exec
->vtx
.prim_count
-1].count
;
84 /* Execute the buffer and save copied vertices.
86 if (exec
->vtx
.vert_count
)
87 vbo_exec_vtx_flush( exec
, GL_FALSE
);
89 exec
->vtx
.prim_count
= 0;
90 exec
->vtx
.copied
.nr
= 0;
93 /* Emit a glBegin to start the new list.
95 assert(exec
->vtx
.prim_count
== 0);
97 if (exec
->ctx
->Driver
.CurrentExecPrimitive
!= PRIM_OUTSIDE_BEGIN_END
) {
98 exec
->vtx
.prim
[0].mode
= exec
->ctx
->Driver
.CurrentExecPrimitive
;
99 exec
->vtx
.prim
[0].start
= 0;
100 exec
->vtx
.prim
[0].count
= 0;
101 exec
->vtx
.prim_count
++;
103 if (exec
->vtx
.copied
.nr
== last_count
)
104 exec
->vtx
.prim
[0].begin
= last_begin
;
111 * Deal with buffer wrapping where provoked by the vertex buffer
112 * filling up, as opposed to upgrade_vertex().
114 void vbo_exec_vtx_wrap( struct vbo_exec_context
*exec
)
116 GLfloat
*data
= exec
->vtx
.copied
.buffer
;
119 /* Run pipeline on current vertices, copy wrapped vertices
120 * to exec->vtx.copied.
122 vbo_exec_wrap_buffers( exec
);
124 /* Copy stored stored vertices to start of new list.
126 assert(exec
->vtx
.max_vert
- exec
->vtx
.vert_count
> exec
->vtx
.copied
.nr
);
128 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
129 memcpy( exec
->vtx
.buffer_ptr
, data
,
130 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
131 exec
->vtx
.buffer_ptr
+= exec
->vtx
.vertex_size
;
132 data
+= exec
->vtx
.vertex_size
;
133 exec
->vtx
.vert_count
++;
136 exec
->vtx
.copied
.nr
= 0;
141 * Copy the active vertex's values to the ctx->Current fields.
143 static void vbo_exec_copy_to_current( struct vbo_exec_context
*exec
)
145 struct gl_context
*ctx
= exec
->ctx
;
146 struct vbo_context
*vbo
= vbo_context(ctx
);
149 for (i
= VBO_ATTRIB_POS
+1 ; i
< VBO_ATTRIB_MAX
; i
++) {
150 if (exec
->vtx
.attrsz
[i
]) {
151 /* Note: the exec->vtx.current[i] pointers point into the
152 * ctx->Current.Attrib and ctx->Light.Material.Attrib arrays.
154 GLfloat
*current
= (GLfloat
*)vbo
->currval
[i
].Ptr
;
159 exec
->vtx
.attrptr
[i
]);
161 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
]);
194 static void vbo_exec_copy_from_current( struct vbo_exec_context
*exec
)
196 struct gl_context
*ctx
= exec
->ctx
;
197 struct vbo_context
*vbo
= vbo_context(ctx
);
200 for (i
= VBO_ATTRIB_POS
+1 ; i
< VBO_ATTRIB_MAX
; i
++) {
201 const GLfloat
*current
= (GLfloat
*)vbo
->currval
[i
].Ptr
;
202 switch (exec
->vtx
.attrsz
[i
]) {
203 case 4: exec
->vtx
.attrptr
[i
][3] = current
[3];
204 case 3: exec
->vtx
.attrptr
[i
][2] = current
[2];
205 case 2: exec
->vtx
.attrptr
[i
][1] = current
[1];
206 case 1: exec
->vtx
.attrptr
[i
][0] = current
[0];
214 * Flush existing data, set new attrib size, replay copied vertices.
216 static void vbo_exec_wrap_upgrade_vertex( struct vbo_exec_context
*exec
,
220 struct gl_context
*ctx
= exec
->ctx
;
221 struct vbo_context
*vbo
= vbo_context(ctx
);
222 GLint lastcount
= exec
->vtx
.vert_count
;
223 GLfloat
*old_attrptr
[VBO_ATTRIB_MAX
];
224 GLuint old_vtx_size
= exec
->vtx
.vertex_size
;
225 GLuint oldsz
= exec
->vtx
.attrsz
[attr
];
228 /* Run pipeline on current vertices, copy wrapped vertices
229 * to exec->vtx.copied.
231 vbo_exec_wrap_buffers( exec
);
233 if (unlikely(exec
->vtx
.copied
.nr
)) {
234 /* We're in the middle of a primitive, keep the old vertex
235 * format around to be able to translate the copied vertices to
238 memcpy(old_attrptr
, exec
->vtx
.attrptr
, sizeof(old_attrptr
));
241 if (unlikely(oldsz
)) {
242 /* Do a COPY_TO_CURRENT to ensure back-copying works for the
243 * case when the attribute already exists in the vertex and is
244 * having its size increased.
246 vbo_exec_copy_to_current( exec
);
249 /* Heuristic: Attempt to isolate attributes received outside
250 * begin/end so that they don't bloat the vertices.
252 if (ctx
->Driver
.CurrentExecPrimitive
== PRIM_OUTSIDE_BEGIN_END
&&
253 !oldsz
&& lastcount
> 8 && exec
->vtx
.vertex_size
) {
254 vbo_exec_copy_to_current( exec
);
255 reset_attrfv( exec
);
260 exec
->vtx
.attrsz
[attr
] = newsz
;
261 exec
->vtx
.vertex_size
+= newsz
- oldsz
;
262 exec
->vtx
.max_vert
= ((VBO_VERT_BUFFER_SIZE
- exec
->vtx
.buffer_used
) /
263 (exec
->vtx
.vertex_size
* sizeof(GLfloat
)));
264 exec
->vtx
.vert_count
= 0;
265 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
267 if (unlikely(oldsz
)) {
268 /* Size changed, recalculate all the attrptr[] values
270 GLfloat
*tmp
= exec
->vtx
.vertex
;
272 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
273 if (exec
->vtx
.attrsz
[i
]) {
274 exec
->vtx
.attrptr
[i
] = tmp
;
275 tmp
+= exec
->vtx
.attrsz
[i
];
278 exec
->vtx
.attrptr
[i
] = NULL
; /* will not be dereferenced */
281 /* Copy from current to repopulate the vertex with correct
284 vbo_exec_copy_from_current( exec
);
287 /* Just have to append the new attribute at the end */
288 exec
->vtx
.attrptr
[attr
] = exec
->vtx
.vertex
+
289 exec
->vtx
.vertex_size
- newsz
;
292 /* Replay stored vertices to translate them
293 * to new format here.
295 * -- No need to replay - just copy piecewise
297 if (unlikely(exec
->vtx
.copied
.nr
)) {
298 GLfloat
*data
= exec
->vtx
.copied
.buffer
;
299 GLfloat
*dest
= exec
->vtx
.buffer_ptr
;
302 assert(exec
->vtx
.buffer_ptr
== exec
->vtx
.buffer_map
);
304 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
305 for (j
= 0 ; j
< VBO_ATTRIB_MAX
; j
++) {
306 GLuint sz
= exec
->vtx
.attrsz
[j
];
309 GLint old_offset
= old_attrptr
[j
] - exec
->vtx
.vertex
;
310 GLint new_offset
= exec
->vtx
.attrptr
[j
] - exec
->vtx
.vertex
;
315 COPY_CLEAN_4V(tmp
, oldsz
, data
+ old_offset
);
316 COPY_SZ_4V(dest
+ new_offset
, newsz
, tmp
);
318 GLfloat
*current
= (GLfloat
*)vbo
->currval
[j
].Ptr
;
319 COPY_SZ_4V(dest
+ new_offset
, sz
, current
);
323 COPY_SZ_4V(dest
+ new_offset
, sz
, data
+ old_offset
);
328 data
+= old_vtx_size
;
329 dest
+= exec
->vtx
.vertex_size
;
332 exec
->vtx
.buffer_ptr
= dest
;
333 exec
->vtx
.vert_count
+= exec
->vtx
.copied
.nr
;
334 exec
->vtx
.copied
.nr
= 0;
339 static void vbo_exec_fixup_vertex( struct gl_context
*ctx
,
340 GLuint attr
, GLuint sz
)
342 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
345 if (sz
> exec
->vtx
.attrsz
[attr
]) {
346 /* New size is larger. Need to flush existing vertices and get
347 * an enlarged vertex format.
349 vbo_exec_wrap_upgrade_vertex( exec
, attr
, sz
);
351 else if (sz
< exec
->vtx
.active_sz
[attr
]) {
352 static const GLfloat id
[4] = { 0, 0, 0, 1 };
354 /* New size is smaller - just need to fill in some
355 * zeros. Don't need to flush or wrap.
357 for (i
= sz
; i
<= exec
->vtx
.attrsz
[attr
] ; i
++)
358 exec
->vtx
.attrptr
[attr
][i
-1] = id
[i
-1];
361 exec
->vtx
.active_sz
[attr
] = sz
;
363 /* Does setting NeedFlush belong here? Necessitates resetting
364 * vtxfmt on each flush (otherwise flags won't get reset
368 exec
->ctx
->Driver
.NeedFlush
|= FLUSH_STORED_VERTICES
;
376 #define ATTR( A, N, V0, V1, V2, V3 ) \
378 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
380 if (unlikely(!(exec->ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT))) \
381 ctx->Driver.BeginVertices( ctx ); \
382 if (unlikely(exec->vtx.active_sz[A] != N)) \
383 vbo_exec_fixup_vertex(ctx, A, N); \
386 GLfloat *dest = exec->vtx.attrptr[A]; \
387 if (N>0) dest[0] = V0; \
388 if (N>1) dest[1] = V1; \
389 if (N>2) dest[2] = V2; \
390 if (N>3) dest[3] = V3; \
396 for (i = 0; i < exec->vtx.vertex_size; i++) \
397 exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i]; \
399 exec->vtx.buffer_ptr += exec->vtx.vertex_size; \
400 exec->ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \
402 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
403 vbo_exec_vtx_wrap( exec ); \
408 #define ERROR() _mesa_error( ctx, GL_INVALID_ENUM, __FUNCTION__ )
409 #define TAG(x) vbo_##x
411 #include "vbo_attrib_tmp.h"
417 #if FEATURE_evaluators
419 static void GLAPIENTRY
vbo_exec_EvalCoord1f( GLfloat u
)
421 GET_CURRENT_CONTEXT( ctx
);
422 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
426 if (exec
->eval
.recalculate_maps
)
427 vbo_exec_eval_update( exec
);
429 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
430 if (exec
->eval
.map1
[i
].map
)
431 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map1
[i
].sz
)
432 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map1
[i
].sz
);
437 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
438 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
440 vbo_exec_do_EvalCoord1f( exec
, u
);
442 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
443 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
446 static void GLAPIENTRY
vbo_exec_EvalCoord2f( GLfloat u
, GLfloat v
)
448 GET_CURRENT_CONTEXT( ctx
);
449 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
453 if (exec
->eval
.recalculate_maps
)
454 vbo_exec_eval_update( exec
);
456 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
457 if (exec
->eval
.map2
[i
].map
)
458 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map2
[i
].sz
)
459 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map2
[i
].sz
);
462 if (ctx
->Eval
.AutoNormal
)
463 if (exec
->vtx
.active_sz
[VBO_ATTRIB_NORMAL
] != 3)
464 vbo_exec_fixup_vertex( ctx
, VBO_ATTRIB_NORMAL
, 3 );
467 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
468 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
470 vbo_exec_do_EvalCoord2f( exec
, u
, v
);
472 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
473 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
476 static void GLAPIENTRY
vbo_exec_EvalCoord1fv( const GLfloat
*u
)
478 vbo_exec_EvalCoord1f( u
[0] );
481 static void GLAPIENTRY
vbo_exec_EvalCoord2fv( const GLfloat
*u
)
483 vbo_exec_EvalCoord2f( u
[0], u
[1] );
486 static void GLAPIENTRY
vbo_exec_EvalPoint1( GLint i
)
488 GET_CURRENT_CONTEXT( ctx
);
489 GLfloat du
= ((ctx
->Eval
.MapGrid1u2
- ctx
->Eval
.MapGrid1u1
) /
490 (GLfloat
) ctx
->Eval
.MapGrid1un
);
491 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid1u1
;
493 vbo_exec_EvalCoord1f( u
);
497 static void GLAPIENTRY
vbo_exec_EvalPoint2( GLint i
, GLint j
)
499 GET_CURRENT_CONTEXT( ctx
);
500 GLfloat du
= ((ctx
->Eval
.MapGrid2u2
- ctx
->Eval
.MapGrid2u1
) /
501 (GLfloat
) ctx
->Eval
.MapGrid2un
);
502 GLfloat dv
= ((ctx
->Eval
.MapGrid2v2
- ctx
->Eval
.MapGrid2v1
) /
503 (GLfloat
) ctx
->Eval
.MapGrid2vn
);
504 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid2u1
;
505 GLfloat v
= j
* dv
+ ctx
->Eval
.MapGrid2v1
;
507 vbo_exec_EvalCoord2f( u
, v
);
510 /* use noop eval mesh */
511 #define vbo_exec_EvalMesh1 _mesa_noop_EvalMesh1
512 #define vbo_exec_EvalMesh2 _mesa_noop_EvalMesh2
514 #endif /* FEATURE_evaluators */
518 * Called via glBegin.
520 static void GLAPIENTRY
vbo_exec_Begin( GLenum mode
)
522 GET_CURRENT_CONTEXT( ctx
);
524 if (ctx
->Driver
.CurrentExecPrimitive
== PRIM_OUTSIDE_BEGIN_END
) {
525 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
529 _mesa_update_state( ctx
);
531 CALL_Begin(ctx
->Exec
, (mode
));
535 if (!_mesa_valid_to_render(ctx
, "glBegin")) {
539 /* Heuristic: attempt to isolate attributes occuring outside
542 if (exec
->vtx
.vertex_size
&& !exec
->vtx
.attrsz
[0])
543 vbo_exec_FlushVertices_internal( ctx
, GL_FALSE
);
545 i
= exec
->vtx
.prim_count
++;
546 exec
->vtx
.prim
[i
].mode
= mode
;
547 exec
->vtx
.prim
[i
].begin
= 1;
548 exec
->vtx
.prim
[i
].end
= 0;
549 exec
->vtx
.prim
[i
].indexed
= 0;
550 exec
->vtx
.prim
[i
].weak
= 0;
551 exec
->vtx
.prim
[i
].pad
= 0;
552 exec
->vtx
.prim
[i
].start
= exec
->vtx
.vert_count
;
553 exec
->vtx
.prim
[i
].count
= 0;
554 exec
->vtx
.prim
[i
].num_instances
= 1;
556 ctx
->Driver
.CurrentExecPrimitive
= mode
;
559 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glBegin" );
567 static void GLAPIENTRY
vbo_exec_End( void )
569 GET_CURRENT_CONTEXT( ctx
);
571 if (ctx
->Driver
.CurrentExecPrimitive
!= PRIM_OUTSIDE_BEGIN_END
) {
572 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
573 int idx
= exec
->vtx
.vert_count
;
574 int i
= exec
->vtx
.prim_count
- 1;
576 exec
->vtx
.prim
[i
].end
= 1;
577 exec
->vtx
.prim
[i
].count
= idx
- exec
->vtx
.prim
[i
].start
;
579 ctx
->Driver
.CurrentExecPrimitive
= PRIM_OUTSIDE_BEGIN_END
;
581 if (exec
->vtx
.prim_count
== VBO_MAX_PRIM
)
582 vbo_exec_vtx_flush( exec
, GL_FALSE
);
585 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glEnd" );
590 * Called via glPrimitiveRestartNV()
592 static void GLAPIENTRY
593 vbo_exec_PrimitiveRestartNV(void)
596 GET_CURRENT_CONTEXT( ctx
);
598 curPrim
= ctx
->Driver
.CurrentExecPrimitive
;
600 if (curPrim
== PRIM_OUTSIDE_BEGIN_END
) {
601 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glPrimitiveRestartNV" );
605 vbo_exec_Begin(curPrim
);
611 static void vbo_exec_vtxfmt_init( struct vbo_exec_context
*exec
)
613 GLvertexformat
*vfmt
= &exec
->vtxfmt
;
615 _MESA_INIT_ARRAYELT_VTXFMT(vfmt
, _ae_
);
617 vfmt
->Begin
= vbo_exec_Begin
;
618 vfmt
->End
= vbo_exec_End
;
619 vfmt
->PrimitiveRestartNV
= vbo_exec_PrimitiveRestartNV
;
621 _MESA_INIT_DLIST_VTXFMT(vfmt
, _mesa_
);
622 _MESA_INIT_EVAL_VTXFMT(vfmt
, vbo_exec_
);
624 vfmt
->Rectf
= _mesa_noop_Rectf
;
626 /* from attrib_tmp.h:
628 vfmt
->Color3f
= vbo_Color3f
;
629 vfmt
->Color3fv
= vbo_Color3fv
;
630 vfmt
->Color4f
= vbo_Color4f
;
631 vfmt
->Color4fv
= vbo_Color4fv
;
632 vfmt
->FogCoordfEXT
= vbo_FogCoordfEXT
;
633 vfmt
->FogCoordfvEXT
= vbo_FogCoordfvEXT
;
634 vfmt
->MultiTexCoord1fARB
= vbo_MultiTexCoord1f
;
635 vfmt
->MultiTexCoord1fvARB
= vbo_MultiTexCoord1fv
;
636 vfmt
->MultiTexCoord2fARB
= vbo_MultiTexCoord2f
;
637 vfmt
->MultiTexCoord2fvARB
= vbo_MultiTexCoord2fv
;
638 vfmt
->MultiTexCoord3fARB
= vbo_MultiTexCoord3f
;
639 vfmt
->MultiTexCoord3fvARB
= vbo_MultiTexCoord3fv
;
640 vfmt
->MultiTexCoord4fARB
= vbo_MultiTexCoord4f
;
641 vfmt
->MultiTexCoord4fvARB
= vbo_MultiTexCoord4fv
;
642 vfmt
->Normal3f
= vbo_Normal3f
;
643 vfmt
->Normal3fv
= vbo_Normal3fv
;
644 vfmt
->SecondaryColor3fEXT
= vbo_SecondaryColor3fEXT
;
645 vfmt
->SecondaryColor3fvEXT
= vbo_SecondaryColor3fvEXT
;
646 vfmt
->TexCoord1f
= vbo_TexCoord1f
;
647 vfmt
->TexCoord1fv
= vbo_TexCoord1fv
;
648 vfmt
->TexCoord2f
= vbo_TexCoord2f
;
649 vfmt
->TexCoord2fv
= vbo_TexCoord2fv
;
650 vfmt
->TexCoord3f
= vbo_TexCoord3f
;
651 vfmt
->TexCoord3fv
= vbo_TexCoord3fv
;
652 vfmt
->TexCoord4f
= vbo_TexCoord4f
;
653 vfmt
->TexCoord4fv
= vbo_TexCoord4fv
;
654 vfmt
->Vertex2f
= vbo_Vertex2f
;
655 vfmt
->Vertex2fv
= vbo_Vertex2fv
;
656 vfmt
->Vertex3f
= vbo_Vertex3f
;
657 vfmt
->Vertex3fv
= vbo_Vertex3fv
;
658 vfmt
->Vertex4f
= vbo_Vertex4f
;
659 vfmt
->Vertex4fv
= vbo_Vertex4fv
;
661 vfmt
->VertexAttrib1fARB
= vbo_VertexAttrib1fARB
;
662 vfmt
->VertexAttrib1fvARB
= vbo_VertexAttrib1fvARB
;
663 vfmt
->VertexAttrib2fARB
= vbo_VertexAttrib2fARB
;
664 vfmt
->VertexAttrib2fvARB
= vbo_VertexAttrib2fvARB
;
665 vfmt
->VertexAttrib3fARB
= vbo_VertexAttrib3fARB
;
666 vfmt
->VertexAttrib3fvARB
= vbo_VertexAttrib3fvARB
;
667 vfmt
->VertexAttrib4fARB
= vbo_VertexAttrib4fARB
;
668 vfmt
->VertexAttrib4fvARB
= vbo_VertexAttrib4fvARB
;
670 vfmt
->VertexAttrib1fNV
= vbo_VertexAttrib1fNV
;
671 vfmt
->VertexAttrib1fvNV
= vbo_VertexAttrib1fvNV
;
672 vfmt
->VertexAttrib2fNV
= vbo_VertexAttrib2fNV
;
673 vfmt
->VertexAttrib2fvNV
= vbo_VertexAttrib2fvNV
;
674 vfmt
->VertexAttrib3fNV
= vbo_VertexAttrib3fNV
;
675 vfmt
->VertexAttrib3fvNV
= vbo_VertexAttrib3fvNV
;
676 vfmt
->VertexAttrib4fNV
= vbo_VertexAttrib4fNV
;
677 vfmt
->VertexAttrib4fvNV
= vbo_VertexAttrib4fvNV
;
680 vfmt
->VertexAttribI1i
= vbo_VertexAttribI1i
;
681 vfmt
->VertexAttribI2i
= vbo_VertexAttribI2i
;
682 vfmt
->VertexAttribI3i
= vbo_VertexAttribI3i
;
683 vfmt
->VertexAttribI4i
= vbo_VertexAttribI4i
;
684 vfmt
->VertexAttribI2iv
= vbo_VertexAttribI2iv
;
685 vfmt
->VertexAttribI3iv
= vbo_VertexAttribI3iv
;
686 vfmt
->VertexAttribI4iv
= vbo_VertexAttribI4iv
;
688 /* unsigned integer-valued */
689 vfmt
->VertexAttribI1ui
= vbo_VertexAttribI1ui
;
690 vfmt
->VertexAttribI2ui
= vbo_VertexAttribI2ui
;
691 vfmt
->VertexAttribI3ui
= vbo_VertexAttribI3ui
;
692 vfmt
->VertexAttribI4ui
= vbo_VertexAttribI4ui
;
693 vfmt
->VertexAttribI2uiv
= vbo_VertexAttribI2uiv
;
694 vfmt
->VertexAttribI3uiv
= vbo_VertexAttribI3uiv
;
695 vfmt
->VertexAttribI4uiv
= vbo_VertexAttribI4uiv
;
697 vfmt
->Materialfv
= vbo_Materialfv
;
699 vfmt
->EdgeFlag
= vbo_EdgeFlag
;
700 vfmt
->Indexf
= vbo_Indexf
;
701 vfmt
->Indexfv
= vbo_Indexfv
;
706 #else /* FEATURE_beginend */
709 #define ATTR( A, N, V0, V1, V2, V3 ) \
711 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
713 /* FLUSH_UPDATE_CURRENT needs to be set manually */ \
714 exec->ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
716 if (exec->vtx.active_sz[A] != N) \
717 vbo_exec_fixup_vertex(ctx, A, N); \
720 GLfloat *dest = exec->vtx.attrptr[A]; \
721 if (N>0) dest[0] = V0; \
722 if (N>1) dest[1] = V1; \
723 if (N>2) dest[2] = V2; \
724 if (N>3) dest[3] = V3; \
728 #define ERROR() _mesa_error( ctx, GL_INVALID_ENUM, __FUNCTION__ )
729 #define TAG(x) vbo_##x
731 #include "vbo_attrib_tmp.h"
733 static void vbo_exec_vtxfmt_init( struct vbo_exec_context
*exec
)
735 /* silence warnings */
740 (void) vbo_FogCoordfEXT
;
741 (void) vbo_FogCoordfvEXT
;
742 (void) vbo_MultiTexCoord1f
;
743 (void) vbo_MultiTexCoord1fv
;
744 (void) vbo_MultiTexCoord2f
;
745 (void) vbo_MultiTexCoord2fv
;
746 (void) vbo_MultiTexCoord3f
;
747 (void) vbo_MultiTexCoord3fv
;
748 (void) vbo_MultiTexCoord4f
;
749 (void) vbo_MultiTexCoord4fv
;
751 (void) vbo_Normal3fv
;
752 (void) vbo_SecondaryColor3fEXT
;
753 (void) vbo_SecondaryColor3fvEXT
;
754 (void) vbo_TexCoord1f
;
755 (void) vbo_TexCoord1fv
;
756 (void) vbo_TexCoord2f
;
757 (void) vbo_TexCoord2fv
;
758 (void) vbo_TexCoord3f
;
759 (void) vbo_TexCoord3fv
;
760 (void) vbo_TexCoord4f
;
761 (void) vbo_TexCoord4fv
;
763 (void) vbo_Vertex2fv
;
765 (void) vbo_Vertex3fv
;
767 (void) vbo_Vertex4fv
;
769 (void) vbo_VertexAttrib1fARB
;
770 (void) vbo_VertexAttrib1fvARB
;
771 (void) vbo_VertexAttrib2fARB
;
772 (void) vbo_VertexAttrib2fvARB
;
773 (void) vbo_VertexAttrib3fARB
;
774 (void) vbo_VertexAttrib3fvARB
;
775 (void) vbo_VertexAttrib4fARB
;
776 (void) vbo_VertexAttrib4fvARB
;
778 (void) vbo_VertexAttrib1fNV
;
779 (void) vbo_VertexAttrib1fvNV
;
780 (void) vbo_VertexAttrib2fNV
;
781 (void) vbo_VertexAttrib2fvNV
;
782 (void) vbo_VertexAttrib3fNV
;
783 (void) vbo_VertexAttrib3fvNV
;
784 (void) vbo_VertexAttrib4fNV
;
785 (void) vbo_VertexAttrib4fvNV
;
787 (void) vbo_Materialfv
;
795 #endif /* FEATURE_beginend */
799 * Tell the VBO module to use a real OpenGL vertex buffer object to
800 * store accumulated immediate-mode vertex data.
801 * This replaces the malloced buffer which was created in
802 * vb_exec_vtx_init() below.
804 void vbo_use_buffer_objects(struct gl_context
*ctx
)
806 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
807 /* Any buffer name but 0 can be used here since this bufferobj won't
808 * go into the bufferobj hashtable.
810 GLuint bufName
= IMM_BUFFER_NAME
;
811 GLenum target
= GL_ARRAY_BUFFER_ARB
;
812 GLenum usage
= GL_STREAM_DRAW_ARB
;
813 GLsizei size
= VBO_VERT_BUFFER_SIZE
;
815 /* Make sure this func is only used once */
816 assert(exec
->vtx
.bufferobj
== ctx
->Shared
->NullBufferObj
);
817 if (exec
->vtx
.buffer_map
) {
818 _mesa_align_free(exec
->vtx
.buffer_map
);
819 exec
->vtx
.buffer_map
= NULL
;
820 exec
->vtx
.buffer_ptr
= NULL
;
823 /* Allocate a real buffer object now */
824 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
825 exec
->vtx
.bufferobj
= ctx
->Driver
.NewBufferObject(ctx
, bufName
, target
);
826 ctx
->Driver
.BufferData(ctx
, target
, size
, NULL
, usage
, exec
->vtx
.bufferobj
);
831 void vbo_exec_vtx_init( struct vbo_exec_context
*exec
)
833 struct gl_context
*ctx
= exec
->ctx
;
834 struct vbo_context
*vbo
= vbo_context(ctx
);
837 /* Allocate a buffer object. Will just reuse this object
838 * continuously, unless vbo_use_buffer_objects() is called to enable
841 _mesa_reference_buffer_object(ctx
,
842 &exec
->vtx
.bufferobj
,
843 ctx
->Shared
->NullBufferObj
);
845 ASSERT(!exec
->vtx
.buffer_map
);
846 exec
->vtx
.buffer_map
= (GLfloat
*)_mesa_align_malloc(VBO_VERT_BUFFER_SIZE
, 64);
847 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
849 vbo_exec_vtxfmt_init( exec
);
851 /* Hook our functions into the dispatch table.
853 _mesa_install_exec_vtxfmt( exec
->ctx
, &exec
->vtxfmt
);
855 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
856 ASSERT(i
< Elements(exec
->vtx
.attrsz
));
857 exec
->vtx
.attrsz
[i
] = 0;
858 ASSERT(i
< Elements(exec
->vtx
.active_sz
));
859 exec
->vtx
.active_sz
[i
] = 0;
861 for (i
= 0 ; i
< VERT_ATTRIB_MAX
; i
++) {
862 ASSERT(i
< Elements(exec
->vtx
.inputs
));
863 ASSERT(i
< Elements(exec
->vtx
.arrays
));
864 exec
->vtx
.inputs
[i
] = &exec
->vtx
.arrays
[i
];
868 struct gl_client_array
*arrays
= exec
->vtx
.arrays
;
871 memcpy(arrays
, vbo
->legacy_currval
, 16 * sizeof(arrays
[0]));
872 memcpy(arrays
+ 16, vbo
->generic_currval
, 16 * sizeof(arrays
[0]));
874 for (i
= 0; i
< 16; ++i
) {
875 arrays
[i
].BufferObj
= NULL
;
876 arrays
[i
+ 16].BufferObj
= NULL
;
877 _mesa_reference_buffer_object(ctx
, &arrays
[i
].BufferObj
,
878 vbo
->legacy_currval
[i
].BufferObj
);
879 _mesa_reference_buffer_object(ctx
, &arrays
[i
+ 16].BufferObj
,
880 vbo
->generic_currval
[i
].BufferObj
);
884 exec
->vtx
.vertex_size
= 0;
888 void vbo_exec_vtx_destroy( struct vbo_exec_context
*exec
)
890 /* using a real VBO for vertex data */
891 struct gl_context
*ctx
= exec
->ctx
;
894 /* True VBOs should already be unmapped
896 if (exec
->vtx
.buffer_map
) {
897 ASSERT(exec
->vtx
.bufferobj
->Name
== 0 ||
898 exec
->vtx
.bufferobj
->Name
== IMM_BUFFER_NAME
);
899 if (exec
->vtx
.bufferobj
->Name
== 0) {
900 _mesa_align_free(exec
->vtx
.buffer_map
);
901 exec
->vtx
.buffer_map
= NULL
;
902 exec
->vtx
.buffer_ptr
= NULL
;
906 /* Drop any outstanding reference to the vertex buffer
908 for (i
= 0; i
< Elements(exec
->vtx
.arrays
); i
++) {
909 _mesa_reference_buffer_object(ctx
,
910 &exec
->vtx
.arrays
[i
].BufferObj
,
914 /* Free the vertex buffer. Unmap first if needed.
916 if (_mesa_bufferobj_mapped(exec
->vtx
.bufferobj
)) {
917 ctx
->Driver
.UnmapBuffer(ctx
, GL_ARRAY_BUFFER
, exec
->vtx
.bufferobj
);
919 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
922 void vbo_exec_BeginVertices( struct gl_context
*ctx
)
924 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
925 if (0) printf("%s\n", __FUNCTION__
);
926 vbo_exec_vtx_map( exec
);
928 assert((exec
->ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
) == 0);
929 exec
->ctx
->Driver
.NeedFlush
|= FLUSH_UPDATE_CURRENT
;
932 void vbo_exec_FlushVertices_internal( struct gl_context
*ctx
, GLboolean unmap
)
934 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
936 if (exec
->vtx
.vert_count
|| unmap
) {
937 vbo_exec_vtx_flush( exec
, unmap
);
940 if (exec
->vtx
.vertex_size
) {
941 vbo_exec_copy_to_current( exec
);
942 reset_attrfv( exec
);
948 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
950 void vbo_exec_FlushVertices( struct gl_context
*ctx
, GLuint flags
)
952 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
955 /* debug check: make sure we don't get called recursively */
956 exec
->flush_call_depth
++;
957 assert(exec
->flush_call_depth
== 1);
960 if (0) printf("%s\n", __FUNCTION__
);
962 if (exec
->ctx
->Driver
.CurrentExecPrimitive
!= PRIM_OUTSIDE_BEGIN_END
) {
963 if (0) printf("%s - inside begin/end\n", __FUNCTION__
);
965 exec
->flush_call_depth
--;
966 assert(exec
->flush_call_depth
== 0);
971 vbo_exec_FlushVertices_internal( ctx
, GL_TRUE
);
973 /* Need to do this to ensure BeginVertices gets called again:
975 if (exec
->ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
)
976 exec
->ctx
->Driver
.NeedFlush
&= ~FLUSH_UPDATE_CURRENT
;
978 exec
->ctx
->Driver
.NeedFlush
&= ~flags
;
981 exec
->flush_call_depth
--;
982 assert(exec
->flush_call_depth
== 0);
987 static void reset_attrfv( struct vbo_exec_context
*exec
)
991 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
992 exec
->vtx
.attrsz
[i
] = 0;
993 exec
->vtx
.active_sz
[i
] = 0;
996 exec
->vtx
.vertex_size
= 0;
1001 _vbo_Color4f(GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
1003 vbo_Color4f(r
, g
, b
, a
);
1008 _vbo_Normal3f(GLfloat x
, GLfloat y
, GLfloat z
)
1010 vbo_Normal3f(x
, y
, z
);
1015 _vbo_MultiTexCoord4f(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1017 vbo_MultiTexCoord4f(target
, s
, t
, r
, q
);
1022 _vbo_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
1024 vbo_Materialfv(face
, pname
, params
);
1029 _vbo_Materialf(GLenum face
, GLenum pname
, GLfloat param
)
1033 p
[1] = p
[2] = p
[3] = 0.0F
;
1034 vbo_Materialfv(face
, pname
, p
);
1039 _vbo_VertexAttrib4f(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1041 vbo_VertexAttrib4fARB(index
, x
, y
, z
, w
);
1046 _vbo_VertexAttrib1f(GLuint indx
, GLfloat x
)
1048 vbo_VertexAttrib1fARB(indx
, x
);
1053 _vbo_VertexAttrib1fv(GLuint indx
, const GLfloat
* values
)
1055 vbo_VertexAttrib1fvARB(indx
, values
);
1060 _vbo_VertexAttrib2f(GLuint indx
, GLfloat x
, GLfloat y
)
1062 vbo_VertexAttrib2fARB(indx
, x
, y
);
1067 _vbo_VertexAttrib2fv(GLuint indx
, const GLfloat
* values
)
1069 vbo_VertexAttrib2fvARB(indx
, values
);
1074 _vbo_VertexAttrib3f(GLuint indx
, GLfloat x
, GLfloat y
, GLfloat z
)
1076 vbo_VertexAttrib3fARB(indx
, x
, y
, z
);
1081 _vbo_VertexAttrib3fv(GLuint indx
, const GLfloat
* values
)
1083 vbo_VertexAttrib3fvARB(indx
, values
);
1088 _vbo_VertexAttrib4fv(GLuint indx
, const GLfloat
* values
)
1090 vbo_VertexAttrib4fvARB(indx
, values
);