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"
56 /** ID/name for immediate-mode VBO */
57 #define IMM_BUFFER_NAME 0xaabbccdd
60 static void reset_attrfv( struct vbo_exec_context
*exec
);
64 * Close off the last primitive, execute the buffer, restart the
65 * primitive. This is called when we fill a vertex buffer before
68 static void vbo_exec_wrap_buffers( struct vbo_exec_context
*exec
)
70 if (exec
->vtx
.prim_count
== 0) {
71 exec
->vtx
.copied
.nr
= 0;
72 exec
->vtx
.vert_count
= 0;
73 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
76 struct _mesa_prim
*last_prim
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
77 const GLuint last_begin
= last_prim
->begin
;
80 if (_mesa_inside_begin_end(exec
->ctx
)) {
81 last_prim
->count
= exec
->vtx
.vert_count
- last_prim
->start
;
84 last_count
= last_prim
->count
;
86 /* Special handling for wrapping GL_LINE_LOOP */
87 if (last_prim
->mode
== GL_LINE_LOOP
&&
90 /* draw this section of the incomplete line loop as a line strip */
91 last_prim
->mode
= GL_LINE_STRIP
;
92 if (!last_prim
->begin
) {
93 /* This is not the first section of the line loop, so don't
94 * draw the 0th vertex. We're saving it until we draw the
95 * very last section of the loop.
102 /* Execute the buffer and save copied vertices.
104 if (exec
->vtx
.vert_count
)
105 vbo_exec_vtx_flush( exec
, GL_FALSE
);
107 exec
->vtx
.prim_count
= 0;
108 exec
->vtx
.copied
.nr
= 0;
111 /* Emit a glBegin to start the new list.
113 assert(exec
->vtx
.prim_count
== 0);
115 if (_mesa_inside_begin_end(exec
->ctx
)) {
116 exec
->vtx
.prim
[0].mode
= exec
->ctx
->Driver
.CurrentExecPrimitive
;
117 exec
->vtx
.prim
[0].begin
= 0;
118 exec
->vtx
.prim
[0].end
= 0;
119 exec
->vtx
.prim
[0].start
= 0;
120 exec
->vtx
.prim
[0].count
= 0;
121 exec
->vtx
.prim_count
++;
123 if (exec
->vtx
.copied
.nr
== last_count
)
124 exec
->vtx
.prim
[0].begin
= last_begin
;
131 * Deal with buffer wrapping where provoked by the vertex buffer
132 * filling up, as opposed to upgrade_vertex().
135 vbo_exec_vtx_wrap(struct vbo_exec_context
*exec
)
137 unsigned numComponents
;
139 /* Run pipeline on current vertices, copy wrapped vertices
140 * to exec->vtx.copied.
142 vbo_exec_wrap_buffers( exec
);
144 if (!exec
->vtx
.buffer_ptr
) {
145 /* probably ran out of memory earlier when allocating the VBO */
149 /* Copy stored stored vertices to start of new list.
151 assert(exec
->vtx
.max_vert
- exec
->vtx
.vert_count
> exec
->vtx
.copied
.nr
);
153 numComponents
= exec
->vtx
.copied
.nr
* exec
->vtx
.vertex_size
;
154 memcpy(exec
->vtx
.buffer_ptr
,
155 exec
->vtx
.copied
.buffer
,
156 numComponents
* sizeof(fi_type
));
157 exec
->vtx
.buffer_ptr
+= numComponents
;
158 exec
->vtx
.vert_count
+= exec
->vtx
.copied
.nr
;
160 exec
->vtx
.copied
.nr
= 0;
165 * Copy the active vertex's values to the ctx->Current fields.
167 static void vbo_exec_copy_to_current( struct vbo_exec_context
*exec
)
169 struct gl_context
*ctx
= exec
->ctx
;
170 struct vbo_context
*vbo
= vbo_context(ctx
);
171 GLbitfield64 enabled
= exec
->vtx
.enabled
& (~BITFIELD64_BIT(VBO_ATTRIB_POS
));
174 const int i
= u_bit_scan64(&enabled
);
176 /* Note: the exec->vtx.current[i] pointers point into the
177 * ctx->Current.Attrib and ctx->Light.Material.Attrib arrays.
179 GLfloat
*current
= (GLfloat
*)vbo
->currval
[i
].Ptr
;
180 fi_type tmp
[8]; /* space for doubles */
181 int dmul
= exec
->vtx
.attrtype
[i
] == GL_DOUBLE
? 2 : 1;
183 assert(exec
->vtx
.attrsz
[i
]);
185 if (exec
->vtx
.attrtype
[i
] == GL_DOUBLE
) {
186 memset(tmp
, 0, sizeof(tmp
));
187 memcpy(tmp
, exec
->vtx
.attrptr
[i
], exec
->vtx
.attrsz
[i
] * sizeof(GLfloat
));
189 COPY_CLEAN_4V_TYPE_AS_UNION(tmp
,
191 exec
->vtx
.attrptr
[i
],
192 exec
->vtx
.attrtype
[i
]);
195 if (exec
->vtx
.attrtype
[i
] != vbo
->currval
[i
].Type
||
196 memcmp(current
, tmp
, 4 * sizeof(GLfloat
) * dmul
) != 0) {
197 memcpy(current
, tmp
, 4 * sizeof(GLfloat
) * dmul
);
199 /* Given that we explicitly state size here, there is no need
200 * for the COPY_CLEAN above, could just copy 16 bytes and be
201 * done. The only problem is when Mesa accesses ctx->Current
204 /* Size here is in components - not bytes */
205 vbo
->currval
[i
].Size
= exec
->vtx
.attrsz
[i
] / dmul
;
206 vbo
->currval
[i
]._ElementSize
= vbo
->currval
[i
].Size
* sizeof(GLfloat
) * dmul
;
207 vbo
->currval
[i
].Type
= exec
->vtx
.attrtype
[i
];
208 vbo
->currval
[i
].Integer
=
209 vbo_attrtype_to_integer_flag(exec
->vtx
.attrtype
[i
]);
210 vbo
->currval
[i
].Doubles
=
211 vbo_attrtype_to_double_flag(exec
->vtx
.attrtype
[i
]);
213 /* This triggers rather too much recalculation of Mesa state
214 * that doesn't get used (eg light positions).
216 if (i
>= VBO_ATTRIB_MAT_FRONT_AMBIENT
&&
217 i
<= VBO_ATTRIB_MAT_BACK_INDEXES
)
218 ctx
->NewState
|= _NEW_LIGHT
;
220 ctx
->NewState
|= _NEW_CURRENT_ATTRIB
;
224 /* Colormaterial -- this kindof sucks.
226 if (ctx
->Light
.ColorMaterialEnabled
&&
227 exec
->vtx
.attrsz
[VBO_ATTRIB_COLOR0
]) {
228 _mesa_update_color_material(ctx
,
229 ctx
->Current
.Attrib
[VBO_ATTRIB_COLOR0
]);
235 * Copy current vertex attribute values into the current vertex.
238 vbo_exec_copy_from_current(struct vbo_exec_context
*exec
)
240 struct gl_context
*ctx
= exec
->ctx
;
241 struct vbo_context
*vbo
= vbo_context(ctx
);
244 for (i
= VBO_ATTRIB_POS
+ 1; i
< VBO_ATTRIB_MAX
; i
++) {
245 if (exec
->vtx
.attrtype
[i
] == GL_DOUBLE
) {
246 memcpy(exec
->vtx
.attrptr
[i
], vbo
->currval
[i
].Ptr
, exec
->vtx
.attrsz
[i
] * sizeof(GLfloat
));
248 const fi_type
*current
= (fi_type
*) vbo
->currval
[i
].Ptr
;
249 switch (exec
->vtx
.attrsz
[i
]) {
250 case 4: exec
->vtx
.attrptr
[i
][3] = current
[3];
251 case 3: exec
->vtx
.attrptr
[i
][2] = current
[2];
252 case 2: exec
->vtx
.attrptr
[i
][1] = current
[1];
253 case 1: exec
->vtx
.attrptr
[i
][0] = current
[0];
262 * Flush existing data, set new attrib size, replay copied vertices.
263 * This is called when we transition from a small vertex attribute size
264 * to a larger one. Ex: glTexCoord2f -> glTexCoord4f.
265 * We need to go back over the previous 2-component texcoords and insert
266 * zero and one values.
269 vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context
*exec
,
270 GLuint attr
, GLuint newSize
)
272 struct gl_context
*ctx
= exec
->ctx
;
273 struct vbo_context
*vbo
= vbo_context(ctx
);
274 const GLint lastcount
= exec
->vtx
.vert_count
;
275 fi_type
*old_attrptr
[VBO_ATTRIB_MAX
];
276 const GLuint old_vtx_size
= exec
->vtx
.vertex_size
; /* floats per vertex */
277 const GLuint oldSize
= exec
->vtx
.attrsz
[attr
];
280 /* Run pipeline on current vertices, copy wrapped vertices
281 * to exec->vtx.copied.
283 vbo_exec_wrap_buffers( exec
);
285 if (unlikely(exec
->vtx
.copied
.nr
)) {
286 /* We're in the middle of a primitive, keep the old vertex
287 * format around to be able to translate the copied vertices to
290 memcpy(old_attrptr
, exec
->vtx
.attrptr
, sizeof(old_attrptr
));
293 if (unlikely(oldSize
)) {
294 /* Do a COPY_TO_CURRENT to ensure back-copying works for the
295 * case when the attribute already exists in the vertex and is
296 * having its size increased.
298 vbo_exec_copy_to_current( exec
);
301 /* Heuristic: Attempt to isolate attributes received outside
302 * begin/end so that they don't bloat the vertices.
304 if (!_mesa_inside_begin_end(ctx
) &&
305 !oldSize
&& lastcount
> 8 && exec
->vtx
.vertex_size
) {
306 vbo_exec_copy_to_current( exec
);
307 reset_attrfv( exec
);
312 exec
->vtx
.attrsz
[attr
] = newSize
;
313 exec
->vtx
.vertex_size
+= newSize
- oldSize
;
314 exec
->vtx
.max_vert
= vbo_compute_max_verts(exec
);
315 exec
->vtx
.vert_count
= 0;
316 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
317 exec
->vtx
.enabled
|= BITFIELD64_BIT(attr
);
319 if (unlikely(oldSize
)) {
320 /* Size changed, recalculate all the attrptr[] values
322 fi_type
*tmp
= exec
->vtx
.vertex
;
324 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
325 if (exec
->vtx
.attrsz
[i
]) {
326 exec
->vtx
.attrptr
[i
] = tmp
;
327 tmp
+= exec
->vtx
.attrsz
[i
];
330 exec
->vtx
.attrptr
[i
] = NULL
; /* will not be dereferenced */
333 /* Copy from current to repopulate the vertex with correct
336 vbo_exec_copy_from_current( exec
);
339 /* Just have to append the new attribute at the end */
340 exec
->vtx
.attrptr
[attr
] = exec
->vtx
.vertex
+
341 exec
->vtx
.vertex_size
- newSize
;
344 /* Replay stored vertices to translate them
345 * to new format here.
347 * -- No need to replay - just copy piecewise
349 if (unlikely(exec
->vtx
.copied
.nr
)) {
350 fi_type
*data
= exec
->vtx
.copied
.buffer
;
351 fi_type
*dest
= exec
->vtx
.buffer_ptr
;
353 assert(exec
->vtx
.buffer_ptr
== exec
->vtx
.buffer_map
);
355 for (i
= 0 ; i
< exec
->vtx
.copied
.nr
; i
++) {
356 GLbitfield64 enabled
= exec
->vtx
.enabled
;
358 const int j
= u_bit_scan64(&enabled
);
359 GLuint sz
= exec
->vtx
.attrsz
[j
];
360 GLint old_offset
= old_attrptr
[j
] - exec
->vtx
.vertex
;
361 GLint new_offset
= exec
->vtx
.attrptr
[j
] - exec
->vtx
.vertex
;
368 COPY_CLEAN_4V_TYPE_AS_UNION(tmp
, oldSize
,
370 exec
->vtx
.attrtype
[j
]);
371 COPY_SZ_4V(dest
+ new_offset
, newSize
, tmp
);
373 fi_type
*current
= (fi_type
*)vbo
->currval
[j
].Ptr
;
374 COPY_SZ_4V(dest
+ new_offset
, sz
, current
);
378 COPY_SZ_4V(dest
+ new_offset
, sz
, data
+ old_offset
);
382 data
+= old_vtx_size
;
383 dest
+= exec
->vtx
.vertex_size
;
386 exec
->vtx
.buffer_ptr
= dest
;
387 exec
->vtx
.vert_count
+= exec
->vtx
.copied
.nr
;
388 exec
->vtx
.copied
.nr
= 0;
394 * This is when a vertex attribute transitions to a different size.
395 * For example, we saw a bunch of glTexCoord2f() calls and now we got a
396 * glTexCoord4f() call. We promote the array from size=2 to size=4.
397 * \param newSize size of new vertex (number of 32-bit words).
400 vbo_exec_fixup_vertex(struct gl_context
*ctx
, GLuint attr
,
401 GLuint newSize
, GLenum newType
)
403 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
405 if (newSize
> exec
->vtx
.attrsz
[attr
] ||
406 newType
!= exec
->vtx
.attrtype
[attr
]) {
407 /* New size is larger. Need to flush existing vertices and get
408 * an enlarged vertex format.
410 vbo_exec_wrap_upgrade_vertex( exec
, attr
, newSize
);
412 else if (newSize
< exec
->vtx
.active_sz
[attr
]) {
415 vbo_get_default_vals_as_union(exec
->vtx
.attrtype
[attr
]);
417 /* New size is smaller - just need to fill in some
418 * zeros. Don't need to flush or wrap.
420 for (i
= newSize
; i
<= exec
->vtx
.attrsz
[attr
]; i
++)
421 exec
->vtx
.attrptr
[attr
][i
-1] = id
[i
-1];
424 exec
->vtx
.active_sz
[attr
] = newSize
;
426 /* Does setting NeedFlush belong here? Necessitates resetting
427 * vtxfmt on each flush (otherwise flags won't get reset
431 ctx
->Driver
.NeedFlush
|= FLUSH_STORED_VERTICES
;
436 * Called upon first glVertex, glColor, glTexCoord, etc.
439 vbo_exec_begin_vertices(struct gl_context
*ctx
)
441 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
443 vbo_exec_vtx_map( exec
);
445 assert((ctx
->Driver
.NeedFlush
& FLUSH_UPDATE_CURRENT
) == 0);
446 assert(exec
->begin_vertices_flags
);
448 ctx
->Driver
.NeedFlush
|= exec
->begin_vertices_flags
;
453 * This macro is used to implement all the glVertex, glColor, glTexCoord,
454 * glVertexAttrib, etc functions.
455 * \param A attribute index
456 * \param N attribute size (1..4)
457 * \param T type (GL_FLOAT, GL_DOUBLE, GL_INT, GL_UNSIGNED_INT)
458 * \param C cast type (fi_type or double)
459 * \param V0, V1, v2, V3 attribute value
461 #define ATTR_UNION( A, N, T, C, V0, V1, V2, V3 ) \
463 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
464 int sz = (sizeof(C) / sizeof(GLfloat)); \
466 assert(sz == 1 || sz == 2); \
468 /* check if attribute size or type is changing */ \
469 if (unlikely(exec->vtx.active_sz[A] != N * sz) || \
470 unlikely(exec->vtx.attrtype[A] != T)) { \
471 vbo_exec_fixup_vertex(ctx, A, N * sz, T); \
474 /* store vertex attribute in vertex buffer */ \
476 C *dest = (C *)exec->vtx.attrptr[A]; \
477 if (N>0) dest[0] = V0; \
478 if (N>1) dest[1] = V1; \
479 if (N>2) dest[2] = V2; \
480 if (N>3) dest[3] = V3; \
481 exec->vtx.attrtype[A] = T; \
485 /* This is a glVertex call */ \
488 if (unlikely((ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) == 0)) { \
489 vbo_exec_begin_vertices(ctx); \
492 if (unlikely(!exec->vtx.buffer_ptr)) { \
493 vbo_exec_vtx_map(exec); \
495 assert(exec->vtx.buffer_ptr); \
497 /* copy 32-bit words */ \
498 for (i = 0; i < exec->vtx.vertex_size; i++) \
499 exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i]; \
501 exec->vtx.buffer_ptr += exec->vtx.vertex_size; \
503 /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \
504 /* something to draw (not just updating a color or texcoord).*/ \
505 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \
507 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
508 vbo_exec_vtx_wrap( exec ); \
510 /* we now have accumulated per-vertex attributes */ \
511 ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; \
515 #define ERROR(err) _mesa_error( ctx, err, __func__ )
516 #define TAG(x) vbo_##x
518 #include "vbo_attrib_tmp.h"
523 * Execute a glMaterial call. Note that if GL_COLOR_MATERIAL is enabled,
524 * this may be a (partial) no-op.
526 static void GLAPIENTRY
527 vbo_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
529 GLbitfield updateMats
;
530 GET_CURRENT_CONTEXT(ctx
);
532 /* This function should be a no-op when it tries to update material
533 * attributes which are currently tracking glColor via glColorMaterial.
534 * The updateMats var will be a mask of the MAT_BIT_FRONT/BACK_x bits
535 * indicating which material attributes can actually be updated below.
537 if (ctx
->Light
.ColorMaterialEnabled
) {
538 updateMats
= ~ctx
->Light
._ColorMaterialBitmask
;
541 /* GL_COLOR_MATERIAL is disabled so don't skip any material updates */
542 updateMats
= ALL_MATERIAL_BITS
;
545 if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_FRONT
) {
546 updateMats
&= FRONT_MATERIAL_BITS
;
548 else if (ctx
->API
== API_OPENGL_COMPAT
&& face
== GL_BACK
) {
549 updateMats
&= BACK_MATERIAL_BITS
;
551 else if (face
!= GL_FRONT_AND_BACK
) {
552 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterial(invalid face)");
558 if (updateMats
& MAT_BIT_FRONT_EMISSION
)
559 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_EMISSION
, 4, params
);
560 if (updateMats
& MAT_BIT_BACK_EMISSION
)
561 MAT_ATTR(VBO_ATTRIB_MAT_BACK_EMISSION
, 4, params
);
564 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
565 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
566 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
567 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
570 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
571 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
572 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
573 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
576 if (updateMats
& MAT_BIT_FRONT_SPECULAR
)
577 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SPECULAR
, 4, params
);
578 if (updateMats
& MAT_BIT_BACK_SPECULAR
)
579 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SPECULAR
, 4, params
);
582 if (*params
< 0 || *params
> ctx
->Const
.MaxShininess
) {
583 _mesa_error(ctx
, GL_INVALID_VALUE
,
584 "glMaterial(invalid shininess: %f out range [0, %f])",
585 *params
, ctx
->Const
.MaxShininess
);
588 if (updateMats
& MAT_BIT_FRONT_SHININESS
)
589 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SHININESS
, 1, params
);
590 if (updateMats
& MAT_BIT_BACK_SHININESS
)
591 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SHININESS
, 1, params
);
593 case GL_COLOR_INDEXES
:
594 if (ctx
->API
!= API_OPENGL_COMPAT
) {
595 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
598 if (updateMats
& MAT_BIT_FRONT_INDEXES
)
599 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_INDEXES
, 3, params
);
600 if (updateMats
& MAT_BIT_BACK_INDEXES
)
601 MAT_ATTR(VBO_ATTRIB_MAT_BACK_INDEXES
, 3, params
);
603 case GL_AMBIENT_AND_DIFFUSE
:
604 if (updateMats
& MAT_BIT_FRONT_AMBIENT
)
605 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT
, 4, params
);
606 if (updateMats
& MAT_BIT_FRONT_DIFFUSE
)
607 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE
, 4, params
);
608 if (updateMats
& MAT_BIT_BACK_AMBIENT
)
609 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT
, 4, params
);
610 if (updateMats
& MAT_BIT_BACK_DIFFUSE
)
611 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE
, 4, params
);
614 _mesa_error(ctx
, GL_INVALID_ENUM
, "glMaterialfv(pname)");
621 * Flush (draw) vertices.
622 * \param unmap - leave VBO unmapped after flushing?
625 vbo_exec_FlushVertices_internal(struct vbo_exec_context
*exec
, GLboolean unmap
)
627 if (exec
->vtx
.vert_count
|| unmap
) {
628 vbo_exec_vtx_flush( exec
, unmap
);
631 if (exec
->vtx
.vertex_size
) {
632 vbo_exec_copy_to_current( exec
);
633 reset_attrfv( exec
);
638 static void GLAPIENTRY
vbo_exec_EvalCoord1f( GLfloat u
)
640 GET_CURRENT_CONTEXT( ctx
);
641 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
645 if (exec
->eval
.recalculate_maps
)
646 vbo_exec_eval_update( exec
);
648 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
649 if (exec
->eval
.map1
[i
].map
)
650 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map1
[i
].sz
)
651 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map1
[i
].sz
, GL_FLOAT
);
656 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
657 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
659 vbo_exec_do_EvalCoord1f( exec
, u
);
661 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
662 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
665 static void GLAPIENTRY
vbo_exec_EvalCoord2f( GLfloat u
, GLfloat v
)
667 GET_CURRENT_CONTEXT( ctx
);
668 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
672 if (exec
->eval
.recalculate_maps
)
673 vbo_exec_eval_update( exec
);
675 for (i
= 0; i
<= VBO_ATTRIB_TEX7
; i
++) {
676 if (exec
->eval
.map2
[i
].map
)
677 if (exec
->vtx
.active_sz
[i
] != exec
->eval
.map2
[i
].sz
)
678 vbo_exec_fixup_vertex( ctx
, i
, exec
->eval
.map2
[i
].sz
, GL_FLOAT
);
681 if (ctx
->Eval
.AutoNormal
)
682 if (exec
->vtx
.active_sz
[VBO_ATTRIB_NORMAL
] != 3)
683 vbo_exec_fixup_vertex( ctx
, VBO_ATTRIB_NORMAL
, 3, GL_FLOAT
);
686 memcpy( exec
->vtx
.copied
.buffer
, exec
->vtx
.vertex
,
687 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
689 vbo_exec_do_EvalCoord2f( exec
, u
, v
);
691 memcpy( exec
->vtx
.vertex
, exec
->vtx
.copied
.buffer
,
692 exec
->vtx
.vertex_size
* sizeof(GLfloat
));
695 static void GLAPIENTRY
vbo_exec_EvalCoord1fv( const GLfloat
*u
)
697 vbo_exec_EvalCoord1f( u
[0] );
700 static void GLAPIENTRY
vbo_exec_EvalCoord2fv( const GLfloat
*u
)
702 vbo_exec_EvalCoord2f( u
[0], u
[1] );
705 static void GLAPIENTRY
vbo_exec_EvalPoint1( GLint i
)
707 GET_CURRENT_CONTEXT( ctx
);
708 GLfloat du
= ((ctx
->Eval
.MapGrid1u2
- ctx
->Eval
.MapGrid1u1
) /
709 (GLfloat
) ctx
->Eval
.MapGrid1un
);
710 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid1u1
;
712 vbo_exec_EvalCoord1f( u
);
716 static void GLAPIENTRY
vbo_exec_EvalPoint2( GLint i
, GLint j
)
718 GET_CURRENT_CONTEXT( ctx
);
719 GLfloat du
= ((ctx
->Eval
.MapGrid2u2
- ctx
->Eval
.MapGrid2u1
) /
720 (GLfloat
) ctx
->Eval
.MapGrid2un
);
721 GLfloat dv
= ((ctx
->Eval
.MapGrid2v2
- ctx
->Eval
.MapGrid2v1
) /
722 (GLfloat
) ctx
->Eval
.MapGrid2vn
);
723 GLfloat u
= i
* du
+ ctx
->Eval
.MapGrid2u1
;
724 GLfloat v
= j
* dv
+ ctx
->Eval
.MapGrid2v1
;
726 vbo_exec_EvalCoord2f( u
, v
);
731 * Called via glBegin.
733 static void GLAPIENTRY
vbo_exec_Begin( GLenum mode
)
735 GET_CURRENT_CONTEXT( ctx
);
736 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
739 if (_mesa_inside_begin_end(ctx
)) {
740 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glBegin");
744 if (!_mesa_valid_prim_mode(ctx
, mode
, "glBegin")) {
748 vbo_draw_method(vbo_context(ctx
), DRAW_BEGIN_END
);
751 _mesa_update_state( ctx
);
753 CALL_Begin(ctx
->Exec
, (mode
));
757 if (!_mesa_valid_to_render(ctx
, "glBegin")) {
761 /* Heuristic: attempt to isolate attributes occurring outside
764 if (exec
->vtx
.vertex_size
&& !exec
->vtx
.attrsz
[0])
765 vbo_exec_FlushVertices_internal(exec
, GL_FALSE
);
767 i
= exec
->vtx
.prim_count
++;
768 exec
->vtx
.prim
[i
].mode
= mode
;
769 exec
->vtx
.prim
[i
].begin
= 1;
770 exec
->vtx
.prim
[i
].end
= 0;
771 exec
->vtx
.prim
[i
].indexed
= 0;
772 exec
->vtx
.prim
[i
].weak
= 0;
773 exec
->vtx
.prim
[i
].pad
= 0;
774 exec
->vtx
.prim
[i
].start
= exec
->vtx
.vert_count
;
775 exec
->vtx
.prim
[i
].count
= 0;
776 exec
->vtx
.prim
[i
].num_instances
= 1;
777 exec
->vtx
.prim
[i
].base_instance
= 0;
778 exec
->vtx
.prim
[i
].is_indirect
= 0;
780 ctx
->Driver
.CurrentExecPrimitive
= mode
;
782 ctx
->Exec
= ctx
->BeginEnd
;
783 /* We may have been called from a display list, in which case we should
784 * leave dlist.c's dispatch table in place.
786 if (ctx
->CurrentDispatch
== ctx
->OutsideBeginEnd
) {
787 ctx
->CurrentDispatch
= ctx
->BeginEnd
;
788 _glapi_set_dispatch(ctx
->CurrentDispatch
);
790 assert(ctx
->CurrentDispatch
== ctx
->Save
);
796 * Try to merge / concatenate the two most recent VBO primitives.
799 try_vbo_merge(struct vbo_exec_context
*exec
)
801 struct _mesa_prim
*cur
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
803 assert(exec
->vtx
.prim_count
>= 1);
805 vbo_try_prim_conversion(cur
);
807 if (exec
->vtx
.prim_count
>= 2) {
808 struct _mesa_prim
*prev
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 2];
809 assert(prev
== cur
- 1);
811 if (vbo_can_merge_prims(prev
, cur
)) {
816 vbo_merge_prims(prev
, cur
);
817 exec
->vtx
.prim_count
--; /* drop the last primitive */
826 static void GLAPIENTRY
vbo_exec_End( void )
828 GET_CURRENT_CONTEXT( ctx
);
829 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
831 if (!_mesa_inside_begin_end(ctx
)) {
832 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glEnd");
836 ctx
->Exec
= ctx
->OutsideBeginEnd
;
837 if (ctx
->CurrentDispatch
== ctx
->BeginEnd
) {
838 ctx
->CurrentDispatch
= ctx
->OutsideBeginEnd
;
839 _glapi_set_dispatch(ctx
->CurrentDispatch
);
842 if (exec
->vtx
.prim_count
> 0) {
843 /* close off current primitive */
844 struct _mesa_prim
*last_prim
= &exec
->vtx
.prim
[exec
->vtx
.prim_count
- 1];
847 last_prim
->count
= exec
->vtx
.vert_count
- last_prim
->start
;
849 /* Special handling for GL_LINE_LOOP */
850 if (last_prim
->mode
== GL_LINE_LOOP
&& last_prim
->begin
== 0) {
851 /* We're finishing drawing a line loop. Append 0th vertex onto
852 * end of vertex buffer so we can draw it as a line strip.
854 const fi_type
*src
= exec
->vtx
.buffer_map
+
855 last_prim
->start
* exec
->vtx
.vertex_size
;
856 fi_type
*dst
= exec
->vtx
.buffer_map
+
857 exec
->vtx
.vert_count
* exec
->vtx
.vertex_size
;
859 /* copy 0th vertex to end of buffer */
860 memcpy(dst
, src
, exec
->vtx
.vertex_size
* sizeof(fi_type
));
862 last_prim
->start
++; /* skip vertex0 */
863 /* note that last_prim->count stays unchanged */
864 last_prim
->mode
= GL_LINE_STRIP
;
866 /* Increment the vertex count so the next primitive doesn't
867 * overwrite the last vertex which we just added.
869 exec
->vtx
.vert_count
++;
870 exec
->vtx
.buffer_ptr
+= exec
->vtx
.vertex_size
;
876 ctx
->Driver
.CurrentExecPrimitive
= PRIM_OUTSIDE_BEGIN_END
;
878 if (exec
->vtx
.prim_count
== VBO_MAX_PRIM
)
879 vbo_exec_vtx_flush( exec
, GL_FALSE
);
881 if (MESA_DEBUG_FLAGS
& DEBUG_ALWAYS_FLUSH
) {
888 * Called via glPrimitiveRestartNV()
890 static void GLAPIENTRY
891 vbo_exec_PrimitiveRestartNV(void)
894 GET_CURRENT_CONTEXT( ctx
);
896 curPrim
= ctx
->Driver
.CurrentExecPrimitive
;
898 if (curPrim
== PRIM_OUTSIDE_BEGIN_END
) {
899 _mesa_error( ctx
, GL_INVALID_OPERATION
, "glPrimitiveRestartNV" );
903 vbo_exec_Begin(curPrim
);
909 static void vbo_exec_vtxfmt_init( struct vbo_exec_context
*exec
)
911 struct gl_context
*ctx
= exec
->ctx
;
912 GLvertexformat
*vfmt
= &exec
->vtxfmt
;
914 vfmt
->ArrayElement
= _ae_ArrayElement
;
916 vfmt
->Begin
= vbo_exec_Begin
;
917 vfmt
->End
= vbo_exec_End
;
918 vfmt
->PrimitiveRestartNV
= vbo_exec_PrimitiveRestartNV
;
920 vfmt
->CallList
= _mesa_CallList
;
921 vfmt
->CallLists
= _mesa_CallLists
;
923 vfmt
->EvalCoord1f
= vbo_exec_EvalCoord1f
;
924 vfmt
->EvalCoord1fv
= vbo_exec_EvalCoord1fv
;
925 vfmt
->EvalCoord2f
= vbo_exec_EvalCoord2f
;
926 vfmt
->EvalCoord2fv
= vbo_exec_EvalCoord2fv
;
927 vfmt
->EvalPoint1
= vbo_exec_EvalPoint1
;
928 vfmt
->EvalPoint2
= vbo_exec_EvalPoint2
;
930 /* from attrib_tmp.h:
932 vfmt
->Color3f
= vbo_Color3f
;
933 vfmt
->Color3fv
= vbo_Color3fv
;
934 vfmt
->Color4f
= vbo_Color4f
;
935 vfmt
->Color4fv
= vbo_Color4fv
;
936 vfmt
->FogCoordfEXT
= vbo_FogCoordfEXT
;
937 vfmt
->FogCoordfvEXT
= vbo_FogCoordfvEXT
;
938 vfmt
->MultiTexCoord1fARB
= vbo_MultiTexCoord1f
;
939 vfmt
->MultiTexCoord1fvARB
= vbo_MultiTexCoord1fv
;
940 vfmt
->MultiTexCoord2fARB
= vbo_MultiTexCoord2f
;
941 vfmt
->MultiTexCoord2fvARB
= vbo_MultiTexCoord2fv
;
942 vfmt
->MultiTexCoord3fARB
= vbo_MultiTexCoord3f
;
943 vfmt
->MultiTexCoord3fvARB
= vbo_MultiTexCoord3fv
;
944 vfmt
->MultiTexCoord4fARB
= vbo_MultiTexCoord4f
;
945 vfmt
->MultiTexCoord4fvARB
= vbo_MultiTexCoord4fv
;
946 vfmt
->Normal3f
= vbo_Normal3f
;
947 vfmt
->Normal3fv
= vbo_Normal3fv
;
948 vfmt
->SecondaryColor3fEXT
= vbo_SecondaryColor3fEXT
;
949 vfmt
->SecondaryColor3fvEXT
= vbo_SecondaryColor3fvEXT
;
950 vfmt
->TexCoord1f
= vbo_TexCoord1f
;
951 vfmt
->TexCoord1fv
= vbo_TexCoord1fv
;
952 vfmt
->TexCoord2f
= vbo_TexCoord2f
;
953 vfmt
->TexCoord2fv
= vbo_TexCoord2fv
;
954 vfmt
->TexCoord3f
= vbo_TexCoord3f
;
955 vfmt
->TexCoord3fv
= vbo_TexCoord3fv
;
956 vfmt
->TexCoord4f
= vbo_TexCoord4f
;
957 vfmt
->TexCoord4fv
= vbo_TexCoord4fv
;
958 vfmt
->Vertex2f
= vbo_Vertex2f
;
959 vfmt
->Vertex2fv
= vbo_Vertex2fv
;
960 vfmt
->Vertex3f
= vbo_Vertex3f
;
961 vfmt
->Vertex3fv
= vbo_Vertex3fv
;
962 vfmt
->Vertex4f
= vbo_Vertex4f
;
963 vfmt
->Vertex4fv
= vbo_Vertex4fv
;
965 if (ctx
->API
== API_OPENGLES2
) {
966 vfmt
->VertexAttrib1fARB
= _es_VertexAttrib1f
;
967 vfmt
->VertexAttrib1fvARB
= _es_VertexAttrib1fv
;
968 vfmt
->VertexAttrib2fARB
= _es_VertexAttrib2f
;
969 vfmt
->VertexAttrib2fvARB
= _es_VertexAttrib2fv
;
970 vfmt
->VertexAttrib3fARB
= _es_VertexAttrib3f
;
971 vfmt
->VertexAttrib3fvARB
= _es_VertexAttrib3fv
;
972 vfmt
->VertexAttrib4fARB
= _es_VertexAttrib4f
;
973 vfmt
->VertexAttrib4fvARB
= _es_VertexAttrib4fv
;
975 vfmt
->VertexAttrib1fARB
= vbo_VertexAttrib1fARB
;
976 vfmt
->VertexAttrib1fvARB
= vbo_VertexAttrib1fvARB
;
977 vfmt
->VertexAttrib2fARB
= vbo_VertexAttrib2fARB
;
978 vfmt
->VertexAttrib2fvARB
= vbo_VertexAttrib2fvARB
;
979 vfmt
->VertexAttrib3fARB
= vbo_VertexAttrib3fARB
;
980 vfmt
->VertexAttrib3fvARB
= vbo_VertexAttrib3fvARB
;
981 vfmt
->VertexAttrib4fARB
= vbo_VertexAttrib4fARB
;
982 vfmt
->VertexAttrib4fvARB
= vbo_VertexAttrib4fvARB
;
985 /* Note that VertexAttrib4fNV is used from dlist.c and api_arrayelt.c so
986 * they can have a single entrypoint for updating any of the legacy
989 vfmt
->VertexAttrib1fNV
= vbo_VertexAttrib1fNV
;
990 vfmt
->VertexAttrib1fvNV
= vbo_VertexAttrib1fvNV
;
991 vfmt
->VertexAttrib2fNV
= vbo_VertexAttrib2fNV
;
992 vfmt
->VertexAttrib2fvNV
= vbo_VertexAttrib2fvNV
;
993 vfmt
->VertexAttrib3fNV
= vbo_VertexAttrib3fNV
;
994 vfmt
->VertexAttrib3fvNV
= vbo_VertexAttrib3fvNV
;
995 vfmt
->VertexAttrib4fNV
= vbo_VertexAttrib4fNV
;
996 vfmt
->VertexAttrib4fvNV
= vbo_VertexAttrib4fvNV
;
999 vfmt
->VertexAttribI1i
= vbo_VertexAttribI1i
;
1000 vfmt
->VertexAttribI2i
= vbo_VertexAttribI2i
;
1001 vfmt
->VertexAttribI3i
= vbo_VertexAttribI3i
;
1002 vfmt
->VertexAttribI4i
= vbo_VertexAttribI4i
;
1003 vfmt
->VertexAttribI2iv
= vbo_VertexAttribI2iv
;
1004 vfmt
->VertexAttribI3iv
= vbo_VertexAttribI3iv
;
1005 vfmt
->VertexAttribI4iv
= vbo_VertexAttribI4iv
;
1007 /* unsigned integer-valued */
1008 vfmt
->VertexAttribI1ui
= vbo_VertexAttribI1ui
;
1009 vfmt
->VertexAttribI2ui
= vbo_VertexAttribI2ui
;
1010 vfmt
->VertexAttribI3ui
= vbo_VertexAttribI3ui
;
1011 vfmt
->VertexAttribI4ui
= vbo_VertexAttribI4ui
;
1012 vfmt
->VertexAttribI2uiv
= vbo_VertexAttribI2uiv
;
1013 vfmt
->VertexAttribI3uiv
= vbo_VertexAttribI3uiv
;
1014 vfmt
->VertexAttribI4uiv
= vbo_VertexAttribI4uiv
;
1016 vfmt
->Materialfv
= vbo_Materialfv
;
1018 vfmt
->EdgeFlag
= vbo_EdgeFlag
;
1019 vfmt
->Indexf
= vbo_Indexf
;
1020 vfmt
->Indexfv
= vbo_Indexfv
;
1022 /* ARB_vertex_type_2_10_10_10_rev */
1023 vfmt
->VertexP2ui
= vbo_VertexP2ui
;
1024 vfmt
->VertexP2uiv
= vbo_VertexP2uiv
;
1025 vfmt
->VertexP3ui
= vbo_VertexP3ui
;
1026 vfmt
->VertexP3uiv
= vbo_VertexP3uiv
;
1027 vfmt
->VertexP4ui
= vbo_VertexP4ui
;
1028 vfmt
->VertexP4uiv
= vbo_VertexP4uiv
;
1030 vfmt
->TexCoordP1ui
= vbo_TexCoordP1ui
;
1031 vfmt
->TexCoordP1uiv
= vbo_TexCoordP1uiv
;
1032 vfmt
->TexCoordP2ui
= vbo_TexCoordP2ui
;
1033 vfmt
->TexCoordP2uiv
= vbo_TexCoordP2uiv
;
1034 vfmt
->TexCoordP3ui
= vbo_TexCoordP3ui
;
1035 vfmt
->TexCoordP3uiv
= vbo_TexCoordP3uiv
;
1036 vfmt
->TexCoordP4ui
= vbo_TexCoordP4ui
;
1037 vfmt
->TexCoordP4uiv
= vbo_TexCoordP4uiv
;
1039 vfmt
->MultiTexCoordP1ui
= vbo_MultiTexCoordP1ui
;
1040 vfmt
->MultiTexCoordP1uiv
= vbo_MultiTexCoordP1uiv
;
1041 vfmt
->MultiTexCoordP2ui
= vbo_MultiTexCoordP2ui
;
1042 vfmt
->MultiTexCoordP2uiv
= vbo_MultiTexCoordP2uiv
;
1043 vfmt
->MultiTexCoordP3ui
= vbo_MultiTexCoordP3ui
;
1044 vfmt
->MultiTexCoordP3uiv
= vbo_MultiTexCoordP3uiv
;
1045 vfmt
->MultiTexCoordP4ui
= vbo_MultiTexCoordP4ui
;
1046 vfmt
->MultiTexCoordP4uiv
= vbo_MultiTexCoordP4uiv
;
1048 vfmt
->NormalP3ui
= vbo_NormalP3ui
;
1049 vfmt
->NormalP3uiv
= vbo_NormalP3uiv
;
1051 vfmt
->ColorP3ui
= vbo_ColorP3ui
;
1052 vfmt
->ColorP3uiv
= vbo_ColorP3uiv
;
1053 vfmt
->ColorP4ui
= vbo_ColorP4ui
;
1054 vfmt
->ColorP4uiv
= vbo_ColorP4uiv
;
1056 vfmt
->SecondaryColorP3ui
= vbo_SecondaryColorP3ui
;
1057 vfmt
->SecondaryColorP3uiv
= vbo_SecondaryColorP3uiv
;
1059 vfmt
->VertexAttribP1ui
= vbo_VertexAttribP1ui
;
1060 vfmt
->VertexAttribP1uiv
= vbo_VertexAttribP1uiv
;
1061 vfmt
->VertexAttribP2ui
= vbo_VertexAttribP2ui
;
1062 vfmt
->VertexAttribP2uiv
= vbo_VertexAttribP2uiv
;
1063 vfmt
->VertexAttribP3ui
= vbo_VertexAttribP3ui
;
1064 vfmt
->VertexAttribP3uiv
= vbo_VertexAttribP3uiv
;
1065 vfmt
->VertexAttribP4ui
= vbo_VertexAttribP4ui
;
1066 vfmt
->VertexAttribP4uiv
= vbo_VertexAttribP4uiv
;
1068 vfmt
->VertexAttribL1d
= vbo_VertexAttribL1d
;
1069 vfmt
->VertexAttribL2d
= vbo_VertexAttribL2d
;
1070 vfmt
->VertexAttribL3d
= vbo_VertexAttribL3d
;
1071 vfmt
->VertexAttribL4d
= vbo_VertexAttribL4d
;
1073 vfmt
->VertexAttribL1dv
= vbo_VertexAttribL1dv
;
1074 vfmt
->VertexAttribL2dv
= vbo_VertexAttribL2dv
;
1075 vfmt
->VertexAttribL3dv
= vbo_VertexAttribL3dv
;
1076 vfmt
->VertexAttribL4dv
= vbo_VertexAttribL4dv
;
1081 * Tell the VBO module to use a real OpenGL vertex buffer object to
1082 * store accumulated immediate-mode vertex data.
1083 * This replaces the malloced buffer which was created in
1084 * vb_exec_vtx_init() below.
1086 void vbo_use_buffer_objects(struct gl_context
*ctx
)
1088 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1089 /* Any buffer name but 0 can be used here since this bufferobj won't
1090 * go into the bufferobj hashtable.
1092 GLuint bufName
= IMM_BUFFER_NAME
;
1093 GLenum target
= GL_ARRAY_BUFFER_ARB
;
1094 GLenum usage
= GL_STREAM_DRAW_ARB
;
1095 GLsizei size
= VBO_VERT_BUFFER_SIZE
;
1097 /* Make sure this func is only used once */
1098 assert(exec
->vtx
.bufferobj
== ctx
->Shared
->NullBufferObj
);
1100 _mesa_align_free(exec
->vtx
.buffer_map
);
1101 exec
->vtx
.buffer_map
= NULL
;
1102 exec
->vtx
.buffer_ptr
= NULL
;
1104 /* Allocate a real buffer object now */
1105 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1106 exec
->vtx
.bufferobj
= ctx
->Driver
.NewBufferObject(ctx
, bufName
);
1107 if (!ctx
->Driver
.BufferData(ctx
, target
, size
, NULL
, usage
,
1109 GL_DYNAMIC_STORAGE_BIT
|
1110 GL_CLIENT_STORAGE_BIT
,
1111 exec
->vtx
.bufferobj
)) {
1112 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "VBO allocation");
1118 * If this function is called, all VBO buffers will be unmapped when
1120 * Otherwise, if a simple command like glColor3f() is called and we flush,
1121 * the current VBO may be left mapped.
1124 vbo_always_unmap_buffers(struct gl_context
*ctx
)
1126 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1127 exec
->begin_vertices_flags
|= FLUSH_STORED_VERTICES
;
1131 void vbo_exec_vtx_init( struct vbo_exec_context
*exec
)
1133 struct gl_context
*ctx
= exec
->ctx
;
1134 struct vbo_context
*vbo
= vbo_context(ctx
);
1137 /* Allocate a buffer object. Will just reuse this object
1138 * continuously, unless vbo_use_buffer_objects() is called to enable
1141 _mesa_reference_buffer_object(ctx
,
1142 &exec
->vtx
.bufferobj
,
1143 ctx
->Shared
->NullBufferObj
);
1145 assert(!exec
->vtx
.buffer_map
);
1146 exec
->vtx
.buffer_map
= _mesa_align_malloc(VBO_VERT_BUFFER_SIZE
, 64);
1147 exec
->vtx
.buffer_ptr
= exec
->vtx
.buffer_map
;
1149 vbo_exec_vtxfmt_init( exec
);
1150 _mesa_noop_vtxfmt_init(&exec
->vtxfmt_noop
);
1152 exec
->vtx
.enabled
= 0;
1153 for (i
= 0 ; i
< VBO_ATTRIB_MAX
; i
++) {
1154 assert(i
< ARRAY_SIZE(exec
->vtx
.attrsz
));
1155 exec
->vtx
.attrsz
[i
] = 0;
1156 assert(i
< ARRAY_SIZE(exec
->vtx
.attrtype
));
1157 exec
->vtx
.attrtype
[i
] = GL_FLOAT
;
1158 assert(i
< ARRAY_SIZE(exec
->vtx
.active_sz
));
1159 exec
->vtx
.active_sz
[i
] = 0;
1161 for (i
= 0 ; i
< VERT_ATTRIB_MAX
; i
++) {
1162 assert(i
< ARRAY_SIZE(exec
->vtx
.inputs
));
1163 assert(i
< ARRAY_SIZE(exec
->vtx
.arrays
));
1164 exec
->vtx
.inputs
[i
] = &exec
->vtx
.arrays
[i
];
1168 struct gl_client_array
*arrays
= exec
->vtx
.arrays
;
1171 memcpy(arrays
, &vbo
->currval
[VBO_ATTRIB_POS
],
1172 VERT_ATTRIB_FF_MAX
* sizeof(arrays
[0]));
1173 for (i
= 0; i
< VERT_ATTRIB_FF_MAX
; ++i
) {
1174 struct gl_client_array
*array
;
1175 array
= &arrays
[VERT_ATTRIB_FF(i
)];
1176 array
->BufferObj
= NULL
;
1177 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1178 vbo
->currval
[VBO_ATTRIB_POS
+i
].BufferObj
);
1181 memcpy(arrays
+ VERT_ATTRIB_GENERIC(0),
1182 &vbo
->currval
[VBO_ATTRIB_GENERIC0
],
1183 VERT_ATTRIB_GENERIC_MAX
* sizeof(arrays
[0]));
1185 for (i
= 0; i
< VERT_ATTRIB_GENERIC_MAX
; ++i
) {
1186 struct gl_client_array
*array
;
1187 array
= &arrays
[VERT_ATTRIB_GENERIC(i
)];
1188 array
->BufferObj
= NULL
;
1189 _mesa_reference_buffer_object(ctx
, &array
->BufferObj
,
1190 vbo
->currval
[VBO_ATTRIB_GENERIC0
+i
].BufferObj
);
1194 exec
->vtx
.vertex_size
= 0;
1196 exec
->begin_vertices_flags
= FLUSH_UPDATE_CURRENT
;
1200 void vbo_exec_vtx_destroy( struct vbo_exec_context
*exec
)
1202 /* using a real VBO for vertex data */
1203 struct gl_context
*ctx
= exec
->ctx
;
1206 /* True VBOs should already be unmapped
1208 if (exec
->vtx
.buffer_map
) {
1209 assert(exec
->vtx
.bufferobj
->Name
== 0 ||
1210 exec
->vtx
.bufferobj
->Name
== IMM_BUFFER_NAME
);
1211 if (exec
->vtx
.bufferobj
->Name
== 0) {
1212 _mesa_align_free(exec
->vtx
.buffer_map
);
1213 exec
->vtx
.buffer_map
= NULL
;
1214 exec
->vtx
.buffer_ptr
= NULL
;
1218 /* Drop any outstanding reference to the vertex buffer
1220 for (i
= 0; i
< ARRAY_SIZE(exec
->vtx
.arrays
); i
++) {
1221 _mesa_reference_buffer_object(ctx
,
1222 &exec
->vtx
.arrays
[i
].BufferObj
,
1226 /* Free the vertex buffer. Unmap first if needed.
1228 if (_mesa_bufferobj_mapped(exec
->vtx
.bufferobj
, MAP_INTERNAL
)) {
1229 ctx
->Driver
.UnmapBuffer(ctx
, exec
->vtx
.bufferobj
, MAP_INTERNAL
);
1231 _mesa_reference_buffer_object(ctx
, &exec
->vtx
.bufferobj
, NULL
);
1236 * If inside glBegin()/glEnd(), it should assert(0). Otherwise, if
1237 * FLUSH_STORED_VERTICES bit in \p flags is set flushes any buffered
1238 * vertices, if FLUSH_UPDATE_CURRENT bit is set updates
1239 * __struct gl_contextRec::Current and gl_light_attrib::Material
1241 * Note that the default T&L engine never clears the
1242 * FLUSH_UPDATE_CURRENT bit, even after performing the update.
1244 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1246 void vbo_exec_FlushVertices( struct gl_context
*ctx
, GLuint flags
)
1248 struct vbo_exec_context
*exec
= &vbo_context(ctx
)->exec
;
1251 /* debug check: make sure we don't get called recursively */
1252 exec
->flush_call_depth
++;
1253 assert(exec
->flush_call_depth
== 1);
1256 if (_mesa_inside_begin_end(ctx
)) {
1257 /* We've had glBegin but not glEnd! */
1259 exec
->flush_call_depth
--;
1260 assert(exec
->flush_call_depth
== 0);
1265 /* Flush (draw), and make sure VBO is left unmapped when done */
1266 vbo_exec_FlushVertices_internal(exec
, GL_TRUE
);
1268 /* Need to do this to ensure vbo_exec_begin_vertices gets called again:
1270 ctx
->Driver
.NeedFlush
&= ~(FLUSH_UPDATE_CURRENT
| flags
);
1273 exec
->flush_call_depth
--;
1274 assert(exec
->flush_call_depth
== 0);
1278 void vbo_reset_attr(struct vbo_exec_context
*exec
, GLuint attr
)
1280 exec
->vtx
.attrsz
[attr
] = 0;
1281 exec
->vtx
.attrtype
[attr
] = GL_FLOAT
;
1282 exec
->vtx
.active_sz
[attr
] = 0;
1285 static void reset_attrfv( struct vbo_exec_context
*exec
)
1287 while (exec
->vtx
.enabled
) {
1288 const int i
= u_bit_scan64(&exec
->vtx
.enabled
);
1289 vbo_reset_attr(exec
, i
);
1292 exec
->vtx
.vertex_size
= 0;
1297 _es_Color4f(GLfloat r
, GLfloat g
, GLfloat b
, GLfloat a
)
1299 vbo_Color4f(r
, g
, b
, a
);
1304 _es_Normal3f(GLfloat x
, GLfloat y
, GLfloat z
)
1306 vbo_Normal3f(x
, y
, z
);
1311 _es_MultiTexCoord4f(GLenum target
, GLfloat s
, GLfloat t
, GLfloat r
, GLfloat q
)
1313 vbo_MultiTexCoord4f(target
, s
, t
, r
, q
);
1318 _es_Materialfv(GLenum face
, GLenum pname
, const GLfloat
*params
)
1320 vbo_Materialfv(face
, pname
, params
);
1325 _es_Materialf(GLenum face
, GLenum pname
, GLfloat param
)
1329 p
[1] = p
[2] = p
[3] = 0.0F
;
1330 vbo_Materialfv(face
, pname
, p
);
1335 * A special version of glVertexAttrib4f that does not treat index 0 as
1339 VertexAttrib4f_nopos(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1341 GET_CURRENT_CONTEXT(ctx
);
1342 if (index
< MAX_VERTEX_GENERIC_ATTRIBS
)
1343 ATTRF(VBO_ATTRIB_GENERIC0
+ index
, 4, x
, y
, z
, w
);
1345 ERROR(GL_INVALID_VALUE
);
1349 _es_VertexAttrib4f(GLuint index
, GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
1351 VertexAttrib4f_nopos(index
, x
, y
, z
, w
);
1356 _es_VertexAttrib1f(GLuint indx
, GLfloat x
)
1358 VertexAttrib4f_nopos(indx
, x
, 0.0f
, 0.0f
, 1.0f
);
1363 _es_VertexAttrib1fv(GLuint indx
, const GLfloat
* values
)
1365 VertexAttrib4f_nopos(indx
, values
[0], 0.0f
, 0.0f
, 1.0f
);
1370 _es_VertexAttrib2f(GLuint indx
, GLfloat x
, GLfloat y
)
1372 VertexAttrib4f_nopos(indx
, x
, y
, 0.0f
, 1.0f
);
1377 _es_VertexAttrib2fv(GLuint indx
, const GLfloat
* values
)
1379 VertexAttrib4f_nopos(indx
, values
[0], values
[1], 0.0f
, 1.0f
);
1384 _es_VertexAttrib3f(GLuint indx
, GLfloat x
, GLfloat y
, GLfloat z
)
1386 VertexAttrib4f_nopos(indx
, x
, y
, z
, 1.0f
);
1391 _es_VertexAttrib3fv(GLuint indx
, const GLfloat
* values
)
1393 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], 1.0f
);
1398 _es_VertexAttrib4fv(GLuint indx
, const GLfloat
* values
)
1400 VertexAttrib4f_nopos(indx
, values
[0], values
[1], values
[2], values
[3]);