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"
437 * Flush (draw) vertices.
438 * \param unmap - leave VBO unmapped after flushing?
441 vbo_exec_FlushVertices_internal(struct vbo_exec_context
*exec
, GLboolean unmap
)
443 if (exec
->vtx
.vert_count
|| unmap
) {
444 vbo_exec_vtx_flush( exec
, unmap
);
447 if (exec
->vtx
.vertex_size
) {
448 vbo_exec_copy_to_current( exec
);
449 reset_attrfv( exec
);
457 #if FEATURE_evaluators
459 static void GLAPIENTRY
vbo_exec_EvalCoord1f( GLfloat u
)
461 GET_CURRENT_CONTEXT( ctx
);
462 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
466 if (exec
->eval
.recalculate_maps
)
467 vbo_exec_eval_update( exec
);
469 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
470 if (exec
->eval
.map1
[i
].map
)
471 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map1
[i
].sz
)
472 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map1
[i
].sz
);
477 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
478 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
480 vbo_exec_do_EvalCoord1f( exec
, u
);
482 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
483 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
486 static void GLAPIENTRY
vbo_exec_EvalCoord2f( GLfloat u
, GLfloat v
)
488 GET_CURRENT_CONTEXT( ctx
);
489 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
493 if (exec
->eval
.recalculate_maps
)
494 vbo_exec_eval_update( exec
);
496 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
497 if (exec
->eval
.map2
[i
].map
)
498 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map2
[i
].sz
)
499 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map2
[i
].sz
);
502 if (ctx
->Eval
.AutoNormal
)
503 if (exec
->vtx
.active_sz
[VBO_ATTRIB_NORMAL
] != 3)
504 vbo_exec_fixup_vertex( ctx
, VBO_ATTRIB_NORMAL
, 3 );
507 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
508 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
510 vbo_exec_do_EvalCoord2f( exec
, u
, v
);
512 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
513 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
516 static void GLAPIENTRY
vbo_exec_EvalCoord1fv( const GLfloat
*u
)
518 vbo_exec_EvalCoord1f( u
[0] );
521 static void GLAPIENTRY
vbo_exec_EvalCoord2fv( const GLfloat
*u
)
523 vbo_exec_EvalCoord2f( u
[0], u
[1] );
526 static void GLAPIENTRY
vbo_exec_EvalPoint1( GLint i
)
528 GET_CURRENT_CONTEXT( ctx
);
529 GLfloat du
= ((ctx
->Eval
.MapGrid1u2
- ctx
->Eval
.MapGrid1u1
) /
530 (GLfloat
) ctx
->Eval
.MapGrid1un
);
531 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid1u1
;
533 vbo_exec_EvalCoord1f( u
);
537 static void GLAPIENTRY
vbo_exec_EvalPoint2( GLint i
, GLint j
)
539 GET_CURRENT_CONTEXT( ctx
);
540 GLfloat du
= ((ctx
->Eval
.MapGrid2u2
- ctx
->Eval
.MapGrid2u1
) /
541 (GLfloat
) ctx
->Eval
.MapGrid2un
);
542 GLfloat dv
= ((ctx
->Eval
.MapGrid2v2
- ctx
->Eval
.MapGrid2v1
) /
543 (GLfloat
) ctx
->Eval
.MapGrid2vn
);
544 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid2u1
;
545 GLfloat v
= j
* dv
+ ctx
->Eval
.MapGrid2v1
;
547 vbo_exec_EvalCoord2f( u
, v
);
551 static void GLAPIENTRY
552 vbo_exec_EvalMesh1(GLenum mode
, GLint i1
, GLint i2
)
554 GET_CURRENT_CONTEXT(ctx
);
559 ASSERT_OUTSIDE_BEGIN_END(ctx
);
566 prim
= GL_LINE_STRIP
;
569 _mesa_error( ctx
, GL_INVALID_ENUM
, "glEvalMesh1(mode)" );
573 /* No effect if vertex maps disabled.
575 if (!ctx
->Eval
.Map1Vertex4
&&
576 !ctx
->Eval
.Map1Vertex3
&&
577 !(ctx
->VertexProgram
._Enabled
&& ctx
->Eval
.Map1Attrib
[VERT_ATTRIB_POS
]))
580 du
= ctx
->Eval
.MapGrid1du
;
581 u
= ctx
->Eval
.MapGrid1u1
+ i1
* du
;
583 CALL_Begin(GET_DISPATCH(), (prim
));
584 for (i
=i1
;i
<=i2
;i
++,u
+=du
) {
585 CALL_EvalCoord1f(GET_DISPATCH(), (u
));
587 CALL_End(GET_DISPATCH(), ());
591 static void GLAPIENTRY
592 vbo_exec_EvalMesh2(GLenum mode
, GLint i1
, GLint i2
, GLint j1
, GLint j2
)
594 GET_CURRENT_CONTEXT(ctx
);
595 GLfloat u
, du
, v
, dv
, v1
, u1
;
598 ASSERT_OUTSIDE_BEGIN_END(ctx
);
606 _mesa_error( ctx
, GL_INVALID_ENUM
, "glEvalMesh2(mode)" );
610 /* No effect if vertex maps disabled.
612 if (!ctx
->Eval
.Map2Vertex4
&&
613 !ctx
->Eval
.Map2Vertex3
&&
614 !(ctx
->VertexProgram
._Enabled
&& ctx
->Eval
.Map2Attrib
[VERT_ATTRIB_POS
]))
617 du
= ctx
->Eval
.MapGrid2du
;
618 dv
= ctx
->Eval
.MapGrid2dv
;
619 v1
= ctx
->Eval
.MapGrid2v1
+ j1
* dv
;
620 u1
= ctx
->Eval
.MapGrid2u1
+ i1
* du
;
624 CALL_Begin(GET_DISPATCH(), (GL_POINTS
));
625 for (v
=v1
,j
=j1
;j
<=j2
;j
++,v
+=dv
) {
626 for (u
=u1
,i
=i1
;i
<=i2
;i
++,u
+=du
) {
627 CALL_EvalCoord2f(GET_DISPATCH(), (u
, v
));
630 CALL_End(GET_DISPATCH(), ());
633 for (v
=v1
,j
=j1
;j
<=j2
;j
++,v
+=dv
) {
634 CALL_Begin(GET_DISPATCH(), (GL_LINE_STRIP
));
635 for (u
=u1
,i
=i1
;i
<=i2
;i
++,u
+=du
) {
636 CALL_EvalCoord2f(GET_DISPATCH(), (u
, v
));
638 CALL_End(GET_DISPATCH(), ());
640 for (u
=u1
,i
=i1
;i
<=i2
;i
++,u
+=du
) {
641 CALL_Begin(GET_DISPATCH(), (GL_LINE_STRIP
));
642 for (v
=v1
,j
=j1
;j
<=j2
;j
++,v
+=dv
) {
643 CALL_EvalCoord2f(GET_DISPATCH(), (u
, v
));
645 CALL_End(GET_DISPATCH(), ());
649 for (v
=v1
,j
=j1
;j
<j2
;j
++,v
+=dv
) {
650 CALL_Begin(GET_DISPATCH(), (GL_TRIANGLE_STRIP
));
651 for (u
=u1
,i
=i1
;i
<=i2
;i
++,u
+=du
) {
652 CALL_EvalCoord2f(GET_DISPATCH(), (u
, v
));
653 CALL_EvalCoord2f(GET_DISPATCH(), (u
, v
+dv
));
655 CALL_End(GET_DISPATCH(), ());
661 #endif /* FEATURE_evaluators */
665 * Execute a glRectf() function. This is not suitable for GL_COMPILE
666 * modes (as the test for outside begin/end is not compiled),
667 * but may be useful for drivers in circumstances which exclude
668 * display list interactions.
670 * (None of the functions in this file are suitable for GL_COMPILE
673 static void GLAPIENTRY
674 vbo_exec_Rectf(GLfloat x1
, GLfloat y1
, GLfloat x2
, GLfloat y2
)
676 GET_CURRENT_CONTEXT(ctx
);
677 ASSERT_OUTSIDE_BEGIN_END(ctx
);
679 CALL_Begin(GET_DISPATCH(), (GL_QUADS
));
680 CALL_Vertex2f(GET_DISPATCH(), (x1
, y1
));
681 CALL_Vertex2f(GET_DISPATCH(), (x2
, y1
));
682 CALL_Vertex2f(GET_DISPATCH(), (x2
, y2
));
683 CALL_Vertex2f(GET_DISPATCH(), (x1
, y2
));
684 CALL_End(GET_DISPATCH(), ());
689 * Called via glBegin.
691 static void GLAPIENTRY
vbo_exec_Begin( GLenum mode
)
693 GET_CURRENT_CONTEXT( ctx
);
695 if (ctx
->Driver
.CurrentExecPrimitive
== PRIM_OUTSIDE_BEGIN_END
) {
696 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
699 if (!_mesa_valid_prim_mode(ctx
, mode
, "glBegin")) {
703 vbo_draw_method(vbo_context(ctx
), DRAW_BEGIN_END
);
705 if (ctx
->Driver
.PrepareExecBegin
)
706 ctx
->Driver
.PrepareExecBegin(ctx
);
709 _mesa_update_state( ctx
);
711 CALL_Begin(ctx
->Exec
, (mode
));
715 if (!_mesa_valid_to_render(ctx
, "glBegin")) {
719 /* Heuristic: attempt to isolate attributes occuring outside
722 if (exec
->vtx
.vertex_size
&& !exec
->vtx
.attrsz
[0])
723 vbo_exec_FlushVertices_internal(exec
, GL_FALSE
);
725 i
= exec
->vtx
.prim_count
++;
726 exec
->vtx
.prim
[i
].mode
= mode
;
727 exec
->vtx
.prim
[i
].begin
= 1;
728 exec
->vtx
.prim
[i
].end
= 0;
729 exec
->vtx
.prim
[i
].indexed
= 0;
730 exec
->vtx
.prim
[i
].weak
= 0;
731 exec
->vtx
.prim
[i
].pad
= 0;
732 exec
->vtx
.prim
[i
].start
= exec
->vtx
.vert_count
;
733 exec
->vtx
.prim
[i
].count
= 0;
734 exec
->vtx
.prim
[i
].num_instances
= 1;
736 ctx
->Driver
.CurrentExecPrimitive
= mode
;
739 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glBegin" );
747 static void GLAPIENTRY
vbo_exec_End( void )
749 GET_CURRENT_CONTEXT( ctx
);
751 if (ctx
->Driver
.CurrentExecPrimitive
!= PRIM_OUTSIDE_BEGIN_END
) {
752 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
754 if (exec
->vtx
.prim_count
> 0) {
755 /* close off current primitive */
756 int idx
= exec
->vtx
.vert_count
;
757 int i
= exec
->vtx
.prim_count
- 1;
759 exec
->vtx
.prim
[i
].end
= 1;
760 exec
->vtx
.prim
[i
].count
= idx
- exec
->vtx
.prim
[i
].start
;
763 ctx
->Driver
.CurrentExecPrimitive
= PRIM_OUTSIDE_BEGIN_END
;
765 if (exec
->vtx
.prim_count
== VBO_MAX_PRIM
)
766 vbo_exec_vtx_flush( exec
, GL_FALSE
);
769 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glEnd" );
774 * Called via glPrimitiveRestartNV()
776 static void GLAPIENTRY
777 vbo_exec_PrimitiveRestartNV(void)
780 GET_CURRENT_CONTEXT( ctx
);
782 curPrim
= ctx
->Driver
.CurrentExecPrimitive
;
784 if (curPrim
== PRIM_OUTSIDE_BEGIN_END
) {
785 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glPrimitiveRestartNV" );
789 vbo_exec_Begin(curPrim
);
795 static void vbo_exec_vtxfmt_init( struct vbo_exec_context
*exec
)
797 GLvertexformat
*vfmt
= &exec
->vtxfmt
;
799 _MESA_INIT_ARRAYELT_VTXFMT(vfmt
, _ae_
);
801 vfmt
->Begin
= vbo_exec_Begin
;
802 vfmt
->End
= vbo_exec_End
;
803 vfmt
->PrimitiveRestartNV
= vbo_exec_PrimitiveRestartNV
;
805 _MESA_INIT_DLIST_VTXFMT(vfmt
, _mesa_
);
806 _MESA_INIT_EVAL_VTXFMT(vfmt
, vbo_exec_
);
808 vfmt
->Rectf
= vbo_exec_Rectf
;
810 /* from attrib_tmp.h:
812 vfmt
->Color3f
= vbo_Color3f
;
813 vfmt
->Color3fv
= vbo_Color3fv
;
814 vfmt
->Color4f
= vbo_Color4f
;
815 vfmt
->Color4fv
= vbo_Color4fv
;
816 vfmt
->FogCoordfEXT
= vbo_FogCoordfEXT
;
817 vfmt
->FogCoordfvEXT
= vbo_FogCoordfvEXT
;
818 vfmt
->MultiTexCoord1fARB
= vbo_MultiTexCoord1f
;
819 vfmt
->MultiTexCoord1fvARB
= vbo_MultiTexCoord1fv
;
820 vfmt
->MultiTexCoord2fARB
= vbo_MultiTexCoord2f
;
821 vfmt
->MultiTexCoord2fvARB
= vbo_MultiTexCoord2fv
;
822 vfmt
->MultiTexCoord3fARB
= vbo_MultiTexCoord3f
;
823 vfmt
->MultiTexCoord3fvARB
= vbo_MultiTexCoord3fv
;
824 vfmt
->MultiTexCoord4fARB
= vbo_MultiTexCoord4f
;
825 vfmt
->MultiTexCoord4fvARB
= vbo_MultiTexCoord4fv
;
826 vfmt
->Normal3f
= vbo_Normal3f
;
827 vfmt
->Normal3fv
= vbo_Normal3fv
;
828 vfmt
->SecondaryColor3fEXT
= vbo_SecondaryColor3fEXT
;
829 vfmt
->SecondaryColor3fvEXT
= vbo_SecondaryColor3fvEXT
;
830 vfmt
->TexCoord1f
= vbo_TexCoord1f
;
831 vfmt
->TexCoord1fv
= vbo_TexCoord1fv
;
832 vfmt
->TexCoord2f
= vbo_TexCoord2f
;
833 vfmt
->TexCoord2fv
= vbo_TexCoord2fv
;
834 vfmt
->TexCoord3f
= vbo_TexCoord3f
;
835 vfmt
->TexCoord3fv
= vbo_TexCoord3fv
;
836 vfmt
->TexCoord4f
= vbo_TexCoord4f
;
837 vfmt
->TexCoord4fv
= vbo_TexCoord4fv
;
838 vfmt
->Vertex2f
= vbo_Vertex2f
;
839 vfmt
->Vertex2fv
= vbo_Vertex2fv
;
840 vfmt
->Vertex3f
= vbo_Vertex3f
;
841 vfmt
->Vertex3fv
= vbo_Vertex3fv
;
842 vfmt
->Vertex4f
= vbo_Vertex4f
;
843 vfmt
->Vertex4fv
= vbo_Vertex4fv
;
845 vfmt
->VertexAttrib1fARB
= vbo_VertexAttrib1fARB
;
846 vfmt
->VertexAttrib1fvARB
= vbo_VertexAttrib1fvARB
;
847 vfmt
->VertexAttrib2fARB
= vbo_VertexAttrib2fARB
;
848 vfmt
->VertexAttrib2fvARB
= vbo_VertexAttrib2fvARB
;
849 vfmt
->VertexAttrib3fARB
= vbo_VertexAttrib3fARB
;
850 vfmt
->VertexAttrib3fvARB
= vbo_VertexAttrib3fvARB
;
851 vfmt
->VertexAttrib4fARB
= vbo_VertexAttrib4fARB
;
852 vfmt
->VertexAttrib4fvARB
= vbo_VertexAttrib4fvARB
;
854 vfmt
->VertexAttrib1fNV
= vbo_VertexAttrib1fNV
;
855 vfmt
->VertexAttrib1fvNV
= vbo_VertexAttrib1fvNV
;
856 vfmt
->VertexAttrib2fNV
= vbo_VertexAttrib2fNV
;
857 vfmt
->VertexAttrib2fvNV
= vbo_VertexAttrib2fvNV
;
858 vfmt
->VertexAttrib3fNV
= vbo_VertexAttrib3fNV
;
859 vfmt
->VertexAttrib3fvNV
= vbo_VertexAttrib3fvNV
;
860 vfmt
->VertexAttrib4fNV
= vbo_VertexAttrib4fNV
;
861 vfmt
->VertexAttrib4fvNV
= vbo_VertexAttrib4fvNV
;
864 vfmt
->VertexAttribI1i
= vbo_VertexAttribI1i
;
865 vfmt
->VertexAttribI2i
= vbo_VertexAttribI2i
;
866 vfmt
->VertexAttribI3i
= vbo_VertexAttribI3i
;
867 vfmt
->VertexAttribI4i
= vbo_VertexAttribI4i
;
868 vfmt
->VertexAttribI2iv
= vbo_VertexAttribI2iv
;
869 vfmt
->VertexAttribI3iv
= vbo_VertexAttribI3iv
;
870 vfmt
->VertexAttribI4iv
= vbo_VertexAttribI4iv
;
872 /* unsigned integer-valued */
873 vfmt
->VertexAttribI1ui
= vbo_VertexAttribI1ui
;
874 vfmt
->VertexAttribI2ui
= vbo_VertexAttribI2ui
;
875 vfmt
->VertexAttribI3ui
= vbo_VertexAttribI3ui
;
876 vfmt
->VertexAttribI4ui
= vbo_VertexAttribI4ui
;
877 vfmt
->VertexAttribI2uiv
= vbo_VertexAttribI2uiv
;
878 vfmt
->VertexAttribI3uiv
= vbo_VertexAttribI3uiv
;
879 vfmt
->VertexAttribI4uiv
= vbo_VertexAttribI4uiv
;
881 vfmt
->Materialfv
= vbo_Materialfv
;
883 vfmt
->EdgeFlag
= vbo_EdgeFlag
;
884 vfmt
->Indexf
= vbo_Indexf
;
885 vfmt
->Indexfv
= vbo_Indexfv
;
887 /* ARB_vertex_type_2_10_10_10_rev */
888 vfmt
->VertexP2ui
= vbo_VertexP2ui
;
889 vfmt
->VertexP2uiv
= vbo_VertexP2uiv
;
890 vfmt
->VertexP3ui
= vbo_VertexP3ui
;
891 vfmt
->VertexP3uiv
= vbo_VertexP3uiv
;
892 vfmt
->VertexP4ui
= vbo_VertexP4ui
;
893 vfmt
->VertexP4uiv
= vbo_VertexP4uiv
;
895 vfmt
->TexCoordP1ui
= vbo_TexCoordP1ui
;
896 vfmt
->TexCoordP1uiv
= vbo_TexCoordP1uiv
;
897 vfmt
->TexCoordP2ui
= vbo_TexCoordP2ui
;
898 vfmt
->TexCoordP2uiv
= vbo_TexCoordP2uiv
;
899 vfmt
->TexCoordP3ui
= vbo_TexCoordP3ui
;
900 vfmt
->TexCoordP3uiv
= vbo_TexCoordP3uiv
;
901 vfmt
->TexCoordP4ui
= vbo_TexCoordP4ui
;
902 vfmt
->TexCoordP4uiv
= vbo_TexCoordP4uiv
;
904 vfmt
->MultiTexCoordP1ui
= vbo_MultiTexCoordP1ui
;
905 vfmt
->MultiTexCoordP1uiv
= vbo_MultiTexCoordP1uiv
;
906 vfmt
->MultiTexCoordP2ui
= vbo_MultiTexCoordP2ui
;
907 vfmt
->MultiTexCoordP2uiv
= vbo_MultiTexCoordP2uiv
;
908 vfmt
->MultiTexCoordP3ui
= vbo_MultiTexCoordP3ui
;
909 vfmt
->MultiTexCoordP3uiv
= vbo_MultiTexCoordP3uiv
;
910 vfmt
->MultiTexCoordP4ui
= vbo_MultiTexCoordP4ui
;
911 vfmt
->MultiTexCoordP4uiv
= vbo_MultiTexCoordP4uiv
;
913 vfmt
->NormalP3ui
= vbo_NormalP3ui
;
914 vfmt
->NormalP3uiv
= vbo_NormalP3uiv
;
916 vfmt
->ColorP3ui
= vbo_ColorP3ui
;
917 vfmt
->ColorP3uiv
= vbo_ColorP3uiv
;
918 vfmt
->ColorP4ui
= vbo_ColorP4ui
;
919 vfmt
->ColorP4uiv
= vbo_ColorP4uiv
;
921 vfmt
->SecondaryColorP3ui
= vbo_SecondaryColorP3ui
;
922 vfmt
->SecondaryColorP3uiv
= vbo_SecondaryColorP3uiv
;
924 vfmt
->VertexAttribP1ui
= vbo_VertexAttribP1ui
;
925 vfmt
->VertexAttribP1uiv
= vbo_VertexAttribP1uiv
;
926 vfmt
->VertexAttribP2ui
= vbo_VertexAttribP2ui
;
927 vfmt
->VertexAttribP2uiv
= vbo_VertexAttribP2uiv
;
928 vfmt
->VertexAttribP3ui
= vbo_VertexAttribP3ui
;
929 vfmt
->VertexAttribP3uiv
= vbo_VertexAttribP3uiv
;
930 vfmt
->VertexAttribP4ui
= vbo_VertexAttribP4ui
;
931 vfmt
->VertexAttribP4uiv
= vbo_VertexAttribP4uiv
;
935 #else /* FEATURE_beginend */
938 static void vbo_exec_vtxfmt_init( struct vbo_exec_context
*exec
)
940 /* silence warnings */
945 (void) vbo_FogCoordfEXT
;
946 (void) vbo_FogCoordfvEXT
;
947 (void) vbo_MultiTexCoord1f
;
948 (void) vbo_MultiTexCoord1fv
;
949 (void) vbo_MultiTexCoord2f
;
950 (void) vbo_MultiTexCoord2fv
;
951 (void) vbo_MultiTexCoord3f
;
952 (void) vbo_MultiTexCoord3fv
;
953 (void) vbo_MultiTexCoord4f
;
954 (void) vbo_MultiTexCoord4fv
;
956 (void) vbo_Normal3fv
;
957 (void) vbo_SecondaryColor3fEXT
;
958 (void) vbo_SecondaryColor3fvEXT
;
959 (void) vbo_TexCoord1f
;
960 (void) vbo_TexCoord1fv
;
961 (void) vbo_TexCoord2f
;
962 (void) vbo_TexCoord2fv
;
963 (void) vbo_TexCoord3f
;
964 (void) vbo_TexCoord3fv
;
965 (void) vbo_TexCoord4f
;
966 (void) vbo_TexCoord4fv
;
968 (void) vbo_Vertex2fv
;
970 (void) vbo_Vertex3fv
;
972 (void) vbo_Vertex4fv
;
974 (void) vbo_VertexAttrib1fARB
;
975 (void) vbo_VertexAttrib1fvARB
;
976 (void) vbo_VertexAttrib2fARB
;
977 (void) vbo_VertexAttrib2fvARB
;
978 (void) vbo_VertexAttrib3fARB
;
979 (void) vbo_VertexAttrib3fvARB
;
980 (void) vbo_VertexAttrib4fARB
;
981 (void) vbo_VertexAttrib4fvARB
;
983 (void) vbo_VertexAttrib1fNV
;
984 (void) vbo_VertexAttrib1fvNV
;
985 (void) vbo_VertexAttrib2fNV
;
986 (void) vbo_VertexAttrib2fvNV
;
987 (void) vbo_VertexAttrib3fNV
;
988 (void) vbo_VertexAttrib3fvNV
;
989 (void) vbo_VertexAttrib4fNV
;
990 (void) vbo_VertexAttrib4fvNV
;
992 (void) vbo_Materialfv
;
1000 #endif /* FEATURE_beginend */
1004 * Tell the VBO module to use a real OpenGL vertex buffer object to
1005 * store accumulated immediate-mode vertex data.
1006 * This replaces the malloced buffer which was created in
1007 * vb_exec_vtx_init() below.
1009 void vbo_use_buffer_objects(struct gl_context
*ctx
)
1011 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1012 /* Any buffer name but 0 can be used here since this bufferobj won't
1013 * go into the bufferobj hashtable.
1015 GLuint bufName
= IMM_BUFFER_NAME
;
1016 GLenum target
= GL_ARRAY_BUFFER_ARB
;
1017 GLenum usage
= GL_STREAM_DRAW_ARB
;
1018 GLsizei size
= VBO_VERT_BUFFER_SIZE
;
1020 /* Make sure this func is only used once */
1021 assert(exec
->vtx
.bufferobj
== ctx
->Shared
->NullBufferObj
);
1022 if (exec
->vtx
.buffer_map
) {
1023 _mesa_align_free(exec
->vtx
.buffer_map
);
1024 exec
->vtx
.buffer_map
= NULL
;
1025 exec
->vtx
.buffer_ptr
= NULL
;
1028 /* Allocate a real buffer object now */
1029 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1030 exec
->vtx
.bufferobj
= ctx
->Driver
.NewBufferObject(ctx
, bufName
, target
);
1031 if (!ctx
->Driver
.BufferData(ctx
, target
, size
, NULL
, usage
, exec
->vtx
.bufferobj
)) {
1032 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "VBO allocation");
1038 * If this function is called, all VBO buffers will be unmapped when
1040 * Otherwise, if a simple command like glColor3f() is called and we flush,
1041 * the current VBO may be left mapped.
1044 vbo_always_unmap_buffers(struct gl_context
*ctx
)
1046 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1047 exec
->begin_vertices_flags
|= FLUSH_STORED_VERTICES
;
1051 void vbo_exec_vtx_init( struct vbo_exec_context
*exec
)
1053 struct gl_context
*ctx
= exec
->ctx
;
1054 struct vbo_context
*vbo
= vbo_context(ctx
);
1057 /* Allocate a buffer object. Will just reuse this object
1058 * continuously, unless vbo_use_buffer_objects() is called to enable
1061 _mesa_reference_buffer_object(ctx
,
1062 &exec
->vtx
.bufferobj
,
1063 ctx
->Shared
->NullBufferObj
);
1065 ASSERT(!exec
->vtx
.buffer_map
);
1066 exec
->vtx
.buffer_map
= (GLfloat
*)_mesa_align_malloc(VBO_VERT_BUFFER_SIZE
, 64);
1067 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
1069 vbo_exec_vtxfmt_init( exec
);
1070 _mesa_noop_vtxfmt_init(&exec
->vtxfmt_noop
);
1072 /* Hook our functions into the dispatch table.
1074 _mesa_install_exec_vtxfmt( ctx
, &exec
->vtxfmt
);
1076 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1077 ASSERT(i
< Elements(exec
->vtx
.attrsz
));
1078 exec
->vtx
.attrsz
[i
] = 0;
1079 ASSERT(i
< Elements(exec
->vtx
.active_sz
));
1080 exec
->vtx
.active_sz
[i
] = 0;
1082 for (i
= 0 ; i
< VERT_ATTRIB_MAX
; i
++) {
1083 ASSERT(i
< Elements(exec
->vtx
.inputs
));
1084 ASSERT(i
< Elements(exec
->vtx
.arrays
));
1085 exec
->vtx
.inputs
[i
] = &exec
->vtx
.arrays
[i
];
1089 struct gl_client_array
*arrays
= exec
->vtx
.arrays
;
1092 memcpy(arrays
, &vbo
->currval
[VBO_ATTRIB_POS
],
1093 VERT_ATTRIB_FF_MAX
* sizeof(arrays
[0]));
1094 for (i
= 0; i
< VERT_ATTRIB_FF_MAX
; ++i
) {
1095 struct gl_client_array
*array
;
1096 array
= &arrays
[VERT_ATTRIB_FF(i
)];
1097 array
->BufferObj
= NULL
;
1098 _mesa_reference_buffer_object(ctx
, &arrays
->BufferObj
,
1099 vbo
->currval
[VBO_ATTRIB_POS
+i
].BufferObj
);
1102 memcpy(arrays
+ VERT_ATTRIB_GENERIC(0),
1103 &vbo
->currval
[VBO_ATTRIB_GENERIC0
],
1104 VERT_ATTRIB_GENERIC_MAX
* sizeof(arrays
[0]));
1106 for (i
= 0; i
< VERT_ATTRIB_GENERIC_MAX
; ++i
) {
1107 struct gl_client_array
*array
;
1108 array
= &arrays
[VERT_ATTRIB_GENERIC(i
)];
1109 array
->BufferObj
= NULL
;
1110 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1111 vbo
->currval
[VBO_ATTRIB_GENERIC0
+i
].BufferObj
);
1115 exec
->vtx
.vertex_size
= 0;
1117 exec
->begin_vertices_flags
= FLUSH_UPDATE_CURRENT
;
1121 void vbo_exec_vtx_destroy( struct vbo_exec_context
*exec
)
1123 /* using a real VBO for vertex data */
1124 struct gl_context
*ctx
= exec
->ctx
;
1127 /* True VBOs should already be unmapped
1129 if (exec
->vtx
.buffer_map
) {
1130 ASSERT(exec
->vtx
.bufferobj
->Name
== 0 ||
1131 exec
->vtx
.bufferobj
->Name
== IMM_BUFFER_NAME
);
1132 if (exec
->vtx
.bufferobj
->Name
== 0) {
1133 _mesa_align_free(exec
->vtx
.buffer_map
);
1134 exec
->vtx
.buffer_map
= NULL
;
1135 exec
->vtx
.buffer_ptr
= NULL
;
1139 /* Drop any outstanding reference to the vertex buffer
1141 for (i
= 0; i
< Elements(exec
->vtx
.arrays
); i
++) {
1142 _mesa_reference_buffer_object(ctx
,
1143 &exec
->vtx
.arrays
[i
].BufferObj
,
1147 /* Free the vertex buffer. Unmap first if needed.
1149 if (_mesa_bufferobj_mapped(exec
->vtx
.bufferobj
)) {
1150 ctx
->Driver
.UnmapBuffer(ctx
, exec
->vtx
.bufferobj
);
1152 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1157 * Called upon first glVertex, glColor, glTexCoord, etc.
1159 void vbo_exec_BeginVertices( struct gl_context
*ctx
)
1161 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1163 vbo_exec_vtx_map( exec
);
1165 assert((ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
) == 0);
1166 assert(exec
->begin_vertices_flags
);
1168 ctx
->Driver
.NeedFlush
|= exec
->begin_vertices_flags
;
1173 * Called via ctx->Driver.FlushVertices()
1174 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1176 void vbo_exec_FlushVertices( struct gl_context
*ctx
, GLuint flags
)
1178 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1181 /* debug check: make sure we don't get called recursively */
1182 exec
->flush_call_depth
++;
1183 assert(exec
->flush_call_depth
== 1);
1186 if (ctx
->Driver
.CurrentExecPrimitive
!= PRIM_OUTSIDE_BEGIN_END
) {
1187 /* We've had glBegin but not glEnd! */
1189 exec
->flush_call_depth
--;
1190 assert(exec
->flush_call_depth
== 0);
1195 /* Flush (draw), and make sure VBO is left unmapped when done */
1196 vbo_exec_FlushVertices_internal(exec
, GL_TRUE
);
1198 /* Need to do this to ensure BeginVertices gets called again:
1200 ctx
->Driver
.NeedFlush
&= ~(FLUSH_UPDATE_CURRENT
| flags
);
1203 exec
->flush_call_depth
--;
1204 assert(exec
->flush_call_depth
== 0);
1209 static void reset_attrfv( struct vbo_exec_context
*exec
)
1213 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1214 exec
->vtx
.attrsz
[i
] = 0;
1215 exec
->vtx
.active_sz
[i
] = 0;
1218 exec
->vtx
.vertex_size
= 0;
1223 _es_Color4f(GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
1225 vbo_Color4f(r
, g
, b
, a
);
1230 _es_Normal3f(GLfloat x
, GLfloat y
, GLfloat z
)
1232 vbo_Normal3f(x
, y
, z
);
1237 _es_MultiTexCoord4f(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1239 vbo_MultiTexCoord4f(target
, s
, t
, r
, q
);
1244 _es_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
1246 vbo_Materialfv(face
, pname
, params
);
1251 _es_Materialf(GLenum face
, GLenum pname
, GLfloat param
)
1255 p
[1] = p
[2] = p
[3] = 0.0F
;
1256 vbo_Materialfv(face
, pname
, p
);
1261 * A special version of glVertexAttrib4f that does not treat index 0 as
1265 VertexAttrib4f_nopos(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1267 GET_CURRENT_CONTEXT(ctx
);
1268 if (index
< MAX_VERTEX_GENERIC_ATTRIBS
)
1269 ATTR(VBO_ATTRIB_GENERIC0
+ index
, 4, x
, y
, z
, w
);
1271 ERROR(GL_INVALID_VALUE
);
1275 _es_VertexAttrib4f(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1277 VertexAttrib4f_nopos(index
, x
, y
, z
, w
);
1282 _es_VertexAttrib1f(GLuint indx
, GLfloat x
)
1284 VertexAttrib4f_nopos(indx
, x
, 0.0f
, 0.0f
, 1.0f
);
1289 _es_VertexAttrib1fv(GLuint indx
, const GLfloat
* values
)
1291 VertexAttrib4f_nopos(indx
, values
[0], 0.0f
, 0.0f
, 1.0f
);
1296 _es_VertexAttrib2f(GLuint indx
, GLfloat x
, GLfloat y
)
1298 VertexAttrib4f_nopos(indx
, x
, y
, 0.0f
, 1.0f
);
1303 _es_VertexAttrib2fv(GLuint indx
, const GLfloat
* values
)
1305 VertexAttrib4f_nopos(indx
, values
[0], values
[1], 0.0f
, 1.0f
);
1310 _es_VertexAttrib3f(GLuint indx
, GLfloat x
, GLfloat y
, GLfloat z
)
1312 VertexAttrib4f_nopos(indx
, x
, y
, z
, 1.0f
);
1317 _es_VertexAttrib3fv(GLuint indx
, const GLfloat
* values
)
1319 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], 1.0f
);
1324 _es_VertexAttrib4fv(GLuint indx
, const GLfloat
* values
)
1326 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], values
[3]);