projects / mesa.git / blob
? search:


52b363da3e9ea8140adf2b92f687e21aa27960b4
[mesa.git] / src / mesa / vbo / vbo_exec_api.c
1 /**************************************************************************
2
3 Copyright 2002-2008 Tungsten Graphics Inc., Cedar Park, Texas.
4
5 All Rights Reserved.
6
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:
13
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
16 Software.
17
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
21 TUNGSTEN GRAPHICS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
22 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
23 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
24 USE OR OTHER DEALINGS IN THE SOFTWARE.
25
26 **************************************************************************/
27
28 /*
29 * Authors:
30 * Keith Whitwell <keith@tungstengraphics.com>
31 */
32
33 #include "main/glheader.h"
34 #include "main/bufferobj.h"
35 #include "main/context.h"
36 #include "main/macros.h"
37 #include "main/mfeatures.h"
38 #include "main/vtxfmt.h"
39 #include "main/dlist.h"
40 #include "main/eval.h"
41 #include "main/state.h"
42 #include "main/light.h"
43 #include "main/api_arrayelt.h"
44 #include "main/api_validate.h"
45 #include "main/dispatch.h"
46
47 #include "vbo_context.h"
48 #include "vbo_noop.h"
49
50
51 #ifdef ERROR
52 #undef ERROR
53 #endif
54
55
56 /** ID/name for immediate-mode VBO */
57 #define IMM_BUFFER_NAME 0xaabbccdd
58
59
60 static void reset_attrfv( struct vbo_exec_context *exec );
61
62
63 /**
64 * Close off the last primitive, execute the buffer, restart the
65 * primitive.
66 */
67 static void vbo_exec_wrap_buffers( struct vbo_exec_context *exec )
68 {
69 if (exec->vtx.prim_count == 0) {
70 exec->vtx.copied.nr = 0;
71 exec->vtx.vert_count = 0;
72 exec->vtx.buffer_ptr = exec->vtx.buffer_map;
73 }
74 else {
75 GLuint last_begin = exec->vtx.prim[exec->vtx.prim_count-1].begin;
76 GLuint last_count;
77
78 if (exec->ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {
79 GLint i = exec->vtx.prim_count - 1;
80 assert(i >= 0);
81 exec->vtx.prim[i].count = (exec->vtx.vert_count -
82 exec->vtx.prim[i].start);
83 }
84
85 last_count = exec->vtx.prim[exec->vtx.prim_count-1].count;
86
87 /* Execute the buffer and save copied vertices.
88 */
89 if (exec->vtx.vert_count)
90 vbo_exec_vtx_flush( exec, GL_FALSE );
91 else {
92 exec->vtx.prim_count = 0;
93 exec->vtx.copied.nr = 0;
94 }
95
96 /* Emit a glBegin to start the new list.
97 */
98 assert(exec->vtx.prim_count == 0);
99
100 if (exec->ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {
101 exec->vtx.prim[0].mode = exec->ctx->Driver.CurrentExecPrimitive;
102 exec->vtx.prim[0].start = 0;
103 exec->vtx.prim[0].count = 0;
104 exec->vtx.prim_count++;
105
106 if (exec->vtx.copied.nr == last_count)
107 exec->vtx.prim[0].begin = last_begin;
108 }
109 }
110 }
111
112
113 /**
114 * Deal with buffer wrapping where provoked by the vertex buffer
115 * filling up, as opposed to upgrade_vertex().
116 */
117 void vbo_exec_vtx_wrap( struct vbo_exec_context *exec )
118 {
119 GLfloat *data = exec->vtx.copied.buffer;
120 GLuint i;
121
122 /* Run pipeline on current vertices, copy wrapped vertices
123 * to exec->vtx.copied.
124 */
125 vbo_exec_wrap_buffers( exec );
126
127 /* Copy stored stored vertices to start of new list.
128 */
129 assert(exec->vtx.max_vert - exec->vtx.vert_count > exec->vtx.copied.nr);
130
131 for (i = 0 ; i < exec->vtx.copied.nr ; i++) {
132 memcpy( exec->vtx.buffer_ptr, data,
133 exec->vtx.vertex_size * sizeof(GLfloat));
134 exec->vtx.buffer_ptr += exec->vtx.vertex_size;
135 data += exec->vtx.vertex_size;
136 exec->vtx.vert_count++;
137 }
138
139 exec->vtx.copied.nr = 0;
140 }
141
142
143 /**
144 * Copy the active vertex's values to the ctx->Current fields.
145 */
146 static void vbo_exec_copy_to_current( struct vbo_exec_context *exec )
147 {
148 struct gl_context *ctx = exec->ctx;
149 struct vbo_context *vbo = vbo_context(ctx);
150 GLuint i;
151
152 for (i = VBO_ATTRIB_POS+1 ; i < VBO_ATTRIB_MAX ; i++) {
153 if (exec->vtx.attrsz[i]) {
154 /* Note: the exec->vtx.current[i] pointers point into the
155 * ctx->Current.Attrib and ctx->Light.Material.Attrib arrays.
156 */
157 GLfloat *current = (GLfloat *)vbo->currval[i].Ptr;
158 GLfloat tmp[4];
159
160 COPY_CLEAN_4V(tmp,
161 exec->vtx.attrsz[i],
162 exec->vtx.attrptr[i]);
163
164 if (memcmp(current, tmp, sizeof(tmp)) != 0) {
165 memcpy(current, tmp, sizeof(tmp));
166
167 /* Given that we explicitly state size here, there is no need
168 * for the COPY_CLEAN above, could just copy 16 bytes and be
169 * done. The only problem is when Mesa accesses ctx->Current
170 * directly.
171 */
172 vbo->currval[i].Size = exec->vtx.attrsz[i];
173 assert(vbo->currval[i].Type == GL_FLOAT);
174 vbo->currval[i]._ElementSize = vbo->currval[i].Size * sizeof(GLfloat);
175
176 /* This triggers rather too much recalculation of Mesa state
177 * that doesn't get used (eg light positions).
178 */
179 if (i >= VBO_ATTRIB_MAT_FRONT_AMBIENT &&
180 i <= VBO_ATTRIB_MAT_BACK_INDEXES)
181 ctx->NewState |= _NEW_LIGHT;
182
183 ctx->NewState |= _NEW_CURRENT_ATTRIB;
184 }
185 }
186 }
187
188 /* Colormaterial -- this kindof sucks.
189 */
190 if (ctx->Light.ColorMaterialEnabled &&
191 exec->vtx.attrsz[VBO_ATTRIB_COLOR0]) {
192 _mesa_update_color_material(ctx,
193 ctx->Current.Attrib[VBO_ATTRIB_COLOR0]);
194 }
195 }
196
197
198 /**
199 * Copy current vertex attribute values into the current vertex.
200 */
201 static void
202 vbo_exec_copy_from_current(struct vbo_exec_context *exec)
203 {
204 struct gl_context *ctx = exec->ctx;
205 struct vbo_context *vbo = vbo_context(ctx);
206 GLint i;
207
208 for (i = VBO_ATTRIB_POS + 1; i < VBO_ATTRIB_MAX; i++) {
209 const GLfloat *current = (GLfloat *) vbo->currval[i].Ptr;
210 switch (exec->vtx.attrsz[i]) {
211 case 4: exec->vtx.attrptr[i][3] = current[3];
212 case 3: exec->vtx.attrptr[i][2] = current[2];
213 case 2: exec->vtx.attrptr[i][1] = current[1];
214 case 1: exec->vtx.attrptr[i][0] = current[0];
215 break;
216 }
217 }
218 }
219
220
221 /**
222 * Flush existing data, set new attrib size, replay copied vertices.
223 * This is called when we transition from a small vertex attribute size
224 * to a larger one. Ex: glTexCoord2f -> glTexCoord4f.
225 * We need to go back over the previous 2-component texcoords and insert
226 * zero and one values.
227 */
228 static void
229 vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context *exec,
230 GLuint attr, GLuint newSize )
231 {
232 struct gl_context *ctx = exec->ctx;
233 struct vbo_context *vbo = vbo_context(ctx);
234 const GLint lastcount = exec->vtx.vert_count;
235 GLfloat *old_attrptr[VBO_ATTRIB_MAX];
236 const GLuint old_vtx_size = exec->vtx.vertex_size; /* floats per vertex */
237 const GLuint oldSize = exec->vtx.attrsz[attr];
238 GLuint i;
239
240 /* Run pipeline on current vertices, copy wrapped vertices
241 * to exec->vtx.copied.
242 */
243 vbo_exec_wrap_buffers( exec );
244
245 if (unlikely(exec->vtx.copied.nr)) {
246 /* We're in the middle of a primitive, keep the old vertex
247 * format around to be able to translate the copied vertices to
248 * the new format.
249 */
250 memcpy(old_attrptr, exec->vtx.attrptr, sizeof(old_attrptr));
251 }
252
253 if (unlikely(oldSize)) {
254 /* Do a COPY_TO_CURRENT to ensure back-copying works for the
255 * case when the attribute already exists in the vertex and is
256 * having its size increased.
257 */
258 vbo_exec_copy_to_current( exec );
259 }
260
261 /* Heuristic: Attempt to isolate attributes received outside
262 * begin/end so that they don't bloat the vertices.
263 */
264 if (ctx->Driver.CurrentExecPrimitive == PRIM_OUTSIDE_BEGIN_END &&
265 !oldSize && lastcount > 8 && exec->vtx.vertex_size) {
266 vbo_exec_copy_to_current( exec );
267 reset_attrfv( exec );
268 }
269
270 /* Fix up sizes:
271 */
272 exec->vtx.attrsz[attr] = newSize;
273 exec->vtx.vertex_size += newSize - oldSize;
274 exec->vtx.max_vert = ((VBO_VERT_BUFFER_SIZE - exec->vtx.buffer_used) /
275 (exec->vtx.vertex_size * sizeof(GLfloat)));
276 exec->vtx.vert_count = 0;
277 exec->vtx.buffer_ptr = exec->vtx.buffer_map;
278
279 if (unlikely(oldSize)) {
280 /* Size changed, recalculate all the attrptr[] values
281 */
282 GLfloat *tmp = exec->vtx.vertex;
283
284 for (i = 0 ; i < VBO_ATTRIB_MAX ; i++) {
285 if (exec->vtx.attrsz[i]) {
286 exec->vtx.attrptr[i] = tmp;
287 tmp += exec->vtx.attrsz[i];
288 }
289 else
290 exec->vtx.attrptr[i] = NULL; /* will not be dereferenced */
291 }
292
293 /* Copy from current to repopulate the vertex with correct
294 * values.
295 */
296 vbo_exec_copy_from_current( exec );
297 }
298 else {
299 /* Just have to append the new attribute at the end */
300 exec->vtx.attrptr[attr] = exec->vtx.vertex +
301 exec->vtx.vertex_size - newSize;
302 }
303
304 /* Replay stored vertices to translate them
305 * to new format here.
306 *
307 * -- No need to replay - just copy piecewise
308 */
309 if (unlikely(exec->vtx.copied.nr)) {
310 GLfloat *data = exec->vtx.copied.buffer;
311 GLfloat *dest = exec->vtx.buffer_ptr;
312 GLuint j;
313
314 assert(exec->vtx.buffer_ptr == exec->vtx.buffer_map);
315
316 for (i = 0 ; i < exec->vtx.copied.nr ; i++) {
317 for (j = 0 ; j < VBO_ATTRIB_MAX ; j++) {
318 GLuint sz = exec->vtx.attrsz[j];
319
320 if (sz) {
321 GLint old_offset = old_attrptr[j] - exec->vtx.vertex;
322 GLint new_offset = exec->vtx.attrptr[j] - exec->vtx.vertex;
323
324 if (j == attr) {
325 if (oldSize) {
326 GLfloat tmp[4];
327 COPY_CLEAN_4V(tmp, oldSize, data + old_offset);
328 COPY_SZ_4V(dest + new_offset, newSize, tmp);
329 } else {
330 GLfloat *current = (GLfloat *)vbo->currval[j].Ptr;
331 COPY_SZ_4V(dest + new_offset, sz, current);
332 }
333 }
334 else {
335 COPY_SZ_4V(dest + new_offset, sz, data + old_offset);
336 }
337 }
338 }
339
340 data += old_vtx_size;
341 dest += exec->vtx.vertex_size;
342 }
343
344 exec->vtx.buffer_ptr = dest;
345 exec->vtx.vert_count += exec->vtx.copied.nr;
346 exec->vtx.copied.nr = 0;
347 }
348 }
349
350
351 /**
352 * This is when a vertex attribute transitions to a different size.
353 * For example, we saw a bunch of glTexCoord2f() calls and now we got a
354 * glTexCoord4f() call. We promote the array from size=2 to size=4.
355 */
356 static void
357 vbo_exec_fixup_vertex(struct gl_context *ctx, GLuint attr, GLuint newSize)
358 {
359 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
360
361 if (newSize > exec->vtx.attrsz[attr]) {
362 /* New size is larger. Need to flush existing vertices and get
363 * an enlarged vertex format.
364 */
365 vbo_exec_wrap_upgrade_vertex( exec, attr, newSize );
366 }
367 else if (newSize < exec->vtx.active_sz[attr]) {
368 static const GLfloat id[4] = { 0, 0, 0, 1 };
369 GLuint i;
370
371 /* New size is smaller - just need to fill in some
372 * zeros. Don't need to flush or wrap.
373 */
374 for (i = newSize; i <= exec->vtx.attrsz[attr]; i++)
375 exec->vtx.attrptr[attr][i-1] = id[i-1];
376 }
377
378 exec->vtx.active_sz[attr] = newSize;
379
380 /* Does setting NeedFlush belong here? Necessitates resetting
381 * vtxfmt on each flush (otherwise flags won't get reset
382 * afterwards).
383 */
384 if (attr == 0)
385 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES;
386 }
387
388
389 /**
390 * This macro is used to implement all the glVertex, glColor, glTexCoord,
391 * glVertexAttrib, etc functions.
392 */
393 #define ATTR( A, N, V0, V1, V2, V3 ) \
394 do { \
395 struct vbo_exec_context *exec = &vbo_context(ctx)->exec; \
396 \
397 if (unlikely(!(ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT))) \
398 ctx->Driver.BeginVertices( ctx ); \
399 \
400 if (unlikely(exec->vtx.active_sz[A] != N)) \
401 vbo_exec_fixup_vertex(ctx, A, N); \
402 \
403 { \
404 GLfloat *dest = exec->vtx.attrptr[A]; \
405 if (N>0) dest[0] = V0; \
406 if (N>1) dest[1] = V1; \
407 if (N>2) dest[2] = V2; \
408 if (N>3) dest[3] = V3; \
409 } \
410 \
411 if ((A) == 0) { \
412 /* This is a glVertex call */ \
413 GLuint i; \
414 \
415 for (i = 0; i < exec->vtx.vertex_size; i++) \
416 exec->vtx.buffer_ptr[i] = exec->vtx.vertex[i]; \
417 \
418 exec->vtx.buffer_ptr += exec->vtx.vertex_size; \
419 \
420 /* Set FLUSH_STORED_VERTICES to indicate that there's now */ \
421 /* something to draw (not just updating a color or texcoord).*/ \
422 ctx->Driver.NeedFlush |= FLUSH_STORED_VERTICES; \
423 \
424 if (++exec->vtx.vert_count >= exec->vtx.max_vert) \
425 vbo_exec_vtx_wrap( exec ); \
426 } \
427 } while (0)
428
429
430 #define ERROR(err) _mesa_error( ctx, err, __FUNCTION__ )
431 #define TAG(x) vbo_##x
432
433 #include "vbo_attrib_tmp.h"
434
435
436
437 /**
438 * Execute a glMaterial call. Note that if GL_COLOR_MATERIAL is enabled,
439 * this may be a (partial) no-op.
440 */
441 static void GLAPIENTRY
442 vbo_Materialfv(GLenum face, GLenum pname, const GLfloat *params)
443 {
444 GLbitfield updateMats;
445 GET_CURRENT_CONTEXT(ctx);
446
447 /* This function should be a no-op when it tries to update material
448 * attributes which are currently tracking glColor via glColorMaterial.
449 * The updateMats var will be a mask of the MAT_BIT_FRONT/BACK_x bits
450 * indicating which material attributes can actually be updated below.
451 */
452 if (ctx->Light.ColorMaterialEnabled) {
453 updateMats = ~ctx->Light._ColorMaterialBitmask;
454 }
455 else {
456 /* GL_COLOR_MATERIAL is disabled so don't skip any material updates */
457 updateMats = ALL_MATERIAL_BITS;
458 }
459
460 if (ctx->API == API_OPENGL && face == GL_FRONT) {
461 updateMats &= FRONT_MATERIAL_BITS;
462 }
463 else if (ctx->API == API_OPENGL && face == GL_BACK) {
464 updateMats &= BACK_MATERIAL_BITS;
465 }
466 else if (face != GL_FRONT_AND_BACK) {
467 _mesa_error(ctx, GL_INVALID_ENUM, "glMaterial(invalid face)");
468 return;
469 }
470
471 switch (pname) {
472 case GL_EMISSION:
473 if (updateMats & MAT_BIT_FRONT_EMISSION)
474 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_EMISSION, 4, params);
475 if (updateMats & MAT_BIT_BACK_EMISSION)
476 MAT_ATTR(VBO_ATTRIB_MAT_BACK_EMISSION, 4, params);
477 break;
478 case GL_AMBIENT:
479 if (updateMats & MAT_BIT_FRONT_AMBIENT)
480 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT, 4, params);
481 if (updateMats & MAT_BIT_BACK_AMBIENT)
482 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT, 4, params);
483 break;
484 case GL_DIFFUSE:
485 if (updateMats & MAT_BIT_FRONT_DIFFUSE)
486 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE, 4, params);
487 if (updateMats & MAT_BIT_BACK_DIFFUSE)
488 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE, 4, params);
489 break;
490 case GL_SPECULAR:
491 if (updateMats & MAT_BIT_FRONT_SPECULAR)
492 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SPECULAR, 4, params);
493 if (updateMats & MAT_BIT_BACK_SPECULAR)
494 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SPECULAR, 4, params);
495 break;
496 case GL_SHININESS:
497 if (*params < 0 || *params > ctx->Const.MaxShininess) {
498 _mesa_error(ctx, GL_INVALID_VALUE,
499 "glMaterial(invalid shininess: %f out range [0, %f])",
500 *params, ctx->Const.MaxShininess);
501 return;
502 }
503 if (updateMats & MAT_BIT_FRONT_SHININESS)
504 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_SHININESS, 1, params);
505 if (updateMats & MAT_BIT_BACK_SHININESS)
506 MAT_ATTR(VBO_ATTRIB_MAT_BACK_SHININESS, 1, params);
507 break;
508 case GL_COLOR_INDEXES:
509 if (ctx->API != API_OPENGL) {
510 _mesa_error(ctx, GL_INVALID_ENUM, "glMaterialfv(pname)");
511 return;
512 }
513 if (updateMats & MAT_BIT_FRONT_INDEXES)
514 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_INDEXES, 3, params);
515 if (updateMats & MAT_BIT_BACK_INDEXES)
516 MAT_ATTR(VBO_ATTRIB_MAT_BACK_INDEXES, 3, params);
517 break;
518 case GL_AMBIENT_AND_DIFFUSE:
519 if (updateMats & MAT_BIT_FRONT_AMBIENT)
520 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_AMBIENT, 4, params);
521 if (updateMats & MAT_BIT_FRONT_DIFFUSE)
522 MAT_ATTR(VBO_ATTRIB_MAT_FRONT_DIFFUSE, 4, params);
523 if (updateMats & MAT_BIT_BACK_AMBIENT)
524 MAT_ATTR(VBO_ATTRIB_MAT_BACK_AMBIENT, 4, params);
525 if (updateMats & MAT_BIT_BACK_DIFFUSE)
526 MAT_ATTR(VBO_ATTRIB_MAT_BACK_DIFFUSE, 4, params);
527 break;
528 default:
529 _mesa_error(ctx, GL_INVALID_ENUM, "glMaterialfv(pname)");
530 return;
531 }
532 }
533
534
535 /**
536 * Flush (draw) vertices.
537 * \param unmap - leave VBO unmapped after flushing?
538 */
539 static void
540 vbo_exec_FlushVertices_internal(struct vbo_exec_context *exec, GLboolean unmap)
541 {
542 if (exec->vtx.vert_count || unmap) {
543 vbo_exec_vtx_flush( exec, unmap );
544 }
545
546 if (exec->vtx.vertex_size) {
547 vbo_exec_copy_to_current( exec );
548 reset_attrfv( exec );
549 }
550 }
551
552
553 static void GLAPIENTRY vbo_exec_EvalCoord1f( GLfloat u )
554 {
555 GET_CURRENT_CONTEXT( ctx );
556 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
557
558 {
559 GLint i;
560 if (exec->eval.recalculate_maps)
561 vbo_exec_eval_update( exec );
562
563 for (i = 0; i <= VBO_ATTRIB_TEX7; i++) {
564 if (exec->eval.map1[i].map)
565 if (exec->vtx.active_sz[i] != exec->eval.map1[i].sz)
566 vbo_exec_fixup_vertex( ctx, i, exec->eval.map1[i].sz );
567 }
568 }
569
570
571 memcpy( exec->vtx.copied.buffer, exec->vtx.vertex,
572 exec->vtx.vertex_size * sizeof(GLfloat));
573
574 vbo_exec_do_EvalCoord1f( exec, u );
575
576 memcpy( exec->vtx.vertex, exec->vtx.copied.buffer,
577 exec->vtx.vertex_size * sizeof(GLfloat));
578 }
579
580 static void GLAPIENTRY vbo_exec_EvalCoord2f( GLfloat u, GLfloat v )
581 {
582 GET_CURRENT_CONTEXT( ctx );
583 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
584
585 {
586 GLint i;
587 if (exec->eval.recalculate_maps)
588 vbo_exec_eval_update( exec );
589
590 for (i = 0; i <= VBO_ATTRIB_TEX7; i++) {
591 if (exec->eval.map2[i].map)
592 if (exec->vtx.active_sz[i] != exec->eval.map2[i].sz)
593 vbo_exec_fixup_vertex( ctx, i, exec->eval.map2[i].sz );
594 }
595
596 if (ctx->Eval.AutoNormal)
597 if (exec->vtx.active_sz[VBO_ATTRIB_NORMAL] != 3)
598 vbo_exec_fixup_vertex( ctx, VBO_ATTRIB_NORMAL, 3 );
599 }
600
601 memcpy( exec->vtx.copied.buffer, exec->vtx.vertex,
602 exec->vtx.vertex_size * sizeof(GLfloat));
603
604 vbo_exec_do_EvalCoord2f( exec, u, v );
605
606 memcpy( exec->vtx.vertex, exec->vtx.copied.buffer,
607 exec->vtx.vertex_size * sizeof(GLfloat));
608 }
609
610 static void GLAPIENTRY vbo_exec_EvalCoord1fv( const GLfloat *u )
611 {
612 vbo_exec_EvalCoord1f( u[0] );
613 }
614
615 static void GLAPIENTRY vbo_exec_EvalCoord2fv( const GLfloat *u )
616 {
617 vbo_exec_EvalCoord2f( u[0], u[1] );
618 }
619
620 static void GLAPIENTRY vbo_exec_EvalPoint1( GLint i )
621 {
622 GET_CURRENT_CONTEXT( ctx );
623 GLfloat du = ((ctx->Eval.MapGrid1u2 - ctx->Eval.MapGrid1u1) /
624 (GLfloat) ctx->Eval.MapGrid1un);
625 GLfloat u = i * du + ctx->Eval.MapGrid1u1;
626
627 vbo_exec_EvalCoord1f( u );
628 }
629
630
631 static void GLAPIENTRY vbo_exec_EvalPoint2( GLint i, GLint j )
632 {
633 GET_CURRENT_CONTEXT( ctx );
634 GLfloat du = ((ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1) /
635 (GLfloat) ctx->Eval.MapGrid2un);
636 GLfloat dv = ((ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1) /
637 (GLfloat) ctx->Eval.MapGrid2vn);
638 GLfloat u = i * du + ctx->Eval.MapGrid2u1;
639 GLfloat v = j * dv + ctx->Eval.MapGrid2v1;
640
641 vbo_exec_EvalCoord2f( u, v );
642 }
643
644
645 static void GLAPIENTRY
646 vbo_exec_EvalMesh1(GLenum mode, GLint i1, GLint i2)
647 {
648 GET_CURRENT_CONTEXT(ctx);
649 GLint i;
650 GLfloat u, du;
651 GLenum prim;
652
653 ASSERT_OUTSIDE_BEGIN_END(ctx);
654
655 switch (mode) {
656 case GL_POINT:
657 prim = GL_POINTS;
658 break;
659 case GL_LINE:
660 prim = GL_LINE_STRIP;
661 break;
662 default:
663 _mesa_error( ctx, GL_INVALID_ENUM, "glEvalMesh1(mode)" );
664 return;
665 }
666
667 /* No effect if vertex maps disabled.
668 */
669 if (!ctx->Eval.Map1Vertex4 &&
670 !ctx->Eval.Map1Vertex3)
671 return;
672
673 du = ctx->Eval.MapGrid1du;
674 u = ctx->Eval.MapGrid1u1 + i1 * du;
675
676 CALL_Begin(GET_DISPATCH(), (prim));
677 for (i=i1;i<=i2;i++,u+=du) {
678 CALL_EvalCoord1f(GET_DISPATCH(), (u));
679 }
680 CALL_End(GET_DISPATCH(), ());
681 }
682
683
684 static void GLAPIENTRY
685 vbo_exec_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
686 {
687 GET_CURRENT_CONTEXT(ctx);
688 GLfloat u, du, v, dv, v1, u1;
689 GLint i, j;
690
691 ASSERT_OUTSIDE_BEGIN_END(ctx);
692
693 switch (mode) {
694 case GL_POINT:
695 case GL_LINE:
696 case GL_FILL:
697 break;
698 default:
699 _mesa_error( ctx, GL_INVALID_ENUM, "glEvalMesh2(mode)" );
700 return;
701 }
702
703 /* No effect if vertex maps disabled.
704 */
705 if (!ctx->Eval.Map2Vertex4 &&
706 !ctx->Eval.Map2Vertex3)
707 return;
708
709 du = ctx->Eval.MapGrid2du;
710 dv = ctx->Eval.MapGrid2dv;
711 v1 = ctx->Eval.MapGrid2v1 + j1 * dv;
712 u1 = ctx->Eval.MapGrid2u1 + i1 * du;
713
714 switch (mode) {
715 case GL_POINT:
716 CALL_Begin(GET_DISPATCH(), (GL_POINTS));
717 for (v=v1,j=j1;j<=j2;j++,v+=dv) {
718 for (u=u1,i=i1;i<=i2;i++,u+=du) {
719 CALL_EvalCoord2f(GET_DISPATCH(), (u, v));
720 }
721 }
722 CALL_End(GET_DISPATCH(), ());
723 break;
724 case GL_LINE:
725 for (v=v1,j=j1;j<=j2;j++,v+=dv) {
726 CALL_Begin(GET_DISPATCH(), (GL_LINE_STRIP));
727 for (u=u1,i=i1;i<=i2;i++,u+=du) {
728 CALL_EvalCoord2f(GET_DISPATCH(), (u, v));
729 }
730 CALL_End(GET_DISPATCH(), ());
731 }
732 for (u=u1,i=i1;i<=i2;i++,u+=du) {
733 CALL_Begin(GET_DISPATCH(), (GL_LINE_STRIP));
734 for (v=v1,j=j1;j<=j2;j++,v+=dv) {
735 CALL_EvalCoord2f(GET_DISPATCH(), (u, v));
736 }
737 CALL_End(GET_DISPATCH(), ());
738 }
739 break;
740 case GL_FILL:
741 for (v=v1,j=j1;j<j2;j++,v+=dv) {
742 CALL_Begin(GET_DISPATCH(), (GL_TRIANGLE_STRIP));
743 for (u=u1,i=i1;i<=i2;i++,u+=du) {
744 CALL_EvalCoord2f(GET_DISPATCH(), (u, v));
745 CALL_EvalCoord2f(GET_DISPATCH(), (u, v+dv));
746 }
747 CALL_End(GET_DISPATCH(), ());
748 }
749 break;
750 }
751 }
752
753
754 /**
755 * Execute a glRectf() function. This is not suitable for GL_COMPILE
756 * modes (as the test for outside begin/end is not compiled),
757 * but may be useful for drivers in circumstances which exclude
758 * display list interactions.
759 *
760 * (None of the functions in this file are suitable for GL_COMPILE
761 * modes).
762 */
763 static void GLAPIENTRY
764 vbo_exec_Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
765 {
766 GET_CURRENT_CONTEXT(ctx);
767 ASSERT_OUTSIDE_BEGIN_END(ctx);
768
769 CALL_Begin(GET_DISPATCH(), (GL_QUADS));
770 CALL_Vertex2f(GET_DISPATCH(), (x1, y1));
771 CALL_Vertex2f(GET_DISPATCH(), (x2, y1));
772 CALL_Vertex2f(GET_DISPATCH(), (x2, y2));
773 CALL_Vertex2f(GET_DISPATCH(), (x1, y2));
774 CALL_End(GET_DISPATCH(), ());
775 }
776
777
778 /**
779 * Called via glBegin.
780 */
781 static void GLAPIENTRY vbo_exec_Begin( GLenum mode )
782 {
783 GET_CURRENT_CONTEXT( ctx );
784
785 if (ctx->Driver.CurrentExecPrimitive == PRIM_OUTSIDE_BEGIN_END) {
786 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
787 int i;
788
789 if (!_mesa_valid_prim_mode(ctx, mode, "glBegin")) {
790 return;
791 }
792
793 vbo_draw_method(vbo_context(ctx), DRAW_BEGIN_END);
794
795 if (ctx->Driver.PrepareExecBegin)
796 ctx->Driver.PrepareExecBegin(ctx);
797
798 if (ctx->NewState) {
799 _mesa_update_state( ctx );
800
801 CALL_Begin(ctx->Exec, (mode));
802 return;
803 }
804
805 if (!_mesa_valid_to_render(ctx, "glBegin")) {
806 return;
807 }
808
809 /* Heuristic: attempt to isolate attributes occuring outside
810 * begin/end pairs.
811 */
812 if (exec->vtx.vertex_size && !exec->vtx.attrsz[0])
813 vbo_exec_FlushVertices_internal(exec, GL_FALSE);
814
815 i = exec->vtx.prim_count++;
816 exec->vtx.prim[i].mode = mode;
817 exec->vtx.prim[i].begin = 1;
818 exec->vtx.prim[i].end = 0;
819 exec->vtx.prim[i].indexed = 0;
820 exec->vtx.prim[i].weak = 0;
821 exec->vtx.prim[i].pad = 0;
822 exec->vtx.prim[i].start = exec->vtx.vert_count;
823 exec->vtx.prim[i].count = 0;
824 exec->vtx.prim[i].num_instances = 1;
825 exec->vtx.prim[i].base_instance = 0;
826
827 ctx->Driver.CurrentExecPrimitive = mode;
828 }
829 else
830 _mesa_error( ctx, GL_INVALID_OPERATION, "glBegin" );
831
832 }
833
834
835 /**
836 * Called via glEnd.
837 */
838 static void GLAPIENTRY vbo_exec_End( void )
839 {
840 GET_CURRENT_CONTEXT( ctx );
841
842 if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {
843 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
844
845 if (exec->vtx.prim_count > 0) {
846 /* close off current primitive */
847 int idx = exec->vtx.vert_count;
848 int i = exec->vtx.prim_count - 1;
849
850 exec->vtx.prim[i].end = 1;
851 exec->vtx.prim[i].count = idx - exec->vtx.prim[i].start;
852 }
853
854 ctx->Driver.CurrentExecPrimitive = PRIM_OUTSIDE_BEGIN_END;
855
856 if (exec->vtx.prim_count == VBO_MAX_PRIM)
857 vbo_exec_vtx_flush( exec, GL_FALSE );
858 }
859 else
860 _mesa_error( ctx, GL_INVALID_OPERATION, "glEnd" );
861
862 if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH) {
863 _mesa_flush(ctx);
864 }
865 }
866
867
868 /**
869 * Called via glPrimitiveRestartNV()
870 */
871 static void GLAPIENTRY
872 vbo_exec_PrimitiveRestartNV(void)
873 {
874 GLenum curPrim;
875 GET_CURRENT_CONTEXT( ctx );
876
877 curPrim = ctx->Driver.CurrentExecPrimitive;
878
879 if (curPrim == PRIM_OUTSIDE_BEGIN_END) {
880 _mesa_error( ctx, GL_INVALID_OPERATION, "glPrimitiveRestartNV" );
881 }
882 else {
883 vbo_exec_End();
884 vbo_exec_Begin(curPrim);
885 }
886 }
887
888
889
890 static void vbo_exec_vtxfmt_init( struct vbo_exec_context *exec )
891 {
892 struct gl_context *ctx = exec->ctx;
893 GLvertexformat *vfmt = &exec->vtxfmt;
894
895 _MESA_INIT_ARRAYELT_VTXFMT(vfmt, _ae_);
896
897 vfmt->Begin = vbo_exec_Begin;
898 vfmt->End = vbo_exec_End;
899 vfmt->PrimitiveRestartNV = vbo_exec_PrimitiveRestartNV;
900
901 _MESA_INIT_DLIST_VTXFMT(vfmt, _mesa_);
902 _MESA_INIT_EVAL_VTXFMT(vfmt, vbo_exec_);
903
904 vfmt->Rectf = vbo_exec_Rectf;
905
906 /* from attrib_tmp.h:
907 */
908 vfmt->Color3f = vbo_Color3f;
909 vfmt->Color3fv = vbo_Color3fv;
910 vfmt->Color4f = vbo_Color4f;
911 vfmt->Color4fv = vbo_Color4fv;
912 vfmt->FogCoordfEXT = vbo_FogCoordfEXT;
913 vfmt->FogCoordfvEXT = vbo_FogCoordfvEXT;
914 vfmt->MultiTexCoord1fARB = vbo_MultiTexCoord1f;
915 vfmt->MultiTexCoord1fvARB = vbo_MultiTexCoord1fv;
916 vfmt->MultiTexCoord2fARB = vbo_MultiTexCoord2f;
917 vfmt->MultiTexCoord2fvARB = vbo_MultiTexCoord2fv;
918 vfmt->MultiTexCoord3fARB = vbo_MultiTexCoord3f;
919 vfmt->MultiTexCoord3fvARB = vbo_MultiTexCoord3fv;
920 vfmt->MultiTexCoord4fARB = vbo_MultiTexCoord4f;
921 vfmt->MultiTexCoord4fvARB = vbo_MultiTexCoord4fv;
922 vfmt->Normal3f = vbo_Normal3f;
923 vfmt->Normal3fv = vbo_Normal3fv;
924 vfmt->SecondaryColor3fEXT = vbo_SecondaryColor3fEXT;
925 vfmt->SecondaryColor3fvEXT = vbo_SecondaryColor3fvEXT;
926 vfmt->TexCoord1f = vbo_TexCoord1f;
927 vfmt->TexCoord1fv = vbo_TexCoord1fv;
928 vfmt->TexCoord2f = vbo_TexCoord2f;
929 vfmt->TexCoord2fv = vbo_TexCoord2fv;
930 vfmt->TexCoord3f = vbo_TexCoord3f;
931 vfmt->TexCoord3fv = vbo_TexCoord3fv;
932 vfmt->TexCoord4f = vbo_TexCoord4f;
933 vfmt->TexCoord4fv = vbo_TexCoord4fv;
934 vfmt->Vertex2f = vbo_Vertex2f;
935 vfmt->Vertex2fv = vbo_Vertex2fv;
936 vfmt->Vertex3f = vbo_Vertex3f;
937 vfmt->Vertex3fv = vbo_Vertex3fv;
938 vfmt->Vertex4f = vbo_Vertex4f;
939 vfmt->Vertex4fv = vbo_Vertex4fv;
940
941 if (ctx->API == API_OPENGLES2) {
942 vfmt->VertexAttrib1fARB = _es_VertexAttrib1f;
943 vfmt->VertexAttrib1fvARB = _es_VertexAttrib1fv;
944 vfmt->VertexAttrib2fARB = _es_VertexAttrib2f;
945 vfmt->VertexAttrib2fvARB = _es_VertexAttrib2fv;
946 vfmt->VertexAttrib3fARB = _es_VertexAttrib3f;
947 vfmt->VertexAttrib3fvARB = _es_VertexAttrib3fv;
948 vfmt->VertexAttrib4fARB = _es_VertexAttrib4f;
949 vfmt->VertexAttrib4fvARB = _es_VertexAttrib4fv;
950 } else {
951 vfmt->VertexAttrib1fARB = vbo_VertexAttrib1fARB;
952 vfmt->VertexAttrib1fvARB = vbo_VertexAttrib1fvARB;
953 vfmt->VertexAttrib2fARB = vbo_VertexAttrib2fARB;
954 vfmt->VertexAttrib2fvARB = vbo_VertexAttrib2fvARB;
955 vfmt->VertexAttrib3fARB = vbo_VertexAttrib3fARB;
956 vfmt->VertexAttrib3fvARB = vbo_VertexAttrib3fvARB;
957 vfmt->VertexAttrib4fARB = vbo_VertexAttrib4fARB;
958 vfmt->VertexAttrib4fvARB = vbo_VertexAttrib4fvARB;
959 }
960
961 vfmt->VertexAttrib1fNV = vbo_VertexAttrib1fNV;
962 vfmt->VertexAttrib1fvNV = vbo_VertexAttrib1fvNV;
963 vfmt->VertexAttrib2fNV = vbo_VertexAttrib2fNV;
964 vfmt->VertexAttrib2fvNV = vbo_VertexAttrib2fvNV;
965 vfmt->VertexAttrib3fNV = vbo_VertexAttrib3fNV;
966 vfmt->VertexAttrib3fvNV = vbo_VertexAttrib3fvNV;
967 vfmt->VertexAttrib4fNV = vbo_VertexAttrib4fNV;
968 vfmt->VertexAttrib4fvNV = vbo_VertexAttrib4fvNV;
969
970 /* integer-valued */
971 vfmt->VertexAttribI1i = vbo_VertexAttribI1i;
972 vfmt->VertexAttribI2i = vbo_VertexAttribI2i;
973 vfmt->VertexAttribI3i = vbo_VertexAttribI3i;
974 vfmt->VertexAttribI4i = vbo_VertexAttribI4i;
975 vfmt->VertexAttribI2iv = vbo_VertexAttribI2iv;
976 vfmt->VertexAttribI3iv = vbo_VertexAttribI3iv;
977 vfmt->VertexAttribI4iv = vbo_VertexAttribI4iv;
978
979 /* unsigned integer-valued */
980 vfmt->VertexAttribI1ui = vbo_VertexAttribI1ui;
981 vfmt->VertexAttribI2ui = vbo_VertexAttribI2ui;
982 vfmt->VertexAttribI3ui = vbo_VertexAttribI3ui;
983 vfmt->VertexAttribI4ui = vbo_VertexAttribI4ui;
984 vfmt->VertexAttribI2uiv = vbo_VertexAttribI2uiv;
985 vfmt->VertexAttribI3uiv = vbo_VertexAttribI3uiv;
986 vfmt->VertexAttribI4uiv = vbo_VertexAttribI4uiv;
987
988 vfmt->Materialfv = vbo_Materialfv;
989
990 vfmt->EdgeFlag = vbo_EdgeFlag;
991 vfmt->Indexf = vbo_Indexf;
992 vfmt->Indexfv = vbo_Indexfv;
993
994 /* ARB_vertex_type_2_10_10_10_rev */
995 vfmt->VertexP2ui = vbo_VertexP2ui;
996 vfmt->VertexP2uiv = vbo_VertexP2uiv;
997 vfmt->VertexP3ui = vbo_VertexP3ui;
998 vfmt->VertexP3uiv = vbo_VertexP3uiv;
999 vfmt->VertexP4ui = vbo_VertexP4ui;
1000 vfmt->VertexP4uiv = vbo_VertexP4uiv;
1001
1002 vfmt->TexCoordP1ui = vbo_TexCoordP1ui;
1003 vfmt->TexCoordP1uiv = vbo_TexCoordP1uiv;
1004 vfmt->TexCoordP2ui = vbo_TexCoordP2ui;
1005 vfmt->TexCoordP2uiv = vbo_TexCoordP2uiv;
1006 vfmt->TexCoordP3ui = vbo_TexCoordP3ui;
1007 vfmt->TexCoordP3uiv = vbo_TexCoordP3uiv;
1008 vfmt->TexCoordP4ui = vbo_TexCoordP4ui;
1009 vfmt->TexCoordP4uiv = vbo_TexCoordP4uiv;
1010
1011 vfmt->MultiTexCoordP1ui = vbo_MultiTexCoordP1ui;
1012 vfmt->MultiTexCoordP1uiv = vbo_MultiTexCoordP1uiv;
1013 vfmt->MultiTexCoordP2ui = vbo_MultiTexCoordP2ui;
1014 vfmt->MultiTexCoordP2uiv = vbo_MultiTexCoordP2uiv;
1015 vfmt->MultiTexCoordP3ui = vbo_MultiTexCoordP3ui;
1016 vfmt->MultiTexCoordP3uiv = vbo_MultiTexCoordP3uiv;
1017 vfmt->MultiTexCoordP4ui = vbo_MultiTexCoordP4ui;
1018 vfmt->MultiTexCoordP4uiv = vbo_MultiTexCoordP4uiv;
1019
1020 vfmt->NormalP3ui = vbo_NormalP3ui;
1021 vfmt->NormalP3uiv = vbo_NormalP3uiv;
1022
1023 vfmt->ColorP3ui = vbo_ColorP3ui;
1024 vfmt->ColorP3uiv = vbo_ColorP3uiv;
1025 vfmt->ColorP4ui = vbo_ColorP4ui;
1026 vfmt->ColorP4uiv = vbo_ColorP4uiv;
1027
1028 vfmt->SecondaryColorP3ui = vbo_SecondaryColorP3ui;
1029 vfmt->SecondaryColorP3uiv = vbo_SecondaryColorP3uiv;
1030
1031 vfmt->VertexAttribP1ui = vbo_VertexAttribP1ui;
1032 vfmt->VertexAttribP1uiv = vbo_VertexAttribP1uiv;
1033 vfmt->VertexAttribP2ui = vbo_VertexAttribP2ui;
1034 vfmt->VertexAttribP2uiv = vbo_VertexAttribP2uiv;
1035 vfmt->VertexAttribP3ui = vbo_VertexAttribP3ui;
1036 vfmt->VertexAttribP3uiv = vbo_VertexAttribP3uiv;
1037 vfmt->VertexAttribP4ui = vbo_VertexAttribP4ui;
1038 vfmt->VertexAttribP4uiv = vbo_VertexAttribP4uiv;
1039 }
1040
1041
1042 /**
1043 * Tell the VBO module to use a real OpenGL vertex buffer object to
1044 * store accumulated immediate-mode vertex data.
1045 * This replaces the malloced buffer which was created in
1046 * vb_exec_vtx_init() below.
1047 */
1048 void vbo_use_buffer_objects(struct gl_context *ctx)
1049 {
1050 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
1051 /* Any buffer name but 0 can be used here since this bufferobj won't
1052 * go into the bufferobj hashtable.
1053 */
1054 GLuint bufName = IMM_BUFFER_NAME;
1055 GLenum target = GL_ARRAY_BUFFER_ARB;
1056 GLenum usage = GL_STREAM_DRAW_ARB;
1057 GLsizei size = VBO_VERT_BUFFER_SIZE;
1058
1059 /* Make sure this func is only used once */
1060 assert(exec->vtx.bufferobj == ctx->Shared->NullBufferObj);
1061 if (exec->vtx.buffer_map) {
1062 _mesa_align_free(exec->vtx.buffer_map);
1063 exec->vtx.buffer_map = NULL;
1064 exec->vtx.buffer_ptr = NULL;
1065 }
1066
1067 /* Allocate a real buffer object now */
1068 _mesa_reference_buffer_object(ctx, &exec->vtx.bufferobj, NULL);
1069 exec->vtx.bufferobj = ctx->Driver.NewBufferObject(ctx, bufName, target);
1070 if (!ctx->Driver.BufferData(ctx, target, size, NULL, usage, exec->vtx.bufferobj)) {
1071 _mesa_error(ctx, GL_OUT_OF_MEMORY, "VBO allocation");
1072 }
1073 }
1074
1075
1076 /**
1077 * If this function is called, all VBO buffers will be unmapped when
1078 * we flush.
1079 * Otherwise, if a simple command like glColor3f() is called and we flush,
1080 * the current VBO may be left mapped.
1081 */
1082 void
1083 vbo_always_unmap_buffers(struct gl_context *ctx)
1084 {
1085 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
1086 exec->begin_vertices_flags |= FLUSH_STORED_VERTICES;
1087 }
1088
1089
1090 void vbo_exec_vtx_init( struct vbo_exec_context *exec )
1091 {
1092 struct gl_context *ctx = exec->ctx;
1093 struct vbo_context *vbo = vbo_context(ctx);
1094 GLuint i;
1095
1096 /* Allocate a buffer object. Will just reuse this object
1097 * continuously, unless vbo_use_buffer_objects() is called to enable
1098 * use of real VBOs.
1099 */
1100 _mesa_reference_buffer_object(ctx,
1101 &exec->vtx.bufferobj,
1102 ctx->Shared->NullBufferObj);
1103
1104 ASSERT(!exec->vtx.buffer_map);
1105 exec->vtx.buffer_map = _mesa_align_malloc(VBO_VERT_BUFFER_SIZE, 64);
1106 exec->vtx.buffer_ptr = exec->vtx.buffer_map;
1107
1108 vbo_exec_vtxfmt_init( exec );
1109 _mesa_noop_vtxfmt_init(&exec->vtxfmt_noop);
1110
1111 /* Hook our functions into the dispatch table.
1112 */
1113 _mesa_install_exec_vtxfmt( ctx, &exec->vtxfmt );
1114
1115 for (i = 0 ; i < VBO_ATTRIB_MAX ; i++) {
1116 ASSERT(i < Elements(exec->vtx.attrsz));
1117 exec->vtx.attrsz[i] = 0;
1118 ASSERT(i < Elements(exec->vtx.active_sz));
1119 exec->vtx.active_sz[i] = 0;
1120 }
1121 for (i = 0 ; i < VERT_ATTRIB_MAX; i++) {
1122 ASSERT(i < Elements(exec->vtx.inputs));
1123 ASSERT(i < Elements(exec->vtx.arrays));
1124 exec->vtx.inputs[i] = &exec->vtx.arrays[i];
1125 }
1126
1127 {
1128 struct gl_client_array *arrays = exec->vtx.arrays;
1129 unsigned i;
1130
1131 memcpy(arrays, &vbo->currval[VBO_ATTRIB_POS],
1132 VERT_ATTRIB_FF_MAX * sizeof(arrays[0]));
1133 for (i = 0; i < VERT_ATTRIB_FF_MAX; ++i) {
1134 struct gl_client_array *array;
1135 array = &arrays[VERT_ATTRIB_FF(i)];
1136 array->BufferObj = NULL;
1137 _mesa_reference_buffer_object(ctx, &arrays->BufferObj,
1138 vbo->currval[VBO_ATTRIB_POS+i].BufferObj);
1139 }
1140
1141 memcpy(arrays + VERT_ATTRIB_GENERIC(0),
1142 &vbo->currval[VBO_ATTRIB_GENERIC0],
1143 VERT_ATTRIB_GENERIC_MAX * sizeof(arrays[0]));
1144
1145 for (i = 0; i < VERT_ATTRIB_GENERIC_MAX; ++i) {
1146 struct gl_client_array *array;
1147 array = &arrays[VERT_ATTRIB_GENERIC(i)];
1148 array->BufferObj = NULL;
1149 _mesa_reference_buffer_object(ctx, &array->BufferObj,
1150 vbo->currval[VBO_ATTRIB_GENERIC0+i].BufferObj);
1151 }
1152 }
1153
1154 exec->vtx.vertex_size = 0;
1155
1156 exec->begin_vertices_flags = FLUSH_UPDATE_CURRENT;
1157 }
1158
1159
1160 void vbo_exec_vtx_destroy( struct vbo_exec_context *exec )
1161 {
1162 /* using a real VBO for vertex data */
1163 struct gl_context *ctx = exec->ctx;
1164 unsigned i;
1165
1166 /* True VBOs should already be unmapped
1167 */
1168 if (exec->vtx.buffer_map) {
1169 ASSERT(exec->vtx.bufferobj->Name == 0 ||
1170 exec->vtx.bufferobj->Name == IMM_BUFFER_NAME);
1171 if (exec->vtx.bufferobj->Name == 0) {
1172 _mesa_align_free(exec->vtx.buffer_map);
1173 exec->vtx.buffer_map = NULL;
1174 exec->vtx.buffer_ptr = NULL;
1175 }
1176 }
1177
1178 /* Drop any outstanding reference to the vertex buffer
1179 */
1180 for (i = 0; i < Elements(exec->vtx.arrays); i++) {
1181 _mesa_reference_buffer_object(ctx,
1182 &exec->vtx.arrays[i].BufferObj,
1183 NULL);
1184 }
1185
1186 /* Free the vertex buffer. Unmap first if needed.
1187 */
1188 if (_mesa_bufferobj_mapped(exec->vtx.bufferobj)) {
1189 ctx->Driver.UnmapBuffer(ctx, exec->vtx.bufferobj);
1190 }
1191 _mesa_reference_buffer_object(ctx, &exec->vtx.bufferobj, NULL);
1192 }
1193
1194
1195 /**
1196 * Called upon first glVertex, glColor, glTexCoord, etc.
1197 */
1198 void vbo_exec_BeginVertices( struct gl_context *ctx )
1199 {
1200 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
1201
1202 vbo_exec_vtx_map( exec );
1203
1204 assert((ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) == 0);
1205 assert(exec->begin_vertices_flags);
1206
1207 ctx->Driver.NeedFlush |= exec->begin_vertices_flags;
1208 }
1209
1210
1211 /**
1212 * Called via ctx->Driver.FlushVertices()
1213 * \param flags bitmask of FLUSH_STORED_VERTICES, FLUSH_UPDATE_CURRENT
1214 */
1215 void vbo_exec_FlushVertices( struct gl_context *ctx, GLuint flags )
1216 {
1217 struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
1218
1219 #ifdef DEBUG
1220 /* debug check: make sure we don't get called recursively */
1221 exec->flush_call_depth++;
1222 assert(exec->flush_call_depth == 1);
1223 #endif
1224
1225 if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {
1226 /* We've had glBegin but not glEnd! */
1227 #ifdef DEBUG
1228 exec->flush_call_depth--;
1229 assert(exec->flush_call_depth == 0);
1230 #endif
1231 return;
1232 }
1233
1234 /* Flush (draw), and make sure VBO is left unmapped when done */
1235 vbo_exec_FlushVertices_internal(exec, GL_TRUE);
1236
1237 /* Need to do this to ensure BeginVertices gets called again:
1238 */
1239 ctx->Driver.NeedFlush &= ~(FLUSH_UPDATE_CURRENT | flags);
1240
1241 #ifdef DEBUG
1242 exec->flush_call_depth--;
1243 assert(exec->flush_call_depth == 0);
1244 #endif
1245 }
1246
1247
1248 static void reset_attrfv( struct vbo_exec_context *exec )
1249 {
1250 GLuint i;
1251
1252 for (i = 0 ; i < VBO_ATTRIB_MAX ; i++) {
1253 exec->vtx.attrsz[i] = 0;
1254 exec->vtx.active_sz[i] = 0;
1255 }
1256
1257 exec->vtx.vertex_size = 0;
1258 }
1259
1260
1261 void GLAPIENTRY
1262 _es_Color4f(GLfloat r, GLfloat g, GLfloat b, GLfloat a)
1263 {
1264 vbo_Color4f(r, g, b, a);
1265 }
1266
1267
1268 void GLAPIENTRY
1269 _es_Normal3f(GLfloat x, GLfloat y, GLfloat z)
1270 {
1271 vbo_Normal3f(x, y, z);
1272 }
1273
1274
1275 void GLAPIENTRY
1276 _es_MultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
1277 {
1278 vbo_MultiTexCoord4f(target, s, t, r, q);
1279 }
1280
1281
1282 void GLAPIENTRY
1283 _es_Materialfv(GLenum face, GLenum pname, const GLfloat *params)
1284 {
1285 vbo_Materialfv(face, pname, params);
1286 }
1287
1288
1289 void GLAPIENTRY
1290 _es_Materialf(GLenum face, GLenum pname, GLfloat param)
1291 {
1292 GLfloat p[4];
1293 p[0] = param;
1294 p[1] = p[2] = p[3] = 0.0F;
1295 vbo_Materialfv(face, pname, p);
1296 }
1297
1298
1299 /**
1300 * A special version of glVertexAttrib4f that does not treat index 0 as
1301 * VBO_ATTRIB_POS.
1302 */
1303 static void
1304 VertexAttrib4f_nopos(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1305 {
1306 GET_CURRENT_CONTEXT(ctx);
1307 if (index < MAX_VERTEX_GENERIC_ATTRIBS)
1308 ATTR(VBO_ATTRIB_GENERIC0 + index, 4, x, y, z, w);
1309 else
1310 ERROR(GL_INVALID_VALUE);
1311 }
1312
1313 void GLAPIENTRY
1314 _es_VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1315 {
1316 VertexAttrib4f_nopos(index, x, y, z, w);
1317 }
1318
1319
1320 void GLAPIENTRY
1321 _es_VertexAttrib1f(GLuint indx, GLfloat x)
1322 {
1323 VertexAttrib4f_nopos(indx, x, 0.0f, 0.0f, 1.0f);
1324 }
1325
1326
1327 void GLAPIENTRY
1328 _es_VertexAttrib1fv(GLuint indx, const GLfloat* values)
1329 {
1330 VertexAttrib4f_nopos(indx, values[0], 0.0f, 0.0f, 1.0f);
1331 }
1332
1333
1334 void GLAPIENTRY
1335 _es_VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
1336 {
1337 VertexAttrib4f_nopos(indx, x, y, 0.0f, 1.0f);
1338 }
1339
1340
1341 void GLAPIENTRY
1342 _es_VertexAttrib2fv(GLuint indx, const GLfloat* values)
1343 {
1344 VertexAttrib4f_nopos(indx, values[0], values[1], 0.0f, 1.0f);
1345 }
1346
1347
1348 void GLAPIENTRY
1349 _es_VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
1350 {
1351 VertexAttrib4f_nopos(indx, x, y, z, 1.0f);
1352 }
1353
1354
1355 void GLAPIENTRY
1356 _es_VertexAttrib3fv(GLuint indx, const GLfloat* values)
1357 {
1358 VertexAttrib4f_nopos(indx, values[0], values[1], values[2], 1.0f);
1359 }
1360
1361
1362 void GLAPIENTRY
1363 _es_VertexAttrib4fv(GLuint indx, const GLfloat* values)
1364 {
1365 VertexAttrib4f_nopos(indx, values[0], values[1], values[2], values[3]);
1366 }