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"
45 #include "util/bitscan.h"
47 #include "vbo_context.h"
51 /** ID/name for immediate-mode VBO */
52 #define IMM_BUFFER_NAME 0xaabbccdd
56 vbo_reset_all_attr(struct vbo_exec_context
*exec
);
60 * Close off the last primitive, execute the buffer, restart the
61 * primitive. This is called when we fill a vertex buffer before
65 vbo_exec_wrap_buffers(struct vbo_exec_context
*exec
)
67 if (exec
->vtx
.prim_count
== 0) {
68 exec
->vtx
.copied
.nr
= 0;
69 exec
->vtx
.vert_count
= 0;
70 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
73 struct _mesa_prim
*last_prim
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
74 const GLuint last_begin
= last_prim
->begin
;
77 if (_mesa_inside_begin_end(exec
->ctx
)) {
78 last_prim
->count
= exec
->vtx
.vert_count
- last_prim
->start
;
81 last_count
= last_prim
->count
;
83 /* Special handling for wrapping GL_LINE_LOOP */
84 if (last_prim
->mode
== GL_LINE_LOOP
&&
87 /* draw this section of the incomplete line loop as a line strip */
88 last_prim
->mode
= GL_LINE_STRIP
;
89 if (!last_prim
->begin
) {
90 /* This is not the first section of the line loop, so don't
91 * draw the 0th vertex. We're saving it until we draw the
92 * very last section of the loop.
99 /* Execute the buffer and save copied vertices.
101 if (exec
->vtx
.vert_count
)
102 vbo_exec_vtx_flush( exec
, GL_FALSE
);
104 exec
->vtx
.prim_count
= 0;
105 exec
->vtx
.copied
.nr
= 0;
108 /* Emit a glBegin to start the new list.
110 assert(exec
->vtx
.prim_count
== 0);
112 if (_mesa_inside_begin_end(exec
->ctx
)) {
113 exec
->vtx
.prim
[0].mode
= exec
->ctx
->Driver
.CurrentExecPrimitive
;
114 exec
->vtx
.prim
[0].begin
= 0;
115 exec
->vtx
.prim
[0].end
= 0;
116 exec
->vtx
.prim
[0].start
= 0;
117 exec
->vtx
.prim
[0].count
= 0;
118 exec
->vtx
.prim_count
++;
120 if (exec
->vtx
.copied
.nr
== last_count
)
121 exec
->vtx
.prim
[0].begin
= last_begin
;
128 * Deal with buffer wrapping where provoked by the vertex buffer
129 * filling up, as opposed to upgrade_vertex().
132 vbo_exec_vtx_wrap(struct vbo_exec_context
*exec
)
134 unsigned numComponents
;
136 /* Run pipeline on current vertices, copy wrapped vertices
137 * to exec->vtx.copied.
139 vbo_exec_wrap_buffers( exec
);
141 if (!exec
->vtx
.buffer_ptr
) {
142 /* probably ran out of memory earlier when allocating the VBO */
146 /* Copy stored stored vertices to start of new list.
148 assert(exec
->vtx
.max_vert
- exec
->vtx
.vert_count
> exec
->vtx
.copied
.nr
);
150 numComponents
= exec
->vtx
.copied
.nr
* exec
->vtx
.vertex_size
;
151 memcpy(exec
->vtx
.buffer_ptr
,
152 exec
->vtx
.copied
.buffer
,
153 numComponents
* sizeof(fi_type
));
154 exec
->vtx
.buffer_ptr
+= numComponents
;
155 exec
->vtx
.vert_count
+= exec
->vtx
.copied
.nr
;
157 exec
->vtx
.copied
.nr
= 0;
162 * Copy the active vertex's values to the ctx->Current fields.
165 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
);
169 GLbitfield64 enabled
= exec
->vtx
.enabled
& (~BITFIELD64_BIT(VBO_ATTRIB_POS
));
172 const int i
= u_bit_scan64(&enabled
);
174 /* Note: the exec->vtx.current[i] pointers point into the
175 * ctx->Current.Attrib and ctx->Light.Material.Attrib arrays.
177 GLfloat
*current
= (GLfloat
*)vbo
->currval
[i
].Ptr
;
178 fi_type tmp
[8]; /* space for doubles */
181 if (exec
->vtx
.attrtype
[i
] == GL_DOUBLE
||
182 exec
->vtx
.attrtype
[i
] == GL_UNSIGNED_INT64_ARB
)
185 assert(exec
->vtx
.attrsz
[i
]);
187 if (exec
->vtx
.attrtype
[i
] == GL_DOUBLE
||
188 exec
->vtx
.attrtype
[i
] == GL_UNSIGNED_INT64_ARB
) {
189 memset(tmp
, 0, sizeof(tmp
));
190 memcpy(tmp
, exec
->vtx
.attrptr
[i
], exec
->vtx
.attrsz
[i
] * sizeof(GLfloat
));
192 COPY_CLEAN_4V_TYPE_AS_UNION(tmp
,
194 exec
->vtx
.attrptr
[i
],
195 exec
->vtx
.attrtype
[i
]);
198 if (exec
->vtx
.attrtype
[i
] != vbo
->currval
[i
].Type
||
199 memcmp(current
, tmp
, 4 * sizeof(GLfloat
) * dmul
) != 0) {
200 memcpy(current
, tmp
, 4 * sizeof(GLfloat
) * dmul
);
202 /* Given that we explicitly state size here, there is no need
203 * for the COPY_CLEAN above, could just copy 16 bytes and be
204 * done. The only problem is when Mesa accesses ctx->Current
207 /* Size here is in components - not bytes */
208 vbo
->currval
[i
].Size
= exec
->vtx
.attrsz
[i
] / dmul
;
209 vbo
->currval
[i
]._ElementSize
=
210 vbo
->currval
[i
].Size
* sizeof(GLfloat
) * dmul
;
211 vbo
->currval
[i
].Type
= exec
->vtx
.attrtype
[i
];
212 vbo
->currval
[i
].Integer
=
213 vbo_attrtype_to_integer_flag(exec
->vtx
.attrtype
[i
]);
214 vbo
->currval
[i
].Doubles
=
215 vbo_attrtype_to_double_flag(exec
->vtx
.attrtype
[i
]);
217 /* This triggers rather too much recalculation of Mesa state
218 * that doesn't get used (eg light positions).
220 if (i
>= VBO_ATTRIB_MAT_FRONT_AMBIENT
&&
221 i
<= VBO_ATTRIB_MAT_BACK_INDEXES
)
222 ctx
->NewState
|= _NEW_LIGHT
;
224 ctx
->NewState
|= _NEW_CURRENT_ATTRIB
;
228 /* Colormaterial -- this kindof sucks.
230 if (ctx
->Light
.ColorMaterialEnabled
&&
231 exec
->vtx
.attrsz
[VBO_ATTRIB_COLOR0
]) {
232 _mesa_update_color_material(ctx
,
233 ctx
->Current
.Attrib
[VBO_ATTRIB_COLOR0
]);
239 * Copy current vertex attribute values into the current vertex.
242 vbo_exec_copy_from_current(struct vbo_exec_context
*exec
)
244 struct gl_context
*ctx
= exec
->ctx
;
245 struct vbo_context
*vbo
= vbo_context(ctx
);
248 for (i
= VBO_ATTRIB_POS
+ 1; i
< VBO_ATTRIB_MAX
; i
++) {
249 if (exec
->vtx
.attrtype
[i
] == GL_DOUBLE
||
250 exec
->vtx
.attrtype
[i
] == GL_UNSIGNED_INT64_ARB
) {
251 memcpy(exec
->vtx
.attrptr
[i
], vbo
->currval
[i
].Ptr
,
252 exec
->vtx
.attrsz
[i
] * sizeof(GLfloat
));
254 const fi_type
*current
= (fi_type
*) vbo
->currval
[i
].Ptr
;
255 switch (exec
->vtx
.attrsz
[i
]) {
256 case 4: exec
->vtx
.attrptr
[i
][3] = current
[3];
257 case 3: exec
->vtx
.attrptr
[i
][2] = current
[2];
258 case 2: exec
->vtx
.attrptr
[i
][1] = current
[1];
259 case 1: exec
->vtx
.attrptr
[i
][0] = current
[0];
268 * Flush existing data, set new attrib size, replay copied vertices.
269 * This is called when we transition from a small vertex attribute size
270 * to a larger one. Ex: glTexCoord2f -> glTexCoord4f.
271 * We need to go back over the previous 2-component texcoords and insert
272 * zero and one values.
275 vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context
*exec
,
276 GLuint attr
, GLuint newSize
)
278 struct gl_context
*ctx
= exec
->ctx
;
279 struct vbo_context
*vbo
= vbo_context(ctx
);
280 const GLint lastcount
= exec
->vtx
.vert_count
;
281 fi_type
*old_attrptr
[VBO_ATTRIB_MAX
];
282 const GLuint old_vtx_size
= exec
->vtx
.vertex_size
; /* floats per vertex */
283 const GLuint oldSize
= exec
->vtx
.attrsz
[attr
];
286 /* Run pipeline on current vertices, copy wrapped vertices
287 * to exec->vtx.copied.
289 vbo_exec_wrap_buffers( exec
);
291 if (unlikely(exec
->vtx
.copied
.nr
)) {
292 /* We're in the middle of a primitive, keep the old vertex
293 * format around to be able to translate the copied vertices to
296 memcpy(old_attrptr
, exec
->vtx
.attrptr
, sizeof(old_attrptr
));
299 if (unlikely(oldSize
)) {
300 /* Do a COPY_TO_CURRENT to ensure back-copying works for the
301 * case when the attribute already exists in the vertex and is
302 * having its size increased.
304 vbo_exec_copy_to_current( exec
);
307 /* Heuristic: Attempt to isolate attributes received outside
308 * begin/end so that they don't bloat the vertices.
310 if (!_mesa_inside_begin_end(ctx
) &&
311 !oldSize
&& lastcount
> 8 && exec
->vtx
.vertex_size
) {
312 vbo_exec_copy_to_current( exec
);
313 vbo_reset_all_attr(exec
);
318 exec
->vtx
.attrsz
[attr
] = newSize
;
319 exec
->vtx
.vertex_size
+= newSize
- oldSize
;
320 exec
->vtx
.max_vert
= vbo_compute_max_verts(exec
);
321 exec
->vtx
.vert_count
= 0;
322 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
323 exec
->vtx
.enabled
|= BITFIELD64_BIT(attr
);
325 if (unlikely(oldSize
)) {
326 /* Size changed, recalculate all the attrptr[] values
328 fi_type
*tmp
= exec
->vtx
.vertex
;
330 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
331 if (exec
->vtx
.attrsz
[i
]) {
332 exec
->vtx
.attrptr
[i
] = tmp
;
333 tmp
+= exec
->vtx
.attrsz
[i
];
336 exec
->vtx
.attrptr
[i
] = NULL
; /* will not be dereferenced */
339 /* Copy from current to repopulate the vertex with correct
342 vbo_exec_copy_from_current( exec
);
345 /* Just have to append the new attribute at the end */
346 exec
->vtx
.attrptr
[attr
] = exec
->vtx
.vertex
+
347 exec
->vtx
.vertex_size
- newSize
;
350 /* Replay stored vertices to translate them
351 * to new format here.
353 * -- No need to replay - just copy piecewise
355 if (unlikely(exec
->vtx
.copied
.nr
)) {
356 fi_type
*data
= exec
->vtx
.copied
.buffer
;
357 fi_type
*dest
= exec
->vtx
.buffer_ptr
;
359 assert(exec
->vtx
.buffer_ptr
== exec
->vtx
.buffer_map
);
361 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
362 GLbitfield64 enabled
= exec
->vtx
.enabled
;
364 const int j
= u_bit_scan64(&enabled
);
365 GLuint sz
= exec
->vtx
.attrsz
[j
];
366 GLint old_offset
= old_attrptr
[j
] - exec
->vtx
.vertex
;
367 GLint new_offset
= exec
->vtx
.attrptr
[j
] - exec
->vtx
.vertex
;
374 COPY_CLEAN_4V_TYPE_AS_UNION(tmp
, oldSize
,
376 exec
->vtx
.attrtype
[j
]);
377 COPY_SZ_4V(dest
+ new_offset
, newSize
, tmp
);
379 fi_type
*current
= (fi_type
*)vbo
->currval
[j
].Ptr
;
380 COPY_SZ_4V(dest
+ new_offset
, sz
, current
);
384 COPY_SZ_4V(dest
+ new_offset
, sz
, data
+ old_offset
);
388 data
+= old_vtx_size
;
389 dest
+= exec
->vtx
.vertex_size
;
392 exec
->vtx
.buffer_ptr
= dest
;
393 exec
->vtx
.vert_count
+= exec
->vtx
.copied
.nr
;
394 exec
->vtx
.copied
.nr
= 0;
400 * This is when a vertex attribute transitions to a different size.
401 * For example, we saw a bunch of glTexCoord2f() calls and now we got a
402 * glTexCoord4f() call. We promote the array from size=2 to size=4.
403 * \param newSize size of new vertex (number of 32-bit words).
406 vbo_exec_fixup_vertex(struct gl_context
*ctx
, GLuint attr
,
407 GLuint newSize
, GLenum newType
)
409 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
411 if (newSize
> exec
->vtx
.attrsz
[attr
] ||
412 newType
!= exec
->vtx
.attrtype
[attr
]) {
413 /* New size is larger. Need to flush existing vertices and get
414 * an enlarged vertex format.
416 vbo_exec_wrap_upgrade_vertex( exec
, attr
, newSize
);
418 else if (newSize
< exec
->vtx
.active_sz
[attr
]) {
421 vbo_get_default_vals_as_union(exec
->vtx
.attrtype
[attr
]);
423 /* New size is smaller - just need to fill in some
424 * zeros. Don't need to flush or wrap.
426 for (i
= newSize
; i
<= exec
->vtx
.attrsz
[attr
]; i
++)
427 exec
->vtx
.attrptr
[attr
][i
-1] = id
[i
-1];
430 exec
->vtx
.active_sz
[attr
] = newSize
;
431 exec
->vtx
.attrtype
[attr
] = newType
;
433 /* Does setting NeedFlush belong here? Necessitates resetting
434 * vtxfmt on each flush (otherwise flags won't get reset
438 ctx
->Driver
.NeedFlush
|= FLUSH_STORED_VERTICES
;
443 * Called upon first glVertex, glColor, glTexCoord, etc.
446 vbo_exec_begin_vertices(struct gl_context
*ctx
)
448 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
450 vbo_exec_vtx_map( exec
);
452 assert((ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
) == 0);
453 assert(exec
->begin_vertices_flags
);
455 ctx
->Driver
.NeedFlush
|= exec
->begin_vertices_flags
;
460 * This macro is used to implement all the glVertex, glColor, glTexCoord,
461 * glVertexAttrib, etc functions.
462 * \param A attribute index
463 * \param N attribute size (1..4)
464 * \param T type (GL_FLOAT, GL_DOUBLE, GL_INT, GL_UNSIGNED_INT)
465 * \param C cast type (fi_type or double)
466 * \param V0, V1, v2, V3 attribute value
468 #define ATTR_UNION( A, N, T, C, V0, V1, V2, V3 ) \
470 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
471 int sz = (sizeof(C) / sizeof(GLfloat)); \
473 assert(sz == 1 || sz == 2); \
475 /* check if attribute size or type is changing */ \
476 if (unlikely(exec->vtx.active_sz[A] != N * sz) || \
477 unlikely(exec->vtx.attrtype[A] != T)) { \
478 vbo_exec_fixup_vertex(ctx, A, N * sz, T); \
481 /* store vertex attribute in vertex buffer */ \
483 C *dest = (C *)exec->vtx.attrptr[A]; \
484 if (N>0) dest[0] = V0; \
485 if (N>1) dest[1] = V1; \
486 if (N>2) dest[2] = V2; \
487 if (N>3) dest[3] = V3; \
488 assert(exec->vtx.attrtype[A] == T); \
492 /* This is a glVertex call */ \
495 if (unlikely((ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) == 0)) { \
496 vbo_exec_begin_vertices(ctx); \
499 if (unlikely(!exec->vtx.buffer_ptr)) { \
500 vbo_exec_vtx_map(exec); \
502 assert(exec->vtx.buffer_ptr); \
504 /* copy 32-bit words */ \
505 for (i = 0; i < exec->vtx.vertex_size; i++) \
506 exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i]; \
508 exec->vtx.buffer_ptr += exec->vtx.vertex_size; \
510 /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \
511 /* something to draw (not just updating a color or texcoord).*/ \
512 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \
514 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
515 vbo_exec_vtx_wrap( exec ); \
517 /* we now have accumulated per-vertex attributes */ \
518 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
524 #define ERROR(err) _mesa_error( ctx, err, __func__ )
525 #define TAG(x) vbo_##x
527 #include "vbo_attrib_tmp.h"
532 * Execute a glMaterial call. Note that if GL_COLOR_MATERIAL is enabled,
533 * this may be a (partial) no-op.
535 static void GLAPIENTRY
536 vbo_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
538 GLbitfield updateMats
;
539 GET_CURRENT_CONTEXT(ctx
);
541 /* This function should be a no-op when it tries to update material
542 * attributes which are currently tracking glColor via glColorMaterial.
543 * The updateMats var will be a mask of the MAT_BIT_FRONT/BACK_x bits
544 * indicating which material attributes can actually be updated below.
546 if (ctx
->Light
.ColorMaterialEnabled
) {
547 updateMats
= ~ctx
->Light
._ColorMaterialBitmask
;
550 /* GL_COLOR_MATERIAL is disabled so don't skip any material updates */
551 updateMats
= ALL_MATERIAL_BITS
;
554 if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_FRONT
) {
555 updateMats
&= FRONT_MATERIAL_BITS
;
557 else if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_BACK
) {
558 updateMats
&= BACK_MATERIAL_BITS
;
560 else if (face
!= GL_FRONT_AND_BACK
) {
561 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterial(invalid face)");
567 if (updateMats
& MAT_BIT_FRONT_EMISSION
)
568 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_EMISSION
, 4, params
);
569 if (updateMats
& MAT_BIT_BACK_EMISSION
)
570 MAT_ATTR(VBO_ATTRIB_MAT_BACK_EMISSION
, 4, params
);
573 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
574 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
575 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
576 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
579 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
580 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
581 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
582 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
585 if (updateMats
& MAT_BIT_FRONT_SPECULAR
)
586 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SPECULAR
, 4, params
);
587 if (updateMats
& MAT_BIT_BACK_SPECULAR
)
588 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SPECULAR
, 4, params
);
591 if (*params
< 0 || *params
> ctx
->Const
.MaxShininess
) {
592 _mesa_error(ctx
, GL_INVALID_VALUE
,
593 "glMaterial(invalid shininess: %f out range [0, %f])",
594 *params
, ctx
->Const
.MaxShininess
);
597 if (updateMats
& MAT_BIT_FRONT_SHININESS
)
598 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SHININESS
, 1, params
);
599 if (updateMats
& MAT_BIT_BACK_SHININESS
)
600 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SHININESS
, 1, params
);
602 case GL_COLOR_INDEXES
:
603 if (ctx
->API
!= API_OPENGL_COMPAT
) {
604 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
607 if (updateMats
& MAT_BIT_FRONT_INDEXES
)
608 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_INDEXES
, 3, params
);
609 if (updateMats
& MAT_BIT_BACK_INDEXES
)
610 MAT_ATTR(VBO_ATTRIB_MAT_BACK_INDEXES
, 3, params
);
612 case GL_AMBIENT_AND_DIFFUSE
:
613 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
614 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
615 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
616 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
617 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
618 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
619 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
620 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
623 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
630 * Flush (draw) vertices.
631 * \param unmap - leave VBO unmapped after flushing?
634 vbo_exec_FlushVertices_internal(struct vbo_exec_context
*exec
, GLboolean unmap
)
636 if (exec
->vtx
.vert_count
|| unmap
) {
637 vbo_exec_vtx_flush( exec
, unmap
);
640 if (exec
->vtx
.vertex_size
) {
641 vbo_exec_copy_to_current( exec
);
642 vbo_reset_all_attr(exec
);
647 static void GLAPIENTRY
648 vbo_exec_EvalCoord1f(GLfloat u
)
650 GET_CURRENT_CONTEXT( ctx
);
651 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
655 if (exec
->eval
.recalculate_maps
)
656 vbo_exec_eval_update( exec
);
658 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
659 if (exec
->eval
.map1
[i
].map
)
660 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map1
[i
].sz
)
661 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map1
[i
].sz
, GL_FLOAT
);
666 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
667 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
669 vbo_exec_do_EvalCoord1f( exec
, u
);
671 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
672 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
676 static void GLAPIENTRY
677 vbo_exec_EvalCoord2f(GLfloat u
, GLfloat v
)
679 GET_CURRENT_CONTEXT( ctx
);
680 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
684 if (exec
->eval
.recalculate_maps
)
685 vbo_exec_eval_update( exec
);
687 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
688 if (exec
->eval
.map2
[i
].map
)
689 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map2
[i
].sz
)
690 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map2
[i
].sz
, GL_FLOAT
);
693 if (ctx
->Eval
.AutoNormal
)
694 if (exec
->vtx
.active_sz
[VBO_ATTRIB_NORMAL
] != 3)
695 vbo_exec_fixup_vertex( ctx
, VBO_ATTRIB_NORMAL
, 3, GL_FLOAT
);
698 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
699 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
701 vbo_exec_do_EvalCoord2f( exec
, u
, v
);
703 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
704 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
708 static void GLAPIENTRY
709 vbo_exec_EvalCoord1fv(const GLfloat
*u
)
711 vbo_exec_EvalCoord1f( u
[0] );
715 static void GLAPIENTRY
716 vbo_exec_EvalCoord2fv(const GLfloat
*u
)
718 vbo_exec_EvalCoord2f( u
[0], u
[1] );
722 static void GLAPIENTRY
723 vbo_exec_EvalPoint1(GLint i
)
725 GET_CURRENT_CONTEXT( ctx
);
726 GLfloat du
= ((ctx
->Eval
.MapGrid1u2
- ctx
->Eval
.MapGrid1u1
) /
727 (GLfloat
) ctx
->Eval
.MapGrid1un
);
728 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid1u1
;
730 vbo_exec_EvalCoord1f( u
);
734 static void GLAPIENTRY
735 vbo_exec_EvalPoint2(GLint i
, GLint j
)
737 GET_CURRENT_CONTEXT( ctx
);
738 GLfloat du
= ((ctx
->Eval
.MapGrid2u2
- ctx
->Eval
.MapGrid2u1
) /
739 (GLfloat
) ctx
->Eval
.MapGrid2un
);
740 GLfloat dv
= ((ctx
->Eval
.MapGrid2v2
- ctx
->Eval
.MapGrid2v1
) /
741 (GLfloat
) ctx
->Eval
.MapGrid2vn
);
742 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid2u1
;
743 GLfloat v
= j
* dv
+ ctx
->Eval
.MapGrid2v1
;
745 vbo_exec_EvalCoord2f( u
, v
);
750 * Called via glBegin.
752 static void GLAPIENTRY
753 vbo_exec_Begin(GLenum mode
)
755 GET_CURRENT_CONTEXT( ctx
);
756 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
759 if (_mesa_inside_begin_end(ctx
)) {
760 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glBegin");
764 if (!_mesa_valid_prim_mode(ctx
, mode
, "glBegin")) {
768 vbo_draw_method(vbo_context(ctx
), DRAW_BEGIN_END
);
771 _mesa_update_state( ctx
);
773 CALL_Begin(ctx
->Exec
, (mode
));
777 if (!_mesa_valid_to_render(ctx
, "glBegin")) {
781 /* Heuristic: attempt to isolate attributes occurring outside
784 if (exec
->vtx
.vertex_size
&& !exec
->vtx
.attrsz
[0])
785 vbo_exec_FlushVertices_internal(exec
, GL_FALSE
);
787 i
= exec
->vtx
.prim_count
++;
788 exec
->vtx
.prim
[i
].mode
= mode
;
789 exec
->vtx
.prim
[i
].begin
= 1;
790 exec
->vtx
.prim
[i
].end
= 0;
791 exec
->vtx
.prim
[i
].indexed
= 0;
792 exec
->vtx
.prim
[i
].weak
= 0;
793 exec
->vtx
.prim
[i
].pad
= 0;
794 exec
->vtx
.prim
[i
].start
= exec
->vtx
.vert_count
;
795 exec
->vtx
.prim
[i
].count
= 0;
796 exec
->vtx
.prim
[i
].num_instances
= 1;
797 exec
->vtx
.prim
[i
].base_instance
= 0;
798 exec
->vtx
.prim
[i
].is_indirect
= 0;
800 ctx
->Driver
.CurrentExecPrimitive
= mode
;
802 ctx
->Exec
= ctx
->BeginEnd
;
803 /* We may have been called from a display list, in which case we should
804 * leave dlist.c's dispatch table in place.
806 if (ctx
->CurrentClientDispatch
== ctx
->OutsideBeginEnd
) {
807 ctx
->CurrentClientDispatch
= ctx
->BeginEnd
;
808 _glapi_set_dispatch(ctx
->CurrentClientDispatch
);
810 assert(ctx
->CurrentClientDispatch
== ctx
->Save
);
816 * Try to merge / concatenate the two most recent VBO primitives.
819 try_vbo_merge(struct vbo_exec_context
*exec
)
821 struct _mesa_prim
*cur
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
823 assert(exec
->vtx
.prim_count
>= 1);
825 vbo_try_prim_conversion(cur
);
827 if (exec
->vtx
.prim_count
>= 2) {
828 struct _mesa_prim
*prev
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 2];
829 assert(prev
== cur
- 1);
831 if (vbo_can_merge_prims(prev
, cur
)) {
836 vbo_merge_prims(prev
, cur
);
837 exec
->vtx
.prim_count
--; /* drop the last primitive */
846 static void GLAPIENTRY
849 GET_CURRENT_CONTEXT( ctx
);
850 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
852 if (!_mesa_inside_begin_end(ctx
)) {
853 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glEnd");
857 ctx
->Exec
= ctx
->OutsideBeginEnd
;
858 if (ctx
->CurrentClientDispatch
== ctx
->BeginEnd
) {
859 ctx
->CurrentClientDispatch
= ctx
->OutsideBeginEnd
;
860 _glapi_set_dispatch(ctx
->CurrentClientDispatch
);
863 if (exec
->vtx
.prim_count
> 0) {
864 /* close off current primitive */
865 struct _mesa_prim
*last_prim
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
868 last_prim
->count
= exec
->vtx
.vert_count
- last_prim
->start
;
870 /* Special handling for GL_LINE_LOOP */
871 if (last_prim
->mode
== GL_LINE_LOOP
&& last_prim
->begin
== 0) {
872 /* We're finishing drawing a line loop. Append 0th vertex onto
873 * end of vertex buffer so we can draw it as a line strip.
875 const fi_type
*src
= exec
->vtx
.buffer_map
+
876 last_prim
->start
* exec
->vtx
.vertex_size
;
877 fi_type
*dst
= exec
->vtx
.buffer_map
+
878 exec
->vtx
.vert_count
* exec
->vtx
.vertex_size
;
880 /* copy 0th vertex to end of buffer */
881 memcpy(dst
, src
, exec
->vtx
.vertex_size
* sizeof(fi_type
));
883 last_prim
->start
++; /* skip vertex0 */
884 /* note that last_prim->count stays unchanged */
885 last_prim
->mode
= GL_LINE_STRIP
;
887 /* Increment the vertex count so the next primitive doesn't
888 * overwrite the last vertex which we just added.
890 exec
->vtx
.vert_count
++;
891 exec
->vtx
.buffer_ptr
+= exec
->vtx
.vertex_size
;
897 ctx
->Driver
.CurrentExecPrimitive
= PRIM_OUTSIDE_BEGIN_END
;
899 if (exec
->vtx
.prim_count
== VBO_MAX_PRIM
)
900 vbo_exec_vtx_flush( exec
, GL_FALSE
);
902 if (MESA_DEBUG_FLAGS
& DEBUG_ALWAYS_FLUSH
) {
909 * Called via glPrimitiveRestartNV()
911 static void GLAPIENTRY
912 vbo_exec_PrimitiveRestartNV(void)
915 GET_CURRENT_CONTEXT(ctx
);
917 curPrim
= ctx
->Driver
.CurrentExecPrimitive
;
919 if (curPrim
== PRIM_OUTSIDE_BEGIN_END
) {
920 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glPrimitiveRestartNV" );
924 vbo_exec_Begin(curPrim
);
930 vbo_exec_vtxfmt_init(struct vbo_exec_context
*exec
)
932 struct gl_context
*ctx
= exec
->ctx
;
933 GLvertexformat
*vfmt
= &exec
->vtxfmt
;
935 vfmt
->ArrayElement
= _ae_ArrayElement
;
937 vfmt
->Begin
= vbo_exec_Begin
;
938 vfmt
->End
= vbo_exec_End
;
939 vfmt
->PrimitiveRestartNV
= vbo_exec_PrimitiveRestartNV
;
941 vfmt
->CallList
= _mesa_CallList
;
942 vfmt
->CallLists
= _mesa_CallLists
;
944 vfmt
->EvalCoord1f
= vbo_exec_EvalCoord1f
;
945 vfmt
->EvalCoord1fv
= vbo_exec_EvalCoord1fv
;
946 vfmt
->EvalCoord2f
= vbo_exec_EvalCoord2f
;
947 vfmt
->EvalCoord2fv
= vbo_exec_EvalCoord2fv
;
948 vfmt
->EvalPoint1
= vbo_exec_EvalPoint1
;
949 vfmt
->EvalPoint2
= vbo_exec_EvalPoint2
;
951 /* from attrib_tmp.h:
953 vfmt
->Color3f
= vbo_Color3f
;
954 vfmt
->Color3fv
= vbo_Color3fv
;
955 vfmt
->Color4f
= vbo_Color4f
;
956 vfmt
->Color4fv
= vbo_Color4fv
;
957 vfmt
->FogCoordfEXT
= vbo_FogCoordfEXT
;
958 vfmt
->FogCoordfvEXT
= vbo_FogCoordfvEXT
;
959 vfmt
->MultiTexCoord1fARB
= vbo_MultiTexCoord1f
;
960 vfmt
->MultiTexCoord1fvARB
= vbo_MultiTexCoord1fv
;
961 vfmt
->MultiTexCoord2fARB
= vbo_MultiTexCoord2f
;
962 vfmt
->MultiTexCoord2fvARB
= vbo_MultiTexCoord2fv
;
963 vfmt
->MultiTexCoord3fARB
= vbo_MultiTexCoord3f
;
964 vfmt
->MultiTexCoord3fvARB
= vbo_MultiTexCoord3fv
;
965 vfmt
->MultiTexCoord4fARB
= vbo_MultiTexCoord4f
;
966 vfmt
->MultiTexCoord4fvARB
= vbo_MultiTexCoord4fv
;
967 vfmt
->Normal3f
= vbo_Normal3f
;
968 vfmt
->Normal3fv
= vbo_Normal3fv
;
969 vfmt
->SecondaryColor3fEXT
= vbo_SecondaryColor3fEXT
;
970 vfmt
->SecondaryColor3fvEXT
= vbo_SecondaryColor3fvEXT
;
971 vfmt
->TexCoord1f
= vbo_TexCoord1f
;
972 vfmt
->TexCoord1fv
= vbo_TexCoord1fv
;
973 vfmt
->TexCoord2f
= vbo_TexCoord2f
;
974 vfmt
->TexCoord2fv
= vbo_TexCoord2fv
;
975 vfmt
->TexCoord3f
= vbo_TexCoord3f
;
976 vfmt
->TexCoord3fv
= vbo_TexCoord3fv
;
977 vfmt
->TexCoord4f
= vbo_TexCoord4f
;
978 vfmt
->TexCoord4fv
= vbo_TexCoord4fv
;
979 vfmt
->Vertex2f
= vbo_Vertex2f
;
980 vfmt
->Vertex2fv
= vbo_Vertex2fv
;
981 vfmt
->Vertex3f
= vbo_Vertex3f
;
982 vfmt
->Vertex3fv
= vbo_Vertex3fv
;
983 vfmt
->Vertex4f
= vbo_Vertex4f
;
984 vfmt
->Vertex4fv
= vbo_Vertex4fv
;
986 if (ctx
->API
== API_OPENGLES2
) {
987 vfmt
->VertexAttrib1fARB
= _es_VertexAttrib1f
;
988 vfmt
->VertexAttrib1fvARB
= _es_VertexAttrib1fv
;
989 vfmt
->VertexAttrib2fARB
= _es_VertexAttrib2f
;
990 vfmt
->VertexAttrib2fvARB
= _es_VertexAttrib2fv
;
991 vfmt
->VertexAttrib3fARB
= _es_VertexAttrib3f
;
992 vfmt
->VertexAttrib3fvARB
= _es_VertexAttrib3fv
;
993 vfmt
->VertexAttrib4fARB
= _es_VertexAttrib4f
;
994 vfmt
->VertexAttrib4fvARB
= _es_VertexAttrib4fv
;
996 vfmt
->VertexAttrib1fARB
= vbo_VertexAttrib1fARB
;
997 vfmt
->VertexAttrib1fvARB
= vbo_VertexAttrib1fvARB
;
998 vfmt
->VertexAttrib2fARB
= vbo_VertexAttrib2fARB
;
999 vfmt
->VertexAttrib2fvARB
= vbo_VertexAttrib2fvARB
;
1000 vfmt
->VertexAttrib3fARB
= vbo_VertexAttrib3fARB
;
1001 vfmt
->VertexAttrib3fvARB
= vbo_VertexAttrib3fvARB
;
1002 vfmt
->VertexAttrib4fARB
= vbo_VertexAttrib4fARB
;
1003 vfmt
->VertexAttrib4fvARB
= vbo_VertexAttrib4fvARB
;
1006 /* Note that VertexAttrib4fNV is used from dlist.c and api_arrayelt.c so
1007 * they can have a single entrypoint for updating any of the legacy
1010 vfmt
->VertexAttrib1fNV
= vbo_VertexAttrib1fNV
;
1011 vfmt
->VertexAttrib1fvNV
= vbo_VertexAttrib1fvNV
;
1012 vfmt
->VertexAttrib2fNV
= vbo_VertexAttrib2fNV
;
1013 vfmt
->VertexAttrib2fvNV
= vbo_VertexAttrib2fvNV
;
1014 vfmt
->VertexAttrib3fNV
= vbo_VertexAttrib3fNV
;
1015 vfmt
->VertexAttrib3fvNV
= vbo_VertexAttrib3fvNV
;
1016 vfmt
->VertexAttrib4fNV
= vbo_VertexAttrib4fNV
;
1017 vfmt
->VertexAttrib4fvNV
= vbo_VertexAttrib4fvNV
;
1019 /* integer-valued */
1020 vfmt
->VertexAttribI1i
= vbo_VertexAttribI1i
;
1021 vfmt
->VertexAttribI2i
= vbo_VertexAttribI2i
;
1022 vfmt
->VertexAttribI3i
= vbo_VertexAttribI3i
;
1023 vfmt
->VertexAttribI4i
= vbo_VertexAttribI4i
;
1024 vfmt
->VertexAttribI2iv
= vbo_VertexAttribI2iv
;
1025 vfmt
->VertexAttribI3iv
= vbo_VertexAttribI3iv
;
1026 vfmt
->VertexAttribI4iv
= vbo_VertexAttribI4iv
;
1028 /* unsigned integer-valued */
1029 vfmt
->VertexAttribI1ui
= vbo_VertexAttribI1ui
;
1030 vfmt
->VertexAttribI2ui
= vbo_VertexAttribI2ui
;
1031 vfmt
->VertexAttribI3ui
= vbo_VertexAttribI3ui
;
1032 vfmt
->VertexAttribI4ui
= vbo_VertexAttribI4ui
;
1033 vfmt
->VertexAttribI2uiv
= vbo_VertexAttribI2uiv
;
1034 vfmt
->VertexAttribI3uiv
= vbo_VertexAttribI3uiv
;
1035 vfmt
->VertexAttribI4uiv
= vbo_VertexAttribI4uiv
;
1037 vfmt
->Materialfv
= vbo_Materialfv
;
1039 vfmt
->EdgeFlag
= vbo_EdgeFlag
;
1040 vfmt
->Indexf
= vbo_Indexf
;
1041 vfmt
->Indexfv
= vbo_Indexfv
;
1043 /* ARB_vertex_type_2_10_10_10_rev */
1044 vfmt
->VertexP2ui
= vbo_VertexP2ui
;
1045 vfmt
->VertexP2uiv
= vbo_VertexP2uiv
;
1046 vfmt
->VertexP3ui
= vbo_VertexP3ui
;
1047 vfmt
->VertexP3uiv
= vbo_VertexP3uiv
;
1048 vfmt
->VertexP4ui
= vbo_VertexP4ui
;
1049 vfmt
->VertexP4uiv
= vbo_VertexP4uiv
;
1051 vfmt
->TexCoordP1ui
= vbo_TexCoordP1ui
;
1052 vfmt
->TexCoordP1uiv
= vbo_TexCoordP1uiv
;
1053 vfmt
->TexCoordP2ui
= vbo_TexCoordP2ui
;
1054 vfmt
->TexCoordP2uiv
= vbo_TexCoordP2uiv
;
1055 vfmt
->TexCoordP3ui
= vbo_TexCoordP3ui
;
1056 vfmt
->TexCoordP3uiv
= vbo_TexCoordP3uiv
;
1057 vfmt
->TexCoordP4ui
= vbo_TexCoordP4ui
;
1058 vfmt
->TexCoordP4uiv
= vbo_TexCoordP4uiv
;
1060 vfmt
->MultiTexCoordP1ui
= vbo_MultiTexCoordP1ui
;
1061 vfmt
->MultiTexCoordP1uiv
= vbo_MultiTexCoordP1uiv
;
1062 vfmt
->MultiTexCoordP2ui
= vbo_MultiTexCoordP2ui
;
1063 vfmt
->MultiTexCoordP2uiv
= vbo_MultiTexCoordP2uiv
;
1064 vfmt
->MultiTexCoordP3ui
= vbo_MultiTexCoordP3ui
;
1065 vfmt
->MultiTexCoordP3uiv
= vbo_MultiTexCoordP3uiv
;
1066 vfmt
->MultiTexCoordP4ui
= vbo_MultiTexCoordP4ui
;
1067 vfmt
->MultiTexCoordP4uiv
= vbo_MultiTexCoordP4uiv
;
1069 vfmt
->NormalP3ui
= vbo_NormalP3ui
;
1070 vfmt
->NormalP3uiv
= vbo_NormalP3uiv
;
1072 vfmt
->ColorP3ui
= vbo_ColorP3ui
;
1073 vfmt
->ColorP3uiv
= vbo_ColorP3uiv
;
1074 vfmt
->ColorP4ui
= vbo_ColorP4ui
;
1075 vfmt
->ColorP4uiv
= vbo_ColorP4uiv
;
1077 vfmt
->SecondaryColorP3ui
= vbo_SecondaryColorP3ui
;
1078 vfmt
->SecondaryColorP3uiv
= vbo_SecondaryColorP3uiv
;
1080 vfmt
->VertexAttribP1ui
= vbo_VertexAttribP1ui
;
1081 vfmt
->VertexAttribP1uiv
= vbo_VertexAttribP1uiv
;
1082 vfmt
->VertexAttribP2ui
= vbo_VertexAttribP2ui
;
1083 vfmt
->VertexAttribP2uiv
= vbo_VertexAttribP2uiv
;
1084 vfmt
->VertexAttribP3ui
= vbo_VertexAttribP3ui
;
1085 vfmt
->VertexAttribP3uiv
= vbo_VertexAttribP3uiv
;
1086 vfmt
->VertexAttribP4ui
= vbo_VertexAttribP4ui
;
1087 vfmt
->VertexAttribP4uiv
= vbo_VertexAttribP4uiv
;
1089 vfmt
->VertexAttribL1d
= vbo_VertexAttribL1d
;
1090 vfmt
->VertexAttribL2d
= vbo_VertexAttribL2d
;
1091 vfmt
->VertexAttribL3d
= vbo_VertexAttribL3d
;
1092 vfmt
->VertexAttribL4d
= vbo_VertexAttribL4d
;
1094 vfmt
->VertexAttribL1dv
= vbo_VertexAttribL1dv
;
1095 vfmt
->VertexAttribL2dv
= vbo_VertexAttribL2dv
;
1096 vfmt
->VertexAttribL3dv
= vbo_VertexAttribL3dv
;
1097 vfmt
->VertexAttribL4dv
= vbo_VertexAttribL4dv
;
1099 vfmt
->VertexAttribL1ui64ARB
= vbo_VertexAttribL1ui64ARB
;
1100 vfmt
->VertexAttribL1ui64vARB
= vbo_VertexAttribL1ui64vARB
;
1105 * Tell the VBO module to use a real OpenGL vertex buffer object to
1106 * store accumulated immediate-mode vertex data.
1107 * This replaces the malloced buffer which was created in
1108 * vb_exec_vtx_init() below.
1111 vbo_use_buffer_objects(struct gl_context
*ctx
)
1113 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1114 /* Any buffer name but 0 can be used here since this bufferobj won't
1115 * go into the bufferobj hashtable.
1117 GLuint bufName
= IMM_BUFFER_NAME
;
1118 GLenum target
= GL_ARRAY_BUFFER_ARB
;
1119 GLenum usage
= GL_STREAM_DRAW_ARB
;
1120 GLsizei size
= VBO_VERT_BUFFER_SIZE
;
1122 /* Make sure this func is only used once */
1123 assert(exec
->vtx
.bufferobj
== ctx
->Shared
->NullBufferObj
);
1125 _mesa_align_free(exec
->vtx
.buffer_map
);
1126 exec
->vtx
.buffer_map
= NULL
;
1127 exec
->vtx
.buffer_ptr
= NULL
;
1129 /* Allocate a real buffer object now */
1130 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1131 exec
->vtx
.bufferobj
= ctx
->Driver
.NewBufferObject(ctx
, bufName
);
1132 if (!ctx
->Driver
.BufferData(ctx
, target
, size
, NULL
, usage
,
1134 GL_DYNAMIC_STORAGE_BIT
|
1135 GL_CLIENT_STORAGE_BIT
,
1136 exec
->vtx
.bufferobj
)) {
1137 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "VBO allocation");
1143 * If this function is called, all VBO buffers will be unmapped when
1145 * Otherwise, if a simple command like glColor3f() is called and we flush,
1146 * the current VBO may be left mapped.
1149 vbo_always_unmap_buffers(struct gl_context
*ctx
)
1151 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1152 exec
->begin_vertices_flags
|= FLUSH_STORED_VERTICES
;
1157 vbo_exec_vtx_init(struct vbo_exec_context
*exec
)
1159 struct gl_context
*ctx
= exec
->ctx
;
1160 struct vbo_context
*vbo
= vbo_context(ctx
);
1163 /* Allocate a buffer object. Will just reuse this object
1164 * continuously, unless vbo_use_buffer_objects() is called to enable
1167 _mesa_reference_buffer_object(ctx
,
1168 &exec
->vtx
.bufferobj
,
1169 ctx
->Shared
->NullBufferObj
);
1171 assert(!exec
->vtx
.buffer_map
);
1172 exec
->vtx
.buffer_map
= _mesa_align_malloc(VBO_VERT_BUFFER_SIZE
, 64);
1173 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
1175 vbo_exec_vtxfmt_init( exec
);
1176 _mesa_noop_vtxfmt_init(&exec
->vtxfmt_noop
);
1178 exec
->vtx
.enabled
= 0;
1179 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1180 assert(i
< ARRAY_SIZE(exec
->vtx
.attrsz
));
1181 exec
->vtx
.attrsz
[i
] = 0;
1182 assert(i
< ARRAY_SIZE(exec
->vtx
.attrtype
));
1183 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1184 assert(i
< ARRAY_SIZE(exec
->vtx
.active_sz
));
1185 exec
->vtx
.active_sz
[i
] = 0;
1187 for (i
= 0 ; i
< VERT_ATTRIB_MAX
; i
++) {
1188 assert(i
< ARRAY_SIZE(exec
->vtx
.inputs
));
1189 assert(i
< ARRAY_SIZE(exec
->vtx
.arrays
));
1190 exec
->vtx
.inputs
[i
] = &exec
->vtx
.arrays
[i
];
1194 struct gl_vertex_array
*arrays
= exec
->vtx
.arrays
;
1197 memcpy(arrays
, &vbo
->currval
[VBO_ATTRIB_POS
],
1198 VERT_ATTRIB_FF_MAX
* sizeof(arrays
[0]));
1199 for (i
= 0; i
< VERT_ATTRIB_FF_MAX
; ++i
) {
1200 struct gl_vertex_array
*array
;
1201 array
= &arrays
[VERT_ATTRIB_FF(i
)];
1202 array
->BufferObj
= NULL
;
1203 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1204 vbo
->currval
[VBO_ATTRIB_POS
+i
].BufferObj
);
1207 memcpy(arrays
+ VERT_ATTRIB_GENERIC(0),
1208 &vbo
->currval
[VBO_ATTRIB_GENERIC0
],
1209 VERT_ATTRIB_GENERIC_MAX
* sizeof(arrays
[0]));
1211 for (i
= 0; i
< VERT_ATTRIB_GENERIC_MAX
; ++i
) {
1212 struct gl_vertex_array
*array
;
1213 array
= &arrays
[VERT_ATTRIB_GENERIC(i
)];
1214 array
->BufferObj
= NULL
;
1215 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1216 vbo
->currval
[VBO_ATTRIB_GENERIC0
+i
].BufferObj
);
1220 exec
->vtx
.vertex_size
= 0;
1222 exec
->begin_vertices_flags
= FLUSH_UPDATE_CURRENT
;
1227 vbo_exec_vtx_destroy(struct vbo_exec_context
*exec
)
1229 /* using a real VBO for vertex data */
1230 struct gl_context
*ctx
= exec
->ctx
;
1233 /* True VBOs should already be unmapped
1235 if (exec
->vtx
.buffer_map
) {
1236 assert(exec
->vtx
.bufferobj
->Name
== 0 ||
1237 exec
->vtx
.bufferobj
->Name
== IMM_BUFFER_NAME
);
1238 if (exec
->vtx
.bufferobj
->Name
== 0) {
1239 _mesa_align_free(exec
->vtx
.buffer_map
);
1240 exec
->vtx
.buffer_map
= NULL
;
1241 exec
->vtx
.buffer_ptr
= NULL
;
1245 /* Drop any outstanding reference to the vertex buffer
1247 for (i
= 0; i
< ARRAY_SIZE(exec
->vtx
.arrays
); i
++) {
1248 _mesa_reference_buffer_object(ctx
,
1249 &exec
->vtx
.arrays
[i
].BufferObj
,
1253 /* Free the vertex buffer. Unmap first if needed.
1255 if (_mesa_bufferobj_mapped(exec
->vtx
.bufferobj
, MAP_INTERNAL
)) {
1256 ctx
->Driver
.UnmapBuffer(ctx
, exec
->vtx
.bufferobj
, MAP_INTERNAL
);
1258 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1263 * If inside glBegin()/glEnd(), it should assert(0). Otherwise, if
1264 * FLUSH_STORED_VERTICES bit in \p flags is set flushes any buffered
1265 * vertices, if FLUSH_UPDATE_CURRENT bit is set updates
1266 * __struct gl_contextRec::Current and gl_light_attrib::Material
1268 * Note that the default T&L engine never clears the
1269 * FLUSH_UPDATE_CURRENT bit, even after performing the update.
1271 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1274 vbo_exec_FlushVertices(struct gl_context
*ctx
, GLuint flags
)
1276 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1279 /* debug check: make sure we don't get called recursively */
1280 exec
->flush_call_depth
++;
1281 assert(exec
->flush_call_depth
== 1);
1284 if (_mesa_inside_begin_end(ctx
)) {
1285 /* We've had glBegin but not glEnd! */
1287 exec
->flush_call_depth
--;
1288 assert(exec
->flush_call_depth
== 0);
1293 /* Flush (draw), and make sure VBO is left unmapped when done */
1294 vbo_exec_FlushVertices_internal(exec
, GL_TRUE
);
1296 /* Need to do this to ensure vbo_exec_begin_vertices gets called again:
1298 ctx
->Driver
.NeedFlush
&= ~(FLUSH_UPDATE_CURRENT
| flags
);
1301 exec
->flush_call_depth
--;
1302 assert(exec
->flush_call_depth
== 0);
1308 * Reset the vertex attribute by setting its size to zero.
1311 vbo_reset_attr(struct vbo_exec_context
*exec
, GLuint attr
)
1313 exec
->vtx
.attrsz
[attr
] = 0;
1314 exec
->vtx
.attrtype
[attr
] = GL_FLOAT
;
1315 exec
->vtx
.active_sz
[attr
] = 0;
1320 vbo_reset_all_attr(struct vbo_exec_context
*exec
)
1322 while (exec
->vtx
.enabled
) {
1323 const int i
= u_bit_scan64(&exec
->vtx
.enabled
);
1324 vbo_reset_attr(exec
, i
);
1327 exec
->vtx
.vertex_size
= 0;
1332 _es_Color4f(GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
1334 vbo_Color4f(r
, g
, b
, a
);
1339 _es_Normal3f(GLfloat x
, GLfloat y
, GLfloat z
)
1341 vbo_Normal3f(x
, y
, z
);
1346 _es_MultiTexCoord4f(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1348 vbo_MultiTexCoord4f(target
, s
, t
, r
, q
);
1353 _es_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
1355 vbo_Materialfv(face
, pname
, params
);
1360 _es_Materialf(GLenum face
, GLenum pname
, GLfloat param
)
1364 p
[1] = p
[2] = p
[3] = 0.0F
;
1365 vbo_Materialfv(face
, pname
, p
);
1370 * A special version of glVertexAttrib4f that does not treat index 0 as
1374 VertexAttrib4f_nopos(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1376 GET_CURRENT_CONTEXT(ctx
);
1377 if (index
< MAX_VERTEX_GENERIC_ATTRIBS
)
1378 ATTRF(VBO_ATTRIB_GENERIC0
+ index
, 4, x
, y
, z
, w
);
1380 ERROR(GL_INVALID_VALUE
);
1384 _es_VertexAttrib4f(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1386 VertexAttrib4f_nopos(index
, x
, y
, z
, w
);
1391 _es_VertexAttrib1f(GLuint indx
, GLfloat x
)
1393 VertexAttrib4f_nopos(indx
, x
, 0.0f
, 0.0f
, 1.0f
);
1398 _es_VertexAttrib1fv(GLuint indx
, const GLfloat
* values
)
1400 VertexAttrib4f_nopos(indx
, values
[0], 0.0f
, 0.0f
, 1.0f
);
1405 _es_VertexAttrib2f(GLuint indx
, GLfloat x
, GLfloat y
)
1407 VertexAttrib4f_nopos(indx
, x
, y
, 0.0f
, 1.0f
);
1412 _es_VertexAttrib2fv(GLuint indx
, const GLfloat
* values
)
1414 VertexAttrib4f_nopos(indx
, values
[0], values
[1], 0.0f
, 1.0f
);
1419 _es_VertexAttrib3f(GLuint indx
, GLfloat x
, GLfloat y
, GLfloat z
)
1421 VertexAttrib4f_nopos(indx
, x
, y
, z
, 1.0f
);
1426 _es_VertexAttrib3fv(GLuint indx
, const GLfloat
* values
)
1428 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], 1.0f
);
1433 _es_VertexAttrib4fv(GLuint indx
, const GLfloat
* values
)
1435 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], values
[3]);