1 /**************************************************************************
3 Copyright 2002-2008 VMware, Inc.
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 VMWARE 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 <keithw@vmware.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_validate.h"
44 #include "main/dispatch.h"
46 #include "vbo_context.h"
55 /** ID/name for immediate-mode VBO */
56 #define IMM_BUFFER_NAME 0xaabbccdd
59 static void reset_attrfv( struct vbo_exec_context
*exec
);
63 * Close off the last primitive, execute the buffer, restart the
64 * primitive. This is called when we fill a vertex buffer before
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 struct _mesa_prim
*last_prim
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
76 const GLuint last_begin
= last_prim
->begin
;
79 if (_mesa_inside_begin_end(exec
->ctx
)) {
80 last_prim
->count
= exec
->vtx
.vert_count
- last_prim
->start
;
83 last_count
= last_prim
->count
;
85 /* Special handling for wrapping GL_LINE_LOOP */
86 if (last_prim
->mode
== GL_LINE_LOOP
&&
89 /* draw this section of the incomplete line loop as a line strip */
90 last_prim
->mode
= GL_LINE_STRIP
;
91 if (!last_prim
->begin
) {
92 /* This is not the first section of the line loop, so don't
93 * draw the 0th vertex. We're saving it until we draw the
94 * very last section of the loop.
101 /* Execute the buffer and save copied vertices.
103 if (exec
->vtx
.vert_count
)
104 vbo_exec_vtx_flush( exec
, GL_FALSE
);
106 exec
->vtx
.prim_count
= 0;
107 exec
->vtx
.copied
.nr
= 0;
110 /* Emit a glBegin to start the new list.
112 assert(exec
->vtx
.prim_count
== 0);
114 if (_mesa_inside_begin_end(exec
->ctx
)) {
115 exec
->vtx
.prim
[0].mode
= exec
->ctx
->Driver
.CurrentExecPrimitive
;
116 exec
->vtx
.prim
[0].begin
= 0;
117 exec
->vtx
.prim
[0].start
= 0;
118 exec
->vtx
.prim
[0].count
= 0;
119 exec
->vtx
.prim_count
++;
121 if (exec
->vtx
.copied
.nr
== last_count
)
122 exec
->vtx
.prim
[0].begin
= last_begin
;
129 * Deal with buffer wrapping where provoked by the vertex buffer
130 * filling up, as opposed to upgrade_vertex().
133 vbo_exec_vtx_wrap(struct vbo_exec_context
*exec
)
135 unsigned numComponents
;
137 /* Run pipeline on current vertices, copy wrapped vertices
138 * to exec->vtx.copied.
140 vbo_exec_wrap_buffers( exec
);
142 if (!exec
->vtx
.buffer_ptr
) {
143 /* probably ran out of memory earlier when allocating the VBO */
147 /* Copy stored stored vertices to start of new list.
149 assert(exec
->vtx
.max_vert
- exec
->vtx
.vert_count
> exec
->vtx
.copied
.nr
);
151 numComponents
= exec
->vtx
.copied
.nr
* exec
->vtx
.vertex_size
;
152 memcpy(exec
->vtx
.buffer_ptr
,
153 exec
->vtx
.copied
.buffer
,
154 numComponents
* sizeof(fi_type
));
155 exec
->vtx
.buffer_ptr
+= numComponents
;
156 exec
->vtx
.vert_count
+= exec
->vtx
.copied
.nr
;
158 exec
->vtx
.copied
.nr
= 0;
163 * Copy the active vertex's values to the ctx->Current fields.
165 static void vbo_exec_copy_to_current( struct vbo_exec_context
*exec
)
167 struct gl_context
*ctx
= exec
->ctx
;
168 struct vbo_context
*vbo
= vbo_context(ctx
);
171 for (i
= VBO_ATTRIB_POS
+1 ; i
< VBO_ATTRIB_MAX
; i
++) {
172 if (exec
->vtx
.attrsz
[i
]) {
173 /* Note: the exec->vtx.current[i] pointers point into the
174 * ctx->Current.Attrib and ctx->Light.Material.Attrib arrays.
176 GLfloat
*current
= (GLfloat
*)vbo
->currval
[i
].Ptr
;
177 fi_type tmp
[8]; /* space for doubles */
178 int dmul
= exec
->vtx
.attrtype
[i
] == GL_DOUBLE
? 2 : 1;
180 if (exec
->vtx
.attrtype
[i
] == GL_DOUBLE
) {
181 memset(tmp
, 0, sizeof(tmp
));
182 memcpy(tmp
, exec
->vtx
.attrptr
[i
], exec
->vtx
.attrsz
[i
] * sizeof(GLfloat
));
184 COPY_CLEAN_4V_TYPE_AS_UNION(tmp
,
186 exec
->vtx
.attrptr
[i
],
187 exec
->vtx
.attrtype
[i
]);
190 if (exec
->vtx
.attrtype
[i
] != vbo
->currval
[i
].Type
||
191 memcmp(current
, tmp
, 4 * sizeof(GLfloat
) * dmul
) != 0) {
192 memcpy(current
, tmp
, 4 * sizeof(GLfloat
) * dmul
);
194 /* Given that we explicitly state size here, there is no need
195 * for the COPY_CLEAN above, could just copy 16 bytes and be
196 * done. The only problem is when Mesa accesses ctx->Current
199 /* Size here is in components - not bytes */
200 vbo
->currval
[i
].Size
= exec
->vtx
.attrsz
[i
] / dmul
;
201 vbo
->currval
[i
]._ElementSize
= vbo
->currval
[i
].Size
* sizeof(GLfloat
) * dmul
;
202 vbo
->currval
[i
].Type
= exec
->vtx
.attrtype
[i
];
203 vbo
->currval
[i
].Integer
=
204 vbo_attrtype_to_integer_flag(exec
->vtx
.attrtype
[i
]);
205 vbo
->currval
[i
].Doubles
=
206 vbo_attrtype_to_double_flag(exec
->vtx
.attrtype
[i
]);
208 /* This triggers rather too much recalculation of Mesa state
209 * that doesn't get used (eg light positions).
211 if (i
>= VBO_ATTRIB_MAT_FRONT_AMBIENT
&&
212 i
<= VBO_ATTRIB_MAT_BACK_INDEXES
)
213 ctx
->NewState
|= _NEW_LIGHT
;
215 ctx
->NewState
|= _NEW_CURRENT_ATTRIB
;
220 /* Colormaterial -- this kindof sucks.
222 if (ctx
->Light
.ColorMaterialEnabled
&&
223 exec
->vtx
.attrsz
[VBO_ATTRIB_COLOR0
]) {
224 _mesa_update_color_material(ctx
,
225 ctx
->Current
.Attrib
[VBO_ATTRIB_COLOR0
]);
231 * Copy current vertex attribute values into the current vertex.
234 vbo_exec_copy_from_current(struct vbo_exec_context
*exec
)
236 struct gl_context
*ctx
= exec
->ctx
;
237 struct vbo_context
*vbo
= vbo_context(ctx
);
240 for (i
= VBO_ATTRIB_POS
+ 1; i
< VBO_ATTRIB_MAX
; i
++) {
241 if (exec
->vtx
.attrtype
[i
] == GL_DOUBLE
) {
242 memcpy(exec
->vtx
.attrptr
[i
], vbo
->currval
[i
].Ptr
, exec
->vtx
.attrsz
[i
] * sizeof(GLfloat
));
244 const fi_type
*current
= (fi_type
*) vbo
->currval
[i
].Ptr
;
245 switch (exec
->vtx
.attrsz
[i
]) {
246 case 4: exec
->vtx
.attrptr
[i
][3] = current
[3];
247 case 3: exec
->vtx
.attrptr
[i
][2] = current
[2];
248 case 2: exec
->vtx
.attrptr
[i
][1] = current
[1];
249 case 1: exec
->vtx
.attrptr
[i
][0] = current
[0];
258 * Flush existing data, set new attrib size, replay copied vertices.
259 * This is called when we transition from a small vertex attribute size
260 * to a larger one. Ex: glTexCoord2f -> glTexCoord4f.
261 * We need to go back over the previous 2-component texcoords and insert
262 * zero and one values.
265 vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context
*exec
,
266 GLuint attr
, GLuint newSize
)
268 struct gl_context
*ctx
= exec
->ctx
;
269 struct vbo_context
*vbo
= vbo_context(ctx
);
270 const GLint lastcount
= exec
->vtx
.vert_count
;
271 fi_type
*old_attrptr
[VBO_ATTRIB_MAX
];
272 const GLuint old_vtx_size
= exec
->vtx
.vertex_size
; /* floats per vertex */
273 const GLuint oldSize
= exec
->vtx
.attrsz
[attr
];
276 /* Run pipeline on current vertices, copy wrapped vertices
277 * to exec->vtx.copied.
279 vbo_exec_wrap_buffers( exec
);
281 if (unlikely(exec
->vtx
.copied
.nr
)) {
282 /* We're in the middle of a primitive, keep the old vertex
283 * format around to be able to translate the copied vertices to
286 memcpy(old_attrptr
, exec
->vtx
.attrptr
, sizeof(old_attrptr
));
289 if (unlikely(oldSize
)) {
290 /* Do a COPY_TO_CURRENT to ensure back-copying works for the
291 * case when the attribute already exists in the vertex and is
292 * having its size increased.
294 vbo_exec_copy_to_current( exec
);
297 /* Heuristic: Attempt to isolate attributes received outside
298 * begin/end so that they don't bloat the vertices.
300 if (!_mesa_inside_begin_end(ctx
) &&
301 !oldSize
&& lastcount
> 8 && exec
->vtx
.vertex_size
) {
302 vbo_exec_copy_to_current( exec
);
303 reset_attrfv( exec
);
308 exec
->vtx
.attrsz
[attr
] = newSize
;
309 exec
->vtx
.vertex_size
+= newSize
- oldSize
;
310 exec
->vtx
.max_vert
= vbo_compute_max_verts(exec
);
311 exec
->vtx
.vert_count
= 0;
312 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
314 if (unlikely(oldSize
)) {
315 /* Size changed, recalculate all the attrptr[] values
317 fi_type
*tmp
= exec
->vtx
.vertex
;
319 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
320 if (exec
->vtx
.attrsz
[i
]) {
321 exec
->vtx
.attrptr
[i
] = tmp
;
322 tmp
+= exec
->vtx
.attrsz
[i
];
325 exec
->vtx
.attrptr
[i
] = NULL
; /* will not be dereferenced */
328 /* Copy from current to repopulate the vertex with correct
331 vbo_exec_copy_from_current( exec
);
334 /* Just have to append the new attribute at the end */
335 exec
->vtx
.attrptr
[attr
] = exec
->vtx
.vertex
+
336 exec
->vtx
.vertex_size
- newSize
;
339 /* Replay stored vertices to translate them
340 * to new format here.
342 * -- No need to replay - just copy piecewise
344 if (unlikely(exec
->vtx
.copied
.nr
)) {
345 fi_type
*data
= exec
->vtx
.copied
.buffer
;
346 fi_type
*dest
= exec
->vtx
.buffer_ptr
;
349 assert(exec
->vtx
.buffer_ptr
== exec
->vtx
.buffer_map
);
351 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
352 for (j
= 0 ; j
< VBO_ATTRIB_MAX
; j
++) {
353 GLuint sz
= exec
->vtx
.attrsz
[j
];
356 GLint old_offset
= old_attrptr
[j
] - exec
->vtx
.vertex
;
357 GLint new_offset
= exec
->vtx
.attrptr
[j
] - exec
->vtx
.vertex
;
362 COPY_CLEAN_4V_TYPE_AS_UNION(tmp
, oldSize
,
364 exec
->vtx
.attrtype
[j
]);
365 COPY_SZ_4V(dest
+ new_offset
, newSize
, tmp
);
367 fi_type
*current
= (fi_type
*)vbo
->currval
[j
].Ptr
;
368 COPY_SZ_4V(dest
+ new_offset
, sz
, current
);
372 COPY_SZ_4V(dest
+ new_offset
, sz
, data
+ old_offset
);
377 data
+= old_vtx_size
;
378 dest
+= exec
->vtx
.vertex_size
;
381 exec
->vtx
.buffer_ptr
= dest
;
382 exec
->vtx
.vert_count
+= exec
->vtx
.copied
.nr
;
383 exec
->vtx
.copied
.nr
= 0;
389 * This is when a vertex attribute transitions to a different size.
390 * For example, we saw a bunch of glTexCoord2f() calls and now we got a
391 * glTexCoord4f() call. We promote the array from size=2 to size=4.
392 * \param newSize size of new vertex (number of 32-bit words).
395 vbo_exec_fixup_vertex(struct gl_context
*ctx
, GLuint attr
,
396 GLuint newSize
, GLenum newType
)
398 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
400 if (newSize
> exec
->vtx
.attrsz
[attr
] ||
401 newType
!= exec
->vtx
.attrtype
[attr
]) {
402 /* New size is larger. Need to flush existing vertices and get
403 * an enlarged vertex format.
405 vbo_exec_wrap_upgrade_vertex( exec
, attr
, newSize
);
407 else if (newSize
< exec
->vtx
.active_sz
[attr
]) {
410 vbo_get_default_vals_as_union(exec
->vtx
.attrtype
[attr
]);
412 /* New size is smaller - just need to fill in some
413 * zeros. Don't need to flush or wrap.
415 for (i
= newSize
; i
<= exec
->vtx
.attrsz
[attr
]; i
++)
416 exec
->vtx
.attrptr
[attr
][i
-1] = id
[i
-1];
419 exec
->vtx
.active_sz
[attr
] = newSize
;
421 /* Does setting NeedFlush belong here? Necessitates resetting
422 * vtxfmt on each flush (otherwise flags won't get reset
426 ctx
->Driver
.NeedFlush
|= FLUSH_STORED_VERTICES
;
431 * Called upon first glVertex, glColor, glTexCoord, etc.
434 vbo_exec_begin_vertices(struct gl_context
*ctx
)
436 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
438 vbo_exec_vtx_map( exec
);
440 assert((ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
) == 0);
441 assert(exec
->begin_vertices_flags
);
443 ctx
->Driver
.NeedFlush
|= exec
->begin_vertices_flags
;
448 * This macro is used to implement all the glVertex, glColor, glTexCoord,
449 * glVertexAttrib, etc functions.
450 * \param A attribute index
451 * \param N attribute size (1..4)
452 * \param T type (GL_FLOAT, GL_DOUBLE, GL_INT, GL_UNSIGNED_INT)
453 * \param C cast type (fi_type or double)
454 * \param V0, V1, v2, V3 attribute value
456 #define ATTR_UNION( A, N, T, C, V0, V1, V2, V3 ) \
458 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
459 int sz = (sizeof(C) / sizeof(GLfloat)); \
461 assert(sz == 1 || sz == 2); \
463 /* check if attribute size or type is changing */ \
464 if (unlikely(exec->vtx.active_sz[A] != N * sz) || \
465 unlikely(exec->vtx.attrtype[A] != T)) { \
466 vbo_exec_fixup_vertex(ctx, A, N * sz, T); \
469 /* store vertex attribute in vertex buffer */ \
471 C *dest = (C *)exec->vtx.attrptr[A]; \
472 if (N>0) dest[0] = V0; \
473 if (N>1) dest[1] = V1; \
474 if (N>2) dest[2] = V2; \
475 if (N>3) dest[3] = V3; \
476 exec->vtx.attrtype[A] = T; \
480 /* This is a glVertex call */ \
483 if (unlikely((ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) == 0)) { \
484 vbo_exec_begin_vertices(ctx); \
487 if (unlikely(!exec->vtx.buffer_ptr)) { \
488 vbo_exec_vtx_map(exec); \
490 assert(exec->vtx.buffer_ptr); \
492 /* copy 32-bit words */ \
493 for (i = 0; i < exec->vtx.vertex_size; i++) \
494 exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i]; \
496 exec->vtx.buffer_ptr += exec->vtx.vertex_size; \
498 /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \
499 /* something to draw (not just updating a color or texcoord).*/ \
500 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \
502 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
503 vbo_exec_vtx_wrap( exec ); \
505 /* we now have accumulated per-vertex attributes */ \
506 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
510 #define ERROR(err) _mesa_error( ctx, err, __func__ )
511 #define TAG(x) vbo_##x
513 #include "vbo_attrib_tmp.h"
518 * Execute a glMaterial call. Note that if GL_COLOR_MATERIAL is enabled,
519 * this may be a (partial) no-op.
521 static void GLAPIENTRY
522 vbo_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
524 GLbitfield updateMats
;
525 GET_CURRENT_CONTEXT(ctx
);
527 /* This function should be a no-op when it tries to update material
528 * attributes which are currently tracking glColor via glColorMaterial.
529 * The updateMats var will be a mask of the MAT_BIT_FRONT/BACK_x bits
530 * indicating which material attributes can actually be updated below.
532 if (ctx
->Light
.ColorMaterialEnabled
) {
533 updateMats
= ~ctx
->Light
._ColorMaterialBitmask
;
536 /* GL_COLOR_MATERIAL is disabled so don't skip any material updates */
537 updateMats
= ALL_MATERIAL_BITS
;
540 if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_FRONT
) {
541 updateMats
&= FRONT_MATERIAL_BITS
;
543 else if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_BACK
) {
544 updateMats
&= BACK_MATERIAL_BITS
;
546 else if (face
!= GL_FRONT_AND_BACK
) {
547 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterial(invalid face)");
553 if (updateMats
& MAT_BIT_FRONT_EMISSION
)
554 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_EMISSION
, 4, params
);
555 if (updateMats
& MAT_BIT_BACK_EMISSION
)
556 MAT_ATTR(VBO_ATTRIB_MAT_BACK_EMISSION
, 4, params
);
559 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
560 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
561 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
562 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
565 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
566 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
567 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
568 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
571 if (updateMats
& MAT_BIT_FRONT_SPECULAR
)
572 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SPECULAR
, 4, params
);
573 if (updateMats
& MAT_BIT_BACK_SPECULAR
)
574 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SPECULAR
, 4, params
);
577 if (*params
< 0 || *params
> ctx
->Const
.MaxShininess
) {
578 _mesa_error(ctx
, GL_INVALID_VALUE
,
579 "glMaterial(invalid shininess: %f out range [0, %f])",
580 *params
, ctx
->Const
.MaxShininess
);
583 if (updateMats
& MAT_BIT_FRONT_SHININESS
)
584 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SHININESS
, 1, params
);
585 if (updateMats
& MAT_BIT_BACK_SHININESS
)
586 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SHININESS
, 1, params
);
588 case GL_COLOR_INDEXES
:
589 if (ctx
->API
!= API_OPENGL_COMPAT
) {
590 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
593 if (updateMats
& MAT_BIT_FRONT_INDEXES
)
594 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_INDEXES
, 3, params
);
595 if (updateMats
& MAT_BIT_BACK_INDEXES
)
596 MAT_ATTR(VBO_ATTRIB_MAT_BACK_INDEXES
, 3, params
);
598 case GL_AMBIENT_AND_DIFFUSE
:
599 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
600 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
601 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
602 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
603 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
604 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
605 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
606 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
609 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
616 * Flush (draw) vertices.
617 * \param unmap - leave VBO unmapped after flushing?
620 vbo_exec_FlushVertices_internal(struct vbo_exec_context
*exec
, GLboolean unmap
)
622 if (exec
->vtx
.vert_count
|| unmap
) {
623 vbo_exec_vtx_flush( exec
, unmap
);
626 if (exec
->vtx
.vertex_size
) {
627 vbo_exec_copy_to_current( exec
);
628 reset_attrfv( exec
);
633 static void GLAPIENTRY
vbo_exec_EvalCoord1f( GLfloat u
)
635 GET_CURRENT_CONTEXT( ctx
);
636 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
640 if (exec
->eval
.recalculate_maps
)
641 vbo_exec_eval_update( exec
);
643 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
644 if (exec
->eval
.map1
[i
].map
)
645 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map1
[i
].sz
)
646 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map1
[i
].sz
, GL_FLOAT
);
651 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
652 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
654 vbo_exec_do_EvalCoord1f( exec
, u
);
656 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
657 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
660 static void GLAPIENTRY
vbo_exec_EvalCoord2f( GLfloat u
, GLfloat v
)
662 GET_CURRENT_CONTEXT( ctx
);
663 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
667 if (exec
->eval
.recalculate_maps
)
668 vbo_exec_eval_update( exec
);
670 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
671 if (exec
->eval
.map2
[i
].map
)
672 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map2
[i
].sz
)
673 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map2
[i
].sz
, GL_FLOAT
);
676 if (ctx
->Eval
.AutoNormal
)
677 if (exec
->vtx
.active_sz
[VBO_ATTRIB_NORMAL
] != 3)
678 vbo_exec_fixup_vertex( ctx
, VBO_ATTRIB_NORMAL
, 3, GL_FLOAT
);
681 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
682 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
684 vbo_exec_do_EvalCoord2f( exec
, u
, v
);
686 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
687 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
690 static void GLAPIENTRY
vbo_exec_EvalCoord1fv( const GLfloat
*u
)
692 vbo_exec_EvalCoord1f( u
[0] );
695 static void GLAPIENTRY
vbo_exec_EvalCoord2fv( const GLfloat
*u
)
697 vbo_exec_EvalCoord2f( u
[0], u
[1] );
700 static void GLAPIENTRY
vbo_exec_EvalPoint1( GLint i
)
702 GET_CURRENT_CONTEXT( ctx
);
703 GLfloat du
= ((ctx
->Eval
.MapGrid1u2
- ctx
->Eval
.MapGrid1u1
) /
704 (GLfloat
) ctx
->Eval
.MapGrid1un
);
705 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid1u1
;
707 vbo_exec_EvalCoord1f( u
);
711 static void GLAPIENTRY
vbo_exec_EvalPoint2( GLint i
, GLint j
)
713 GET_CURRENT_CONTEXT( ctx
);
714 GLfloat du
= ((ctx
->Eval
.MapGrid2u2
- ctx
->Eval
.MapGrid2u1
) /
715 (GLfloat
) ctx
->Eval
.MapGrid2un
);
716 GLfloat dv
= ((ctx
->Eval
.MapGrid2v2
- ctx
->Eval
.MapGrid2v1
) /
717 (GLfloat
) ctx
->Eval
.MapGrid2vn
);
718 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid2u1
;
719 GLfloat v
= j
* dv
+ ctx
->Eval
.MapGrid2v1
;
721 vbo_exec_EvalCoord2f( u
, v
);
726 * Called via glBegin.
728 static void GLAPIENTRY
vbo_exec_Begin( GLenum mode
)
730 GET_CURRENT_CONTEXT( ctx
);
731 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
734 if (_mesa_inside_begin_end(ctx
)) {
735 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glBegin");
739 if (!_mesa_valid_prim_mode(ctx
, mode
, "glBegin")) {
743 vbo_draw_method(vbo_context(ctx
), DRAW_BEGIN_END
);
746 _mesa_update_state( ctx
);
748 CALL_Begin(ctx
->Exec
, (mode
));
752 if (!_mesa_valid_to_render(ctx
, "glBegin")) {
756 /* Heuristic: attempt to isolate attributes occurring outside
759 if (exec
->vtx
.vertex_size
&& !exec
->vtx
.attrsz
[0])
760 vbo_exec_FlushVertices_internal(exec
, GL_FALSE
);
762 i
= exec
->vtx
.prim_count
++;
763 exec
->vtx
.prim
[i
].mode
= mode
;
764 exec
->vtx
.prim
[i
].begin
= 1;
765 exec
->vtx
.prim
[i
].end
= 0;
766 exec
->vtx
.prim
[i
].indexed
= 0;
767 exec
->vtx
.prim
[i
].weak
= 0;
768 exec
->vtx
.prim
[i
].pad
= 0;
769 exec
->vtx
.prim
[i
].start
= exec
->vtx
.vert_count
;
770 exec
->vtx
.prim
[i
].count
= 0;
771 exec
->vtx
.prim
[i
].num_instances
= 1;
772 exec
->vtx
.prim
[i
].base_instance
= 0;
773 exec
->vtx
.prim
[i
].is_indirect
= 0;
775 ctx
->Driver
.CurrentExecPrimitive
= mode
;
777 ctx
->Exec
= ctx
->BeginEnd
;
778 /* We may have been called from a display list, in which case we should
779 * leave dlist.c's dispatch table in place.
781 if (ctx
->CurrentDispatch
== ctx
->OutsideBeginEnd
) {
782 ctx
->CurrentDispatch
= ctx
->BeginEnd
;
783 _glapi_set_dispatch(ctx
->CurrentDispatch
);
785 assert(ctx
->CurrentDispatch
== ctx
->Save
);
791 * Try to merge / concatenate the two most recent VBO primitives.
794 try_vbo_merge(struct vbo_exec_context
*exec
)
796 struct _mesa_prim
*cur
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
798 assert(exec
->vtx
.prim_count
>= 1);
800 vbo_try_prim_conversion(cur
);
802 if (exec
->vtx
.prim_count
>= 2) {
803 struct _mesa_prim
*prev
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 2];
804 assert(prev
== cur
- 1);
806 if (vbo_can_merge_prims(prev
, cur
)) {
811 vbo_merge_prims(prev
, cur
);
812 exec
->vtx
.prim_count
--; /* drop the last primitive */
821 static void GLAPIENTRY
vbo_exec_End( void )
823 GET_CURRENT_CONTEXT( ctx
);
824 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
826 if (!_mesa_inside_begin_end(ctx
)) {
827 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glEnd");
831 ctx
->Exec
= ctx
->OutsideBeginEnd
;
832 if (ctx
->CurrentDispatch
== ctx
->BeginEnd
) {
833 ctx
->CurrentDispatch
= ctx
->OutsideBeginEnd
;
834 _glapi_set_dispatch(ctx
->CurrentDispatch
);
837 if (exec
->vtx
.prim_count
> 0) {
838 /* close off current primitive */
839 struct _mesa_prim
*last_prim
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
842 last_prim
->count
= exec
->vtx
.vert_count
- last_prim
->start
;
844 /* Special handling for GL_LINE_LOOP */
845 if (last_prim
->mode
== GL_LINE_LOOP
&& last_prim
->begin
== 0) {
846 /* We're finishing drawing a line loop. Append 0th vertex onto
847 * end of vertex buffer so we can draw it as a line strip.
849 const fi_type
*src
= exec
->vtx
.buffer_map
;
850 fi_type
*dst
= exec
->vtx
.buffer_map
+
851 exec
->vtx
.vert_count
* exec
->vtx
.vertex_size
;
853 /* copy 0th vertex to end of buffer */
854 memcpy(dst
, src
, exec
->vtx
.vertex_size
* sizeof(fi_type
));
856 assert(last_prim
->start
== 0);
857 last_prim
->start
++; /* skip vertex0 */
858 /* note that last_prim->count stays unchanged */
859 last_prim
->mode
= GL_LINE_STRIP
;
865 ctx
->Driver
.CurrentExecPrimitive
= PRIM_OUTSIDE_BEGIN_END
;
867 if (exec
->vtx
.prim_count
== VBO_MAX_PRIM
)
868 vbo_exec_vtx_flush( exec
, GL_FALSE
);
870 if (MESA_DEBUG_FLAGS
& DEBUG_ALWAYS_FLUSH
) {
877 * Called via glPrimitiveRestartNV()
879 static void GLAPIENTRY
880 vbo_exec_PrimitiveRestartNV(void)
883 GET_CURRENT_CONTEXT( ctx
);
885 curPrim
= ctx
->Driver
.CurrentExecPrimitive
;
887 if (curPrim
== PRIM_OUTSIDE_BEGIN_END
) {
888 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glPrimitiveRestartNV" );
892 vbo_exec_Begin(curPrim
);
898 static void vbo_exec_vtxfmt_init( struct vbo_exec_context
*exec
)
900 struct gl_context
*ctx
= exec
->ctx
;
901 GLvertexformat
*vfmt
= &exec
->vtxfmt
;
903 vfmt
->ArrayElement
= _ae_ArrayElement
;
905 vfmt
->Begin
= vbo_exec_Begin
;
906 vfmt
->End
= vbo_exec_End
;
907 vfmt
->PrimitiveRestartNV
= vbo_exec_PrimitiveRestartNV
;
909 vfmt
->CallList
= _mesa_CallList
;
910 vfmt
->CallLists
= _mesa_CallLists
;
912 vfmt
->EvalCoord1f
= vbo_exec_EvalCoord1f
;
913 vfmt
->EvalCoord1fv
= vbo_exec_EvalCoord1fv
;
914 vfmt
->EvalCoord2f
= vbo_exec_EvalCoord2f
;
915 vfmt
->EvalCoord2fv
= vbo_exec_EvalCoord2fv
;
916 vfmt
->EvalPoint1
= vbo_exec_EvalPoint1
;
917 vfmt
->EvalPoint2
= vbo_exec_EvalPoint2
;
919 /* from attrib_tmp.h:
921 vfmt
->Color3f
= vbo_Color3f
;
922 vfmt
->Color3fv
= vbo_Color3fv
;
923 vfmt
->Color4f
= vbo_Color4f
;
924 vfmt
->Color4fv
= vbo_Color4fv
;
925 vfmt
->FogCoordfEXT
= vbo_FogCoordfEXT
;
926 vfmt
->FogCoordfvEXT
= vbo_FogCoordfvEXT
;
927 vfmt
->MultiTexCoord1fARB
= vbo_MultiTexCoord1f
;
928 vfmt
->MultiTexCoord1fvARB
= vbo_MultiTexCoord1fv
;
929 vfmt
->MultiTexCoord2fARB
= vbo_MultiTexCoord2f
;
930 vfmt
->MultiTexCoord2fvARB
= vbo_MultiTexCoord2fv
;
931 vfmt
->MultiTexCoord3fARB
= vbo_MultiTexCoord3f
;
932 vfmt
->MultiTexCoord3fvARB
= vbo_MultiTexCoord3fv
;
933 vfmt
->MultiTexCoord4fARB
= vbo_MultiTexCoord4f
;
934 vfmt
->MultiTexCoord4fvARB
= vbo_MultiTexCoord4fv
;
935 vfmt
->Normal3f
= vbo_Normal3f
;
936 vfmt
->Normal3fv
= vbo_Normal3fv
;
937 vfmt
->SecondaryColor3fEXT
= vbo_SecondaryColor3fEXT
;
938 vfmt
->SecondaryColor3fvEXT
= vbo_SecondaryColor3fvEXT
;
939 vfmt
->TexCoord1f
= vbo_TexCoord1f
;
940 vfmt
->TexCoord1fv
= vbo_TexCoord1fv
;
941 vfmt
->TexCoord2f
= vbo_TexCoord2f
;
942 vfmt
->TexCoord2fv
= vbo_TexCoord2fv
;
943 vfmt
->TexCoord3f
= vbo_TexCoord3f
;
944 vfmt
->TexCoord3fv
= vbo_TexCoord3fv
;
945 vfmt
->TexCoord4f
= vbo_TexCoord4f
;
946 vfmt
->TexCoord4fv
= vbo_TexCoord4fv
;
947 vfmt
->Vertex2f
= vbo_Vertex2f
;
948 vfmt
->Vertex2fv
= vbo_Vertex2fv
;
949 vfmt
->Vertex3f
= vbo_Vertex3f
;
950 vfmt
->Vertex3fv
= vbo_Vertex3fv
;
951 vfmt
->Vertex4f
= vbo_Vertex4f
;
952 vfmt
->Vertex4fv
= vbo_Vertex4fv
;
954 if (ctx
->API
== API_OPENGLES2
) {
955 vfmt
->VertexAttrib1fARB
= _es_VertexAttrib1f
;
956 vfmt
->VertexAttrib1fvARB
= _es_VertexAttrib1fv
;
957 vfmt
->VertexAttrib2fARB
= _es_VertexAttrib2f
;
958 vfmt
->VertexAttrib2fvARB
= _es_VertexAttrib2fv
;
959 vfmt
->VertexAttrib3fARB
= _es_VertexAttrib3f
;
960 vfmt
->VertexAttrib3fvARB
= _es_VertexAttrib3fv
;
961 vfmt
->VertexAttrib4fARB
= _es_VertexAttrib4f
;
962 vfmt
->VertexAttrib4fvARB
= _es_VertexAttrib4fv
;
964 vfmt
->VertexAttrib1fARB
= vbo_VertexAttrib1fARB
;
965 vfmt
->VertexAttrib1fvARB
= vbo_VertexAttrib1fvARB
;
966 vfmt
->VertexAttrib2fARB
= vbo_VertexAttrib2fARB
;
967 vfmt
->VertexAttrib2fvARB
= vbo_VertexAttrib2fvARB
;
968 vfmt
->VertexAttrib3fARB
= vbo_VertexAttrib3fARB
;
969 vfmt
->VertexAttrib3fvARB
= vbo_VertexAttrib3fvARB
;
970 vfmt
->VertexAttrib4fARB
= vbo_VertexAttrib4fARB
;
971 vfmt
->VertexAttrib4fvARB
= vbo_VertexAttrib4fvARB
;
974 /* Note that VertexAttrib4fNV is used from dlist.c and api_arrayelt.c so
975 * they can have a single entrypoint for updating any of the legacy
978 vfmt
->VertexAttrib1fNV
= vbo_VertexAttrib1fNV
;
979 vfmt
->VertexAttrib1fvNV
= vbo_VertexAttrib1fvNV
;
980 vfmt
->VertexAttrib2fNV
= vbo_VertexAttrib2fNV
;
981 vfmt
->VertexAttrib2fvNV
= vbo_VertexAttrib2fvNV
;
982 vfmt
->VertexAttrib3fNV
= vbo_VertexAttrib3fNV
;
983 vfmt
->VertexAttrib3fvNV
= vbo_VertexAttrib3fvNV
;
984 vfmt
->VertexAttrib4fNV
= vbo_VertexAttrib4fNV
;
985 vfmt
->VertexAttrib4fvNV
= vbo_VertexAttrib4fvNV
;
988 vfmt
->VertexAttribI1i
= vbo_VertexAttribI1i
;
989 vfmt
->VertexAttribI2i
= vbo_VertexAttribI2i
;
990 vfmt
->VertexAttribI3i
= vbo_VertexAttribI3i
;
991 vfmt
->VertexAttribI4i
= vbo_VertexAttribI4i
;
992 vfmt
->VertexAttribI2iv
= vbo_VertexAttribI2iv
;
993 vfmt
->VertexAttribI3iv
= vbo_VertexAttribI3iv
;
994 vfmt
->VertexAttribI4iv
= vbo_VertexAttribI4iv
;
996 /* unsigned integer-valued */
997 vfmt
->VertexAttribI1ui
= vbo_VertexAttribI1ui
;
998 vfmt
->VertexAttribI2ui
= vbo_VertexAttribI2ui
;
999 vfmt
->VertexAttribI3ui
= vbo_VertexAttribI3ui
;
1000 vfmt
->VertexAttribI4ui
= vbo_VertexAttribI4ui
;
1001 vfmt
->VertexAttribI2uiv
= vbo_VertexAttribI2uiv
;
1002 vfmt
->VertexAttribI3uiv
= vbo_VertexAttribI3uiv
;
1003 vfmt
->VertexAttribI4uiv
= vbo_VertexAttribI4uiv
;
1005 vfmt
->Materialfv
= vbo_Materialfv
;
1007 vfmt
->EdgeFlag
= vbo_EdgeFlag
;
1008 vfmt
->Indexf
= vbo_Indexf
;
1009 vfmt
->Indexfv
= vbo_Indexfv
;
1011 /* ARB_vertex_type_2_10_10_10_rev */
1012 vfmt
->VertexP2ui
= vbo_VertexP2ui
;
1013 vfmt
->VertexP2uiv
= vbo_VertexP2uiv
;
1014 vfmt
->VertexP3ui
= vbo_VertexP3ui
;
1015 vfmt
->VertexP3uiv
= vbo_VertexP3uiv
;
1016 vfmt
->VertexP4ui
= vbo_VertexP4ui
;
1017 vfmt
->VertexP4uiv
= vbo_VertexP4uiv
;
1019 vfmt
->TexCoordP1ui
= vbo_TexCoordP1ui
;
1020 vfmt
->TexCoordP1uiv
= vbo_TexCoordP1uiv
;
1021 vfmt
->TexCoordP2ui
= vbo_TexCoordP2ui
;
1022 vfmt
->TexCoordP2uiv
= vbo_TexCoordP2uiv
;
1023 vfmt
->TexCoordP3ui
= vbo_TexCoordP3ui
;
1024 vfmt
->TexCoordP3uiv
= vbo_TexCoordP3uiv
;
1025 vfmt
->TexCoordP4ui
= vbo_TexCoordP4ui
;
1026 vfmt
->TexCoordP4uiv
= vbo_TexCoordP4uiv
;
1028 vfmt
->MultiTexCoordP1ui
= vbo_MultiTexCoordP1ui
;
1029 vfmt
->MultiTexCoordP1uiv
= vbo_MultiTexCoordP1uiv
;
1030 vfmt
->MultiTexCoordP2ui
= vbo_MultiTexCoordP2ui
;
1031 vfmt
->MultiTexCoordP2uiv
= vbo_MultiTexCoordP2uiv
;
1032 vfmt
->MultiTexCoordP3ui
= vbo_MultiTexCoordP3ui
;
1033 vfmt
->MultiTexCoordP3uiv
= vbo_MultiTexCoordP3uiv
;
1034 vfmt
->MultiTexCoordP4ui
= vbo_MultiTexCoordP4ui
;
1035 vfmt
->MultiTexCoordP4uiv
= vbo_MultiTexCoordP4uiv
;
1037 vfmt
->NormalP3ui
= vbo_NormalP3ui
;
1038 vfmt
->NormalP3uiv
= vbo_NormalP3uiv
;
1040 vfmt
->ColorP3ui
= vbo_ColorP3ui
;
1041 vfmt
->ColorP3uiv
= vbo_ColorP3uiv
;
1042 vfmt
->ColorP4ui
= vbo_ColorP4ui
;
1043 vfmt
->ColorP4uiv
= vbo_ColorP4uiv
;
1045 vfmt
->SecondaryColorP3ui
= vbo_SecondaryColorP3ui
;
1046 vfmt
->SecondaryColorP3uiv
= vbo_SecondaryColorP3uiv
;
1048 vfmt
->VertexAttribP1ui
= vbo_VertexAttribP1ui
;
1049 vfmt
->VertexAttribP1uiv
= vbo_VertexAttribP1uiv
;
1050 vfmt
->VertexAttribP2ui
= vbo_VertexAttribP2ui
;
1051 vfmt
->VertexAttribP2uiv
= vbo_VertexAttribP2uiv
;
1052 vfmt
->VertexAttribP3ui
= vbo_VertexAttribP3ui
;
1053 vfmt
->VertexAttribP3uiv
= vbo_VertexAttribP3uiv
;
1054 vfmt
->VertexAttribP4ui
= vbo_VertexAttribP4ui
;
1055 vfmt
->VertexAttribP4uiv
= vbo_VertexAttribP4uiv
;
1057 vfmt
->VertexAttribL1d
= vbo_VertexAttribL1d
;
1058 vfmt
->VertexAttribL2d
= vbo_VertexAttribL2d
;
1059 vfmt
->VertexAttribL3d
= vbo_VertexAttribL3d
;
1060 vfmt
->VertexAttribL4d
= vbo_VertexAttribL4d
;
1062 vfmt
->VertexAttribL1dv
= vbo_VertexAttribL1dv
;
1063 vfmt
->VertexAttribL2dv
= vbo_VertexAttribL2dv
;
1064 vfmt
->VertexAttribL3dv
= vbo_VertexAttribL3dv
;
1065 vfmt
->VertexAttribL4dv
= vbo_VertexAttribL4dv
;
1070 * Tell the VBO module to use a real OpenGL vertex buffer object to
1071 * store accumulated immediate-mode vertex data.
1072 * This replaces the malloced buffer which was created in
1073 * vb_exec_vtx_init() below.
1075 void vbo_use_buffer_objects(struct gl_context
*ctx
)
1077 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1078 /* Any buffer name but 0 can be used here since this bufferobj won't
1079 * go into the bufferobj hashtable.
1081 GLuint bufName
= IMM_BUFFER_NAME
;
1082 GLenum target
= GL_ARRAY_BUFFER_ARB
;
1083 GLenum usage
= GL_STREAM_DRAW_ARB
;
1084 GLsizei size
= VBO_VERT_BUFFER_SIZE
;
1086 /* Make sure this func is only used once */
1087 assert(exec
->vtx
.bufferobj
== ctx
->Shared
->NullBufferObj
);
1089 _mesa_align_free(exec
->vtx
.buffer_map
);
1090 exec
->vtx
.buffer_map
= NULL
;
1091 exec
->vtx
.buffer_ptr
= NULL
;
1093 /* Allocate a real buffer object now */
1094 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1095 exec
->vtx
.bufferobj
= ctx
->Driver
.NewBufferObject(ctx
, bufName
);
1096 if (!ctx
->Driver
.BufferData(ctx
, target
, size
, NULL
, usage
,
1098 GL_DYNAMIC_STORAGE_BIT
|
1099 GL_CLIENT_STORAGE_BIT
,
1100 exec
->vtx
.bufferobj
)) {
1101 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "VBO allocation");
1107 * If this function is called, all VBO buffers will be unmapped when
1109 * Otherwise, if a simple command like glColor3f() is called and we flush,
1110 * the current VBO may be left mapped.
1113 vbo_always_unmap_buffers(struct gl_context
*ctx
)
1115 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1116 exec
->begin_vertices_flags
|= FLUSH_STORED_VERTICES
;
1120 void vbo_exec_vtx_init( struct vbo_exec_context
*exec
)
1122 struct gl_context
*ctx
= exec
->ctx
;
1123 struct vbo_context
*vbo
= vbo_context(ctx
);
1126 /* Allocate a buffer object. Will just reuse this object
1127 * continuously, unless vbo_use_buffer_objects() is called to enable
1130 _mesa_reference_buffer_object(ctx
,
1131 &exec
->vtx
.bufferobj
,
1132 ctx
->Shared
->NullBufferObj
);
1134 assert(!exec
->vtx
.buffer_map
);
1135 exec
->vtx
.buffer_map
= _mesa_align_malloc(VBO_VERT_BUFFER_SIZE
, 64);
1136 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
1138 vbo_exec_vtxfmt_init( exec
);
1139 _mesa_noop_vtxfmt_init(&exec
->vtxfmt_noop
);
1141 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1142 assert(i
< ARRAY_SIZE(exec
->vtx
.attrsz
));
1143 exec
->vtx
.attrsz
[i
] = 0;
1144 assert(i
< ARRAY_SIZE(exec
->vtx
.attrtype
));
1145 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1146 assert(i
< ARRAY_SIZE(exec
->vtx
.active_sz
));
1147 exec
->vtx
.active_sz
[i
] = 0;
1149 for (i
= 0 ; i
< VERT_ATTRIB_MAX
; i
++) {
1150 assert(i
< ARRAY_SIZE(exec
->vtx
.inputs
));
1151 assert(i
< ARRAY_SIZE(exec
->vtx
.arrays
));
1152 exec
->vtx
.inputs
[i
] = &exec
->vtx
.arrays
[i
];
1156 struct gl_client_array
*arrays
= exec
->vtx
.arrays
;
1159 memcpy(arrays
, &vbo
->currval
[VBO_ATTRIB_POS
],
1160 VERT_ATTRIB_FF_MAX
* sizeof(arrays
[0]));
1161 for (i
= 0; i
< VERT_ATTRIB_FF_MAX
; ++i
) {
1162 struct gl_client_array
*array
;
1163 array
= &arrays
[VERT_ATTRIB_FF(i
)];
1164 array
->BufferObj
= NULL
;
1165 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1166 vbo
->currval
[VBO_ATTRIB_POS
+i
].BufferObj
);
1169 memcpy(arrays
+ VERT_ATTRIB_GENERIC(0),
1170 &vbo
->currval
[VBO_ATTRIB_GENERIC0
],
1171 VERT_ATTRIB_GENERIC_MAX
* sizeof(arrays
[0]));
1173 for (i
= 0; i
< VERT_ATTRIB_GENERIC_MAX
; ++i
) {
1174 struct gl_client_array
*array
;
1175 array
= &arrays
[VERT_ATTRIB_GENERIC(i
)];
1176 array
->BufferObj
= NULL
;
1177 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1178 vbo
->currval
[VBO_ATTRIB_GENERIC0
+i
].BufferObj
);
1182 exec
->vtx
.vertex_size
= 0;
1184 exec
->begin_vertices_flags
= FLUSH_UPDATE_CURRENT
;
1188 void vbo_exec_vtx_destroy( struct vbo_exec_context
*exec
)
1190 /* using a real VBO for vertex data */
1191 struct gl_context
*ctx
= exec
->ctx
;
1194 /* True VBOs should already be unmapped
1196 if (exec
->vtx
.buffer_map
) {
1197 assert(exec
->vtx
.bufferobj
->Name
== 0 ||
1198 exec
->vtx
.bufferobj
->Name
== IMM_BUFFER_NAME
);
1199 if (exec
->vtx
.bufferobj
->Name
== 0) {
1200 _mesa_align_free(exec
->vtx
.buffer_map
);
1201 exec
->vtx
.buffer_map
= NULL
;
1202 exec
->vtx
.buffer_ptr
= NULL
;
1206 /* Drop any outstanding reference to the vertex buffer
1208 for (i
= 0; i
< ARRAY_SIZE(exec
->vtx
.arrays
); i
++) {
1209 _mesa_reference_buffer_object(ctx
,
1210 &exec
->vtx
.arrays
[i
].BufferObj
,
1214 /* Free the vertex buffer. Unmap first if needed.
1216 if (_mesa_bufferobj_mapped(exec
->vtx
.bufferobj
, MAP_INTERNAL
)) {
1217 ctx
->Driver
.UnmapBuffer(ctx
, exec
->vtx
.bufferobj
, MAP_INTERNAL
);
1219 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1224 * If inside glBegin()/glEnd(), it should assert(0). Otherwise, if
1225 * FLUSH_STORED_VERTICES bit in \p flags is set flushes any buffered
1226 * vertices, if FLUSH_UPDATE_CURRENT bit is set updates
1227 * __struct gl_contextRec::Current and gl_light_attrib::Material
1229 * Note that the default T&L engine never clears the
1230 * FLUSH_UPDATE_CURRENT bit, even after performing the update.
1232 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1234 void vbo_exec_FlushVertices( struct gl_context
*ctx
, GLuint flags
)
1236 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1239 /* debug check: make sure we don't get called recursively */
1240 exec
->flush_call_depth
++;
1241 assert(exec
->flush_call_depth
== 1);
1244 if (_mesa_inside_begin_end(ctx
)) {
1245 /* We've had glBegin but not glEnd! */
1247 exec
->flush_call_depth
--;
1248 assert(exec
->flush_call_depth
== 0);
1253 /* Flush (draw), and make sure VBO is left unmapped when done */
1254 vbo_exec_FlushVertices_internal(exec
, GL_TRUE
);
1256 /* Need to do this to ensure vbo_exec_begin_vertices gets called again:
1258 ctx
->Driver
.NeedFlush
&= ~(FLUSH_UPDATE_CURRENT
| flags
);
1261 exec
->flush_call_depth
--;
1262 assert(exec
->flush_call_depth
== 0);
1267 static void reset_attrfv( struct vbo_exec_context
*exec
)
1271 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1272 exec
->vtx
.attrsz
[i
] = 0;
1273 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1274 exec
->vtx
.active_sz
[i
] = 0;
1277 exec
->vtx
.vertex_size
= 0;
1282 _es_Color4f(GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
1284 vbo_Color4f(r
, g
, b
, a
);
1289 _es_Normal3f(GLfloat x
, GLfloat y
, GLfloat z
)
1291 vbo_Normal3f(x
, y
, z
);
1296 _es_MultiTexCoord4f(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1298 vbo_MultiTexCoord4f(target
, s
, t
, r
, q
);
1303 _es_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
1305 vbo_Materialfv(face
, pname
, params
);
1310 _es_Materialf(GLenum face
, GLenum pname
, GLfloat param
)
1314 p
[1] = p
[2] = p
[3] = 0.0F
;
1315 vbo_Materialfv(face
, pname
, p
);
1320 * A special version of glVertexAttrib4f that does not treat index 0 as
1324 VertexAttrib4f_nopos(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1326 GET_CURRENT_CONTEXT(ctx
);
1327 if (index
< MAX_VERTEX_GENERIC_ATTRIBS
)
1328 ATTRF(VBO_ATTRIB_GENERIC0
+ index
, 4, x
, y
, z
, w
);
1330 ERROR(GL_INVALID_VALUE
);
1334 _es_VertexAttrib4f(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1336 VertexAttrib4f_nopos(index
, x
, y
, z
, w
);
1341 _es_VertexAttrib1f(GLuint indx
, GLfloat x
)
1343 VertexAttrib4f_nopos(indx
, x
, 0.0f
, 0.0f
, 1.0f
);
1348 _es_VertexAttrib1fv(GLuint indx
, const GLfloat
* values
)
1350 VertexAttrib4f_nopos(indx
, values
[0], 0.0f
, 0.0f
, 1.0f
);
1355 _es_VertexAttrib2f(GLuint indx
, GLfloat x
, GLfloat y
)
1357 VertexAttrib4f_nopos(indx
, x
, y
, 0.0f
, 1.0f
);
1362 _es_VertexAttrib2fv(GLuint indx
, const GLfloat
* values
)
1364 VertexAttrib4f_nopos(indx
, values
[0], values
[1], 0.0f
, 1.0f
);
1369 _es_VertexAttrib3f(GLuint indx
, GLfloat x
, GLfloat y
, GLfloat z
)
1371 VertexAttrib4f_nopos(indx
, x
, y
, z
, 1.0f
);
1376 _es_VertexAttrib3fv(GLuint indx
, const GLfloat
* values
)
1378 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], 1.0f
);
1383 _es_VertexAttrib4fv(GLuint indx
, const GLfloat
* values
)
1385 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], values
[3]);