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
66 static void vbo_exec_wrap_buffers( struct vbo_exec_context
*exec
)
68 if (exec
->vtx
.prim_count
== 0) {
69 exec
->vtx
.copied
.nr
= 0;
70 exec
->vtx
.vert_count
= 0;
71 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
74 struct _mesa_prim
*last_prim
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
75 const GLuint last_begin
= last_prim
->begin
;
78 if (_mesa_inside_begin_end(exec
->ctx
)) {
79 last_prim
->count
= exec
->vtx
.vert_count
- last_prim
->start
;
82 last_count
= last_prim
->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 (_mesa_inside_begin_end(exec
->ctx
)) {
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().
115 vbo_exec_vtx_wrap(struct vbo_exec_context
*exec
)
117 fi_type
*data
= exec
->vtx
.copied
.buffer
;
120 /* Run pipeline on current vertices, copy wrapped vertices
121 * to exec->vtx.copied.
123 vbo_exec_wrap_buffers( exec
);
125 if (!exec
->vtx
.buffer_ptr
) {
126 /* probably ran out of memory earlier when allocating the VBO */
130 /* Copy stored stored vertices to start of new list.
132 assert(exec
->vtx
.max_vert
- exec
->vtx
.vert_count
> exec
->vtx
.copied
.nr
);
134 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
135 memcpy( exec
->vtx
.buffer_ptr
, data
,
136 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
137 exec
->vtx
.buffer_ptr
+= exec
->vtx
.vertex_size
;
138 data
+= exec
->vtx
.vertex_size
;
139 exec
->vtx
.vert_count
++;
142 exec
->vtx
.copied
.nr
= 0;
147 * Copy the active vertex's values to the ctx->Current fields.
149 static void vbo_exec_copy_to_current( struct vbo_exec_context
*exec
)
151 struct gl_context
*ctx
= exec
->ctx
;
152 struct vbo_context
*vbo
= vbo_context(ctx
);
155 for (i
= VBO_ATTRIB_POS
+1 ; i
< VBO_ATTRIB_MAX
; i
++) {
156 if (exec
->vtx
.attrsz
[i
]) {
157 /* Note: the exec->vtx.current[i] pointers point into the
158 * ctx->Current.Attrib and ctx->Light.Material.Attrib arrays.
160 GLfloat
*current
= (GLfloat
*)vbo
->currval
[i
].Ptr
;
161 fi_type tmp
[8]; /* space for doubles */
162 int dmul
= exec
->vtx
.attrtype
[i
] == GL_DOUBLE
? 2 : 1;
164 if (exec
->vtx
.attrtype
[i
] == GL_DOUBLE
) {
165 memset(tmp
, 0, sizeof(tmp
));
166 memcpy(tmp
, exec
->vtx
.attrptr
[i
], exec
->vtx
.attrsz
[i
] * sizeof(GLfloat
));
168 COPY_CLEAN_4V_TYPE_AS_UNION(tmp
,
170 exec
->vtx
.attrptr
[i
],
171 exec
->vtx
.attrtype
[i
]);
174 if (exec
->vtx
.attrtype
[i
] != vbo
->currval
[i
].Type
||
175 memcmp(current
, tmp
, 4 * sizeof(GLfloat
) * dmul
) != 0) {
176 memcpy(current
, tmp
, 4 * sizeof(GLfloat
) * dmul
);
178 /* Given that we explicitly state size here, there is no need
179 * for the COPY_CLEAN above, could just copy 16 bytes and be
180 * done. The only problem is when Mesa accesses ctx->Current
183 /* Size here is in components - not bytes */
184 vbo
->currval
[i
].Size
= exec
->vtx
.attrsz
[i
] / dmul
;
185 vbo
->currval
[i
]._ElementSize
= vbo
->currval
[i
].Size
* sizeof(GLfloat
) * dmul
;
186 vbo
->currval
[i
].Type
= exec
->vtx
.attrtype
[i
];
187 vbo
->currval
[i
].Integer
=
188 vbo_attrtype_to_integer_flag(exec
->vtx
.attrtype
[i
]);
189 vbo
->currval
[i
].Doubles
=
190 vbo_attrtype_to_double_flag(exec
->vtx
.attrtype
[i
]);
192 /* This triggers rather too much recalculation of Mesa state
193 * that doesn't get used (eg light positions).
195 if (i
>= VBO_ATTRIB_MAT_FRONT_AMBIENT
&&
196 i
<= VBO_ATTRIB_MAT_BACK_INDEXES
)
197 ctx
->NewState
|= _NEW_LIGHT
;
199 ctx
->NewState
|= _NEW_CURRENT_ATTRIB
;
204 /* Colormaterial -- this kindof sucks.
206 if (ctx
->Light
.ColorMaterialEnabled
&&
207 exec
->vtx
.attrsz
[VBO_ATTRIB_COLOR0
]) {
208 _mesa_update_color_material(ctx
,
209 ctx
->Current
.Attrib
[VBO_ATTRIB_COLOR0
]);
215 * Copy current vertex attribute values into the current vertex.
218 vbo_exec_copy_from_current(struct vbo_exec_context
*exec
)
220 struct gl_context
*ctx
= exec
->ctx
;
221 struct vbo_context
*vbo
= vbo_context(ctx
);
224 for (i
= VBO_ATTRIB_POS
+ 1; i
< VBO_ATTRIB_MAX
; i
++) {
225 if (exec
->vtx
.attrtype
[i
] == GL_DOUBLE
) {
226 memcpy(exec
->vtx
.attrptr
[i
], vbo
->currval
[i
].Ptr
, exec
->vtx
.attrsz
[i
] * sizeof(GLfloat
));
228 const fi_type
*current
= (fi_type
*) vbo
->currval
[i
].Ptr
;
229 switch (exec
->vtx
.attrsz
[i
]) {
230 case 4: exec
->vtx
.attrptr
[i
][3] = current
[3];
231 case 3: exec
->vtx
.attrptr
[i
][2] = current
[2];
232 case 2: exec
->vtx
.attrptr
[i
][1] = current
[1];
233 case 1: exec
->vtx
.attrptr
[i
][0] = current
[0];
242 * Flush existing data, set new attrib size, replay copied vertices.
243 * This is called when we transition from a small vertex attribute size
244 * to a larger one. Ex: glTexCoord2f -> glTexCoord4f.
245 * We need to go back over the previous 2-component texcoords and insert
246 * zero and one values.
249 vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context
*exec
,
250 GLuint attr
, GLuint newSize
)
252 struct gl_context
*ctx
= exec
->ctx
;
253 struct vbo_context
*vbo
= vbo_context(ctx
);
254 const GLint lastcount
= exec
->vtx
.vert_count
;
255 fi_type
*old_attrptr
[VBO_ATTRIB_MAX
];
256 const GLuint old_vtx_size
= exec
->vtx
.vertex_size
; /* floats per vertex */
257 const GLuint oldSize
= exec
->vtx
.attrsz
[attr
];
260 /* Run pipeline on current vertices, copy wrapped vertices
261 * to exec->vtx.copied.
263 vbo_exec_wrap_buffers( exec
);
265 if (unlikely(exec
->vtx
.copied
.nr
)) {
266 /* We're in the middle of a primitive, keep the old vertex
267 * format around to be able to translate the copied vertices to
270 memcpy(old_attrptr
, exec
->vtx
.attrptr
, sizeof(old_attrptr
));
273 if (unlikely(oldSize
)) {
274 /* Do a COPY_TO_CURRENT to ensure back-copying works for the
275 * case when the attribute already exists in the vertex and is
276 * having its size increased.
278 vbo_exec_copy_to_current( exec
);
281 /* Heuristic: Attempt to isolate attributes received outside
282 * begin/end so that they don't bloat the vertices.
284 if (!_mesa_inside_begin_end(ctx
) &&
285 !oldSize
&& lastcount
> 8 && exec
->vtx
.vertex_size
) {
286 vbo_exec_copy_to_current( exec
);
287 reset_attrfv( exec
);
292 exec
->vtx
.attrsz
[attr
] = newSize
;
293 exec
->vtx
.vertex_size
+= newSize
- oldSize
;
294 exec
->vtx
.max_vert
= vbo_compute_max_verts(exec
);
295 exec
->vtx
.vert_count
= 0;
296 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
298 if (unlikely(oldSize
)) {
299 /* Size changed, recalculate all the attrptr[] values
301 fi_type
*tmp
= exec
->vtx
.vertex
;
303 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
304 if (exec
->vtx
.attrsz
[i
]) {
305 exec
->vtx
.attrptr
[i
] = tmp
;
306 tmp
+= exec
->vtx
.attrsz
[i
];
309 exec
->vtx
.attrptr
[i
] = NULL
; /* will not be dereferenced */
312 /* Copy from current to repopulate the vertex with correct
315 vbo_exec_copy_from_current( exec
);
318 /* Just have to append the new attribute at the end */
319 exec
->vtx
.attrptr
[attr
] = exec
->vtx
.vertex
+
320 exec
->vtx
.vertex_size
- newSize
;
323 /* Replay stored vertices to translate them
324 * to new format here.
326 * -- No need to replay - just copy piecewise
328 if (unlikely(exec
->vtx
.copied
.nr
)) {
329 fi_type
*data
= exec
->vtx
.copied
.buffer
;
330 fi_type
*dest
= exec
->vtx
.buffer_ptr
;
333 assert(exec
->vtx
.buffer_ptr
== exec
->vtx
.buffer_map
);
335 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
336 for (j
= 0 ; j
< VBO_ATTRIB_MAX
; j
++) {
337 GLuint sz
= exec
->vtx
.attrsz
[j
];
340 GLint old_offset
= old_attrptr
[j
] - exec
->vtx
.vertex
;
341 GLint new_offset
= exec
->vtx
.attrptr
[j
] - exec
->vtx
.vertex
;
346 COPY_CLEAN_4V_TYPE_AS_UNION(tmp
, oldSize
,
348 exec
->vtx
.attrtype
[j
]);
349 COPY_SZ_4V(dest
+ new_offset
, newSize
, tmp
);
351 fi_type
*current
= (fi_type
*)vbo
->currval
[j
].Ptr
;
352 COPY_SZ_4V(dest
+ new_offset
, sz
, current
);
356 COPY_SZ_4V(dest
+ new_offset
, sz
, data
+ old_offset
);
361 data
+= old_vtx_size
;
362 dest
+= exec
->vtx
.vertex_size
;
365 exec
->vtx
.buffer_ptr
= dest
;
366 exec
->vtx
.vert_count
+= exec
->vtx
.copied
.nr
;
367 exec
->vtx
.copied
.nr
= 0;
373 * This is when a vertex attribute transitions to a different size.
374 * For example, we saw a bunch of glTexCoord2f() calls and now we got a
375 * glTexCoord4f() call. We promote the array from size=2 to size=4.
376 * \param newSize size of new vertex (number of 32-bit words).
379 vbo_exec_fixup_vertex(struct gl_context
*ctx
, GLuint attr
,
380 GLuint newSize
, GLenum newType
)
382 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
384 if (newSize
> exec
->vtx
.attrsz
[attr
] ||
385 newType
!= exec
->vtx
.attrtype
[attr
]) {
386 /* New size is larger. Need to flush existing vertices and get
387 * an enlarged vertex format.
389 vbo_exec_wrap_upgrade_vertex( exec
, attr
, newSize
);
391 else if (newSize
< exec
->vtx
.active_sz
[attr
]) {
394 vbo_get_default_vals_as_union(exec
->vtx
.attrtype
[attr
]);
396 /* New size is smaller - just need to fill in some
397 * zeros. Don't need to flush or wrap.
399 for (i
= newSize
; i
<= exec
->vtx
.attrsz
[attr
]; i
++)
400 exec
->vtx
.attrptr
[attr
][i
-1] = id
[i
-1];
403 exec
->vtx
.active_sz
[attr
] = newSize
;
405 /* Does setting NeedFlush belong here? Necessitates resetting
406 * vtxfmt on each flush (otherwise flags won't get reset
410 ctx
->Driver
.NeedFlush
|= FLUSH_STORED_VERTICES
;
415 * Called upon first glVertex, glColor, glTexCoord, etc.
418 vbo_exec_begin_vertices(struct gl_context
*ctx
)
420 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
422 vbo_exec_vtx_map( exec
);
424 assert((ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
) == 0);
425 assert(exec
->begin_vertices_flags
);
427 ctx
->Driver
.NeedFlush
|= exec
->begin_vertices_flags
;
432 * This macro is used to implement all the glVertex, glColor, glTexCoord,
433 * glVertexAttrib, etc functions.
434 * \param A attribute index
435 * \param N attribute size (1..4)
436 * \param T type (GL_FLOAT, GL_DOUBLE, GL_INT, GL_UNSIGNED_INT)
437 * \param C cast type (fi_type or double)
438 * \param V0, V1, v2, V3 attribute value
440 #define ATTR_UNION( A, N, T, C, V0, V1, V2, V3 ) \
442 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
443 int sz = (sizeof(C) / sizeof(GLfloat)); \
445 assert(sz == 1 || sz == 2); \
447 /* check if attribute size or type is changing */ \
448 if (unlikely(exec->vtx.active_sz[A] != N * sz) || \
449 unlikely(exec->vtx.attrtype[A] != T)) { \
450 vbo_exec_fixup_vertex(ctx, A, N * sz, T); \
453 /* store vertex attribute in vertex buffer */ \
455 C *dest = (C *)exec->vtx.attrptr[A]; \
456 if (N>0) dest[0] = V0; \
457 if (N>1) dest[1] = V1; \
458 if (N>2) dest[2] = V2; \
459 if (N>3) dest[3] = V3; \
460 exec->vtx.attrtype[A] = T; \
464 /* This is a glVertex call */ \
467 if (unlikely((ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) == 0)) { \
468 vbo_exec_begin_vertices(ctx); \
471 if (unlikely(!exec->vtx.buffer_ptr)) { \
472 vbo_exec_vtx_map(exec); \
474 assert(exec->vtx.buffer_ptr); \
476 /* copy 32-bit words */ \
477 for (i = 0; i < exec->vtx.vertex_size; i++) \
478 exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i]; \
480 exec->vtx.buffer_ptr += exec->vtx.vertex_size; \
482 /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \
483 /* something to draw (not just updating a color or texcoord).*/ \
484 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \
486 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
487 vbo_exec_vtx_wrap( exec ); \
489 /* we now have accumulated per-vertex attributes */ \
490 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
494 #define ERROR(err) _mesa_error( ctx, err, __func__ )
495 #define TAG(x) vbo_##x
497 #include "vbo_attrib_tmp.h"
502 * Execute a glMaterial call. Note that if GL_COLOR_MATERIAL is enabled,
503 * this may be a (partial) no-op.
505 static void GLAPIENTRY
506 vbo_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
508 GLbitfield updateMats
;
509 GET_CURRENT_CONTEXT(ctx
);
511 /* This function should be a no-op when it tries to update material
512 * attributes which are currently tracking glColor via glColorMaterial.
513 * The updateMats var will be a mask of the MAT_BIT_FRONT/BACK_x bits
514 * indicating which material attributes can actually be updated below.
516 if (ctx
->Light
.ColorMaterialEnabled
) {
517 updateMats
= ~ctx
->Light
._ColorMaterialBitmask
;
520 /* GL_COLOR_MATERIAL is disabled so don't skip any material updates */
521 updateMats
= ALL_MATERIAL_BITS
;
524 if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_FRONT
) {
525 updateMats
&= FRONT_MATERIAL_BITS
;
527 else if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_BACK
) {
528 updateMats
&= BACK_MATERIAL_BITS
;
530 else if (face
!= GL_FRONT_AND_BACK
) {
531 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterial(invalid face)");
537 if (updateMats
& MAT_BIT_FRONT_EMISSION
)
538 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_EMISSION
, 4, params
);
539 if (updateMats
& MAT_BIT_BACK_EMISSION
)
540 MAT_ATTR(VBO_ATTRIB_MAT_BACK_EMISSION
, 4, params
);
543 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
544 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
545 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
546 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
549 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
550 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
551 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
552 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
555 if (updateMats
& MAT_BIT_FRONT_SPECULAR
)
556 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SPECULAR
, 4, params
);
557 if (updateMats
& MAT_BIT_BACK_SPECULAR
)
558 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SPECULAR
, 4, params
);
561 if (*params
< 0 || *params
> ctx
->Const
.MaxShininess
) {
562 _mesa_error(ctx
, GL_INVALID_VALUE
,
563 "glMaterial(invalid shininess: %f out range [0, %f])",
564 *params
, ctx
->Const
.MaxShininess
);
567 if (updateMats
& MAT_BIT_FRONT_SHININESS
)
568 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SHININESS
, 1, params
);
569 if (updateMats
& MAT_BIT_BACK_SHININESS
)
570 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SHININESS
, 1, params
);
572 case GL_COLOR_INDEXES
:
573 if (ctx
->API
!= API_OPENGL_COMPAT
) {
574 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
577 if (updateMats
& MAT_BIT_FRONT_INDEXES
)
578 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_INDEXES
, 3, params
);
579 if (updateMats
& MAT_BIT_BACK_INDEXES
)
580 MAT_ATTR(VBO_ATTRIB_MAT_BACK_INDEXES
, 3, params
);
582 case GL_AMBIENT_AND_DIFFUSE
:
583 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
584 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
585 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
586 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
587 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
588 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
589 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
590 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
593 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
600 * Flush (draw) vertices.
601 * \param unmap - leave VBO unmapped after flushing?
604 vbo_exec_FlushVertices_internal(struct vbo_exec_context
*exec
, GLboolean unmap
)
606 if (exec
->vtx
.vert_count
|| unmap
) {
607 vbo_exec_vtx_flush( exec
, unmap
);
610 if (exec
->vtx
.vertex_size
) {
611 vbo_exec_copy_to_current( exec
);
612 reset_attrfv( exec
);
617 static void GLAPIENTRY
vbo_exec_EvalCoord1f( GLfloat u
)
619 GET_CURRENT_CONTEXT( ctx
);
620 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
624 if (exec
->eval
.recalculate_maps
)
625 vbo_exec_eval_update( exec
);
627 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
628 if (exec
->eval
.map1
[i
].map
)
629 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map1
[i
].sz
)
630 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map1
[i
].sz
, GL_FLOAT
);
635 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
636 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
638 vbo_exec_do_EvalCoord1f( exec
, u
);
640 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
641 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
644 static void GLAPIENTRY
vbo_exec_EvalCoord2f( GLfloat u
, GLfloat v
)
646 GET_CURRENT_CONTEXT( ctx
);
647 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
651 if (exec
->eval
.recalculate_maps
)
652 vbo_exec_eval_update( exec
);
654 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
655 if (exec
->eval
.map2
[i
].map
)
656 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map2
[i
].sz
)
657 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map2
[i
].sz
, GL_FLOAT
);
660 if (ctx
->Eval
.AutoNormal
)
661 if (exec
->vtx
.active_sz
[VBO_ATTRIB_NORMAL
] != 3)
662 vbo_exec_fixup_vertex( ctx
, VBO_ATTRIB_NORMAL
, 3, GL_FLOAT
);
665 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
666 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
668 vbo_exec_do_EvalCoord2f( exec
, u
, v
);
670 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
671 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
674 static void GLAPIENTRY
vbo_exec_EvalCoord1fv( const GLfloat
*u
)
676 vbo_exec_EvalCoord1f( u
[0] );
679 static void GLAPIENTRY
vbo_exec_EvalCoord2fv( const GLfloat
*u
)
681 vbo_exec_EvalCoord2f( u
[0], u
[1] );
684 static void GLAPIENTRY
vbo_exec_EvalPoint1( GLint i
)
686 GET_CURRENT_CONTEXT( ctx
);
687 GLfloat du
= ((ctx
->Eval
.MapGrid1u2
- ctx
->Eval
.MapGrid1u1
) /
688 (GLfloat
) ctx
->Eval
.MapGrid1un
);
689 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid1u1
;
691 vbo_exec_EvalCoord1f( u
);
695 static void GLAPIENTRY
vbo_exec_EvalPoint2( GLint i
, GLint j
)
697 GET_CURRENT_CONTEXT( ctx
);
698 GLfloat du
= ((ctx
->Eval
.MapGrid2u2
- ctx
->Eval
.MapGrid2u1
) /
699 (GLfloat
) ctx
->Eval
.MapGrid2un
);
700 GLfloat dv
= ((ctx
->Eval
.MapGrid2v2
- ctx
->Eval
.MapGrid2v1
) /
701 (GLfloat
) ctx
->Eval
.MapGrid2vn
);
702 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid2u1
;
703 GLfloat v
= j
* dv
+ ctx
->Eval
.MapGrid2v1
;
705 vbo_exec_EvalCoord2f( u
, v
);
710 * Called via glBegin.
712 static void GLAPIENTRY
vbo_exec_Begin( GLenum mode
)
714 GET_CURRENT_CONTEXT( ctx
);
715 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
718 if (_mesa_inside_begin_end(ctx
)) {
719 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glBegin");
723 if (!_mesa_valid_prim_mode(ctx
, mode
, "glBegin")) {
727 vbo_draw_method(vbo_context(ctx
), DRAW_BEGIN_END
);
730 _mesa_update_state( ctx
);
732 CALL_Begin(ctx
->Exec
, (mode
));
736 if (!_mesa_valid_to_render(ctx
, "glBegin")) {
740 /* Heuristic: attempt to isolate attributes occurring outside
743 if (exec
->vtx
.vertex_size
&& !exec
->vtx
.attrsz
[0])
744 vbo_exec_FlushVertices_internal(exec
, GL_FALSE
);
746 i
= exec
->vtx
.prim_count
++;
747 exec
->vtx
.prim
[i
].mode
= mode
;
748 exec
->vtx
.prim
[i
].begin
= 1;
749 exec
->vtx
.prim
[i
].end
= 0;
750 exec
->vtx
.prim
[i
].indexed
= 0;
751 exec
->vtx
.prim
[i
].weak
= 0;
752 exec
->vtx
.prim
[i
].pad
= 0;
753 exec
->vtx
.prim
[i
].start
= exec
->vtx
.vert_count
;
754 exec
->vtx
.prim
[i
].count
= 0;
755 exec
->vtx
.prim
[i
].num_instances
= 1;
756 exec
->vtx
.prim
[i
].base_instance
= 0;
757 exec
->vtx
.prim
[i
].is_indirect
= 0;
759 ctx
->Driver
.CurrentExecPrimitive
= mode
;
761 ctx
->Exec
= ctx
->BeginEnd
;
762 /* We may have been called from a display list, in which case we should
763 * leave dlist.c's dispatch table in place.
765 if (ctx
->CurrentDispatch
== ctx
->OutsideBeginEnd
) {
766 ctx
->CurrentDispatch
= ctx
->BeginEnd
;
767 _glapi_set_dispatch(ctx
->CurrentDispatch
);
769 assert(ctx
->CurrentDispatch
== ctx
->Save
);
775 * Try to merge / concatenate the two most recent VBO primitives.
778 try_vbo_merge(struct vbo_exec_context
*exec
)
780 struct _mesa_prim
*cur
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
782 assert(exec
->vtx
.prim_count
>= 1);
784 vbo_try_prim_conversion(cur
);
786 if (exec
->vtx
.prim_count
>= 2) {
787 struct _mesa_prim
*prev
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 2];
788 assert(prev
== cur
- 1);
790 if (vbo_can_merge_prims(prev
, cur
)) {
795 vbo_merge_prims(prev
, cur
);
796 exec
->vtx
.prim_count
--; /* drop the last primitive */
805 static void GLAPIENTRY
vbo_exec_End( void )
807 GET_CURRENT_CONTEXT( ctx
);
808 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
810 if (!_mesa_inside_begin_end(ctx
)) {
811 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glEnd");
815 ctx
->Exec
= ctx
->OutsideBeginEnd
;
816 if (ctx
->CurrentDispatch
== ctx
->BeginEnd
) {
817 ctx
->CurrentDispatch
= ctx
->OutsideBeginEnd
;
818 _glapi_set_dispatch(ctx
->CurrentDispatch
);
821 if (exec
->vtx
.prim_count
> 0) {
822 /* close off current primitive */
823 struct _mesa_prim
*last_prim
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
826 last_prim
->count
= exec
->vtx
.vert_count
- last_prim
->start
;
831 ctx
->Driver
.CurrentExecPrimitive
= PRIM_OUTSIDE_BEGIN_END
;
833 if (exec
->vtx
.prim_count
== VBO_MAX_PRIM
)
834 vbo_exec_vtx_flush( exec
, GL_FALSE
);
836 if (MESA_DEBUG_FLAGS
& DEBUG_ALWAYS_FLUSH
) {
843 * Called via glPrimitiveRestartNV()
845 static void GLAPIENTRY
846 vbo_exec_PrimitiveRestartNV(void)
849 GET_CURRENT_CONTEXT( ctx
);
851 curPrim
= ctx
->Driver
.CurrentExecPrimitive
;
853 if (curPrim
== PRIM_OUTSIDE_BEGIN_END
) {
854 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glPrimitiveRestartNV" );
858 vbo_exec_Begin(curPrim
);
864 static void vbo_exec_vtxfmt_init( struct vbo_exec_context
*exec
)
866 struct gl_context
*ctx
= exec
->ctx
;
867 GLvertexformat
*vfmt
= &exec
->vtxfmt
;
869 vfmt
->ArrayElement
= _ae_ArrayElement
;
871 vfmt
->Begin
= vbo_exec_Begin
;
872 vfmt
->End
= vbo_exec_End
;
873 vfmt
->PrimitiveRestartNV
= vbo_exec_PrimitiveRestartNV
;
875 vfmt
->CallList
= _mesa_CallList
;
876 vfmt
->CallLists
= _mesa_CallLists
;
878 vfmt
->EvalCoord1f
= vbo_exec_EvalCoord1f
;
879 vfmt
->EvalCoord1fv
= vbo_exec_EvalCoord1fv
;
880 vfmt
->EvalCoord2f
= vbo_exec_EvalCoord2f
;
881 vfmt
->EvalCoord2fv
= vbo_exec_EvalCoord2fv
;
882 vfmt
->EvalPoint1
= vbo_exec_EvalPoint1
;
883 vfmt
->EvalPoint2
= vbo_exec_EvalPoint2
;
885 /* from attrib_tmp.h:
887 vfmt
->Color3f
= vbo_Color3f
;
888 vfmt
->Color3fv
= vbo_Color3fv
;
889 vfmt
->Color4f
= vbo_Color4f
;
890 vfmt
->Color4fv
= vbo_Color4fv
;
891 vfmt
->FogCoordfEXT
= vbo_FogCoordfEXT
;
892 vfmt
->FogCoordfvEXT
= vbo_FogCoordfvEXT
;
893 vfmt
->MultiTexCoord1fARB
= vbo_MultiTexCoord1f
;
894 vfmt
->MultiTexCoord1fvARB
= vbo_MultiTexCoord1fv
;
895 vfmt
->MultiTexCoord2fARB
= vbo_MultiTexCoord2f
;
896 vfmt
->MultiTexCoord2fvARB
= vbo_MultiTexCoord2fv
;
897 vfmt
->MultiTexCoord3fARB
= vbo_MultiTexCoord3f
;
898 vfmt
->MultiTexCoord3fvARB
= vbo_MultiTexCoord3fv
;
899 vfmt
->MultiTexCoord4fARB
= vbo_MultiTexCoord4f
;
900 vfmt
->MultiTexCoord4fvARB
= vbo_MultiTexCoord4fv
;
901 vfmt
->Normal3f
= vbo_Normal3f
;
902 vfmt
->Normal3fv
= vbo_Normal3fv
;
903 vfmt
->SecondaryColor3fEXT
= vbo_SecondaryColor3fEXT
;
904 vfmt
->SecondaryColor3fvEXT
= vbo_SecondaryColor3fvEXT
;
905 vfmt
->TexCoord1f
= vbo_TexCoord1f
;
906 vfmt
->TexCoord1fv
= vbo_TexCoord1fv
;
907 vfmt
->TexCoord2f
= vbo_TexCoord2f
;
908 vfmt
->TexCoord2fv
= vbo_TexCoord2fv
;
909 vfmt
->TexCoord3f
= vbo_TexCoord3f
;
910 vfmt
->TexCoord3fv
= vbo_TexCoord3fv
;
911 vfmt
->TexCoord4f
= vbo_TexCoord4f
;
912 vfmt
->TexCoord4fv
= vbo_TexCoord4fv
;
913 vfmt
->Vertex2f
= vbo_Vertex2f
;
914 vfmt
->Vertex2fv
= vbo_Vertex2fv
;
915 vfmt
->Vertex3f
= vbo_Vertex3f
;
916 vfmt
->Vertex3fv
= vbo_Vertex3fv
;
917 vfmt
->Vertex4f
= vbo_Vertex4f
;
918 vfmt
->Vertex4fv
= vbo_Vertex4fv
;
920 if (ctx
->API
== API_OPENGLES2
) {
921 vfmt
->VertexAttrib1fARB
= _es_VertexAttrib1f
;
922 vfmt
->VertexAttrib1fvARB
= _es_VertexAttrib1fv
;
923 vfmt
->VertexAttrib2fARB
= _es_VertexAttrib2f
;
924 vfmt
->VertexAttrib2fvARB
= _es_VertexAttrib2fv
;
925 vfmt
->VertexAttrib3fARB
= _es_VertexAttrib3f
;
926 vfmt
->VertexAttrib3fvARB
= _es_VertexAttrib3fv
;
927 vfmt
->VertexAttrib4fARB
= _es_VertexAttrib4f
;
928 vfmt
->VertexAttrib4fvARB
= _es_VertexAttrib4fv
;
930 vfmt
->VertexAttrib1fARB
= vbo_VertexAttrib1fARB
;
931 vfmt
->VertexAttrib1fvARB
= vbo_VertexAttrib1fvARB
;
932 vfmt
->VertexAttrib2fARB
= vbo_VertexAttrib2fARB
;
933 vfmt
->VertexAttrib2fvARB
= vbo_VertexAttrib2fvARB
;
934 vfmt
->VertexAttrib3fARB
= vbo_VertexAttrib3fARB
;
935 vfmt
->VertexAttrib3fvARB
= vbo_VertexAttrib3fvARB
;
936 vfmt
->VertexAttrib4fARB
= vbo_VertexAttrib4fARB
;
937 vfmt
->VertexAttrib4fvARB
= vbo_VertexAttrib4fvARB
;
940 /* Note that VertexAttrib4fNV is used from dlist.c and api_arrayelt.c so
941 * they can have a single entrypoint for updating any of the legacy
944 vfmt
->VertexAttrib1fNV
= vbo_VertexAttrib1fNV
;
945 vfmt
->VertexAttrib1fvNV
= vbo_VertexAttrib1fvNV
;
946 vfmt
->VertexAttrib2fNV
= vbo_VertexAttrib2fNV
;
947 vfmt
->VertexAttrib2fvNV
= vbo_VertexAttrib2fvNV
;
948 vfmt
->VertexAttrib3fNV
= vbo_VertexAttrib3fNV
;
949 vfmt
->VertexAttrib3fvNV
= vbo_VertexAttrib3fvNV
;
950 vfmt
->VertexAttrib4fNV
= vbo_VertexAttrib4fNV
;
951 vfmt
->VertexAttrib4fvNV
= vbo_VertexAttrib4fvNV
;
954 vfmt
->VertexAttribI1i
= vbo_VertexAttribI1i
;
955 vfmt
->VertexAttribI2i
= vbo_VertexAttribI2i
;
956 vfmt
->VertexAttribI3i
= vbo_VertexAttribI3i
;
957 vfmt
->VertexAttribI4i
= vbo_VertexAttribI4i
;
958 vfmt
->VertexAttribI2iv
= vbo_VertexAttribI2iv
;
959 vfmt
->VertexAttribI3iv
= vbo_VertexAttribI3iv
;
960 vfmt
->VertexAttribI4iv
= vbo_VertexAttribI4iv
;
962 /* unsigned integer-valued */
963 vfmt
->VertexAttribI1ui
= vbo_VertexAttribI1ui
;
964 vfmt
->VertexAttribI2ui
= vbo_VertexAttribI2ui
;
965 vfmt
->VertexAttribI3ui
= vbo_VertexAttribI3ui
;
966 vfmt
->VertexAttribI4ui
= vbo_VertexAttribI4ui
;
967 vfmt
->VertexAttribI2uiv
= vbo_VertexAttribI2uiv
;
968 vfmt
->VertexAttribI3uiv
= vbo_VertexAttribI3uiv
;
969 vfmt
->VertexAttribI4uiv
= vbo_VertexAttribI4uiv
;
971 vfmt
->Materialfv
= vbo_Materialfv
;
973 vfmt
->EdgeFlag
= vbo_EdgeFlag
;
974 vfmt
->Indexf
= vbo_Indexf
;
975 vfmt
->Indexfv
= vbo_Indexfv
;
977 /* ARB_vertex_type_2_10_10_10_rev */
978 vfmt
->VertexP2ui
= vbo_VertexP2ui
;
979 vfmt
->VertexP2uiv
= vbo_VertexP2uiv
;
980 vfmt
->VertexP3ui
= vbo_VertexP3ui
;
981 vfmt
->VertexP3uiv
= vbo_VertexP3uiv
;
982 vfmt
->VertexP4ui
= vbo_VertexP4ui
;
983 vfmt
->VertexP4uiv
= vbo_VertexP4uiv
;
985 vfmt
->TexCoordP1ui
= vbo_TexCoordP1ui
;
986 vfmt
->TexCoordP1uiv
= vbo_TexCoordP1uiv
;
987 vfmt
->TexCoordP2ui
= vbo_TexCoordP2ui
;
988 vfmt
->TexCoordP2uiv
= vbo_TexCoordP2uiv
;
989 vfmt
->TexCoordP3ui
= vbo_TexCoordP3ui
;
990 vfmt
->TexCoordP3uiv
= vbo_TexCoordP3uiv
;
991 vfmt
->TexCoordP4ui
= vbo_TexCoordP4ui
;
992 vfmt
->TexCoordP4uiv
= vbo_TexCoordP4uiv
;
994 vfmt
->MultiTexCoordP1ui
= vbo_MultiTexCoordP1ui
;
995 vfmt
->MultiTexCoordP1uiv
= vbo_MultiTexCoordP1uiv
;
996 vfmt
->MultiTexCoordP2ui
= vbo_MultiTexCoordP2ui
;
997 vfmt
->MultiTexCoordP2uiv
= vbo_MultiTexCoordP2uiv
;
998 vfmt
->MultiTexCoordP3ui
= vbo_MultiTexCoordP3ui
;
999 vfmt
->MultiTexCoordP3uiv
= vbo_MultiTexCoordP3uiv
;
1000 vfmt
->MultiTexCoordP4ui
= vbo_MultiTexCoordP4ui
;
1001 vfmt
->MultiTexCoordP4uiv
= vbo_MultiTexCoordP4uiv
;
1003 vfmt
->NormalP3ui
= vbo_NormalP3ui
;
1004 vfmt
->NormalP3uiv
= vbo_NormalP3uiv
;
1006 vfmt
->ColorP3ui
= vbo_ColorP3ui
;
1007 vfmt
->ColorP3uiv
= vbo_ColorP3uiv
;
1008 vfmt
->ColorP4ui
= vbo_ColorP4ui
;
1009 vfmt
->ColorP4uiv
= vbo_ColorP4uiv
;
1011 vfmt
->SecondaryColorP3ui
= vbo_SecondaryColorP3ui
;
1012 vfmt
->SecondaryColorP3uiv
= vbo_SecondaryColorP3uiv
;
1014 vfmt
->VertexAttribP1ui
= vbo_VertexAttribP1ui
;
1015 vfmt
->VertexAttribP1uiv
= vbo_VertexAttribP1uiv
;
1016 vfmt
->VertexAttribP2ui
= vbo_VertexAttribP2ui
;
1017 vfmt
->VertexAttribP2uiv
= vbo_VertexAttribP2uiv
;
1018 vfmt
->VertexAttribP3ui
= vbo_VertexAttribP3ui
;
1019 vfmt
->VertexAttribP3uiv
= vbo_VertexAttribP3uiv
;
1020 vfmt
->VertexAttribP4ui
= vbo_VertexAttribP4ui
;
1021 vfmt
->VertexAttribP4uiv
= vbo_VertexAttribP4uiv
;
1023 vfmt
->VertexAttribL1d
= vbo_VertexAttribL1d
;
1024 vfmt
->VertexAttribL2d
= vbo_VertexAttribL2d
;
1025 vfmt
->VertexAttribL3d
= vbo_VertexAttribL3d
;
1026 vfmt
->VertexAttribL4d
= vbo_VertexAttribL4d
;
1028 vfmt
->VertexAttribL1dv
= vbo_VertexAttribL1dv
;
1029 vfmt
->VertexAttribL2dv
= vbo_VertexAttribL2dv
;
1030 vfmt
->VertexAttribL3dv
= vbo_VertexAttribL3dv
;
1031 vfmt
->VertexAttribL4dv
= vbo_VertexAttribL4dv
;
1036 * Tell the VBO module to use a real OpenGL vertex buffer object to
1037 * store accumulated immediate-mode vertex data.
1038 * This replaces the malloced buffer which was created in
1039 * vb_exec_vtx_init() below.
1041 void vbo_use_buffer_objects(struct gl_context
*ctx
)
1043 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1044 /* Any buffer name but 0 can be used here since this bufferobj won't
1045 * go into the bufferobj hashtable.
1047 GLuint bufName
= IMM_BUFFER_NAME
;
1048 GLenum target
= GL_ARRAY_BUFFER_ARB
;
1049 GLenum usage
= GL_STREAM_DRAW_ARB
;
1050 GLsizei size
= VBO_VERT_BUFFER_SIZE
;
1052 /* Make sure this func is only used once */
1053 assert(exec
->vtx
.bufferobj
== ctx
->Shared
->NullBufferObj
);
1055 _mesa_align_free(exec
->vtx
.buffer_map
);
1056 exec
->vtx
.buffer_map
= NULL
;
1057 exec
->vtx
.buffer_ptr
= NULL
;
1059 /* Allocate a real buffer object now */
1060 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1061 exec
->vtx
.bufferobj
= ctx
->Driver
.NewBufferObject(ctx
, bufName
);
1062 if (!ctx
->Driver
.BufferData(ctx
, target
, size
, NULL
, usage
,
1064 GL_DYNAMIC_STORAGE_BIT
|
1065 GL_CLIENT_STORAGE_BIT
,
1066 exec
->vtx
.bufferobj
)) {
1067 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "VBO allocation");
1073 * If this function is called, all VBO buffers will be unmapped when
1075 * Otherwise, if a simple command like glColor3f() is called and we flush,
1076 * the current VBO may be left mapped.
1079 vbo_always_unmap_buffers(struct gl_context
*ctx
)
1081 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1082 exec
->begin_vertices_flags
|= FLUSH_STORED_VERTICES
;
1086 void vbo_exec_vtx_init( struct vbo_exec_context
*exec
)
1088 struct gl_context
*ctx
= exec
->ctx
;
1089 struct vbo_context
*vbo
= vbo_context(ctx
);
1092 /* Allocate a buffer object. Will just reuse this object
1093 * continuously, unless vbo_use_buffer_objects() is called to enable
1096 _mesa_reference_buffer_object(ctx
,
1097 &exec
->vtx
.bufferobj
,
1098 ctx
->Shared
->NullBufferObj
);
1100 assert(!exec
->vtx
.buffer_map
);
1101 exec
->vtx
.buffer_map
= _mesa_align_malloc(VBO_VERT_BUFFER_SIZE
, 64);
1102 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
1104 vbo_exec_vtxfmt_init( exec
);
1105 _mesa_noop_vtxfmt_init(&exec
->vtxfmt_noop
);
1107 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1108 assert(i
< ARRAY_SIZE(exec
->vtx
.attrsz
));
1109 exec
->vtx
.attrsz
[i
] = 0;
1110 assert(i
< ARRAY_SIZE(exec
->vtx
.attrtype
));
1111 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1112 assert(i
< ARRAY_SIZE(exec
->vtx
.active_sz
));
1113 exec
->vtx
.active_sz
[i
] = 0;
1115 for (i
= 0 ; i
< VERT_ATTRIB_MAX
; i
++) {
1116 assert(i
< ARRAY_SIZE(exec
->vtx
.inputs
));
1117 assert(i
< ARRAY_SIZE(exec
->vtx
.arrays
));
1118 exec
->vtx
.inputs
[i
] = &exec
->vtx
.arrays
[i
];
1122 struct gl_client_array
*arrays
= exec
->vtx
.arrays
;
1125 memcpy(arrays
, &vbo
->currval
[VBO_ATTRIB_POS
],
1126 VERT_ATTRIB_FF_MAX
* sizeof(arrays
[0]));
1127 for (i
= 0; i
< VERT_ATTRIB_FF_MAX
; ++i
) {
1128 struct gl_client_array
*array
;
1129 array
= &arrays
[VERT_ATTRIB_FF(i
)];
1130 array
->BufferObj
= NULL
;
1131 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1132 vbo
->currval
[VBO_ATTRIB_POS
+i
].BufferObj
);
1135 memcpy(arrays
+ VERT_ATTRIB_GENERIC(0),
1136 &vbo
->currval
[VBO_ATTRIB_GENERIC0
],
1137 VERT_ATTRIB_GENERIC_MAX
* sizeof(arrays
[0]));
1139 for (i
= 0; i
< VERT_ATTRIB_GENERIC_MAX
; ++i
) {
1140 struct gl_client_array
*array
;
1141 array
= &arrays
[VERT_ATTRIB_GENERIC(i
)];
1142 array
->BufferObj
= NULL
;
1143 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1144 vbo
->currval
[VBO_ATTRIB_GENERIC0
+i
].BufferObj
);
1148 exec
->vtx
.vertex_size
= 0;
1150 exec
->begin_vertices_flags
= FLUSH_UPDATE_CURRENT
;
1154 void vbo_exec_vtx_destroy( struct vbo_exec_context
*exec
)
1156 /* using a real VBO for vertex data */
1157 struct gl_context
*ctx
= exec
->ctx
;
1160 /* True VBOs should already be unmapped
1162 if (exec
->vtx
.buffer_map
) {
1163 assert(exec
->vtx
.bufferobj
->Name
== 0 ||
1164 exec
->vtx
.bufferobj
->Name
== IMM_BUFFER_NAME
);
1165 if (exec
->vtx
.bufferobj
->Name
== 0) {
1166 _mesa_align_free(exec
->vtx
.buffer_map
);
1167 exec
->vtx
.buffer_map
= NULL
;
1168 exec
->vtx
.buffer_ptr
= NULL
;
1172 /* Drop any outstanding reference to the vertex buffer
1174 for (i
= 0; i
< ARRAY_SIZE(exec
->vtx
.arrays
); i
++) {
1175 _mesa_reference_buffer_object(ctx
,
1176 &exec
->vtx
.arrays
[i
].BufferObj
,
1180 /* Free the vertex buffer. Unmap first if needed.
1182 if (_mesa_bufferobj_mapped(exec
->vtx
.bufferobj
, MAP_INTERNAL
)) {
1183 ctx
->Driver
.UnmapBuffer(ctx
, exec
->vtx
.bufferobj
, MAP_INTERNAL
);
1185 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1190 * If inside glBegin()/glEnd(), it should assert(0). Otherwise, if
1191 * FLUSH_STORED_VERTICES bit in \p flags is set flushes any buffered
1192 * vertices, if FLUSH_UPDATE_CURRENT bit is set updates
1193 * __struct gl_contextRec::Current and gl_light_attrib::Material
1195 * Note that the default T&L engine never clears the
1196 * FLUSH_UPDATE_CURRENT bit, even after performing the update.
1198 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1200 void vbo_exec_FlushVertices( struct gl_context
*ctx
, GLuint flags
)
1202 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1205 /* debug check: make sure we don't get called recursively */
1206 exec
->flush_call_depth
++;
1207 assert(exec
->flush_call_depth
== 1);
1210 if (_mesa_inside_begin_end(ctx
)) {
1211 /* We've had glBegin but not glEnd! */
1213 exec
->flush_call_depth
--;
1214 assert(exec
->flush_call_depth
== 0);
1219 /* Flush (draw), and make sure VBO is left unmapped when done */
1220 vbo_exec_FlushVertices_internal(exec
, GL_TRUE
);
1222 /* Need to do this to ensure vbo_exec_begin_vertices gets called again:
1224 ctx
->Driver
.NeedFlush
&= ~(FLUSH_UPDATE_CURRENT
| flags
);
1227 exec
->flush_call_depth
--;
1228 assert(exec
->flush_call_depth
== 0);
1233 static void reset_attrfv( struct vbo_exec_context
*exec
)
1237 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1238 exec
->vtx
.attrsz
[i
] = 0;
1239 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1240 exec
->vtx
.active_sz
[i
] = 0;
1243 exec
->vtx
.vertex_size
= 0;
1248 _es_Color4f(GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
1250 vbo_Color4f(r
, g
, b
, a
);
1255 _es_Normal3f(GLfloat x
, GLfloat y
, GLfloat z
)
1257 vbo_Normal3f(x
, y
, z
);
1262 _es_MultiTexCoord4f(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1264 vbo_MultiTexCoord4f(target
, s
, t
, r
, q
);
1269 _es_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
1271 vbo_Materialfv(face
, pname
, params
);
1276 _es_Materialf(GLenum face
, GLenum pname
, GLfloat param
)
1280 p
[1] = p
[2] = p
[3] = 0.0F
;
1281 vbo_Materialfv(face
, pname
, p
);
1286 * A special version of glVertexAttrib4f that does not treat index 0 as
1290 VertexAttrib4f_nopos(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1292 GET_CURRENT_CONTEXT(ctx
);
1293 if (index
< MAX_VERTEX_GENERIC_ATTRIBS
)
1294 ATTRF(VBO_ATTRIB_GENERIC0
+ index
, 4, x
, y
, z
, w
);
1296 ERROR(GL_INVALID_VALUE
);
1300 _es_VertexAttrib4f(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1302 VertexAttrib4f_nopos(index
, x
, y
, z
, w
);
1307 _es_VertexAttrib1f(GLuint indx
, GLfloat x
)
1309 VertexAttrib4f_nopos(indx
, x
, 0.0f
, 0.0f
, 1.0f
);
1314 _es_VertexAttrib1fv(GLuint indx
, const GLfloat
* values
)
1316 VertexAttrib4f_nopos(indx
, values
[0], 0.0f
, 0.0f
, 1.0f
);
1321 _es_VertexAttrib2f(GLuint indx
, GLfloat x
, GLfloat y
)
1323 VertexAttrib4f_nopos(indx
, x
, y
, 0.0f
, 1.0f
);
1328 _es_VertexAttrib2fv(GLuint indx
, const GLfloat
* values
)
1330 VertexAttrib4f_nopos(indx
, values
[0], values
[1], 0.0f
, 1.0f
);
1335 _es_VertexAttrib3f(GLuint indx
, GLfloat x
, GLfloat y
, GLfloat z
)
1337 VertexAttrib4f_nopos(indx
, x
, y
, z
, 1.0f
);
1342 _es_VertexAttrib3fv(GLuint indx
, const GLfloat
* values
)
1344 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], 1.0f
);
1349 _es_VertexAttrib4fv(GLuint indx
, const GLfloat
* values
)
1351 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], values
[3]);