projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge commit 'origin/gallium-0.1' into gallium-0.2
[mesa.git] / src / mesa / main / dlist.c
1 /*
2 * Mesa 3-D graphics library
3 * Version: 7.1
4 *
5 * Copyright (C) 1999-2007 Brian Paul 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 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25
26 /**
27 * \file dlist.c
28 * Display lists management functions.
29 */
30
31 #include "glheader.h"
32 #include "imports.h"
33 #include "api_arrayelt.h"
34 #include "api_loopback.h"
35 #include "config.h"
36 #include "attrib.h"
37 #include "blend.h"
38 #include "buffers.h"
39 #if FEATURE_ARB_vertex_buffer_object
40 #include "bufferobj.h"
41 #endif
42 #include "arrayobj.h"
43 #include "clip.h"
44 #include "colortab.h"
45 #include "context.h"
46 #include "convolve.h"
47 #include "depth.h"
48 #include "dlist.h"
49 #include "enable.h"
50 #include "enums.h"
51 #include "eval.h"
52 #include "extensions.h"
53 #include "feedback.h"
54 #include "framebuffer.h"
55 #include "get.h"
56 #include "glapi/glapi.h"
57 #include "hash.h"
58 #include "histogram.h"
59 #include "image.h"
60 #include "light.h"
61 #include "lines.h"
62 #include "dlist.h"
63 #include "macros.h"
64 #include "matrix.h"
65 #include "pixel.h"
66 #include "points.h"
67 #include "polygon.h"
68 #include "queryobj.h"
69 #include "state.h"
70 #include "texobj.h"
71 #include "teximage.h"
72 #include "texstate.h"
73 #include "mtypes.h"
74 #include "varray.h"
75 #if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
76 #include "shader/arbprogram.h"
77 #include "shader/program.h"
78 #endif
79 #if FEATURE_NV_vertex_program || FEATURE_NV_fragment_program
80 #include "shader/nvprogram.h"
81 #include "shader/program.h"
82 #endif
83 #if FEATURE_ATI_fragment_shader
84 #include "shader/atifragshader.h"
85 #endif
86
87 #include "math/m_matrix.h"
88 #include "math/m_xform.h"
89
90 #include "glapi/dispatch.h"
91
92
93 /**
94 * Flush vertices.
95 *
96 * \param ctx GL context.
97 *
98 * Checks if dd_function_table::SaveNeedFlush is marked to flush
99 * stored (save) vertices, and calls
100 * dd_function_table::SaveFlushVertices if so.
101 */
102 #define SAVE_FLUSH_VERTICES(ctx) \
103 do { \
104 if (ctx->Driver.SaveNeedFlush) \
105 ctx->Driver.SaveFlushVertices(ctx); \
106 } while (0)
107
108
109 /**
110 * Macro to assert that the API call was made outside the
111 * glBegin()/glEnd() pair, with return value.
112 *
113 * \param ctx GL context.
114 * \param retval value to return value in case the assertion fails.
115 */
116 #define ASSERT_OUTSIDE_SAVE_BEGIN_END_WITH_RETVAL(ctx, retval) \
117 do { \
118 if (ctx->Driver.CurrentSavePrimitive <= GL_POLYGON || \
119 ctx->Driver.CurrentSavePrimitive == PRIM_INSIDE_UNKNOWN_PRIM) { \
120 _mesa_compile_error( ctx, GL_INVALID_OPERATION, "begin/end" ); \
121 return retval; \
122 } \
123 } while (0)
124
125 /**
126 * Macro to assert that the API call was made outside the
127 * glBegin()/glEnd() pair.
128 *
129 * \param ctx GL context.
130 */
131 #define ASSERT_OUTSIDE_SAVE_BEGIN_END(ctx) \
132 do { \
133 if (ctx->Driver.CurrentSavePrimitive <= GL_POLYGON || \
134 ctx->Driver.CurrentSavePrimitive == PRIM_INSIDE_UNKNOWN_PRIM) { \
135 _mesa_compile_error( ctx, GL_INVALID_OPERATION, "begin/end" ); \
136 return; \
137 } \
138 } while (0)
139
140 /**
141 * Macro to assert that the API call was made outside the
142 * glBegin()/glEnd() pair and flush the vertices.
143 *
144 * \param ctx GL context.
145 */
146 #define ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx) \
147 do { \
148 ASSERT_OUTSIDE_SAVE_BEGIN_END(ctx); \
149 SAVE_FLUSH_VERTICES(ctx); \
150 } while (0)
151
152 /**
153 * Macro to assert that the API call was made outside the
154 * glBegin()/glEnd() pair and flush the vertices, with return value.
155 *
156 * \param ctx GL context.
157 * \param retval value to return value in case the assertion fails.
158 */
159 #define ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, retval)\
160 do { \
161 ASSERT_OUTSIDE_SAVE_BEGIN_END_WITH_RETVAL(ctx, retval); \
162 SAVE_FLUSH_VERTICES(ctx); \
163 } while (0)
164
165
166
167 /**
168 * Display list opcodes.
169 *
170 * The fact that these identifiers are assigned consecutive
171 * integer values starting at 0 is very important, see InstSize array usage)
172 */
173 typedef enum
174 {
175 OPCODE_INVALID = -1, /* Force signed enum */
176 OPCODE_ACCUM,
177 OPCODE_ALPHA_FUNC,
178 OPCODE_BIND_TEXTURE,
179 OPCODE_BITMAP,
180 OPCODE_BLEND_COLOR,
181 OPCODE_BLEND_EQUATION,
182 OPCODE_BLEND_EQUATION_SEPARATE,
183 OPCODE_BLEND_FUNC_SEPARATE,
184 OPCODE_CALL_LIST,
185 OPCODE_CALL_LIST_OFFSET,
186 OPCODE_CLEAR,
187 OPCODE_CLEAR_ACCUM,
188 OPCODE_CLEAR_COLOR,
189 OPCODE_CLEAR_DEPTH,
190 OPCODE_CLEAR_INDEX,
191 OPCODE_CLEAR_STENCIL,
192 OPCODE_CLIP_PLANE,
193 OPCODE_COLOR_MASK,
194 OPCODE_COLOR_MATERIAL,
195 OPCODE_COLOR_TABLE,
196 OPCODE_COLOR_TABLE_PARAMETER_FV,
197 OPCODE_COLOR_TABLE_PARAMETER_IV,
198 OPCODE_COLOR_SUB_TABLE,
199 OPCODE_CONVOLUTION_FILTER_1D,
200 OPCODE_CONVOLUTION_FILTER_2D,
201 OPCODE_CONVOLUTION_PARAMETER_I,
202 OPCODE_CONVOLUTION_PARAMETER_IV,
203 OPCODE_CONVOLUTION_PARAMETER_F,
204 OPCODE_CONVOLUTION_PARAMETER_FV,
205 OPCODE_COPY_COLOR_SUB_TABLE,
206 OPCODE_COPY_COLOR_TABLE,
207 OPCODE_COPY_PIXELS,
208 OPCODE_COPY_TEX_IMAGE1D,
209 OPCODE_COPY_TEX_IMAGE2D,
210 OPCODE_COPY_TEX_SUB_IMAGE1D,
211 OPCODE_COPY_TEX_SUB_IMAGE2D,
212 OPCODE_COPY_TEX_SUB_IMAGE3D,
213 OPCODE_CULL_FACE,
214 OPCODE_DEPTH_FUNC,
215 OPCODE_DEPTH_MASK,
216 OPCODE_DEPTH_RANGE,
217 OPCODE_DISABLE,
218 OPCODE_DRAW_BUFFER,
219 OPCODE_DRAW_PIXELS,
220 OPCODE_ENABLE,
221 OPCODE_EVALMESH1,
222 OPCODE_EVALMESH2,
223 OPCODE_FOG,
224 OPCODE_FRONT_FACE,
225 OPCODE_FRUSTUM,
226 OPCODE_HINT,
227 OPCODE_HISTOGRAM,
228 OPCODE_INDEX_MASK,
229 OPCODE_INIT_NAMES,
230 OPCODE_LIGHT,
231 OPCODE_LIGHT_MODEL,
232 OPCODE_LINE_STIPPLE,
233 OPCODE_LINE_WIDTH,
234 OPCODE_LIST_BASE,
235 OPCODE_LOAD_IDENTITY,
236 OPCODE_LOAD_MATRIX,
237 OPCODE_LOAD_NAME,
238 OPCODE_LOGIC_OP,
239 OPCODE_MAP1,
240 OPCODE_MAP2,
241 OPCODE_MAPGRID1,
242 OPCODE_MAPGRID2,
243 OPCODE_MATRIX_MODE,
244 OPCODE_MIN_MAX,
245 OPCODE_MULT_MATRIX,
246 OPCODE_ORTHO,
247 OPCODE_PASSTHROUGH,
248 OPCODE_PIXEL_MAP,
249 OPCODE_PIXEL_TRANSFER,
250 OPCODE_PIXEL_ZOOM,
251 OPCODE_POINT_SIZE,
252 OPCODE_POINT_PARAMETERS,
253 OPCODE_POLYGON_MODE,
254 OPCODE_POLYGON_STIPPLE,
255 OPCODE_POLYGON_OFFSET,
256 OPCODE_POP_ATTRIB,
257 OPCODE_POP_MATRIX,
258 OPCODE_POP_NAME,
259 OPCODE_PRIORITIZE_TEXTURE,
260 OPCODE_PUSH_ATTRIB,
261 OPCODE_PUSH_MATRIX,
262 OPCODE_PUSH_NAME,
263 OPCODE_RASTER_POS,
264 OPCODE_READ_BUFFER,
265 OPCODE_RESET_HISTOGRAM,
266 OPCODE_RESET_MIN_MAX,
267 OPCODE_ROTATE,
268 OPCODE_SCALE,
269 OPCODE_SCISSOR,
270 OPCODE_SELECT_TEXTURE_SGIS,
271 OPCODE_SELECT_TEXTURE_COORD_SET,
272 OPCODE_SHADE_MODEL,
273 OPCODE_STENCIL_FUNC,
274 OPCODE_STENCIL_MASK,
275 OPCODE_STENCIL_OP,
276 OPCODE_TEXENV,
277 OPCODE_TEXGEN,
278 OPCODE_TEXPARAMETER,
279 OPCODE_TEX_IMAGE1D,
280 OPCODE_TEX_IMAGE2D,
281 OPCODE_TEX_IMAGE3D,
282 OPCODE_TEX_SUB_IMAGE1D,
283 OPCODE_TEX_SUB_IMAGE2D,
284 OPCODE_TEX_SUB_IMAGE3D,
285 OPCODE_TRANSLATE,
286 OPCODE_VIEWPORT,
287 OPCODE_WINDOW_POS,
288 /* GL_ARB_multitexture */
289 OPCODE_ACTIVE_TEXTURE,
290 /* GL_ARB_texture_compression */
291 OPCODE_COMPRESSED_TEX_IMAGE_1D,
292 OPCODE_COMPRESSED_TEX_IMAGE_2D,
293 OPCODE_COMPRESSED_TEX_IMAGE_3D,
294 OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D,
295 OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D,
296 OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D,
297 /* GL_ARB_multisample */
298 OPCODE_SAMPLE_COVERAGE,
299 /* GL_ARB_window_pos */
300 OPCODE_WINDOW_POS_ARB,
301 /* GL_NV_vertex_program */
302 OPCODE_BIND_PROGRAM_NV,
303 OPCODE_EXECUTE_PROGRAM_NV,
304 OPCODE_REQUEST_RESIDENT_PROGRAMS_NV,
305 OPCODE_LOAD_PROGRAM_NV,
306 OPCODE_TRACK_MATRIX_NV,
307 /* GL_NV_fragment_program */
308 OPCODE_PROGRAM_LOCAL_PARAMETER_ARB,
309 OPCODE_PROGRAM_NAMED_PARAMETER_NV,
310 /* GL_EXT_stencil_two_side */
311 OPCODE_ACTIVE_STENCIL_FACE_EXT,
312 /* GL_EXT_depth_bounds_test */
313 OPCODE_DEPTH_BOUNDS_EXT,
314 /* GL_ARB_vertex/fragment_program */
315 OPCODE_PROGRAM_STRING_ARB,
316 OPCODE_PROGRAM_ENV_PARAMETER_ARB,
317 /* GL_ARB_occlusion_query */
318 OPCODE_BEGIN_QUERY_ARB,
319 OPCODE_END_QUERY_ARB,
320 /* GL_ARB_draw_buffers */
321 OPCODE_DRAW_BUFFERS_ARB,
322 /* GL_ATI_fragment_shader */
323 OPCODE_BIND_FRAGMENT_SHADER_ATI,
324 OPCODE_SET_FRAGMENT_SHADER_CONSTANTS_ATI,
325 /* OpenGL 2.0 */
326 OPCODE_STENCIL_FUNC_SEPARATE,
327 OPCODE_STENCIL_OP_SEPARATE,
328 OPCODE_STENCIL_MASK_SEPARATE,
329
330 /* GL_EXT_framebuffer_blit */
331 OPCODE_BLIT_FRAMEBUFFER,
332
333 /* Vertex attributes -- fallback for when optimized display
334 * list build isn't active.
335 */
336 OPCODE_ATTR_1F_NV,
337 OPCODE_ATTR_2F_NV,
338 OPCODE_ATTR_3F_NV,
339 OPCODE_ATTR_4F_NV,
340 OPCODE_ATTR_1F_ARB,
341 OPCODE_ATTR_2F_ARB,
342 OPCODE_ATTR_3F_ARB,
343 OPCODE_ATTR_4F_ARB,
344 OPCODE_MATERIAL,
345 OPCODE_BEGIN,
346 OPCODE_END,
347 OPCODE_RECTF,
348 OPCODE_EVAL_C1,
349 OPCODE_EVAL_C2,
350 OPCODE_EVAL_P1,
351 OPCODE_EVAL_P2,
352
353 /* The following three are meta instructions */
354 OPCODE_ERROR, /* raise compiled-in error */
355 OPCODE_CONTINUE,
356 OPCODE_END_OF_LIST,
357 OPCODE_EXT_0
358 } OpCode;
359
360
361
362 /**
363 * Display list node.
364 *
365 * Display list instructions are stored as sequences of "nodes". Nodes
366 * are allocated in blocks. Each block has BLOCK_SIZE nodes. Blocks
367 * are linked together with a pointer.
368 *
369 * Each instruction in the display list is stored as a sequence of
370 * contiguous nodes in memory.
371 * Each node is the union of a variety of data types.
372 */
373 union node
374 {
375 OpCode opcode;
376 GLboolean b;
377 GLbitfield bf;
378 GLubyte ub;
379 GLshort s;
380 GLushort us;
381 GLint i;
382 GLuint ui;
383 GLenum e;
384 GLfloat f;
385 GLvoid *data;
386 void *next; /* If prev node's opcode==OPCODE_CONTINUE */
387 };
388
389
390 /**
391 * How many nodes to allocate at a time.
392 *
393 * \note Reduced now that we hold vertices etc. elsewhere.
394 */
395 #define BLOCK_SIZE 256
396
397
398
399 /**
400 * Number of nodes of storage needed for each instruction.
401 * Sizes for dynamically allocated opcodes are stored in the context struct.
402 */
403 static GLuint InstSize[OPCODE_END_OF_LIST + 1];
404
405 void mesa_print_display_list(GLuint list);
406
407
408 /**********************************************************************/
409 /***** Private *****/
410 /**********************************************************************/
411
412
413 /**
414 * Make an empty display list. This is used by glGenLists() to
415 * reserve display list IDs.
416 */
417 static struct mesa_display_list *
418 make_list(GLuint list, GLuint count)
419 {
420 struct mesa_display_list *dlist = CALLOC_STRUCT(mesa_display_list);
421 dlist->id = list;
422 dlist->node = (Node *) _mesa_malloc(sizeof(Node) * count);
423 dlist->node[0].opcode = OPCODE_END_OF_LIST;
424 return dlist;
425 }
426
427
428 /**
429 * Lookup function to just encapsulate casting.
430 */
431 static INLINE struct mesa_display_list *
432 lookup_list(GLcontext *ctx, GLuint list)
433 {
434 return (struct mesa_display_list *)
435 _mesa_HashLookup(ctx->Shared->DisplayList, list);
436 }
437
438
439
440 /**
441 * Delete the named display list, but don't remove from hash table.
442 * \param dlist - display list pointer
443 */
444 void
445 _mesa_delete_list(GLcontext *ctx, struct mesa_display_list *dlist)
446 {
447 Node *n, *block;
448 GLboolean done;
449
450 n = block = dlist->node;
451
452 done = block ? GL_FALSE : GL_TRUE;
453 while (!done) {
454
455 /* check for extension opcodes first */
456
457 GLint i = (GLint) n[0].opcode - (GLint) OPCODE_EXT_0;
458 if (i >= 0 && i < (GLint) ctx->ListExt.NumOpcodes) {
459 ctx->ListExt.Opcode[i].Destroy(ctx, &n[1]);
460 n += ctx->ListExt.Opcode[i].Size;
461 }
462 else {
463 switch (n[0].opcode) {
464 /* for some commands, we need to free malloc'd memory */
465 case OPCODE_MAP1:
466 _mesa_free(n[6].data);
467 n += InstSize[n[0].opcode];
468 break;
469 case OPCODE_MAP2:
470 _mesa_free(n[10].data);
471 n += InstSize[n[0].opcode];
472 break;
473 case OPCODE_DRAW_PIXELS:
474 _mesa_free(n[5].data);
475 n += InstSize[n[0].opcode];
476 break;
477 case OPCODE_BITMAP:
478 _mesa_free(n[7].data);
479 n += InstSize[n[0].opcode];
480 break;
481 case OPCODE_COLOR_TABLE:
482 _mesa_free(n[6].data);
483 n += InstSize[n[0].opcode];
484 break;
485 case OPCODE_COLOR_SUB_TABLE:
486 _mesa_free(n[6].data);
487 n += InstSize[n[0].opcode];
488 break;
489 case OPCODE_CONVOLUTION_FILTER_1D:
490 _mesa_free(n[6].data);
491 n += InstSize[n[0].opcode];
492 break;
493 case OPCODE_CONVOLUTION_FILTER_2D:
494 _mesa_free(n[7].data);
495 n += InstSize[n[0].opcode];
496 break;
497 case OPCODE_POLYGON_STIPPLE:
498 _mesa_free(n[1].data);
499 n += InstSize[n[0].opcode];
500 break;
501 case OPCODE_TEX_IMAGE1D:
502 _mesa_free(n[8].data);
503 n += InstSize[n[0].opcode];
504 break;
505 case OPCODE_TEX_IMAGE2D:
506 _mesa_free(n[9].data);
507 n += InstSize[n[0].opcode];
508 break;
509 case OPCODE_TEX_IMAGE3D:
510 _mesa_free(n[10].data);
511 n += InstSize[n[0].opcode];
512 break;
513 case OPCODE_TEX_SUB_IMAGE1D:
514 _mesa_free(n[7].data);
515 n += InstSize[n[0].opcode];
516 break;
517 case OPCODE_TEX_SUB_IMAGE2D:
518 _mesa_free(n[9].data);
519 n += InstSize[n[0].opcode];
520 break;
521 case OPCODE_TEX_SUB_IMAGE3D:
522 _mesa_free(n[11].data);
523 n += InstSize[n[0].opcode];
524 break;
525 case OPCODE_COMPRESSED_TEX_IMAGE_1D:
526 _mesa_free(n[7].data);
527 n += InstSize[n[0].opcode];
528 break;
529 case OPCODE_COMPRESSED_TEX_IMAGE_2D:
530 _mesa_free(n[8].data);
531 n += InstSize[n[0].opcode];
532 break;
533 case OPCODE_COMPRESSED_TEX_IMAGE_3D:
534 _mesa_free(n[9].data);
535 n += InstSize[n[0].opcode];
536 break;
537 case OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D:
538 _mesa_free(n[7].data);
539 n += InstSize[n[0].opcode];
540 break;
541 case OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D:
542 _mesa_free(n[9].data);
543 n += InstSize[n[0].opcode];
544 break;
545 case OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D:
546 _mesa_free(n[11].data);
547 n += InstSize[n[0].opcode];
548 break;
549 #if FEATURE_NV_vertex_program
550 case OPCODE_LOAD_PROGRAM_NV:
551 _mesa_free(n[4].data); /* program string */
552 n += InstSize[n[0].opcode];
553 break;
554 case OPCODE_REQUEST_RESIDENT_PROGRAMS_NV:
555 _mesa_free(n[2].data); /* array of program ids */
556 n += InstSize[n[0].opcode];
557 break;
558 #endif
559 #if FEATURE_NV_fragment_program
560 case OPCODE_PROGRAM_NAMED_PARAMETER_NV:
561 _mesa_free(n[3].data); /* parameter name */
562 n += InstSize[n[0].opcode];
563 break;
564 #endif
565 #if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
566 case OPCODE_PROGRAM_STRING_ARB:
567 _mesa_free(n[4].data); /* program string */
568 n += InstSize[n[0].opcode];
569 break;
570 #endif
571 case OPCODE_CONTINUE:
572 n = (Node *) n[1].next;
573 _mesa_free(block);
574 block = n;
575 break;
576 case OPCODE_END_OF_LIST:
577 _mesa_free(block);
578 done = GL_TRUE;
579 break;
580 default:
581 /* Most frequent case */
582 n += InstSize[n[0].opcode];
583 break;
584 }
585 }
586 }
587
588 _mesa_free(dlist);
589 }
590
591
592 /**
593 * Destroy a display list and remove from hash table.
594 * \param list - display list number
595 */
596 static void
597 destroy_list(GLcontext *ctx, GLuint list)
598 {
599 struct mesa_display_list *dlist;
600
601 if (list == 0)
602 return;
603
604 dlist = lookup_list(ctx, list);
605 if (!dlist)
606 return;
607
608 _mesa_delete_list(ctx, dlist);
609 _mesa_HashRemove(ctx->Shared->DisplayList, list);
610 }
611
612
613 /*
614 * Translate the nth element of list from <type> to GLint.
615 */
616 static GLint
617 translate_id(GLsizei n, GLenum type, const GLvoid * list)
618 {
619 GLbyte *bptr;
620 GLubyte *ubptr;
621 GLshort *sptr;
622 GLushort *usptr;
623 GLint *iptr;
624 GLuint *uiptr;
625 GLfloat *fptr;
626
627 switch (type) {
628 case GL_BYTE:
629 bptr = (GLbyte *) list;
630 return (GLint) bptr[n];
631 case GL_UNSIGNED_BYTE:
632 ubptr = (GLubyte *) list;
633 return (GLint) ubptr[n];
634 case GL_SHORT:
635 sptr = (GLshort *) list;
636 return (GLint) sptr[n];
637 case GL_UNSIGNED_SHORT:
638 usptr = (GLushort *) list;
639 return (GLint) usptr[n];
640 case GL_INT:
641 iptr = (GLint *) list;
642 return iptr[n];
643 case GL_UNSIGNED_INT:
644 uiptr = (GLuint *) list;
645 return (GLint) uiptr[n];
646 case GL_FLOAT:
647 fptr = (GLfloat *) list;
648 return (GLint) FLOORF(fptr[n]);
649 case GL_2_BYTES:
650 ubptr = ((GLubyte *) list) + 2 * n;
651 return (GLint) ubptr[0] * 256
652 + (GLint) ubptr[1];
653 case GL_3_BYTES:
654 ubptr = ((GLubyte *) list) + 3 * n;
655 return (GLint) ubptr[0] * 65536
656 + (GLint) ubptr[1] * 256
657 + (GLint) ubptr[2];
658 case GL_4_BYTES:
659 ubptr = ((GLubyte *) list) + 4 * n;
660 return (GLint) ubptr[0] * 16777216
661 + (GLint) ubptr[1] * 65536
662 + (GLint) ubptr[2] * 256
663 + (GLint) ubptr[3];
664 default:
665 return 0;
666 }
667 }
668
669
670
671
672 /**********************************************************************/
673 /***** Public *****/
674 /**********************************************************************/
675
676 /**
677 * Wrapper for _mesa_unpack_image() that handles pixel buffer objects.
678 * \todo This won't suffice when the PBO is really in VRAM/GPU memory.
679 */
680 static GLvoid *
681 unpack_image(GLuint dimensions, GLsizei width, GLsizei height, GLsizei depth,
682 GLenum format, GLenum type, const GLvoid * pixels,
683 const struct gl_pixelstore_attrib *unpack)
684 {
685 if (unpack->BufferObj->Name == 0) {
686 /* no PBO */
687 return _mesa_unpack_image(dimensions, width, height, depth, format,
688 type, pixels, unpack);
689 }
690 else
691 if (_mesa_validate_pbo_access
692 (dimensions, unpack, width, height, depth, format, type, pixels)) {
693 const GLubyte *src = ADD_POINTERS(unpack->BufferObj->Data, pixels);
694 return _mesa_unpack_image(dimensions, width, height, depth, format,
695 type, src, unpack);
696 }
697 /* bad access! */
698 return NULL;
699 }
700
701
702 /**
703 * Allocate space for a display list instruction.
704 * \param opcode the instruction opcode (OPCODE_* value)
705 * \param size instruction size in bytes, not counting opcode.
706 * \return pointer to the usable data area (not including the internal
707 * opcode).
708 */
709 void *
710 _mesa_alloc_instruction(GLcontext *ctx, GLuint opcode, GLuint bytes)
711 {
712 const GLuint numNodes = 1 + (bytes + sizeof(Node) - 1) / sizeof(Node);
713 Node *n;
714
715 if (opcode < (GLuint) OPCODE_EXT_0) {
716 if (InstSize[opcode] == 0) {
717 /* save instruction size now */
718 InstSize[opcode] = numNodes;
719 }
720 else {
721 /* make sure instruction size agrees */
722 ASSERT(numNodes == InstSize[opcode]);
723 }
724 }
725
726 if (ctx->ListState.CurrentPos + numNodes + 2 > BLOCK_SIZE) {
727 /* This block is full. Allocate a new block and chain to it */
728 Node *newblock;
729 n = ctx->ListState.CurrentBlock + ctx->ListState.CurrentPos;
730 n[0].opcode = OPCODE_CONTINUE;
731 newblock = (Node *) _mesa_malloc(sizeof(Node) * BLOCK_SIZE);
732 if (!newblock) {
733 _mesa_error(ctx, GL_OUT_OF_MEMORY, "Building display list");
734 return NULL;
735 }
736 n[1].next = (Node *) newblock;
737 ctx->ListState.CurrentBlock = newblock;
738 ctx->ListState.CurrentPos = 0;
739 }
740
741 n = ctx->ListState.CurrentBlock + ctx->ListState.CurrentPos;
742 ctx->ListState.CurrentPos += numNodes;
743
744 n[0].opcode = (OpCode) opcode;
745
746 return (void *) (n + 1); /* return ptr to node following opcode */
747 }
748
749
750 /**
751 * This function allows modules and drivers to get their own opcodes
752 * for extending display list functionality.
753 * \param ctx the rendering context
754 * \param size number of bytes for storing the new display list command
755 * \param execute function to execute the new display list command
756 * \param destroy function to destroy the new display list command
757 * \param print function to print the new display list command
758 * \return the new opcode number or -1 if error
759 */
760 GLint
761 _mesa_alloc_opcode(GLcontext *ctx,
762 GLuint size,
763 void (*execute) (GLcontext *, void *),
764 void (*destroy) (GLcontext *, void *),
765 void (*print) (GLcontext *, void *))
766 {
767 if (ctx->ListExt.NumOpcodes < MAX_DLIST_EXT_OPCODES) {
768 const GLuint i = ctx->ListExt.NumOpcodes++;
769 ctx->ListExt.Opcode[i].Size =
770 1 + (size + sizeof(Node) - 1) / sizeof(Node);
771 ctx->ListExt.Opcode[i].Execute = execute;
772 ctx->ListExt.Opcode[i].Destroy = destroy;
773 ctx->ListExt.Opcode[i].Print = print;
774 return i + OPCODE_EXT_0;
775 }
776 return -1;
777 }
778
779
780
781 /**
782 * Allocate display list instruction. Returns Node ptr to where the opcode
783 * is stored.
784 * - nParams is the number of function parameters
785 * - return value a pointer to sizeof(Node) before the actual
786 * usable data area.
787 */
788 #define ALLOC_INSTRUCTION(CTX, OPCODE, NPARAMS) \
789 ((Node *)_mesa_alloc_instruction(CTX, OPCODE, (NPARAMS)*sizeof(Node)) - 1)
790
791
792
793 /*
794 * Display List compilation functions
795 */
796 static void GLAPIENTRY
797 save_Accum(GLenum op, GLfloat value)
798 {
799 GET_CURRENT_CONTEXT(ctx);
800 Node *n;
801 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
802 n = ALLOC_INSTRUCTION(ctx, OPCODE_ACCUM, 2);
803 if (n) {
804 n[1].e = op;
805 n[2].f = value;
806 }
807 if (ctx->ExecuteFlag) {
808 CALL_Accum(ctx->Exec, (op, value));
809 }
810 }
811
812
813 static void GLAPIENTRY
814 save_AlphaFunc(GLenum func, GLclampf ref)
815 {
816 GET_CURRENT_CONTEXT(ctx);
817 Node *n;
818 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
819 n = ALLOC_INSTRUCTION(ctx, OPCODE_ALPHA_FUNC, 2);
820 if (n) {
821 n[1].e = func;
822 n[2].f = (GLfloat) ref;
823 }
824 if (ctx->ExecuteFlag) {
825 CALL_AlphaFunc(ctx->Exec, (func, ref));
826 }
827 }
828
829
830 static void GLAPIENTRY
831 save_BindTexture(GLenum target, GLuint texture)
832 {
833 GET_CURRENT_CONTEXT(ctx);
834 Node *n;
835 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
836 n = ALLOC_INSTRUCTION(ctx, OPCODE_BIND_TEXTURE, 2);
837 if (n) {
838 n[1].e = target;
839 n[2].ui = texture;
840 }
841 if (ctx->ExecuteFlag) {
842 CALL_BindTexture(ctx->Exec, (target, texture));
843 }
844 }
845
846
847 static void GLAPIENTRY
848 save_Bitmap(GLsizei width, GLsizei height,
849 GLfloat xorig, GLfloat yorig,
850 GLfloat xmove, GLfloat ymove, const GLubyte * pixels)
851 {
852 GET_CURRENT_CONTEXT(ctx);
853 GLvoid *image = _mesa_unpack_bitmap(width, height, pixels, &ctx->Unpack);
854 Node *n;
855 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
856 n = ALLOC_INSTRUCTION(ctx, OPCODE_BITMAP, 7);
857 if (n) {
858 n[1].i = (GLint) width;
859 n[2].i = (GLint) height;
860 n[3].f = xorig;
861 n[4].f = yorig;
862 n[5].f = xmove;
863 n[6].f = ymove;
864 n[7].data = image;
865 }
866 else if (image) {
867 _mesa_free(image);
868 }
869 if (ctx->ExecuteFlag) {
870 CALL_Bitmap(ctx->Exec, (width, height,
871 xorig, yorig, xmove, ymove, pixels));
872 }
873 }
874
875
876 static void GLAPIENTRY
877 save_BlendEquation(GLenum mode)
878 {
879 GET_CURRENT_CONTEXT(ctx);
880 Node *n;
881 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
882 n = ALLOC_INSTRUCTION(ctx, OPCODE_BLEND_EQUATION, 1);
883 if (n) {
884 n[1].e = mode;
885 }
886 if (ctx->ExecuteFlag) {
887 CALL_BlendEquation(ctx->Exec, (mode));
888 }
889 }
890
891
892 static void GLAPIENTRY
893 save_BlendEquationSeparateEXT(GLenum modeRGB, GLenum modeA)
894 {
895 GET_CURRENT_CONTEXT(ctx);
896 Node *n;
897 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
898 n = ALLOC_INSTRUCTION(ctx, OPCODE_BLEND_EQUATION_SEPARATE, 2);
899 if (n) {
900 n[1].e = modeRGB;
901 n[2].e = modeA;
902 }
903 if (ctx->ExecuteFlag) {
904 CALL_BlendEquationSeparateEXT(ctx->Exec, (modeRGB, modeA));
905 }
906 }
907
908
909 static void GLAPIENTRY
910 save_BlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB,
911 GLenum sfactorA, GLenum dfactorA)
912 {
913 GET_CURRENT_CONTEXT(ctx);
914 Node *n;
915 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
916 n = ALLOC_INSTRUCTION(ctx, OPCODE_BLEND_FUNC_SEPARATE, 4);
917 if (n) {
918 n[1].e = sfactorRGB;
919 n[2].e = dfactorRGB;
920 n[3].e = sfactorA;
921 n[4].e = dfactorA;
922 }
923 if (ctx->ExecuteFlag) {
924 CALL_BlendFuncSeparateEXT(ctx->Exec,
925 (sfactorRGB, dfactorRGB, sfactorA, dfactorA));
926 }
927 }
928
929
930 static void GLAPIENTRY
931 save_BlendFunc(GLenum srcfactor, GLenum dstfactor)
932 {
933 save_BlendFuncSeparateEXT(srcfactor, dstfactor, srcfactor, dstfactor);
934 }
935
936
937 static void GLAPIENTRY
938 save_BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
939 {
940 GET_CURRENT_CONTEXT(ctx);
941 Node *n;
942 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
943 n = ALLOC_INSTRUCTION(ctx, OPCODE_BLEND_COLOR, 4);
944 if (n) {
945 n[1].f = red;
946 n[2].f = green;
947 n[3].f = blue;
948 n[4].f = alpha;
949 }
950 if (ctx->ExecuteFlag) {
951 CALL_BlendColor(ctx->Exec, (red, green, blue, alpha));
952 }
953 }
954
955
956 void GLAPIENTRY
957 _mesa_save_CallList(GLuint list)
958 {
959 GET_CURRENT_CONTEXT(ctx);
960 Node *n;
961 SAVE_FLUSH_VERTICES(ctx);
962
963 n = ALLOC_INSTRUCTION(ctx, OPCODE_CALL_LIST, 1);
964 if (n) {
965 n[1].ui = list;
966 }
967
968 /* After this, we don't know what begin/end state we're in:
969 */
970 ctx->Driver.CurrentSavePrimitive = PRIM_UNKNOWN;
971
972 if (ctx->ExecuteFlag) {
973 CALL_CallList(ctx->Exec, (list));
974 }
975 }
976
977
978 void GLAPIENTRY
979 _mesa_save_CallLists(GLsizei n, GLenum type, const GLvoid * lists)
980 {
981 GET_CURRENT_CONTEXT(ctx);
982 GLint i;
983 GLboolean typeErrorFlag;
984
985 SAVE_FLUSH_VERTICES(ctx);
986
987 switch (type) {
988 case GL_BYTE:
989 case GL_UNSIGNED_BYTE:
990 case GL_SHORT:
991 case GL_UNSIGNED_SHORT:
992 case GL_INT:
993 case GL_UNSIGNED_INT:
994 case GL_FLOAT:
995 case GL_2_BYTES:
996 case GL_3_BYTES:
997 case GL_4_BYTES:
998 typeErrorFlag = GL_FALSE;
999 break;
1000 default:
1001 typeErrorFlag = GL_TRUE;
1002 }
1003
1004 for (i = 0; i < n; i++) {
1005 GLint list = translate_id(i, type, lists);
1006 Node *n = ALLOC_INSTRUCTION(ctx, OPCODE_CALL_LIST_OFFSET, 2);
1007 if (n) {
1008 n[1].i = list;
1009 n[2].b = typeErrorFlag;
1010 }
1011 }
1012
1013 /* After this, we don't know what begin/end state we're in:
1014 */
1015 ctx->Driver.CurrentSavePrimitive = PRIM_UNKNOWN;
1016
1017 if (ctx->ExecuteFlag) {
1018 CALL_CallLists(ctx->Exec, (n, type, lists));
1019 }
1020 }
1021
1022
1023 static void GLAPIENTRY
1024 save_Clear(GLbitfield mask)
1025 {
1026 GET_CURRENT_CONTEXT(ctx);
1027 Node *n;
1028 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1029 n = ALLOC_INSTRUCTION(ctx, OPCODE_CLEAR, 1);
1030 if (n) {
1031 n[1].bf = mask;
1032 }
1033 if (ctx->ExecuteFlag) {
1034 CALL_Clear(ctx->Exec, (mask));
1035 }
1036 }
1037
1038
1039 static void GLAPIENTRY
1040 save_ClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
1041 {
1042 GET_CURRENT_CONTEXT(ctx);
1043 Node *n;
1044 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1045 n = ALLOC_INSTRUCTION(ctx, OPCODE_CLEAR_ACCUM, 4);
1046 if (n) {
1047 n[1].f = red;
1048 n[2].f = green;
1049 n[3].f = blue;
1050 n[4].f = alpha;
1051 }
1052 if (ctx->ExecuteFlag) {
1053 CALL_ClearAccum(ctx->Exec, (red, green, blue, alpha));
1054 }
1055 }
1056
1057
1058 static void GLAPIENTRY
1059 save_ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
1060 {
1061 GET_CURRENT_CONTEXT(ctx);
1062 Node *n;
1063 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1064 n = ALLOC_INSTRUCTION(ctx, OPCODE_CLEAR_COLOR, 4);
1065 if (n) {
1066 n[1].f = red;
1067 n[2].f = green;
1068 n[3].f = blue;
1069 n[4].f = alpha;
1070 }
1071 if (ctx->ExecuteFlag) {
1072 CALL_ClearColor(ctx->Exec, (red, green, blue, alpha));
1073 }
1074 }
1075
1076
1077 static void GLAPIENTRY
1078 save_ClearDepth(GLclampd depth)
1079 {
1080 GET_CURRENT_CONTEXT(ctx);
1081 Node *n;
1082 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1083 n = ALLOC_INSTRUCTION(ctx, OPCODE_CLEAR_DEPTH, 1);
1084 if (n) {
1085 n[1].f = (GLfloat) depth;
1086 }
1087 if (ctx->ExecuteFlag) {
1088 CALL_ClearDepth(ctx->Exec, (depth));
1089 }
1090 }
1091
1092
1093 static void GLAPIENTRY
1094 save_ClearIndex(GLfloat c)
1095 {
1096 GET_CURRENT_CONTEXT(ctx);
1097 Node *n;
1098 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1099 n = ALLOC_INSTRUCTION(ctx, OPCODE_CLEAR_INDEX, 1);
1100 if (n) {
1101 n[1].f = c;
1102 }
1103 if (ctx->ExecuteFlag) {
1104 CALL_ClearIndex(ctx->Exec, (c));
1105 }
1106 }
1107
1108
1109 static void GLAPIENTRY
1110 save_ClearStencil(GLint s)
1111 {
1112 GET_CURRENT_CONTEXT(ctx);
1113 Node *n;
1114 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1115 n = ALLOC_INSTRUCTION(ctx, OPCODE_CLEAR_STENCIL, 1);
1116 if (n) {
1117 n[1].i = s;
1118 }
1119 if (ctx->ExecuteFlag) {
1120 CALL_ClearStencil(ctx->Exec, (s));
1121 }
1122 }
1123
1124
1125 static void GLAPIENTRY
1126 save_ClipPlane(GLenum plane, const GLdouble * equ)
1127 {
1128 GET_CURRENT_CONTEXT(ctx);
1129 Node *n;
1130 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1131 n = ALLOC_INSTRUCTION(ctx, OPCODE_CLIP_PLANE, 5);
1132 if (n) {
1133 n[1].e = plane;
1134 n[2].f = (GLfloat) equ[0];
1135 n[3].f = (GLfloat) equ[1];
1136 n[4].f = (GLfloat) equ[2];
1137 n[5].f = (GLfloat) equ[3];
1138 }
1139 if (ctx->ExecuteFlag) {
1140 CALL_ClipPlane(ctx->Exec, (plane, equ));
1141 }
1142 }
1143
1144
1145
1146 static void GLAPIENTRY
1147 save_ColorMask(GLboolean red, GLboolean green,
1148 GLboolean blue, GLboolean alpha)
1149 {
1150 GET_CURRENT_CONTEXT(ctx);
1151 Node *n;
1152 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1153 n = ALLOC_INSTRUCTION(ctx, OPCODE_COLOR_MASK, 4);
1154 if (n) {
1155 n[1].b = red;
1156 n[2].b = green;
1157 n[3].b = blue;
1158 n[4].b = alpha;
1159 }
1160 if (ctx->ExecuteFlag) {
1161 CALL_ColorMask(ctx->Exec, (red, green, blue, alpha));
1162 }
1163 }
1164
1165
1166 static void GLAPIENTRY
1167 save_ColorMaterial(GLenum face, GLenum mode)
1168 {
1169 GET_CURRENT_CONTEXT(ctx);
1170 Node *n;
1171 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1172
1173 n = ALLOC_INSTRUCTION(ctx, OPCODE_COLOR_MATERIAL, 2);
1174 if (n) {
1175 n[1].e = face;
1176 n[2].e = mode;
1177 }
1178 if (ctx->ExecuteFlag) {
1179 CALL_ColorMaterial(ctx->Exec, (face, mode));
1180 }
1181 }
1182
1183
1184 static void GLAPIENTRY
1185 save_ColorTable(GLenum target, GLenum internalFormat,
1186 GLsizei width, GLenum format, GLenum type,
1187 const GLvoid * table)
1188 {
1189 GET_CURRENT_CONTEXT(ctx);
1190 if (_mesa_is_proxy_texture(target)) {
1191 /* execute immediately */
1192 CALL_ColorTable(ctx->Exec, (target, internalFormat, width,
1193 format, type, table));
1194 }
1195 else {
1196 GLvoid *image = unpack_image(1, width, 1, 1, format, type, table,
1197 &ctx->Unpack);
1198 Node *n;
1199 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1200 n = ALLOC_INSTRUCTION(ctx, OPCODE_COLOR_TABLE, 6);
1201 if (n) {
1202 n[1].e = target;
1203 n[2].e = internalFormat;
1204 n[3].i = width;
1205 n[4].e = format;
1206 n[5].e = type;
1207 n[6].data = image;
1208 }
1209 else if (image) {
1210 _mesa_free(image);
1211 }
1212 if (ctx->ExecuteFlag) {
1213 CALL_ColorTable(ctx->Exec, (target, internalFormat, width,
1214 format, type, table));
1215 }
1216 }
1217 }
1218
1219
1220
1221 static void GLAPIENTRY
1222 save_ColorTableParameterfv(GLenum target, GLenum pname,
1223 const GLfloat *params)
1224 {
1225 GET_CURRENT_CONTEXT(ctx);
1226 Node *n;
1227
1228 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1229
1230 n = ALLOC_INSTRUCTION(ctx, OPCODE_COLOR_TABLE_PARAMETER_FV, 6);
1231 if (n) {
1232 n[1].e = target;
1233 n[2].e = pname;
1234 n[3].f = params[0];
1235 if (pname == GL_COLOR_TABLE_SGI ||
1236 pname == GL_POST_CONVOLUTION_COLOR_TABLE_SGI ||
1237 pname == GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI ||
1238 pname == GL_TEXTURE_COLOR_TABLE_SGI) {
1239 n[4].f = params[1];
1240 n[5].f = params[2];
1241 n[6].f = params[3];
1242 }
1243 }
1244
1245 if (ctx->ExecuteFlag) {
1246 CALL_ColorTableParameterfv(ctx->Exec, (target, pname, params));
1247 }
1248 }
1249
1250
1251 static void GLAPIENTRY
1252 save_ColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
1253 {
1254 GET_CURRENT_CONTEXT(ctx);
1255 Node *n;
1256
1257 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1258
1259 n = ALLOC_INSTRUCTION(ctx, OPCODE_COLOR_TABLE_PARAMETER_IV, 6);
1260 if (n) {
1261 n[1].e = target;
1262 n[2].e = pname;
1263 n[3].i = params[0];
1264 if (pname == GL_COLOR_TABLE_SGI ||
1265 pname == GL_POST_CONVOLUTION_COLOR_TABLE_SGI ||
1266 pname == GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI ||
1267 pname == GL_TEXTURE_COLOR_TABLE_SGI) {
1268 n[4].i = params[1];
1269 n[5].i = params[2];
1270 n[6].i = params[3];
1271 }
1272 }
1273
1274 if (ctx->ExecuteFlag) {
1275 CALL_ColorTableParameteriv(ctx->Exec, (target, pname, params));
1276 }
1277 }
1278
1279
1280
1281 static void GLAPIENTRY
1282 save_ColorSubTable(GLenum target, GLsizei start, GLsizei count,
1283 GLenum format, GLenum type, const GLvoid * table)
1284 {
1285 GET_CURRENT_CONTEXT(ctx);
1286 GLvoid *image = unpack_image(1, count, 1, 1, format, type, table,
1287 &ctx->Unpack);
1288 Node *n;
1289 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1290 n = ALLOC_INSTRUCTION(ctx, OPCODE_COLOR_SUB_TABLE, 6);
1291 if (n) {
1292 n[1].e = target;
1293 n[2].i = start;
1294 n[3].i = count;
1295 n[4].e = format;
1296 n[5].e = type;
1297 n[6].data = image;
1298 }
1299 else if (image) {
1300 _mesa_free(image);
1301 }
1302 if (ctx->ExecuteFlag) {
1303 CALL_ColorSubTable(ctx->Exec,
1304 (target, start, count, format, type, table));
1305 }
1306 }
1307
1308
1309 static void GLAPIENTRY
1310 save_CopyColorSubTable(GLenum target, GLsizei start,
1311 GLint x, GLint y, GLsizei width)
1312 {
1313 GET_CURRENT_CONTEXT(ctx);
1314 Node *n;
1315
1316 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1317 n = ALLOC_INSTRUCTION(ctx, OPCODE_COPY_COLOR_SUB_TABLE, 5);
1318 if (n) {
1319 n[1].e = target;
1320 n[2].i = start;
1321 n[3].i = x;
1322 n[4].i = y;
1323 n[5].i = width;
1324 }
1325 if (ctx->ExecuteFlag) {
1326 CALL_CopyColorSubTable(ctx->Exec, (target, start, x, y, width));
1327 }
1328 }
1329
1330
1331 static void GLAPIENTRY
1332 save_CopyColorTable(GLenum target, GLenum internalformat,
1333 GLint x, GLint y, GLsizei width)
1334 {
1335 GET_CURRENT_CONTEXT(ctx);
1336 Node *n;
1337
1338 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1339 n = ALLOC_INSTRUCTION(ctx, OPCODE_COPY_COLOR_TABLE, 5);
1340 if (n) {
1341 n[1].e = target;
1342 n[2].e = internalformat;
1343 n[3].i = x;
1344 n[4].i = y;
1345 n[5].i = width;
1346 }
1347 if (ctx->ExecuteFlag) {
1348 CALL_CopyColorTable(ctx->Exec, (target, internalformat, x, y, width));
1349 }
1350 }
1351
1352
1353 static void GLAPIENTRY
1354 save_ConvolutionFilter1D(GLenum target, GLenum internalFormat, GLsizei width,
1355 GLenum format, GLenum type, const GLvoid * filter)
1356 {
1357 GET_CURRENT_CONTEXT(ctx);
1358 GLvoid *image = unpack_image(1, width, 1, 1, format, type, filter,
1359 &ctx->Unpack);
1360 Node *n;
1361 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1362 n = ALLOC_INSTRUCTION(ctx, OPCODE_CONVOLUTION_FILTER_1D, 6);
1363 if (n) {
1364 n[1].e = target;
1365 n[2].e = internalFormat;
1366 n[3].i = width;
1367 n[4].e = format;
1368 n[5].e = type;
1369 n[6].data = image;
1370 }
1371 else if (image) {
1372 _mesa_free(image);
1373 }
1374 if (ctx->ExecuteFlag) {
1375 CALL_ConvolutionFilter1D(ctx->Exec, (target, internalFormat, width,
1376 format, type, filter));
1377 }
1378 }
1379
1380
1381 static void GLAPIENTRY
1382 save_ConvolutionFilter2D(GLenum target, GLenum internalFormat,
1383 GLsizei width, GLsizei height, GLenum format,
1384 GLenum type, const GLvoid * filter)
1385 {
1386 GET_CURRENT_CONTEXT(ctx);
1387 GLvoid *image = unpack_image(2, width, height, 1, format, type, filter,
1388 &ctx->Unpack);
1389 Node *n;
1390 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1391 n = ALLOC_INSTRUCTION(ctx, OPCODE_CONVOLUTION_FILTER_2D, 7);
1392 if (n) {
1393 n[1].e = target;
1394 n[2].e = internalFormat;
1395 n[3].i = width;
1396 n[4].i = height;
1397 n[5].e = format;
1398 n[6].e = type;
1399 n[7].data = image;
1400 }
1401 else if (image) {
1402 _mesa_free(image);
1403 }
1404 if (ctx->ExecuteFlag) {
1405 CALL_ConvolutionFilter2D(ctx->Exec,
1406 (target, internalFormat, width, height, format,
1407 type, filter));
1408 }
1409 }
1410
1411
1412 static void GLAPIENTRY
1413 save_ConvolutionParameteri(GLenum target, GLenum pname, GLint param)
1414 {
1415 GET_CURRENT_CONTEXT(ctx);
1416 Node *n;
1417 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1418 n = ALLOC_INSTRUCTION(ctx, OPCODE_CONVOLUTION_PARAMETER_I, 3);
1419 if (n) {
1420 n[1].e = target;
1421 n[2].e = pname;
1422 n[3].i = param;
1423 }
1424 if (ctx->ExecuteFlag) {
1425 CALL_ConvolutionParameteri(ctx->Exec, (target, pname, param));
1426 }
1427 }
1428
1429
1430 static void GLAPIENTRY
1431 save_ConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
1432 {
1433 GET_CURRENT_CONTEXT(ctx);
1434 Node *n;
1435 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1436 n = ALLOC_INSTRUCTION(ctx, OPCODE_CONVOLUTION_PARAMETER_IV, 6);
1437 if (n) {
1438 n[1].e = target;
1439 n[2].e = pname;
1440 n[3].i = params[0];
1441 if (pname == GL_CONVOLUTION_BORDER_COLOR ||
1442 pname == GL_CONVOLUTION_FILTER_SCALE ||
1443 pname == GL_CONVOLUTION_FILTER_BIAS) {
1444 n[4].i = params[1];
1445 n[5].i = params[2];
1446 n[6].i = params[3];
1447 }
1448 else {
1449 n[4].i = n[5].i = n[6].i = 0;
1450 }
1451 }
1452 if (ctx->ExecuteFlag) {
1453 CALL_ConvolutionParameteriv(ctx->Exec, (target, pname, params));
1454 }
1455 }
1456
1457
1458 static void GLAPIENTRY
1459 save_ConvolutionParameterf(GLenum target, GLenum pname, GLfloat param)
1460 {
1461 GET_CURRENT_CONTEXT(ctx);
1462 Node *n;
1463 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1464 n = ALLOC_INSTRUCTION(ctx, OPCODE_CONVOLUTION_PARAMETER_F, 3);
1465 if (n) {
1466 n[1].e = target;
1467 n[2].e = pname;
1468 n[3].f = param;
1469 }
1470 if (ctx->ExecuteFlag) {
1471 CALL_ConvolutionParameterf(ctx->Exec, (target, pname, param));
1472 }
1473 }
1474
1475
1476 static void GLAPIENTRY
1477 save_ConvolutionParameterfv(GLenum target, GLenum pname,
1478 const GLfloat *params)
1479 {
1480 GET_CURRENT_CONTEXT(ctx);
1481 Node *n;
1482 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1483 n = ALLOC_INSTRUCTION(ctx, OPCODE_CONVOLUTION_PARAMETER_FV, 6);
1484 if (n) {
1485 n[1].e = target;
1486 n[2].e = pname;
1487 n[3].f = params[0];
1488 if (pname == GL_CONVOLUTION_BORDER_COLOR ||
1489 pname == GL_CONVOLUTION_FILTER_SCALE ||
1490 pname == GL_CONVOLUTION_FILTER_BIAS) {
1491 n[4].f = params[1];
1492 n[5].f = params[2];
1493 n[6].f = params[3];
1494 }
1495 else {
1496 n[4].f = n[5].f = n[6].f = 0.0F;
1497 }
1498 }
1499 if (ctx->ExecuteFlag) {
1500 CALL_ConvolutionParameterfv(ctx->Exec, (target, pname, params));
1501 }
1502 }
1503
1504
1505 static void GLAPIENTRY
1506 save_CopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
1507 {
1508 GET_CURRENT_CONTEXT(ctx);
1509 Node *n;
1510 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1511 n = ALLOC_INSTRUCTION(ctx, OPCODE_COPY_PIXELS, 5);
1512 if (n) {
1513 n[1].i = x;
1514 n[2].i = y;
1515 n[3].i = (GLint) width;
1516 n[4].i = (GLint) height;
1517 n[5].e = type;
1518 }
1519 if (ctx->ExecuteFlag) {
1520 CALL_CopyPixels(ctx->Exec, (x, y, width, height, type));
1521 }
1522 }
1523
1524
1525
1526 static void GLAPIENTRY
1527 save_CopyTexImage1D(GLenum target, GLint level, GLenum internalformat,
1528 GLint x, GLint y, GLsizei width, GLint border)
1529 {
1530 GET_CURRENT_CONTEXT(ctx);
1531 Node *n;
1532 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1533 n = ALLOC_INSTRUCTION(ctx, OPCODE_COPY_TEX_IMAGE1D, 7);
1534 if (n) {
1535 n[1].e = target;
1536 n[2].i = level;
1537 n[3].e = internalformat;
1538 n[4].i = x;
1539 n[5].i = y;
1540 n[6].i = width;
1541 n[7].i = border;
1542 }
1543 if (ctx->ExecuteFlag) {
1544 CALL_CopyTexImage1D(ctx->Exec, (target, level, internalformat,
1545 x, y, width, border));
1546 }
1547 }
1548
1549
1550 static void GLAPIENTRY
1551 save_CopyTexImage2D(GLenum target, GLint level,
1552 GLenum internalformat,
1553 GLint x, GLint y, GLsizei width,
1554 GLsizei height, GLint border)
1555 {
1556 GET_CURRENT_CONTEXT(ctx);
1557 Node *n;
1558 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1559 n = ALLOC_INSTRUCTION(ctx, OPCODE_COPY_TEX_IMAGE2D, 8);
1560 if (n) {
1561 n[1].e = target;
1562 n[2].i = level;
1563 n[3].e = internalformat;
1564 n[4].i = x;
1565 n[5].i = y;
1566 n[6].i = width;
1567 n[7].i = height;
1568 n[8].i = border;
1569 }
1570 if (ctx->ExecuteFlag) {
1571 CALL_CopyTexImage2D(ctx->Exec, (target, level, internalformat,
1572 x, y, width, height, border));
1573 }
1574 }
1575
1576
1577
1578 static void GLAPIENTRY
1579 save_CopyTexSubImage1D(GLenum target, GLint level,
1580 GLint xoffset, GLint x, GLint y, GLsizei width)
1581 {
1582 GET_CURRENT_CONTEXT(ctx);
1583 Node *n;
1584 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1585 n = ALLOC_INSTRUCTION(ctx, OPCODE_COPY_TEX_SUB_IMAGE1D, 6);
1586 if (n) {
1587 n[1].e = target;
1588 n[2].i = level;
1589 n[3].i = xoffset;
1590 n[4].i = x;
1591 n[5].i = y;
1592 n[6].i = width;
1593 }
1594 if (ctx->ExecuteFlag) {
1595 CALL_CopyTexSubImage1D(ctx->Exec,
1596 (target, level, xoffset, x, y, width));
1597 }
1598 }
1599
1600
1601 static void GLAPIENTRY
1602 save_CopyTexSubImage2D(GLenum target, GLint level,
1603 GLint xoffset, GLint yoffset,
1604 GLint x, GLint y, GLsizei width, GLint height)
1605 {
1606 GET_CURRENT_CONTEXT(ctx);
1607 Node *n;
1608 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1609 n = ALLOC_INSTRUCTION(ctx, OPCODE_COPY_TEX_SUB_IMAGE2D, 8);
1610 if (n) {
1611 n[1].e = target;
1612 n[2].i = level;
1613 n[3].i = xoffset;
1614 n[4].i = yoffset;
1615 n[5].i = x;
1616 n[6].i = y;
1617 n[7].i = width;
1618 n[8].i = height;
1619 }
1620 if (ctx->ExecuteFlag) {
1621 CALL_CopyTexSubImage2D(ctx->Exec, (target, level, xoffset, yoffset,
1622 x, y, width, height));
1623 }
1624 }
1625
1626
1627 static void GLAPIENTRY
1628 save_CopyTexSubImage3D(GLenum target, GLint level,
1629 GLint xoffset, GLint yoffset, GLint zoffset,
1630 GLint x, GLint y, GLsizei width, GLint height)
1631 {
1632 GET_CURRENT_CONTEXT(ctx);
1633 Node *n;
1634 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1635 n = ALLOC_INSTRUCTION(ctx, OPCODE_COPY_TEX_SUB_IMAGE3D, 9);
1636 if (n) {
1637 n[1].e = target;
1638 n[2].i = level;
1639 n[3].i = xoffset;
1640 n[4].i = yoffset;
1641 n[5].i = zoffset;
1642 n[6].i = x;
1643 n[7].i = y;
1644 n[8].i = width;
1645 n[9].i = height;
1646 }
1647 if (ctx->ExecuteFlag) {
1648 CALL_CopyTexSubImage3D(ctx->Exec, (target, level,
1649 xoffset, yoffset, zoffset,
1650 x, y, width, height));
1651 }
1652 }
1653
1654
1655 static void GLAPIENTRY
1656 save_CullFace(GLenum mode)
1657 {
1658 GET_CURRENT_CONTEXT(ctx);
1659 Node *n;
1660 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1661 n = ALLOC_INSTRUCTION(ctx, OPCODE_CULL_FACE, 1);
1662 if (n) {
1663 n[1].e = mode;
1664 }
1665 if (ctx->ExecuteFlag) {
1666 CALL_CullFace(ctx->Exec, (mode));
1667 }
1668 }
1669
1670
1671 static void GLAPIENTRY
1672 save_DepthFunc(GLenum func)
1673 {
1674 GET_CURRENT_CONTEXT(ctx);
1675 Node *n;
1676 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1677 n = ALLOC_INSTRUCTION(ctx, OPCODE_DEPTH_FUNC, 1);
1678 if (n) {
1679 n[1].e = func;
1680 }
1681 if (ctx->ExecuteFlag) {
1682 CALL_DepthFunc(ctx->Exec, (func));
1683 }
1684 }
1685
1686
1687 static void GLAPIENTRY
1688 save_DepthMask(GLboolean mask)
1689 {
1690 GET_CURRENT_CONTEXT(ctx);
1691 Node *n;
1692 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1693 n = ALLOC_INSTRUCTION(ctx, OPCODE_DEPTH_MASK, 1);
1694 if (n) {
1695 n[1].b = mask;
1696 }
1697 if (ctx->ExecuteFlag) {
1698 CALL_DepthMask(ctx->Exec, (mask));
1699 }
1700 }
1701
1702
1703 static void GLAPIENTRY
1704 save_DepthRange(GLclampd nearval, GLclampd farval)
1705 {
1706 GET_CURRENT_CONTEXT(ctx);
1707 Node *n;
1708 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1709 n = ALLOC_INSTRUCTION(ctx, OPCODE_DEPTH_RANGE, 2);
1710 if (n) {
1711 n[1].f = (GLfloat) nearval;
1712 n[2].f = (GLfloat) farval;
1713 }
1714 if (ctx->ExecuteFlag) {
1715 CALL_DepthRange(ctx->Exec, (nearval, farval));
1716 }
1717 }
1718
1719
1720 static void GLAPIENTRY
1721 save_Disable(GLenum cap)
1722 {
1723 GET_CURRENT_CONTEXT(ctx);
1724 Node *n;
1725 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1726 n = ALLOC_INSTRUCTION(ctx, OPCODE_DISABLE, 1);
1727 if (n) {
1728 n[1].e = cap;
1729 }
1730 if (ctx->ExecuteFlag) {
1731 CALL_Disable(ctx->Exec, (cap));
1732 }
1733 }
1734
1735
1736 static void GLAPIENTRY
1737 save_DrawBuffer(GLenum mode)
1738 {
1739 GET_CURRENT_CONTEXT(ctx);
1740 Node *n;
1741 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1742 n = ALLOC_INSTRUCTION(ctx, OPCODE_DRAW_BUFFER, 1);
1743 if (n) {
1744 n[1].e = mode;
1745 }
1746 if (ctx->ExecuteFlag) {
1747 CALL_DrawBuffer(ctx->Exec, (mode));
1748 }
1749 }
1750
1751
1752 static void GLAPIENTRY
1753 save_DrawPixels(GLsizei width, GLsizei height,
1754 GLenum format, GLenum type, const GLvoid * pixels)
1755 {
1756 GET_CURRENT_CONTEXT(ctx);
1757 GLvoid *image = unpack_image(2, width, height, 1, format, type,
1758 pixels, &ctx->Unpack);
1759 Node *n;
1760 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1761 n = ALLOC_INSTRUCTION(ctx, OPCODE_DRAW_PIXELS, 5);
1762 if (n) {
1763 n[1].i = width;
1764 n[2].i = height;
1765 n[3].e = format;
1766 n[4].e = type;
1767 n[5].data = image;
1768 }
1769 else if (image) {
1770 _mesa_free(image);
1771 }
1772 if (ctx->ExecuteFlag) {
1773 CALL_DrawPixels(ctx->Exec, (width, height, format, type, pixels));
1774 }
1775 }
1776
1777
1778
1779 static void GLAPIENTRY
1780 save_Enable(GLenum cap)
1781 {
1782 GET_CURRENT_CONTEXT(ctx);
1783 Node *n;
1784 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1785 n = ALLOC_INSTRUCTION(ctx, OPCODE_ENABLE, 1);
1786 if (n) {
1787 n[1].e = cap;
1788 }
1789 if (ctx->ExecuteFlag) {
1790 CALL_Enable(ctx->Exec, (cap));
1791 }
1792 }
1793
1794
1795
1796 static void GLAPIENTRY
1797 _mesa_save_EvalMesh1(GLenum mode, GLint i1, GLint i2)
1798 {
1799 GET_CURRENT_CONTEXT(ctx);
1800 Node *n;
1801 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1802 n = ALLOC_INSTRUCTION(ctx, OPCODE_EVALMESH1, 3);
1803 if (n) {
1804 n[1].e = mode;
1805 n[2].i = i1;
1806 n[3].i = i2;
1807 }
1808 if (ctx->ExecuteFlag) {
1809 CALL_EvalMesh1(ctx->Exec, (mode, i1, i2));
1810 }
1811 }
1812
1813
1814 static void GLAPIENTRY
1815 _mesa_save_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
1816 {
1817 GET_CURRENT_CONTEXT(ctx);
1818 Node *n;
1819 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1820 n = ALLOC_INSTRUCTION(ctx, OPCODE_EVALMESH2, 5);
1821 if (n) {
1822 n[1].e = mode;
1823 n[2].i = i1;
1824 n[3].i = i2;
1825 n[4].i = j1;
1826 n[5].i = j2;
1827 }
1828 if (ctx->ExecuteFlag) {
1829 CALL_EvalMesh2(ctx->Exec, (mode, i1, i2, j1, j2));
1830 }
1831 }
1832
1833
1834
1835
1836 static void GLAPIENTRY
1837 save_Fogfv(GLenum pname, const GLfloat *params)
1838 {
1839 GET_CURRENT_CONTEXT(ctx);
1840 Node *n;
1841 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1842 n = ALLOC_INSTRUCTION(ctx, OPCODE_FOG, 5);
1843 if (n) {
1844 n[1].e = pname;
1845 n[2].f = params[0];
1846 n[3].f = params[1];
1847 n[4].f = params[2];
1848 n[5].f = params[3];
1849 }
1850 if (ctx->ExecuteFlag) {
1851 CALL_Fogfv(ctx->Exec, (pname, params));
1852 }
1853 }
1854
1855
1856 static void GLAPIENTRY
1857 save_Fogf(GLenum pname, GLfloat param)
1858 {
1859 save_Fogfv(pname, &param);
1860 }
1861
1862
1863 static void GLAPIENTRY
1864 save_Fogiv(GLenum pname, const GLint *params)
1865 {
1866 GLfloat p[4];
1867 switch (pname) {
1868 case GL_FOG_MODE:
1869 case GL_FOG_DENSITY:
1870 case GL_FOG_START:
1871 case GL_FOG_END:
1872 case GL_FOG_INDEX:
1873 p[0] = (GLfloat) *params;
1874 break;
1875 case GL_FOG_COLOR:
1876 p[0] = INT_TO_FLOAT(params[0]);
1877 p[1] = INT_TO_FLOAT(params[1]);
1878 p[2] = INT_TO_FLOAT(params[2]);
1879 p[3] = INT_TO_FLOAT(params[3]);
1880 break;
1881 default:
1882 /* Error will be caught later in gl_Fogfv */
1883 ;
1884 }
1885 save_Fogfv(pname, p);
1886 }
1887
1888
1889 static void GLAPIENTRY
1890 save_Fogi(GLenum pname, GLint param)
1891 {
1892 save_Fogiv(pname, &param);
1893 }
1894
1895
1896 static void GLAPIENTRY
1897 save_FrontFace(GLenum mode)
1898 {
1899 GET_CURRENT_CONTEXT(ctx);
1900 Node *n;
1901 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1902 n = ALLOC_INSTRUCTION(ctx, OPCODE_FRONT_FACE, 1);
1903 if (n) {
1904 n[1].e = mode;
1905 }
1906 if (ctx->ExecuteFlag) {
1907 CALL_FrontFace(ctx->Exec, (mode));
1908 }
1909 }
1910
1911
1912 static void GLAPIENTRY
1913 save_Frustum(GLdouble left, GLdouble right,
1914 GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval)
1915 {
1916 GET_CURRENT_CONTEXT(ctx);
1917 Node *n;
1918 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1919 n = ALLOC_INSTRUCTION(ctx, OPCODE_FRUSTUM, 6);
1920 if (n) {
1921 n[1].f = (GLfloat) left;
1922 n[2].f = (GLfloat) right;
1923 n[3].f = (GLfloat) bottom;
1924 n[4].f = (GLfloat) top;
1925 n[5].f = (GLfloat) nearval;
1926 n[6].f = (GLfloat) farval;
1927 }
1928 if (ctx->ExecuteFlag) {
1929 CALL_Frustum(ctx->Exec, (left, right, bottom, top, nearval, farval));
1930 }
1931 }
1932
1933
1934 static void GLAPIENTRY
1935 save_Hint(GLenum target, GLenum mode)
1936 {
1937 GET_CURRENT_CONTEXT(ctx);
1938 Node *n;
1939 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1940 n = ALLOC_INSTRUCTION(ctx, OPCODE_HINT, 2);
1941 if (n) {
1942 n[1].e = target;
1943 n[2].e = mode;
1944 }
1945 if (ctx->ExecuteFlag) {
1946 CALL_Hint(ctx->Exec, (target, mode));
1947 }
1948 }
1949
1950
1951 static void GLAPIENTRY
1952 save_Histogram(GLenum target, GLsizei width, GLenum internalFormat,
1953 GLboolean sink)
1954 {
1955 GET_CURRENT_CONTEXT(ctx);
1956 Node *n;
1957
1958 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1959 n = ALLOC_INSTRUCTION(ctx, OPCODE_HISTOGRAM, 4);
1960 if (n) {
1961 n[1].e = target;
1962 n[2].i = width;
1963 n[3].e = internalFormat;
1964 n[4].b = sink;
1965 }
1966 if (ctx->ExecuteFlag) {
1967 CALL_Histogram(ctx->Exec, (target, width, internalFormat, sink));
1968 }
1969 }
1970
1971
1972 static void GLAPIENTRY
1973 save_IndexMask(GLuint mask)
1974 {
1975 GET_CURRENT_CONTEXT(ctx);
1976 Node *n;
1977 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1978 n = ALLOC_INSTRUCTION(ctx, OPCODE_INDEX_MASK, 1);
1979 if (n) {
1980 n[1].ui = mask;
1981 }
1982 if (ctx->ExecuteFlag) {
1983 CALL_IndexMask(ctx->Exec, (mask));
1984 }
1985 }
1986
1987
1988 static void GLAPIENTRY
1989 save_InitNames(void)
1990 {
1991 GET_CURRENT_CONTEXT(ctx);
1992 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1993 (void) ALLOC_INSTRUCTION(ctx, OPCODE_INIT_NAMES, 0);
1994 if (ctx->ExecuteFlag) {
1995 CALL_InitNames(ctx->Exec, ());
1996 }
1997 }
1998
1999
2000 static void GLAPIENTRY
2001 save_Lightfv(GLenum light, GLenum pname, const GLfloat *params)
2002 {
2003 GET_CURRENT_CONTEXT(ctx);
2004 Node *n;
2005 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2006 n = ALLOC_INSTRUCTION(ctx, OPCODE_LIGHT, 6);
2007 if (OPCODE_LIGHT) {
2008 GLint i, nParams;
2009 n[1].e = light;
2010 n[2].e = pname;
2011 switch (pname) {
2012 case GL_AMBIENT:
2013 nParams = 4;
2014 break;
2015 case GL_DIFFUSE:
2016 nParams = 4;
2017 break;
2018 case GL_SPECULAR:
2019 nParams = 4;
2020 break;
2021 case GL_POSITION:
2022 nParams = 4;
2023 break;
2024 case GL_SPOT_DIRECTION:
2025 nParams = 3;
2026 break;
2027 case GL_SPOT_EXPONENT:
2028 nParams = 1;
2029 break;
2030 case GL_SPOT_CUTOFF:
2031 nParams = 1;
2032 break;
2033 case GL_CONSTANT_ATTENUATION:
2034 nParams = 1;
2035 break;
2036 case GL_LINEAR_ATTENUATION:
2037 nParams = 1;
2038 break;
2039 case GL_QUADRATIC_ATTENUATION:
2040 nParams = 1;
2041 break;
2042 default:
2043 nParams = 0;
2044 }
2045 for (i = 0; i < nParams; i++) {
2046 n[3 + i].f = params[i];
2047 }
2048 }
2049 if (ctx->ExecuteFlag) {
2050 CALL_Lightfv(ctx->Exec, (light, pname, params));
2051 }
2052 }
2053
2054
2055 static void GLAPIENTRY
2056 save_Lightf(GLenum light, GLenum pname, GLfloat params)
2057 {
2058 save_Lightfv(light, pname, &params);
2059 }
2060
2061
2062 static void GLAPIENTRY
2063 save_Lightiv(GLenum light, GLenum pname, const GLint *params)
2064 {
2065 GLfloat fparam[4];
2066 switch (pname) {
2067 case GL_AMBIENT:
2068 case GL_DIFFUSE:
2069 case GL_SPECULAR:
2070 fparam[0] = INT_TO_FLOAT(params[0]);
2071 fparam[1] = INT_TO_FLOAT(params[1]);
2072 fparam[2] = INT_TO_FLOAT(params[2]);
2073 fparam[3] = INT_TO_FLOAT(params[3]);
2074 break;
2075 case GL_POSITION:
2076 fparam[0] = (GLfloat) params[0];
2077 fparam[1] = (GLfloat) params[1];
2078 fparam[2] = (GLfloat) params[2];
2079 fparam[3] = (GLfloat) params[3];
2080 break;
2081 case GL_SPOT_DIRECTION:
2082 fparam[0] = (GLfloat) params[0];
2083 fparam[1] = (GLfloat) params[1];
2084 fparam[2] = (GLfloat) params[2];
2085 break;
2086 case GL_SPOT_EXPONENT:
2087 case GL_SPOT_CUTOFF:
2088 case GL_CONSTANT_ATTENUATION:
2089 case GL_LINEAR_ATTENUATION:
2090 case GL_QUADRATIC_ATTENUATION:
2091 fparam[0] = (GLfloat) params[0];
2092 break;
2093 default:
2094 /* error will be caught later in gl_Lightfv */
2095 ;
2096 }
2097 save_Lightfv(light, pname, fparam);
2098 }
2099
2100
2101 static void GLAPIENTRY
2102 save_Lighti(GLenum light, GLenum pname, GLint param)
2103 {
2104 save_Lightiv(light, pname, &param);
2105 }
2106
2107
2108 static void GLAPIENTRY
2109 save_LightModelfv(GLenum pname, const GLfloat *params)
2110 {
2111 GET_CURRENT_CONTEXT(ctx);
2112 Node *n;
2113 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2114 n = ALLOC_INSTRUCTION(ctx, OPCODE_LIGHT_MODEL, 5);
2115 if (n) {
2116 n[1].e = pname;
2117 n[2].f = params[0];
2118 n[3].f = params[1];
2119 n[4].f = params[2];
2120 n[5].f = params[3];
2121 }
2122 if (ctx->ExecuteFlag) {
2123 CALL_LightModelfv(ctx->Exec, (pname, params));
2124 }
2125 }
2126
2127
2128 static void GLAPIENTRY
2129 save_LightModelf(GLenum pname, GLfloat param)
2130 {
2131 save_LightModelfv(pname, &param);
2132 }
2133
2134
2135 static void GLAPIENTRY
2136 save_LightModeliv(GLenum pname, const GLint *params)
2137 {
2138 GLfloat fparam[4];
2139 switch (pname) {
2140 case GL_LIGHT_MODEL_AMBIENT:
2141 fparam[0] = INT_TO_FLOAT(params[0]);
2142 fparam[1] = INT_TO_FLOAT(params[1]);
2143 fparam[2] = INT_TO_FLOAT(params[2]);
2144 fparam[3] = INT_TO_FLOAT(params[3]);
2145 break;
2146 case GL_LIGHT_MODEL_LOCAL_VIEWER:
2147 case GL_LIGHT_MODEL_TWO_SIDE:
2148 case GL_LIGHT_MODEL_COLOR_CONTROL:
2149 fparam[0] = (GLfloat) params[0];
2150 break;
2151 default:
2152 /* Error will be caught later in gl_LightModelfv */
2153 ;
2154 }
2155 save_LightModelfv(pname, fparam);
2156 }
2157
2158
2159 static void GLAPIENTRY
2160 save_LightModeli(GLenum pname, GLint param)
2161 {
2162 save_LightModeliv(pname, &param);
2163 }
2164
2165
2166 static void GLAPIENTRY
2167 save_LineStipple(GLint factor, GLushort pattern)
2168 {
2169 GET_CURRENT_CONTEXT(ctx);
2170 Node *n;
2171 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2172 n = ALLOC_INSTRUCTION(ctx, OPCODE_LINE_STIPPLE, 2);
2173 if (n) {
2174 n[1].i = factor;
2175 n[2].us = pattern;
2176 }
2177 if (ctx->ExecuteFlag) {
2178 CALL_LineStipple(ctx->Exec, (factor, pattern));
2179 }
2180 }
2181
2182
2183 static void GLAPIENTRY
2184 save_LineWidth(GLfloat width)
2185 {
2186 GET_CURRENT_CONTEXT(ctx);
2187 Node *n;
2188 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2189 n = ALLOC_INSTRUCTION(ctx, OPCODE_LINE_WIDTH, 1);
2190 if (n) {
2191 n[1].f = width;
2192 }
2193 if (ctx->ExecuteFlag) {
2194 CALL_LineWidth(ctx->Exec, (width));
2195 }
2196 }
2197
2198
2199 static void GLAPIENTRY
2200 save_ListBase(GLuint base)
2201 {
2202 GET_CURRENT_CONTEXT(ctx);
2203 Node *n;
2204 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2205 n = ALLOC_INSTRUCTION(ctx, OPCODE_LIST_BASE, 1);
2206 if (n) {
2207 n[1].ui = base;
2208 }
2209 if (ctx->ExecuteFlag) {
2210 CALL_ListBase(ctx->Exec, (base));
2211 }
2212 }
2213
2214
2215 static void GLAPIENTRY
2216 save_LoadIdentity(void)
2217 {
2218 GET_CURRENT_CONTEXT(ctx);
2219 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2220 (void) ALLOC_INSTRUCTION(ctx, OPCODE_LOAD_IDENTITY, 0);
2221 if (ctx->ExecuteFlag) {
2222 CALL_LoadIdentity(ctx->Exec, ());
2223 }
2224 }
2225
2226
2227 static void GLAPIENTRY
2228 save_LoadMatrixf(const GLfloat * m)
2229 {
2230 GET_CURRENT_CONTEXT(ctx);
2231 Node *n;
2232 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2233 n = ALLOC_INSTRUCTION(ctx, OPCODE_LOAD_MATRIX, 16);
2234 if (n) {
2235 GLuint i;
2236 for (i = 0; i < 16; i++) {
2237 n[1 + i].f = m[i];
2238 }
2239 }
2240 if (ctx->ExecuteFlag) {
2241 CALL_LoadMatrixf(ctx->Exec, (m));
2242 }
2243 }
2244
2245
2246 static void GLAPIENTRY
2247 save_LoadMatrixd(const GLdouble * m)
2248 {
2249 GLfloat f[16];
2250 GLint i;
2251 for (i = 0; i < 16; i++) {
2252 f[i] = (GLfloat) m[i];
2253 }
2254 save_LoadMatrixf(f);
2255 }
2256
2257
2258 static void GLAPIENTRY
2259 save_LoadName(GLuint name)
2260 {
2261 GET_CURRENT_CONTEXT(ctx);
2262 Node *n;
2263 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2264 n = ALLOC_INSTRUCTION(ctx, OPCODE_LOAD_NAME, 1);
2265 if (n) {
2266 n[1].ui = name;
2267 }
2268 if (ctx->ExecuteFlag) {
2269 CALL_LoadName(ctx->Exec, (name));
2270 }
2271 }
2272
2273
2274 static void GLAPIENTRY
2275 save_LogicOp(GLenum opcode)
2276 {
2277 GET_CURRENT_CONTEXT(ctx);
2278 Node *n;
2279 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2280 n = ALLOC_INSTRUCTION(ctx, OPCODE_LOGIC_OP, 1);
2281 if (n) {
2282 n[1].e = opcode;
2283 }
2284 if (ctx->ExecuteFlag) {
2285 CALL_LogicOp(ctx->Exec, (opcode));
2286 }
2287 }
2288
2289
2290 static void GLAPIENTRY
2291 save_Map1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride,
2292 GLint order, const GLdouble * points)
2293 {
2294 GET_CURRENT_CONTEXT(ctx);
2295 Node *n;
2296 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2297 n = ALLOC_INSTRUCTION(ctx, OPCODE_MAP1, 6);
2298 if (n) {
2299 GLfloat *pnts = _mesa_copy_map_points1d(target, stride, order, points);
2300 n[1].e = target;
2301 n[2].f = (GLfloat) u1;
2302 n[3].f = (GLfloat) u2;
2303 n[4].i = _mesa_evaluator_components(target); /* stride */
2304 n[5].i = order;
2305 n[6].data = (void *) pnts;
2306 }
2307 if (ctx->ExecuteFlag) {
2308 CALL_Map1d(ctx->Exec, (target, u1, u2, stride, order, points));
2309 }
2310 }
2311
2312 static void GLAPIENTRY
2313 save_Map1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride,
2314 GLint order, const GLfloat * points)
2315 {
2316 GET_CURRENT_CONTEXT(ctx);
2317 Node *n;
2318 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2319 n = ALLOC_INSTRUCTION(ctx, OPCODE_MAP1, 6);
2320 if (n) {
2321 GLfloat *pnts = _mesa_copy_map_points1f(target, stride, order, points);
2322 n[1].e = target;
2323 n[2].f = u1;
2324 n[3].f = u2;
2325 n[4].i = _mesa_evaluator_components(target); /* stride */
2326 n[5].i = order;
2327 n[6].data = (void *) pnts;
2328 }
2329 if (ctx->ExecuteFlag) {
2330 CALL_Map1f(ctx->Exec, (target, u1, u2, stride, order, points));
2331 }
2332 }
2333
2334
2335 static void GLAPIENTRY
2336 save_Map2d(GLenum target,
2337 GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
2338 GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
2339 const GLdouble * points)
2340 {
2341 GET_CURRENT_CONTEXT(ctx);
2342 Node *n;
2343 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2344 n = ALLOC_INSTRUCTION(ctx, OPCODE_MAP2, 10);
2345 if (n) {
2346 GLfloat *pnts = _mesa_copy_map_points2d(target, ustride, uorder,
2347 vstride, vorder, points);
2348 n[1].e = target;
2349 n[2].f = (GLfloat) u1;
2350 n[3].f = (GLfloat) u2;
2351 n[4].f = (GLfloat) v1;
2352 n[5].f = (GLfloat) v2;
2353 /* XXX verify these strides are correct */
2354 n[6].i = _mesa_evaluator_components(target) * vorder; /*ustride */
2355 n[7].i = _mesa_evaluator_components(target); /*vstride */
2356 n[8].i = uorder;
2357 n[9].i = vorder;
2358 n[10].data = (void *) pnts;
2359 }
2360 if (ctx->ExecuteFlag) {
2361 CALL_Map2d(ctx->Exec, (target,
2362 u1, u2, ustride, uorder,
2363 v1, v2, vstride, vorder, points));
2364 }
2365 }
2366
2367
2368 static void GLAPIENTRY
2369 save_Map2f(GLenum target,
2370 GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
2371 GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
2372 const GLfloat * points)
2373 {
2374 GET_CURRENT_CONTEXT(ctx);
2375 Node *n;
2376 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2377 n = ALLOC_INSTRUCTION(ctx, OPCODE_MAP2, 10);
2378 if (n) {
2379 GLfloat *pnts = _mesa_copy_map_points2f(target, ustride, uorder,
2380 vstride, vorder, points);
2381 n[1].e = target;
2382 n[2].f = u1;
2383 n[3].f = u2;
2384 n[4].f = v1;
2385 n[5].f = v2;
2386 /* XXX verify these strides are correct */
2387 n[6].i = _mesa_evaluator_components(target) * vorder; /*ustride */
2388 n[7].i = _mesa_evaluator_components(target); /*vstride */
2389 n[8].i = uorder;
2390 n[9].i = vorder;
2391 n[10].data = (void *) pnts;
2392 }
2393 if (ctx->ExecuteFlag) {
2394 CALL_Map2f(ctx->Exec, (target, u1, u2, ustride, uorder,
2395 v1, v2, vstride, vorder, points));
2396 }
2397 }
2398
2399
2400 static void GLAPIENTRY
2401 save_MapGrid1f(GLint un, GLfloat u1, GLfloat u2)
2402 {
2403 GET_CURRENT_CONTEXT(ctx);
2404 Node *n;
2405 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2406 n = ALLOC_INSTRUCTION(ctx, OPCODE_MAPGRID1, 3);
2407 if (n) {
2408 n[1].i = un;
2409 n[2].f = u1;
2410 n[3].f = u2;
2411 }
2412 if (ctx->ExecuteFlag) {
2413 CALL_MapGrid1f(ctx->Exec, (un, u1, u2));
2414 }
2415 }
2416
2417
2418 static void GLAPIENTRY
2419 save_MapGrid1d(GLint un, GLdouble u1, GLdouble u2)
2420 {
2421 save_MapGrid1f(un, (GLfloat) u1, (GLfloat) u2);
2422 }
2423
2424
2425 static void GLAPIENTRY
2426 save_MapGrid2f(GLint un, GLfloat u1, GLfloat u2,
2427 GLint vn, GLfloat v1, GLfloat v2)
2428 {
2429 GET_CURRENT_CONTEXT(ctx);
2430 Node *n;
2431 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2432 n = ALLOC_INSTRUCTION(ctx, OPCODE_MAPGRID2, 6);
2433 if (n) {
2434 n[1].i = un;
2435 n[2].f = u1;
2436 n[3].f = u2;
2437 n[4].i = vn;
2438 n[5].f = v1;
2439 n[6].f = v2;
2440 }
2441 if (ctx->ExecuteFlag) {
2442 CALL_MapGrid2f(ctx->Exec, (un, u1, u2, vn, v1, v2));
2443 }
2444 }
2445
2446
2447
2448 static void GLAPIENTRY
2449 save_MapGrid2d(GLint un, GLdouble u1, GLdouble u2,
2450 GLint vn, GLdouble v1, GLdouble v2)
2451 {
2452 save_MapGrid2f(un, (GLfloat) u1, (GLfloat) u2,
2453 vn, (GLfloat) v1, (GLfloat) v2);
2454 }
2455
2456
2457 static void GLAPIENTRY
2458 save_MatrixMode(GLenum mode)
2459 {
2460 GET_CURRENT_CONTEXT(ctx);
2461 Node *n;
2462 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2463 n = ALLOC_INSTRUCTION(ctx, OPCODE_MATRIX_MODE, 1);
2464 if (n) {
2465 n[1].e = mode;
2466 }
2467 if (ctx->ExecuteFlag) {
2468 CALL_MatrixMode(ctx->Exec, (mode));
2469 }
2470 }
2471
2472
2473 static void GLAPIENTRY
2474 save_Minmax(GLenum target, GLenum internalFormat, GLboolean sink)
2475 {
2476 GET_CURRENT_CONTEXT(ctx);
2477 Node *n;
2478
2479 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2480 n = ALLOC_INSTRUCTION(ctx, OPCODE_MIN_MAX, 3);
2481 if (n) {
2482 n[1].e = target;
2483 n[2].e = internalFormat;
2484 n[3].b = sink;
2485 }
2486 if (ctx->ExecuteFlag) {
2487 CALL_Minmax(ctx->Exec, (target, internalFormat, sink));
2488 }
2489 }
2490
2491
2492 static void GLAPIENTRY
2493 save_MultMatrixf(const GLfloat * m)
2494 {
2495 GET_CURRENT_CONTEXT(ctx);
2496 Node *n;
2497 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2498 n = ALLOC_INSTRUCTION(ctx, OPCODE_MULT_MATRIX, 16);
2499 if (n) {
2500 GLuint i;
2501 for (i = 0; i < 16; i++) {
2502 n[1 + i].f = m[i];
2503 }
2504 }
2505 if (ctx->ExecuteFlag) {
2506 CALL_MultMatrixf(ctx->Exec, (m));
2507 }
2508 }
2509
2510
2511 static void GLAPIENTRY
2512 save_MultMatrixd(const GLdouble * m)
2513 {
2514 GLfloat f[16];
2515 GLint i;
2516 for (i = 0; i < 16; i++) {
2517 f[i] = (GLfloat) m[i];
2518 }
2519 save_MultMatrixf(f);
2520 }
2521
2522
2523 static void GLAPIENTRY
2524 save_NewList(GLuint list, GLenum mode)
2525 {
2526 GET_CURRENT_CONTEXT(ctx);
2527 /* It's an error to call this function while building a display list */
2528 _mesa_error(ctx, GL_INVALID_OPERATION, "glNewList");
2529 (void) list;
2530 (void) mode;
2531 }
2532
2533
2534
2535 static void GLAPIENTRY
2536 save_Ortho(GLdouble left, GLdouble right,
2537 GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval)
2538 {
2539 GET_CURRENT_CONTEXT(ctx);
2540 Node *n;
2541 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2542 n = ALLOC_INSTRUCTION(ctx, OPCODE_ORTHO, 6);
2543 if (n) {
2544 n[1].f = (GLfloat) left;
2545 n[2].f = (GLfloat) right;
2546 n[3].f = (GLfloat) bottom;
2547 n[4].f = (GLfloat) top;
2548 n[5].f = (GLfloat) nearval;
2549 n[6].f = (GLfloat) farval;
2550 }
2551 if (ctx->ExecuteFlag) {
2552 CALL_Ortho(ctx->Exec, (left, right, bottom, top, nearval, farval));
2553 }
2554 }
2555
2556
2557 static void GLAPIENTRY
2558 save_PixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
2559 {
2560 GET_CURRENT_CONTEXT(ctx);
2561 Node *n;
2562 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2563 n = ALLOC_INSTRUCTION(ctx, OPCODE_PIXEL_MAP, 3);
2564 if (n) {
2565 n[1].e = map;
2566 n[2].i = mapsize;
2567 n[3].data = (void *) _mesa_malloc(mapsize * sizeof(GLfloat));
2568 MEMCPY(n[3].data, (void *) values, mapsize * sizeof(GLfloat));
2569 }
2570 if (ctx->ExecuteFlag) {
2571 CALL_PixelMapfv(ctx->Exec, (map, mapsize, values));
2572 }
2573 }
2574
2575
2576 static void GLAPIENTRY
2577 save_PixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
2578 {
2579 GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
2580 GLint i;
2581 if (map == GL_PIXEL_MAP_I_TO_I || map == GL_PIXEL_MAP_S_TO_S) {
2582 for (i = 0; i < mapsize; i++) {
2583 fvalues[i] = (GLfloat) values[i];
2584 }
2585 }
2586 else {
2587 for (i = 0; i < mapsize; i++) {
2588 fvalues[i] = UINT_TO_FLOAT(values[i]);
2589 }
2590 }
2591 save_PixelMapfv(map, mapsize, fvalues);
2592 }
2593
2594
2595 static void GLAPIENTRY
2596 save_PixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
2597 {
2598 GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
2599 GLint i;
2600 if (map == GL_PIXEL_MAP_I_TO_I || map == GL_PIXEL_MAP_S_TO_S) {
2601 for (i = 0; i < mapsize; i++) {
2602 fvalues[i] = (GLfloat) values[i];
2603 }
2604 }
2605 else {
2606 for (i = 0; i < mapsize; i++) {
2607 fvalues[i] = USHORT_TO_FLOAT(values[i]);
2608 }
2609 }
2610 save_PixelMapfv(map, mapsize, fvalues);
2611 }
2612
2613
2614 static void GLAPIENTRY
2615 save_PixelTransferf(GLenum pname, GLfloat param)
2616 {
2617 GET_CURRENT_CONTEXT(ctx);
2618 Node *n;
2619 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2620 n = ALLOC_INSTRUCTION(ctx, OPCODE_PIXEL_TRANSFER, 2);
2621 if (n) {
2622 n[1].e = pname;
2623 n[2].f = param;
2624 }
2625 if (ctx->ExecuteFlag) {
2626 CALL_PixelTransferf(ctx->Exec, (pname, param));
2627 }
2628 }
2629
2630
2631 static void GLAPIENTRY
2632 save_PixelTransferi(GLenum pname, GLint param)
2633 {
2634 save_PixelTransferf(pname, (GLfloat) param);
2635 }
2636
2637
2638 static void GLAPIENTRY
2639 save_PixelZoom(GLfloat xfactor, GLfloat yfactor)
2640 {
2641 GET_CURRENT_CONTEXT(ctx);
2642 Node *n;
2643 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2644 n = ALLOC_INSTRUCTION(ctx, OPCODE_PIXEL_ZOOM, 2);
2645 if (n) {
2646 n[1].f = xfactor;
2647 n[2].f = yfactor;
2648 }
2649 if (ctx->ExecuteFlag) {
2650 CALL_PixelZoom(ctx->Exec, (xfactor, yfactor));
2651 }
2652 }
2653
2654
2655 static void GLAPIENTRY
2656 save_PointParameterfvEXT(GLenum pname, const GLfloat *params)
2657 {
2658 GET_CURRENT_CONTEXT(ctx);
2659 Node *n;
2660 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2661 n = ALLOC_INSTRUCTION(ctx, OPCODE_POINT_PARAMETERS, 4);
2662 if (n) {
2663 n[1].e = pname;
2664 n[2].f = params[0];
2665 n[3].f = params[1];
2666 n[4].f = params[2];
2667 }
2668 if (ctx->ExecuteFlag) {
2669 CALL_PointParameterfvEXT(ctx->Exec, (pname, params));
2670 }
2671 }
2672
2673
2674 static void GLAPIENTRY
2675 save_PointParameterfEXT(GLenum pname, GLfloat param)
2676 {
2677 save_PointParameterfvEXT(pname, &param);
2678 }
2679
2680 static void GLAPIENTRY
2681 save_PointParameteriNV(GLenum pname, GLint param)
2682 {
2683 GLfloat p = (GLfloat) param;
2684 save_PointParameterfvEXT(pname, &p);
2685 }
2686
2687 static void GLAPIENTRY
2688 save_PointParameterivNV(GLenum pname, const GLint * param)
2689 {
2690 GLfloat p = (GLfloat) param[0];
2691 save_PointParameterfvEXT(pname, &p);
2692 }
2693
2694
2695 static void GLAPIENTRY
2696 save_PointSize(GLfloat size)
2697 {
2698 GET_CURRENT_CONTEXT(ctx);
2699 Node *n;
2700 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2701 n = ALLOC_INSTRUCTION(ctx, OPCODE_POINT_SIZE, 1);
2702 if (n) {
2703 n[1].f = size;
2704 }
2705 if (ctx->ExecuteFlag) {
2706 CALL_PointSize(ctx->Exec, (size));
2707 }
2708 }
2709
2710
2711 static void GLAPIENTRY
2712 save_PolygonMode(GLenum face, GLenum mode)
2713 {
2714 GET_CURRENT_CONTEXT(ctx);
2715 Node *n;
2716 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2717 n = ALLOC_INSTRUCTION(ctx, OPCODE_POLYGON_MODE, 2);
2718 if (n) {
2719 n[1].e = face;
2720 n[2].e = mode;
2721 }
2722 if (ctx->ExecuteFlag) {
2723 CALL_PolygonMode(ctx->Exec, (face, mode));
2724 }
2725 }
2726
2727
2728 static void GLAPIENTRY
2729 save_PolygonStipple(const GLubyte * pattern)
2730 {
2731 GET_CURRENT_CONTEXT(ctx);
2732 GLvoid *image = unpack_image(2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP,
2733 pattern, &ctx->Unpack);
2734 Node *n;
2735 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2736 n = ALLOC_INSTRUCTION(ctx, OPCODE_POLYGON_STIPPLE, 1);
2737 if (n) {
2738 n[1].data = image;
2739 }
2740 else if (image) {
2741 _mesa_free(image);
2742 }
2743 if (ctx->ExecuteFlag) {
2744 CALL_PolygonStipple(ctx->Exec, ((GLubyte *) pattern));
2745 }
2746 }
2747
2748
2749 static void GLAPIENTRY
2750 save_PolygonOffset(GLfloat factor, GLfloat units)
2751 {
2752 GET_CURRENT_CONTEXT(ctx);
2753 Node *n;
2754 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2755 n = ALLOC_INSTRUCTION(ctx, OPCODE_POLYGON_OFFSET, 2);
2756 if (n) {
2757 n[1].f = factor;
2758 n[2].f = units;
2759 }
2760 if (ctx->ExecuteFlag) {
2761 CALL_PolygonOffset(ctx->Exec, (factor, units));
2762 }
2763 }
2764
2765
2766 static void GLAPIENTRY
2767 save_PolygonOffsetEXT(GLfloat factor, GLfloat bias)
2768 {
2769 GET_CURRENT_CONTEXT(ctx);
2770 /* XXX mult by DepthMaxF here??? */
2771 save_PolygonOffset(factor, ctx->DrawBuffer->_DepthMaxF * bias);
2772 }
2773
2774
2775 static void GLAPIENTRY
2776 save_PopAttrib(void)
2777 {
2778 GET_CURRENT_CONTEXT(ctx);
2779 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2780 (void) ALLOC_INSTRUCTION(ctx, OPCODE_POP_ATTRIB, 0);
2781 if (ctx->ExecuteFlag) {
2782 CALL_PopAttrib(ctx->Exec, ());
2783 }
2784 }
2785
2786
2787 static void GLAPIENTRY
2788 save_PopMatrix(void)
2789 {
2790 GET_CURRENT_CONTEXT(ctx);
2791 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2792 (void) ALLOC_INSTRUCTION(ctx, OPCODE_POP_MATRIX, 0);
2793 if (ctx->ExecuteFlag) {
2794 CALL_PopMatrix(ctx->Exec, ());
2795 }
2796 }
2797
2798
2799 static void GLAPIENTRY
2800 save_PopName(void)
2801 {
2802 GET_CURRENT_CONTEXT(ctx);
2803 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2804 (void) ALLOC_INSTRUCTION(ctx, OPCODE_POP_NAME, 0);
2805 if (ctx->ExecuteFlag) {
2806 CALL_PopName(ctx->Exec, ());
2807 }
2808 }
2809
2810
2811 static void GLAPIENTRY
2812 save_PrioritizeTextures(GLsizei num, const GLuint * textures,
2813 const GLclampf * priorities)
2814 {
2815 GET_CURRENT_CONTEXT(ctx);
2816 GLint i;
2817 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2818
2819 for (i = 0; i < num; i++) {
2820 Node *n;
2821 n = ALLOC_INSTRUCTION(ctx, OPCODE_PRIORITIZE_TEXTURE, 2);
2822 if (n) {
2823 n[1].ui = textures[i];
2824 n[2].f = priorities[i];
2825 }
2826 }
2827 if (ctx->ExecuteFlag) {
2828 CALL_PrioritizeTextures(ctx->Exec, (num, textures, priorities));
2829 }
2830 }
2831
2832
2833 static void GLAPIENTRY
2834 save_PushAttrib(GLbitfield mask)
2835 {
2836 GET_CURRENT_CONTEXT(ctx);
2837 Node *n;
2838 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2839 n = ALLOC_INSTRUCTION(ctx, OPCODE_PUSH_ATTRIB, 1);
2840 if (n) {
2841 n[1].bf = mask;
2842 }
2843 if (ctx->ExecuteFlag) {
2844 CALL_PushAttrib(ctx->Exec, (mask));
2845 }
2846 }
2847
2848
2849 static void GLAPIENTRY
2850 save_PushMatrix(void)
2851 {
2852 GET_CURRENT_CONTEXT(ctx);
2853 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2854 (void) ALLOC_INSTRUCTION(ctx, OPCODE_PUSH_MATRIX, 0);
2855 if (ctx->ExecuteFlag) {
2856 CALL_PushMatrix(ctx->Exec, ());
2857 }
2858 }
2859
2860
2861 static void GLAPIENTRY
2862 save_PushName(GLuint name)
2863 {
2864 GET_CURRENT_CONTEXT(ctx);
2865 Node *n;
2866 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2867 n = ALLOC_INSTRUCTION(ctx, OPCODE_PUSH_NAME, 1);
2868 if (n) {
2869 n[1].ui = name;
2870 }
2871 if (ctx->ExecuteFlag) {
2872 CALL_PushName(ctx->Exec, (name));
2873 }
2874 }
2875
2876
2877 static void GLAPIENTRY
2878 save_RasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
2879 {
2880 GET_CURRENT_CONTEXT(ctx);
2881 Node *n;
2882 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2883 n = ALLOC_INSTRUCTION(ctx, OPCODE_RASTER_POS, 4);
2884 if (n) {
2885 n[1].f = x;
2886 n[2].f = y;
2887 n[3].f = z;
2888 n[4].f = w;
2889 }
2890 if (ctx->ExecuteFlag) {
2891 CALL_RasterPos4f(ctx->Exec, (x, y, z, w));
2892 }
2893 }
2894
2895 static void GLAPIENTRY
2896 save_RasterPos2d(GLdouble x, GLdouble y)
2897 {
2898 save_RasterPos4f((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
2899 }
2900
2901 static void GLAPIENTRY
2902 save_RasterPos2f(GLfloat x, GLfloat y)
2903 {
2904 save_RasterPos4f(x, y, 0.0F, 1.0F);
2905 }
2906
2907 static void GLAPIENTRY
2908 save_RasterPos2i(GLint x, GLint y)
2909 {
2910 save_RasterPos4f((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
2911 }
2912
2913 static void GLAPIENTRY
2914 save_RasterPos2s(GLshort x, GLshort y)
2915 {
2916 save_RasterPos4f(x, y, 0.0F, 1.0F);
2917 }
2918
2919 static void GLAPIENTRY
2920 save_RasterPos3d(GLdouble x, GLdouble y, GLdouble z)
2921 {
2922 save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
2923 }
2924
2925 static void GLAPIENTRY
2926 save_RasterPos3f(GLfloat x, GLfloat y, GLfloat z)
2927 {
2928 save_RasterPos4f(x, y, z, 1.0F);
2929 }
2930
2931 static void GLAPIENTRY
2932 save_RasterPos3i(GLint x, GLint y, GLint z)
2933 {
2934 save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
2935 }
2936
2937 static void GLAPIENTRY
2938 save_RasterPos3s(GLshort x, GLshort y, GLshort z)
2939 {
2940 save_RasterPos4f(x, y, z, 1.0F);
2941 }
2942
2943 static void GLAPIENTRY
2944 save_RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
2945 {
2946 save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
2947 }
2948
2949 static void GLAPIENTRY
2950 save_RasterPos4i(GLint x, GLint y, GLint z, GLint w)
2951 {
2952 save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
2953 }
2954
2955 static void GLAPIENTRY
2956 save_RasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
2957 {
2958 save_RasterPos4f(x, y, z, w);
2959 }
2960
2961 static void GLAPIENTRY
2962 save_RasterPos2dv(const GLdouble * v)
2963 {
2964 save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
2965 }
2966
2967 static void GLAPIENTRY
2968 save_RasterPos2fv(const GLfloat * v)
2969 {
2970 save_RasterPos4f(v[0], v[1], 0.0F, 1.0F);
2971 }
2972
2973 static void GLAPIENTRY
2974 save_RasterPos2iv(const GLint * v)
2975 {
2976 save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
2977 }
2978
2979 static void GLAPIENTRY
2980 save_RasterPos2sv(const GLshort * v)
2981 {
2982 save_RasterPos4f(v[0], v[1], 0.0F, 1.0F);
2983 }
2984
2985 static void GLAPIENTRY
2986 save_RasterPos3dv(const GLdouble * v)
2987 {
2988 save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
2989 }
2990
2991 static void GLAPIENTRY
2992 save_RasterPos3fv(const GLfloat * v)
2993 {
2994 save_RasterPos4f(v[0], v[1], v[2], 1.0F);
2995 }
2996
2997 static void GLAPIENTRY
2998 save_RasterPos3iv(const GLint * v)
2999 {
3000 save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
3001 }
3002
3003 static void GLAPIENTRY
3004 save_RasterPos3sv(const GLshort * v)
3005 {
3006 save_RasterPos4f(v[0], v[1], v[2], 1.0F);
3007 }
3008
3009 static void GLAPIENTRY
3010 save_RasterPos4dv(const GLdouble * v)
3011 {
3012 save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1],
3013 (GLfloat) v[2], (GLfloat) v[3]);
3014 }
3015
3016 static void GLAPIENTRY
3017 save_RasterPos4fv(const GLfloat * v)
3018 {
3019 save_RasterPos4f(v[0], v[1], v[2], v[3]);
3020 }
3021
3022 static void GLAPIENTRY
3023 save_RasterPos4iv(const GLint * v)
3024 {
3025 save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1],
3026 (GLfloat) v[2], (GLfloat) v[3]);
3027 }
3028
3029 static void GLAPIENTRY
3030 save_RasterPos4sv(const GLshort * v)
3031 {
3032 save_RasterPos4f(v[0], v[1], v[2], v[3]);
3033 }
3034
3035
3036 static void GLAPIENTRY
3037 save_PassThrough(GLfloat token)
3038 {
3039 GET_CURRENT_CONTEXT(ctx);
3040 Node *n;
3041 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3042 n = ALLOC_INSTRUCTION(ctx, OPCODE_PASSTHROUGH, 1);
3043 if (n) {
3044 n[1].f = token;
3045 }
3046 if (ctx->ExecuteFlag) {
3047 CALL_PassThrough(ctx->Exec, (token));
3048 }
3049 }
3050
3051
3052 static void GLAPIENTRY
3053 save_ReadBuffer(GLenum mode)
3054 {
3055 GET_CURRENT_CONTEXT(ctx);
3056 Node *n;
3057 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3058 n = ALLOC_INSTRUCTION(ctx, OPCODE_READ_BUFFER, 1);
3059 if (n) {
3060 n[1].e = mode;
3061 }
3062 if (ctx->ExecuteFlag) {
3063 CALL_ReadBuffer(ctx->Exec, (mode));
3064 }
3065 }
3066
3067
3068 static void GLAPIENTRY
3069 save_ResetHistogram(GLenum target)
3070 {
3071 GET_CURRENT_CONTEXT(ctx);
3072 Node *n;
3073 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3074 n = ALLOC_INSTRUCTION(ctx, OPCODE_RESET_HISTOGRAM, 1);
3075 if (n) {
3076 n[1].e = target;
3077 }
3078 if (ctx->ExecuteFlag) {
3079 CALL_ResetHistogram(ctx->Exec, (target));
3080 }
3081 }
3082
3083
3084 static void GLAPIENTRY
3085 save_ResetMinmax(GLenum target)
3086 {
3087 GET_CURRENT_CONTEXT(ctx);
3088 Node *n;
3089 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3090 n = ALLOC_INSTRUCTION(ctx, OPCODE_RESET_MIN_MAX, 1);
3091 if (n) {
3092 n[1].e = target;
3093 }
3094 if (ctx->ExecuteFlag) {
3095 CALL_ResetMinmax(ctx->Exec, (target));
3096 }
3097 }
3098
3099
3100 static void GLAPIENTRY
3101 save_Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
3102 {
3103 GET_CURRENT_CONTEXT(ctx);
3104 Node *n;
3105 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3106 n = ALLOC_INSTRUCTION(ctx, OPCODE_ROTATE, 4);
3107 if (n) {
3108 n[1].f = angle;
3109 n[2].f = x;
3110 n[3].f = y;
3111 n[4].f = z;
3112 }
3113 if (ctx->ExecuteFlag) {
3114 CALL_Rotatef(ctx->Exec, (angle, x, y, z));
3115 }
3116 }
3117
3118
3119 static void GLAPIENTRY
3120 save_Rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
3121 {
3122 save_Rotatef((GLfloat) angle, (GLfloat) x, (GLfloat) y, (GLfloat) z);
3123 }
3124
3125
3126 static void GLAPIENTRY
3127 save_Scalef(GLfloat x, GLfloat y, GLfloat z)
3128 {
3129 GET_CURRENT_CONTEXT(ctx);
3130 Node *n;
3131 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3132 n = ALLOC_INSTRUCTION(ctx, OPCODE_SCALE, 3);
3133 if (n) {
3134 n[1].f = x;
3135 n[2].f = y;
3136 n[3].f = z;
3137 }
3138 if (ctx->ExecuteFlag) {
3139 CALL_Scalef(ctx->Exec, (x, y, z));
3140 }
3141 }
3142
3143
3144 static void GLAPIENTRY
3145 save_Scaled(GLdouble x, GLdouble y, GLdouble z)
3146 {
3147 save_Scalef((GLfloat) x, (GLfloat) y, (GLfloat) z);
3148 }
3149
3150
3151 static void GLAPIENTRY
3152 save_Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
3153 {
3154 GET_CURRENT_CONTEXT(ctx);
3155 Node *n;
3156 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3157 n = ALLOC_INSTRUCTION(ctx, OPCODE_SCISSOR, 4);
3158 if (n) {
3159 n[1].i = x;
3160 n[2].i = y;
3161 n[3].i = width;
3162 n[4].i = height;
3163 }
3164 if (ctx->ExecuteFlag) {
3165 CALL_Scissor(ctx->Exec, (x, y, width, height));
3166 }
3167 }
3168
3169
3170 static void GLAPIENTRY
3171 save_ShadeModel(GLenum mode)
3172 {
3173 GET_CURRENT_CONTEXT(ctx);
3174 Node *n;
3175 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3176 n = ALLOC_INSTRUCTION(ctx, OPCODE_SHADE_MODEL, 1);
3177 if (n) {
3178 n[1].e = mode;
3179 }
3180 if (ctx->ExecuteFlag) {
3181 CALL_ShadeModel(ctx->Exec, (mode));
3182 }
3183 }
3184
3185
3186 static void GLAPIENTRY
3187 save_StencilFunc(GLenum func, GLint ref, GLuint mask)
3188 {
3189 GET_CURRENT_CONTEXT(ctx);
3190 Node *n;
3191 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3192 n = ALLOC_INSTRUCTION(ctx, OPCODE_STENCIL_FUNC, 3);
3193 if (n) {
3194 n[1].e = func;
3195 n[2].i = ref;
3196 n[3].ui = mask;
3197 }
3198 if (ctx->ExecuteFlag) {
3199 CALL_StencilFunc(ctx->Exec, (func, ref, mask));
3200 }
3201 }
3202
3203
3204 static void GLAPIENTRY
3205 save_StencilMask(GLuint mask)
3206 {
3207 GET_CURRENT_CONTEXT(ctx);
3208 Node *n;
3209 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3210 n = ALLOC_INSTRUCTION(ctx, OPCODE_STENCIL_MASK, 1);
3211 if (n) {
3212 n[1].ui = mask;
3213 }
3214 if (ctx->ExecuteFlag) {
3215 CALL_StencilMask(ctx->Exec, (mask));
3216 }
3217 }
3218
3219
3220 static void GLAPIENTRY
3221 save_StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
3222 {
3223 GET_CURRENT_CONTEXT(ctx);
3224 Node *n;
3225 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3226 n = ALLOC_INSTRUCTION(ctx, OPCODE_STENCIL_OP, 3);
3227 if (n) {
3228 n[1].e = fail;
3229 n[2].e = zfail;
3230 n[3].e = zpass;
3231 }
3232 if (ctx->ExecuteFlag) {
3233 CALL_StencilOp(ctx->Exec, (fail, zfail, zpass));
3234 }
3235 }
3236
3237
3238 static void GLAPIENTRY
3239 save_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
3240 {
3241 GET_CURRENT_CONTEXT(ctx);
3242 Node *n;
3243 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3244 n = ALLOC_INSTRUCTION(ctx, OPCODE_STENCIL_FUNC_SEPARATE, 4);
3245 if (n) {
3246 n[1].e = face;
3247 n[2].e = func;
3248 n[3].i = ref;
3249 n[4].ui = mask;
3250 }
3251 if (ctx->ExecuteFlag) {
3252 CALL_StencilFuncSeparate(ctx->Exec, (face, func, ref, mask));
3253 }
3254 }
3255
3256
3257 static void GLAPIENTRY
3258 save_StencilFuncSeparateATI(GLenum frontfunc, GLenum backfunc, GLint ref,
3259 GLuint mask)
3260 {
3261 GET_CURRENT_CONTEXT(ctx);
3262 Node *n;
3263 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3264 /* GL_FRONT */
3265 n = ALLOC_INSTRUCTION(ctx, OPCODE_STENCIL_FUNC_SEPARATE, 4);
3266 if (n) {
3267 n[1].e = GL_FRONT;
3268 n[2].e = frontfunc;
3269 n[3].i = ref;
3270 n[4].ui = mask;
3271 }
3272 /* GL_BACK */
3273 n = ALLOC_INSTRUCTION(ctx, OPCODE_STENCIL_FUNC_SEPARATE, 4);
3274 if (n) {
3275 n[1].e = GL_BACK;
3276 n[2].e = backfunc;
3277 n[3].i = ref;
3278 n[4].ui = mask;
3279 }
3280 if (ctx->ExecuteFlag) {
3281 CALL_StencilFuncSeparate(ctx->Exec, (GL_FRONT, frontfunc, ref, mask));
3282 CALL_StencilFuncSeparate(ctx->Exec, (GL_BACK, backfunc, ref, mask));
3283 }
3284 }
3285
3286
3287 static void GLAPIENTRY
3288 save_StencilMaskSeparate(GLenum face, GLuint mask)
3289 {
3290 GET_CURRENT_CONTEXT(ctx);
3291 Node *n;
3292 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3293 n = ALLOC_INSTRUCTION(ctx, OPCODE_STENCIL_MASK_SEPARATE, 2);
3294 if (n) {
3295 n[1].e = face;
3296 n[2].ui = mask;
3297 }
3298 if (ctx->ExecuteFlag) {
3299 CALL_StencilMaskSeparate(ctx->Exec, (face, mask));
3300 }
3301 }
3302
3303
3304 static void GLAPIENTRY
3305 save_StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
3306 {
3307 GET_CURRENT_CONTEXT(ctx);
3308 Node *n;
3309 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3310 n = ALLOC_INSTRUCTION(ctx, OPCODE_STENCIL_OP_SEPARATE, 4);
3311 if (n) {
3312 n[1].e = face;
3313 n[2].e = fail;
3314 n[3].e = zfail;
3315 n[4].e = zpass;
3316 }
3317 if (ctx->ExecuteFlag) {
3318 CALL_StencilOpSeparate(ctx->Exec, (face, fail, zfail, zpass));
3319 }
3320 }
3321
3322
3323 static void GLAPIENTRY
3324 save_TexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
3325 {
3326 GET_CURRENT_CONTEXT(ctx);
3327 Node *n;
3328 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3329 n = ALLOC_INSTRUCTION(ctx, OPCODE_TEXENV, 6);
3330 if (n) {
3331 n[1].e = target;
3332 n[2].e = pname;
3333 if (pname == GL_TEXTURE_ENV_COLOR) {
3334 n[3].f = params[0];
3335 n[4].f = params[1];
3336 n[5].f = params[2];
3337 n[6].f = params[3];
3338 }
3339 else {
3340 n[3].f = params[0];
3341 n[4].f = n[5].f = n[6].f = 0.0F;
3342 }
3343 }
3344 if (ctx->ExecuteFlag) {
3345 CALL_TexEnvfv(ctx->Exec, (target, pname, params));
3346 }
3347 }
3348
3349
3350 static void GLAPIENTRY
3351 save_TexEnvf(GLenum target, GLenum pname, GLfloat param)
3352 {
3353 save_TexEnvfv(target, pname, &param);
3354 }
3355
3356
3357 static void GLAPIENTRY
3358 save_TexEnvi(GLenum target, GLenum pname, GLint param)
3359 {
3360 GLfloat p[4];
3361 p[0] = (GLfloat) param;
3362 p[1] = p[2] = p[3] = 0.0;
3363 save_TexEnvfv(target, pname, p);
3364 }
3365
3366
3367 static void GLAPIENTRY
3368 save_TexEnviv(GLenum target, GLenum pname, const GLint * param)
3369 {
3370 GLfloat p[4];
3371 if (pname == GL_TEXTURE_ENV_COLOR) {
3372 p[0] = INT_TO_FLOAT(param[0]);
3373 p[1] = INT_TO_FLOAT(param[1]);
3374 p[2] = INT_TO_FLOAT(param[2]);
3375 p[3] = INT_TO_FLOAT(param[3]);
3376 }
3377 else {
3378 p[0] = (GLfloat) param[0];
3379 p[1] = p[2] = p[3] = 0.0F;
3380 }
3381 save_TexEnvfv(target, pname, p);
3382 }
3383
3384
3385 static void GLAPIENTRY
3386 save_TexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
3387 {
3388 GET_CURRENT_CONTEXT(ctx);
3389 Node *n;
3390 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3391 n = ALLOC_INSTRUCTION(ctx, OPCODE_TEXGEN, 6);
3392 if (n) {
3393 n[1].e = coord;
3394 n[2].e = pname;
3395 n[3].f = params[0];
3396 n[4].f = params[1];
3397 n[5].f = params[2];
3398 n[6].f = params[3];
3399 }
3400 if (ctx->ExecuteFlag) {
3401 CALL_TexGenfv(ctx->Exec, (coord, pname, params));
3402 }
3403 }
3404
3405
3406 static void GLAPIENTRY
3407 save_TexGeniv(GLenum coord, GLenum pname, const GLint *params)
3408 {
3409 GLfloat p[4];
3410 p[0] = (GLfloat) params[0];
3411 p[1] = (GLfloat) params[1];
3412 p[2] = (GLfloat) params[2];
3413 p[3] = (GLfloat) params[3];
3414 save_TexGenfv(coord, pname, p);
3415 }
3416
3417
3418 static void GLAPIENTRY
3419 save_TexGend(GLenum coord, GLenum pname, GLdouble param)
3420 {
3421 GLfloat p = (GLfloat) param;
3422 save_TexGenfv(coord, pname, &p);
3423 }
3424
3425
3426 static void GLAPIENTRY
3427 save_TexGendv(GLenum coord, GLenum pname, const GLdouble *params)
3428 {
3429 GLfloat p[4];
3430 p[0] = (GLfloat) params[0];
3431 p[1] = (GLfloat) params[1];
3432 p[2] = (GLfloat) params[2];
3433 p[3] = (GLfloat) params[3];
3434 save_TexGenfv(coord, pname, p);
3435 }
3436
3437
3438 static void GLAPIENTRY
3439 save_TexGenf(GLenum coord, GLenum pname, GLfloat param)
3440 {
3441 save_TexGenfv(coord, pname, &param);
3442 }
3443
3444
3445 static void GLAPIENTRY
3446 save_TexGeni(GLenum coord, GLenum pname, GLint param)
3447 {
3448 save_TexGeniv(coord, pname, &param);
3449 }
3450
3451
3452 static void GLAPIENTRY
3453 save_TexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
3454 {
3455 GET_CURRENT_CONTEXT(ctx);
3456 Node *n;
3457 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3458 n = ALLOC_INSTRUCTION(ctx, OPCODE_TEXPARAMETER, 6);
3459 if (n) {
3460 n[1].e = target;
3461 n[2].e = pname;
3462 n[3].f = params[0];
3463 n[4].f = params[1];
3464 n[5].f = params[2];
3465 n[6].f = params[3];
3466 }
3467 if (ctx->ExecuteFlag) {
3468 CALL_TexParameterfv(ctx->Exec, (target, pname, params));
3469 }
3470 }
3471
3472
3473 static void GLAPIENTRY
3474 save_TexParameterf(GLenum target, GLenum pname, GLfloat param)
3475 {
3476 save_TexParameterfv(target, pname, &param);
3477 }
3478
3479
3480 static void GLAPIENTRY
3481 save_TexParameteri(GLenum target, GLenum pname, GLint param)
3482 {
3483 GLfloat fparam[4];
3484 fparam[0] = (GLfloat) param;
3485 fparam[1] = fparam[2] = fparam[3] = 0.0;
3486 save_TexParameterfv(target, pname, fparam);
3487 }
3488
3489
3490 static void GLAPIENTRY
3491 save_TexParameteriv(GLenum target, GLenum pname, const GLint *params)
3492 {
3493 GLfloat fparam[4];
3494 fparam[0] = (GLfloat) params[0];
3495 fparam[1] = fparam[2] = fparam[3] = 0.0;
3496 save_TexParameterfv(target, pname, fparam);
3497 }
3498
3499
3500 static void GLAPIENTRY
3501 save_TexImage1D(GLenum target,
3502 GLint level, GLint components,
3503 GLsizei width, GLint border,
3504 GLenum format, GLenum type, const GLvoid * pixels)
3505 {
3506 GET_CURRENT_CONTEXT(ctx);
3507 if (target == GL_PROXY_TEXTURE_1D) {
3508 /* don't compile, execute immediately */
3509 CALL_TexImage1D(ctx->Exec, (target, level, components, width,
3510 border, format, type, pixels));
3511 }
3512 else {
3513 GLvoid *image = unpack_image(1, width, 1, 1, format, type,
3514 pixels, &ctx->Unpack);
3515 Node *n;
3516 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3517 n = ALLOC_INSTRUCTION(ctx, OPCODE_TEX_IMAGE1D, 8);
3518 if (n) {
3519 n[1].e = target;
3520 n[2].i = level;
3521 n[3].i = components;
3522 n[4].i = (GLint) width;
3523 n[5].i = border;
3524 n[6].e = format;
3525 n[7].e = type;
3526 n[8].data = image;
3527 }
3528 else if (image) {
3529 _mesa_free(image);
3530 }
3531 if (ctx->ExecuteFlag) {
3532 CALL_TexImage1D(ctx->Exec, (target, level, components, width,
3533 border, format, type, pixels));
3534 }
3535 }
3536 }
3537
3538
3539 static void GLAPIENTRY
3540 save_TexImage2D(GLenum target,
3541 GLint level, GLint components,
3542 GLsizei width, GLsizei height, GLint border,
3543 GLenum format, GLenum type, const GLvoid * pixels)
3544 {
3545 GET_CURRENT_CONTEXT(ctx);
3546 if (target == GL_PROXY_TEXTURE_2D) {
3547 /* don't compile, execute immediately */
3548 CALL_TexImage2D(ctx->Exec, (target, level, components, width,
3549 height, border, format, type, pixels));
3550 }
3551 else {
3552 GLvoid *image = unpack_image(2, width, height, 1, format, type,
3553 pixels, &ctx->Unpack);
3554 Node *n;
3555 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3556 n = ALLOC_INSTRUCTION(ctx, OPCODE_TEX_IMAGE2D, 9);
3557 if (n) {
3558 n[1].e = target;
3559 n[2].i = level;
3560 n[3].i = components;
3561 n[4].i = (GLint) width;
3562 n[5].i = (GLint) height;
3563 n[6].i = border;
3564 n[7].e = format;
3565 n[8].e = type;
3566 n[9].data = image;
3567 }
3568 else if (image) {
3569 _mesa_free(image);
3570 }
3571 if (ctx->ExecuteFlag) {
3572 CALL_TexImage2D(ctx->Exec, (target, level, components, width,
3573 height, border, format, type, pixels));
3574 }
3575 }
3576 }
3577
3578
3579 static void GLAPIENTRY
3580 save_TexImage3D(GLenum target,
3581 GLint level, GLint internalFormat,
3582 GLsizei width, GLsizei height, GLsizei depth,
3583 GLint border,
3584 GLenum format, GLenum type, const GLvoid * pixels)
3585 {
3586 GET_CURRENT_CONTEXT(ctx);
3587 if (target == GL_PROXY_TEXTURE_3D) {
3588 /* don't compile, execute immediately */
3589 CALL_TexImage3D(ctx->Exec, (target, level, internalFormat, width,
3590 height, depth, border, format, type,
3591 pixels));
3592 }
3593 else {
3594 Node *n;
3595 GLvoid *image = unpack_image(3, width, height, depth, format, type,
3596 pixels, &ctx->Unpack);
3597 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3598 n = ALLOC_INSTRUCTION(ctx, OPCODE_TEX_IMAGE3D, 10);
3599 if (n) {
3600 n[1].e = target;
3601 n[2].i = level;
3602 n[3].i = (GLint) internalFormat;
3603 n[4].i = (GLint) width;
3604 n[5].i = (GLint) height;
3605 n[6].i = (GLint) depth;
3606 n[7].i = border;
3607 n[8].e = format;
3608 n[9].e = type;
3609 n[10].data = image;
3610 }
3611 else if (image) {
3612 _mesa_free(image);
3613 }
3614 if (ctx->ExecuteFlag) {
3615 CALL_TexImage3D(ctx->Exec, (target, level, internalFormat, width,
3616 height, depth, border, format, type,
3617 pixels));
3618 }
3619 }
3620 }
3621
3622
3623 static void GLAPIENTRY
3624 save_TexSubImage1D(GLenum target, GLint level, GLint xoffset,
3625 GLsizei width, GLenum format, GLenum type,
3626 const GLvoid * pixels)
3627 {
3628 GET_CURRENT_CONTEXT(ctx);
3629 Node *n;
3630 GLvoid *image = unpack_image(1, width, 1, 1, format, type,
3631 pixels, &ctx->Unpack);
3632 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3633 n = ALLOC_INSTRUCTION(ctx, OPCODE_TEX_SUB_IMAGE1D, 7);
3634 if (n) {
3635 n[1].e = target;
3636 n[2].i = level;
3637 n[3].i = xoffset;
3638 n[4].i = (GLint) width;
3639 n[5].e = format;
3640 n[6].e = type;
3641 n[7].data = image;
3642 }
3643 else if (image) {
3644 _mesa_free(image);
3645 }
3646 if (ctx->ExecuteFlag) {
3647 CALL_TexSubImage1D(ctx->Exec, (target, level, xoffset, width,
3648 format, type, pixels));
3649 }
3650 }
3651
3652
3653 static void GLAPIENTRY
3654 save_TexSubImage2D(GLenum target, GLint level,
3655 GLint xoffset, GLint yoffset,
3656 GLsizei width, GLsizei height,
3657 GLenum format, GLenum type, const GLvoid * pixels)
3658 {
3659 GET_CURRENT_CONTEXT(ctx);
3660 Node *n;
3661 GLvoid *image = unpack_image(2, width, height, 1, format, type,
3662 pixels, &ctx->Unpack);
3663 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3664 n = ALLOC_INSTRUCTION(ctx, OPCODE_TEX_SUB_IMAGE2D, 9);
3665 if (n) {
3666 n[1].e = target;
3667 n[2].i = level;
3668 n[3].i = xoffset;
3669 n[4].i = yoffset;
3670 n[5].i = (GLint) width;
3671 n[6].i = (GLint) height;
3672 n[7].e = format;
3673 n[8].e = type;
3674 n[9].data = image;
3675 }
3676 else if (image) {
3677 _mesa_free(image);
3678 }
3679 if (ctx->ExecuteFlag) {
3680 CALL_TexSubImage2D(ctx->Exec, (target, level, xoffset, yoffset,
3681 width, height, format, type, pixels));
3682 }
3683 }
3684
3685
3686 static void GLAPIENTRY
3687 save_TexSubImage3D(GLenum target, GLint level,
3688 GLint xoffset, GLint yoffset, GLint zoffset,
3689 GLsizei width, GLsizei height, GLsizei depth,
3690 GLenum format, GLenum type, const GLvoid * pixels)
3691 {
3692 GET_CURRENT_CONTEXT(ctx);
3693 Node *n;
3694 GLvoid *image = unpack_image(3, width, height, depth, format, type,
3695 pixels, &ctx->Unpack);
3696 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3697 n = ALLOC_INSTRUCTION(ctx, OPCODE_TEX_SUB_IMAGE3D, 11);
3698 if (n) {
3699 n[1].e = target;
3700 n[2].i = level;
3701 n[3].i = xoffset;
3702 n[4].i = yoffset;
3703 n[5].i = zoffset;
3704 n[6].i = (GLint) width;
3705 n[7].i = (GLint) height;
3706 n[8].i = (GLint) depth;
3707 n[9].e = format;
3708 n[10].e = type;
3709 n[11].data = image;
3710 }
3711 else if (image) {
3712 _mesa_free(image);
3713 }
3714 if (ctx->ExecuteFlag) {
3715 CALL_TexSubImage3D(ctx->Exec, (target, level,
3716 xoffset, yoffset, zoffset,
3717 width, height, depth, format, type,
3718 pixels));
3719 }
3720 }
3721
3722
3723 static void GLAPIENTRY
3724 save_Translatef(GLfloat x, GLfloat y, GLfloat z)
3725 {
3726 GET_CURRENT_CONTEXT(ctx);
3727 Node *n;
3728 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3729 n = ALLOC_INSTRUCTION(ctx, OPCODE_TRANSLATE, 3);
3730 if (n) {
3731 n[1].f = x;
3732 n[2].f = y;
3733 n[3].f = z;
3734 }
3735 if (ctx->ExecuteFlag) {
3736 CALL_Translatef(ctx->Exec, (x, y, z));
3737 }
3738 }
3739
3740
3741 static void GLAPIENTRY
3742 save_Translated(GLdouble x, GLdouble y, GLdouble z)
3743 {
3744 save_Translatef((GLfloat) x, (GLfloat) y, (GLfloat) z);
3745 }
3746
3747
3748
3749 static void GLAPIENTRY
3750 save_Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
3751 {
3752 GET_CURRENT_CONTEXT(ctx);
3753 Node *n;
3754 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3755 n = ALLOC_INSTRUCTION(ctx, OPCODE_VIEWPORT, 4);
3756 if (n) {
3757 n[1].i = x;
3758 n[2].i = y;
3759 n[3].i = (GLint) width;
3760 n[4].i = (GLint) height;
3761 }
3762 if (ctx->ExecuteFlag) {
3763 CALL_Viewport(ctx->Exec, (x, y, width, height));
3764 }
3765 }
3766
3767
3768 static void GLAPIENTRY
3769 save_WindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
3770 {
3771 GET_CURRENT_CONTEXT(ctx);
3772 Node *n;
3773 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3774 n = ALLOC_INSTRUCTION(ctx, OPCODE_WINDOW_POS, 4);
3775 if (n) {
3776 n[1].f = x;
3777 n[2].f = y;
3778 n[3].f = z;
3779 n[4].f = w;
3780 }
3781 if (ctx->ExecuteFlag) {
3782 CALL_WindowPos4fMESA(ctx->Exec, (x, y, z, w));
3783 }
3784 }
3785
3786 static void GLAPIENTRY
3787 save_WindowPos2dMESA(GLdouble x, GLdouble y)
3788 {
3789 save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
3790 }
3791
3792 static void GLAPIENTRY
3793 save_WindowPos2fMESA(GLfloat x, GLfloat y)
3794 {
3795 save_WindowPos4fMESA(x, y, 0.0F, 1.0F);
3796 }
3797
3798 static void GLAPIENTRY
3799 save_WindowPos2iMESA(GLint x, GLint y)
3800 {
3801 save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
3802 }
3803
3804 static void GLAPIENTRY
3805 save_WindowPos2sMESA(GLshort x, GLshort y)
3806 {
3807 save_WindowPos4fMESA(x, y, 0.0F, 1.0F);
3808 }
3809
3810 static void GLAPIENTRY
3811 save_WindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z)
3812 {
3813 save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
3814 }
3815
3816 static void GLAPIENTRY
3817 save_WindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
3818 {
3819 save_WindowPos4fMESA(x, y, z, 1.0F);
3820 }
3821
3822 static void GLAPIENTRY
3823 save_WindowPos3iMESA(GLint x, GLint y, GLint z)
3824 {
3825 save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
3826 }
3827
3828 static void GLAPIENTRY
3829 save_WindowPos3sMESA(GLshort x, GLshort y, GLshort z)
3830 {
3831 save_WindowPos4fMESA(x, y, z, 1.0F);
3832 }
3833
3834 static void GLAPIENTRY
3835 save_WindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
3836 {
3837 save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
3838 }
3839
3840 static void GLAPIENTRY
3841 save_WindowPos4iMESA(GLint x, GLint y, GLint z, GLint w)
3842 {
3843 save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
3844 }
3845
3846 static void GLAPIENTRY
3847 save_WindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w)
3848 {
3849 save_WindowPos4fMESA(x, y, z, w);
3850 }
3851
3852 static void GLAPIENTRY
3853 save_WindowPos2dvMESA(const GLdouble * v)
3854 {
3855 save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
3856 }
3857
3858 static void GLAPIENTRY
3859 save_WindowPos2fvMESA(const GLfloat * v)
3860 {
3861 save_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);
3862 }
3863
3864 static void GLAPIENTRY
3865 save_WindowPos2ivMESA(const GLint * v)
3866 {
3867 save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
3868 }
3869
3870 static void GLAPIENTRY
3871 save_WindowPos2svMESA(const GLshort * v)
3872 {
3873 save_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);
3874 }
3875
3876 static void GLAPIENTRY
3877 save_WindowPos3dvMESA(const GLdouble * v)
3878 {
3879 save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
3880 }
3881
3882 static void GLAPIENTRY
3883 save_WindowPos3fvMESA(const GLfloat * v)
3884 {
3885 save_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);
3886 }
3887
3888 static void GLAPIENTRY
3889 save_WindowPos3ivMESA(const GLint * v)
3890 {
3891 save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
3892 }
3893
3894 static void GLAPIENTRY
3895 save_WindowPos3svMESA(const GLshort * v)
3896 {
3897 save_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);
3898 }
3899
3900 static void GLAPIENTRY
3901 save_WindowPos4dvMESA(const GLdouble * v)
3902 {
3903 save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1],
3904 (GLfloat) v[2], (GLfloat) v[3]);
3905 }
3906
3907 static void GLAPIENTRY
3908 save_WindowPos4fvMESA(const GLfloat * v)
3909 {
3910 save_WindowPos4fMESA(v[0], v[1], v[2], v[3]);
3911 }
3912
3913 static void GLAPIENTRY
3914 save_WindowPos4ivMESA(const GLint * v)
3915 {
3916 save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1],
3917 (GLfloat) v[2], (GLfloat) v[3]);
3918 }
3919
3920 static void GLAPIENTRY
3921 save_WindowPos4svMESA(const GLshort * v)
3922 {
3923 save_WindowPos4fMESA(v[0], v[1], v[2], v[3]);
3924 }
3925
3926
3927
3928 /* GL_ARB_multitexture */
3929 static void GLAPIENTRY
3930 save_ActiveTextureARB(GLenum target)
3931 {
3932 GET_CURRENT_CONTEXT(ctx);
3933 Node *n;
3934 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3935 n = ALLOC_INSTRUCTION(ctx, OPCODE_ACTIVE_TEXTURE, 1);
3936 if (n) {
3937 n[1].e = target;
3938 }
3939 if (ctx->ExecuteFlag) {
3940 CALL_ActiveTextureARB(ctx->Exec, (target));
3941 }
3942 }
3943
3944
3945 /* GL_ARB_transpose_matrix */
3946
3947 static void GLAPIENTRY
3948 save_LoadTransposeMatrixdARB(const GLdouble m[16])
3949 {
3950 GLfloat tm[16];
3951 _math_transposefd(tm, m);
3952 save_LoadMatrixf(tm);
3953 }
3954
3955
3956 static void GLAPIENTRY
3957 save_LoadTransposeMatrixfARB(const GLfloat m[16])
3958 {
3959 GLfloat tm[16];
3960 _math_transposef(tm, m);
3961 save_LoadMatrixf(tm);
3962 }
3963
3964
3965 static void GLAPIENTRY
3966 save_MultTransposeMatrixdARB(const GLdouble m[16])
3967 {
3968 GLfloat tm[16];
3969 _math_transposefd(tm, m);
3970 save_MultMatrixf(tm);
3971 }
3972
3973
3974 static void GLAPIENTRY
3975 save_MultTransposeMatrixfARB(const GLfloat m[16])
3976 {
3977 GLfloat tm[16];
3978 _math_transposef(tm, m);
3979 save_MultMatrixf(tm);
3980 }
3981
3982
3983 /* GL_ARB_texture_compression */
3984 static void GLAPIENTRY
3985 save_CompressedTexImage1DARB(GLenum target, GLint level,
3986 GLenum internalFormat, GLsizei width,
3987 GLint border, GLsizei imageSize,
3988 const GLvoid * data)
3989 {
3990 GET_CURRENT_CONTEXT(ctx);
3991 if (target == GL_PROXY_TEXTURE_1D) {
3992 /* don't compile, execute immediately */
3993 CALL_CompressedTexImage1DARB(ctx->Exec, (target, level, internalFormat,
3994 width, border, imageSize,
3995 data));
3996 }
3997 else {
3998 Node *n;
3999 GLvoid *image;
4000 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4001 /* make copy of image */
4002 image = _mesa_malloc(imageSize);
4003 if (!image) {
4004 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage1DARB");
4005 return;
4006 }
4007 MEMCPY(image, data, imageSize);
4008 n = ALLOC_INSTRUCTION(ctx, OPCODE_COMPRESSED_TEX_IMAGE_1D, 7);
4009 if (n) {
4010 n[1].e = target;
4011 n[2].i = level;
4012 n[3].e = internalFormat;
4013 n[4].i = (GLint) width;
4014 n[5].i = border;
4015 n[6].i = imageSize;
4016 n[7].data = image;
4017 }
4018 else if (image) {
4019 _mesa_free(image);
4020 }
4021 if (ctx->ExecuteFlag) {
4022 CALL_CompressedTexImage1DARB(ctx->Exec,
4023 (target, level, internalFormat, width,
4024 border, imageSize, data));
4025 }
4026 }
4027 }
4028
4029
4030 static void GLAPIENTRY
4031 save_CompressedTexImage2DARB(GLenum target, GLint level,
4032 GLenum internalFormat, GLsizei width,
4033 GLsizei height, GLint border, GLsizei imageSize,
4034 const GLvoid * data)
4035 {
4036 GET_CURRENT_CONTEXT(ctx);
4037 if (target == GL_PROXY_TEXTURE_2D) {
4038 /* don't compile, execute immediately */
4039 CALL_CompressedTexImage2DARB(ctx->Exec, (target, level, internalFormat,
4040 width, height, border,
4041 imageSize, data));
4042 }
4043 else {
4044 Node *n;
4045 GLvoid *image;
4046 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4047 /* make copy of image */
4048 image = _mesa_malloc(imageSize);
4049 if (!image) {
4050 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2DARB");
4051 return;
4052 }
4053 MEMCPY(image, data, imageSize);
4054 n = ALLOC_INSTRUCTION(ctx, OPCODE_COMPRESSED_TEX_IMAGE_2D, 8);
4055 if (n) {
4056 n[1].e = target;
4057 n[2].i = level;
4058 n[3].e = internalFormat;
4059 n[4].i = (GLint) width;
4060 n[5].i = (GLint) height;
4061 n[6].i = border;
4062 n[7].i = imageSize;
4063 n[8].data = image;
4064 }
4065 else if (image) {
4066 _mesa_free(image);
4067 }
4068 if (ctx->ExecuteFlag) {
4069 CALL_CompressedTexImage2DARB(ctx->Exec,
4070 (target, level, internalFormat, width,
4071 height, border, imageSize, data));
4072 }
4073 }
4074 }
4075
4076
4077 static void GLAPIENTRY
4078 save_CompressedTexImage3DARB(GLenum target, GLint level,
4079 GLenum internalFormat, GLsizei width,
4080 GLsizei height, GLsizei depth, GLint border,
4081 GLsizei imageSize, const GLvoid * data)
4082 {
4083 GET_CURRENT_CONTEXT(ctx);
4084 if (target == GL_PROXY_TEXTURE_3D) {
4085 /* don't compile, execute immediately */
4086 CALL_CompressedTexImage3DARB(ctx->Exec, (target, level, internalFormat,
4087 width, height, depth, border,
4088 imageSize, data));
4089 }
4090 else {
4091 Node *n;
4092 GLvoid *image;
4093 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4094 /* make copy of image */
4095 image = _mesa_malloc(imageSize);
4096 if (!image) {
4097 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage3DARB");
4098 return;
4099 }
4100 MEMCPY(image, data, imageSize);
4101 n = ALLOC_INSTRUCTION(ctx, OPCODE_COMPRESSED_TEX_IMAGE_3D, 9);
4102 if (n) {
4103 n[1].e = target;
4104 n[2].i = level;
4105 n[3].e = internalFormat;
4106 n[4].i = (GLint) width;
4107 n[5].i = (GLint) height;
4108 n[6].i = (GLint) depth;
4109 n[7].i = border;
4110 n[8].i = imageSize;
4111 n[9].data = image;
4112 }
4113 else if (image) {
4114 _mesa_free(image);
4115 }
4116 if (ctx->ExecuteFlag) {
4117 CALL_CompressedTexImage3DARB(ctx->Exec,
4118 (target, level, internalFormat, width,
4119 height, depth, border, imageSize,
4120 data));
4121 }
4122 }
4123 }
4124
4125
4126 static void GLAPIENTRY
4127 save_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset,
4128 GLsizei width, GLenum format,
4129 GLsizei imageSize, const GLvoid * data)
4130 {
4131 Node *n;
4132 GLvoid *image;
4133
4134 GET_CURRENT_CONTEXT(ctx);
4135 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4136
4137 /* make copy of image */
4138 image = _mesa_malloc(imageSize);
4139 if (!image) {
4140 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage1DARB");
4141 return;
4142 }
4143 MEMCPY(image, data, imageSize);
4144 n = ALLOC_INSTRUCTION(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D, 7);
4145 if (n) {
4146 n[1].e = target;
4147 n[2].i = level;
4148 n[3].i = xoffset;
4149 n[4].i = (GLint) width;
4150 n[5].e = format;
4151 n[6].i = imageSize;
4152 n[7].data = image;
4153 }
4154 else if (image) {
4155 _mesa_free(image);
4156 }
4157 if (ctx->ExecuteFlag) {
4158 CALL_CompressedTexSubImage1DARB(ctx->Exec, (target, level, xoffset,
4159 width, format, imageSize,
4160 data));
4161 }
4162 }
4163
4164
4165 static void GLAPIENTRY
4166 save_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset,
4167 GLint yoffset, GLsizei width, GLsizei height,
4168 GLenum format, GLsizei imageSize,
4169 const GLvoid * data)
4170 {
4171 Node *n;
4172 GLvoid *image;
4173
4174 GET_CURRENT_CONTEXT(ctx);
4175 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4176
4177 /* make copy of image */
4178 image = _mesa_malloc(imageSize);
4179 if (!image) {
4180 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage2DARB");
4181 return;
4182 }
4183 MEMCPY(image, data, imageSize);
4184 n = ALLOC_INSTRUCTION(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D, 9);
4185 if (n) {
4186 n[1].e = target;
4187 n[2].i = level;
4188 n[3].i = xoffset;
4189 n[4].i = yoffset;
4190 n[5].i = (GLint) width;
4191 n[6].i = (GLint) height;
4192 n[7].e = format;
4193 n[8].i = imageSize;
4194 n[9].data = image;
4195 }
4196 else if (image) {
4197 _mesa_free(image);
4198 }
4199 if (ctx->ExecuteFlag) {
4200 CALL_CompressedTexSubImage2DARB(ctx->Exec,
4201 (target, level, xoffset, yoffset, width,
4202 height, format, imageSize, data));
4203 }
4204 }
4205
4206
4207 static void GLAPIENTRY
4208 save_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset,
4209 GLint yoffset, GLint zoffset, GLsizei width,
4210 GLsizei height, GLsizei depth, GLenum format,
4211 GLsizei imageSize, const GLvoid * data)
4212 {
4213 Node *n;
4214 GLvoid *image;
4215
4216 GET_CURRENT_CONTEXT(ctx);
4217 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4218
4219 /* make copy of image */
4220 image = _mesa_malloc(imageSize);
4221 if (!image) {
4222 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexSubImage3DARB");
4223 return;
4224 }
4225 MEMCPY(image, data, imageSize);
4226 n = ALLOC_INSTRUCTION(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D, 11);
4227 if (n) {
4228 n[1].e = target;
4229 n[2].i = level;
4230 n[3].i = xoffset;
4231 n[4].i = yoffset;
4232 n[5].i = zoffset;
4233 n[6].i = (GLint) width;
4234 n[7].i = (GLint) height;
4235 n[8].i = (GLint) depth;
4236 n[9].e = format;
4237 n[10].i = imageSize;
4238 n[11].data = image;
4239 }
4240 else if (image) {
4241 _mesa_free(image);
4242 }
4243 if (ctx->ExecuteFlag) {
4244 CALL_CompressedTexSubImage3DARB(ctx->Exec,
4245 (target, level, xoffset, yoffset,
4246 zoffset, width, height, depth, format,
4247 imageSize, data));
4248 }
4249 }
4250
4251
4252 /* GL_ARB_multisample */
4253 static void GLAPIENTRY
4254 save_SampleCoverageARB(GLclampf value, GLboolean invert)
4255 {
4256 GET_CURRENT_CONTEXT(ctx);
4257 Node *n;
4258 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4259 n = ALLOC_INSTRUCTION(ctx, OPCODE_SAMPLE_COVERAGE, 2);
4260 if (n) {
4261 n[1].f = value;
4262 n[2].b = invert;
4263 }
4264 if (ctx->ExecuteFlag) {
4265 CALL_SampleCoverageARB(ctx->Exec, (value, invert));
4266 }
4267 }
4268
4269
4270 /*
4271 * GL_NV_vertex_program
4272 */
4273 #if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
4274 static void GLAPIENTRY
4275 save_BindProgramNV(GLenum target, GLuint id)
4276 {
4277 GET_CURRENT_CONTEXT(ctx);
4278 Node *n;
4279 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4280 n = ALLOC_INSTRUCTION(ctx, OPCODE_BIND_PROGRAM_NV, 2);
4281 if (n) {
4282 n[1].e = target;
4283 n[2].ui = id;
4284 }
4285 if (ctx->ExecuteFlag) {
4286 CALL_BindProgramNV(ctx->Exec, (target, id));
4287 }
4288 }
4289
4290 static void GLAPIENTRY
4291 save_ProgramEnvParameter4fARB(GLenum target, GLuint index,
4292 GLfloat x, GLfloat y, GLfloat z, GLfloat w)
4293 {
4294 GET_CURRENT_CONTEXT(ctx);
4295 Node *n;
4296 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4297 n = ALLOC_INSTRUCTION(ctx, OPCODE_PROGRAM_ENV_PARAMETER_ARB, 6);
4298 if (n) {
4299 n[1].e = target;
4300 n[2].ui = index;
4301 n[3].f = x;
4302 n[4].f = y;
4303 n[5].f = z;
4304 n[6].f = w;
4305 }
4306 if (ctx->ExecuteFlag) {
4307 CALL_ProgramEnvParameter4fARB(ctx->Exec, (target, index, x, y, z, w));
4308 }
4309 }
4310
4311
4312 static void GLAPIENTRY
4313 save_ProgramEnvParameter4fvARB(GLenum target, GLuint index,
4314 const GLfloat *params)
4315 {
4316 save_ProgramEnvParameter4fARB(target, index, params[0], params[1],
4317 params[2], params[3]);
4318 }
4319
4320
4321 static void GLAPIENTRY
4322 save_ProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count,
4323 const GLfloat * params)
4324 {
4325 GET_CURRENT_CONTEXT(ctx);
4326 Node *n;
4327 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4328
4329 if (count > 0) {
4330 GLint i;
4331 const GLfloat * p = params;
4332
4333 for (i = 0 ; i < count ; i++) {
4334 n = ALLOC_INSTRUCTION(ctx, OPCODE_PROGRAM_ENV_PARAMETER_ARB, 6);
4335 if (n) {
4336 n[1].e = target;
4337 n[2].ui = index;
4338 n[3].f = p[0];
4339 n[4].f = p[1];
4340 n[5].f = p[2];
4341 n[6].f = p[3];
4342 p += 4;
4343 }
4344 }
4345 }
4346
4347 if (ctx->ExecuteFlag) {
4348 CALL_ProgramEnvParameters4fvEXT(ctx->Exec, (target, index, count, params));
4349 }
4350 }
4351
4352
4353 static void GLAPIENTRY
4354 save_ProgramEnvParameter4dARB(GLenum target, GLuint index,
4355 GLdouble x, GLdouble y, GLdouble z, GLdouble w)
4356 {
4357 save_ProgramEnvParameter4fARB(target, index,
4358 (GLfloat) x,
4359 (GLfloat) y, (GLfloat) z, (GLfloat) w);
4360 }
4361
4362
4363 static void GLAPIENTRY
4364 save_ProgramEnvParameter4dvARB(GLenum target, GLuint index,
4365 const GLdouble *params)
4366 {
4367 save_ProgramEnvParameter4fARB(target, index,
4368 (GLfloat) params[0],
4369 (GLfloat) params[1],
4370 (GLfloat) params[2], (GLfloat) params[3]);
4371 }
4372
4373 #endif /* FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program || FEATURE_NV_vertex_program */
4374
4375 #if FEATURE_NV_vertex_program
4376 static void GLAPIENTRY
4377 save_ExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params)
4378 {
4379 GET_CURRENT_CONTEXT(ctx);
4380 Node *n;
4381 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4382 n = ALLOC_INSTRUCTION(ctx, OPCODE_EXECUTE_PROGRAM_NV, 6);
4383 if (n) {
4384 n[1].e = target;
4385 n[2].ui = id;
4386 n[3].f = params[0];
4387 n[4].f = params[1];
4388 n[5].f = params[2];
4389 n[6].f = params[3];
4390 }
4391 if (ctx->ExecuteFlag) {
4392 CALL_ExecuteProgramNV(ctx->Exec, (target, id, params));
4393 }
4394 }
4395
4396
4397 static void GLAPIENTRY
4398 save_ProgramParameters4dvNV(GLenum target, GLuint index,
4399 GLuint num, const GLdouble *params)
4400 {
4401 GLuint i;
4402 for (i = 0; i < num; i++) {
4403 save_ProgramEnvParameter4dvARB(target, index + i, params + 4 * i);
4404 }
4405 }
4406
4407
4408 static void GLAPIENTRY
4409 save_ProgramParameters4fvNV(GLenum target, GLuint index,
4410 GLuint num, const GLfloat *params)
4411 {
4412 GLuint i;
4413 for (i = 0; i < num; i++) {
4414 save_ProgramEnvParameter4fvARB(target, index + i, params + 4 * i);
4415 }
4416 }
4417
4418
4419 static void GLAPIENTRY
4420 save_LoadProgramNV(GLenum target, GLuint id, GLsizei len,
4421 const GLubyte * program)
4422 {
4423 GET_CURRENT_CONTEXT(ctx);
4424 Node *n;
4425 GLubyte *programCopy;
4426
4427 programCopy = (GLubyte *) _mesa_malloc(len);
4428 if (!programCopy) {
4429 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV");
4430 return;
4431 }
4432 _mesa_memcpy(programCopy, program, len);
4433
4434 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4435 n = ALLOC_INSTRUCTION(ctx, OPCODE_LOAD_PROGRAM_NV, 4);
4436 if (n) {
4437 n[1].e = target;
4438 n[2].ui = id;
4439 n[3].i = len;
4440 n[4].data = programCopy;
4441 }
4442 if (ctx->ExecuteFlag) {
4443 CALL_LoadProgramNV(ctx->Exec, (target, id, len, program));
4444 }
4445 }
4446
4447
4448 static void GLAPIENTRY
4449 save_RequestResidentProgramsNV(GLsizei num, const GLuint * ids)
4450 {
4451 GET_CURRENT_CONTEXT(ctx);
4452 Node *n;
4453 GLuint *idCopy = (GLuint *) _mesa_malloc(num * sizeof(GLuint));
4454 if (!idCopy) {
4455 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glRequestResidentProgramsNV");
4456 return;
4457 }
4458 _mesa_memcpy(idCopy, ids, num * sizeof(GLuint));
4459 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4460 n = ALLOC_INSTRUCTION(ctx, OPCODE_TRACK_MATRIX_NV, 2);
4461 if (n) {
4462 n[1].i = num;
4463 n[2].data = idCopy;
4464 }
4465 if (ctx->ExecuteFlag) {
4466 CALL_RequestResidentProgramsNV(ctx->Exec, (num, ids));
4467 }
4468 }
4469
4470
4471 static void GLAPIENTRY
4472 save_TrackMatrixNV(GLenum target, GLuint address,
4473 GLenum matrix, GLenum transform)
4474 {
4475 GET_CURRENT_CONTEXT(ctx);
4476 Node *n;
4477 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4478 n = ALLOC_INSTRUCTION(ctx, OPCODE_TRACK_MATRIX_NV, 4);
4479 if (n) {
4480 n[1].e = target;
4481 n[2].ui = address;
4482 n[3].e = matrix;
4483 n[4].e = transform;
4484 }
4485 if (ctx->ExecuteFlag) {
4486 CALL_TrackMatrixNV(ctx->Exec, (target, address, matrix, transform));
4487 }
4488 }
4489 #endif /* FEATURE_NV_vertex_program */
4490
4491
4492 /*
4493 * GL_NV_fragment_program
4494 */
4495 #if FEATURE_NV_fragment_program
4496 static void GLAPIENTRY
4497 save_ProgramLocalParameter4fARB(GLenum target, GLuint index,
4498 GLfloat x, GLfloat y, GLfloat z, GLfloat w)
4499 {
4500 GET_CURRENT_CONTEXT(ctx);
4501 Node *n;
4502 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4503 n = ALLOC_INSTRUCTION(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
4504 if (n) {
4505 n[1].e = target;
4506 n[2].ui = index;
4507 n[3].f = x;
4508 n[4].f = y;
4509 n[5].f = z;
4510 n[6].f = w;
4511 }
4512 if (ctx->ExecuteFlag) {
4513 CALL_ProgramLocalParameter4fARB(ctx->Exec, (target, index, x, y, z, w));
4514 }
4515 }
4516
4517
4518 static void GLAPIENTRY
4519 save_ProgramLocalParameter4fvARB(GLenum target, GLuint index,
4520 const GLfloat *params)
4521 {
4522 GET_CURRENT_CONTEXT(ctx);
4523 Node *n;
4524 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4525 n = ALLOC_INSTRUCTION(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
4526 if (n) {
4527 n[1].e = target;
4528 n[2].ui = index;
4529 n[3].f = params[0];
4530 n[4].f = params[1];
4531 n[5].f = params[2];
4532 n[6].f = params[3];
4533 }
4534 if (ctx->ExecuteFlag) {
4535 CALL_ProgramLocalParameter4fvARB(ctx->Exec, (target, index, params));
4536 }
4537 }
4538
4539
4540 static void GLAPIENTRY
4541 save_ProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count,
4542 const GLfloat *params)
4543 {
4544 GET_CURRENT_CONTEXT(ctx);
4545 Node *n;
4546 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4547
4548 if (count > 0) {
4549 GLint i;
4550 const GLfloat * p = params;
4551
4552 for (i = 0 ; i < count ; i++) {
4553 n = ALLOC_INSTRUCTION(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
4554 if (n) {
4555 n[1].e = target;
4556 n[2].ui = index;
4557 n[3].f = p[0];
4558 n[4].f = p[1];
4559 n[5].f = p[2];
4560 n[6].f = p[3];
4561 p += 4;
4562 }
4563 }
4564 }
4565
4566 if (ctx->ExecuteFlag) {
4567 CALL_ProgramLocalParameters4fvEXT(ctx->Exec, (target, index, count, params));
4568 }
4569 }
4570
4571
4572 static void GLAPIENTRY
4573 save_ProgramLocalParameter4dARB(GLenum target, GLuint index,
4574 GLdouble x, GLdouble y,
4575 GLdouble z, GLdouble w)
4576 {
4577 GET_CURRENT_CONTEXT(ctx);
4578 Node *n;
4579 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4580 n = ALLOC_INSTRUCTION(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
4581 if (n) {
4582 n[1].e = target;
4583 n[2].ui = index;
4584 n[3].f = (GLfloat) x;
4585 n[4].f = (GLfloat) y;
4586 n[5].f = (GLfloat) z;
4587 n[6].f = (GLfloat) w;
4588 }
4589 if (ctx->ExecuteFlag) {
4590 CALL_ProgramLocalParameter4dARB(ctx->Exec, (target, index, x, y, z, w));
4591 }
4592 }
4593
4594
4595 static void GLAPIENTRY
4596 save_ProgramLocalParameter4dvARB(GLenum target, GLuint index,
4597 const GLdouble *params)
4598 {
4599 GET_CURRENT_CONTEXT(ctx);
4600 Node *n;
4601 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4602 n = ALLOC_INSTRUCTION(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
4603 if (n) {
4604 n[1].e = target;
4605 n[2].ui = index;
4606 n[3].f = (GLfloat) params[0];
4607 n[4].f = (GLfloat) params[1];
4608 n[5].f = (GLfloat) params[2];
4609 n[6].f = (GLfloat) params[3];
4610 }
4611 if (ctx->ExecuteFlag) {
4612 CALL_ProgramLocalParameter4dvARB(ctx->Exec, (target, index, params));
4613 }
4614 }
4615
4616 static void GLAPIENTRY
4617 save_ProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name,
4618 GLfloat x, GLfloat y, GLfloat z, GLfloat w)
4619 {
4620 GET_CURRENT_CONTEXT(ctx);
4621 Node *n;
4622 GLubyte *nameCopy = (GLubyte *) _mesa_malloc(len);
4623 if (!nameCopy) {
4624 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramNamedParameter4fNV");
4625 return;
4626 }
4627 _mesa_memcpy(nameCopy, name, len);
4628
4629 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4630 n = ALLOC_INSTRUCTION(ctx, OPCODE_PROGRAM_NAMED_PARAMETER_NV, 6);
4631 if (n) {
4632 n[1].ui = id;
4633 n[2].i = len;
4634 n[3].data = nameCopy;
4635 n[4].f = x;
4636 n[5].f = y;
4637 n[6].f = z;
4638 n[7].f = w;
4639 }
4640 if (ctx->ExecuteFlag) {
4641 CALL_ProgramNamedParameter4fNV(ctx->Exec, (id, len, name, x, y, z, w));
4642 }
4643 }
4644
4645
4646 static void GLAPIENTRY
4647 save_ProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte * name,
4648 const float v[])
4649 {
4650 save_ProgramNamedParameter4fNV(id, len, name, v[0], v[1], v[2], v[3]);
4651 }
4652
4653
4654 static void GLAPIENTRY
4655 save_ProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte * name,
4656 GLdouble x, GLdouble y, GLdouble z, GLdouble w)
4657 {
4658 save_ProgramNamedParameter4fNV(id, len, name, (GLfloat) x, (GLfloat) y,
4659 (GLfloat) z, (GLfloat) w);
4660 }
4661
4662
4663 static void GLAPIENTRY
4664 save_ProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte * name,
4665 const double v[])
4666 {
4667 save_ProgramNamedParameter4fNV(id, len, name, (GLfloat) v[0],
4668 (GLfloat) v[1], (GLfloat) v[2],
4669 (GLfloat) v[3]);
4670 }
4671
4672 #endif /* FEATURE_NV_fragment_program */
4673
4674
4675
4676 /* GL_EXT_stencil_two_side */
4677 static void GLAPIENTRY
4678 save_ActiveStencilFaceEXT(GLenum face)
4679 {
4680 GET_CURRENT_CONTEXT(ctx);
4681 Node *n;
4682 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4683 n = ALLOC_INSTRUCTION(ctx, OPCODE_ACTIVE_STENCIL_FACE_EXT, 1);
4684 if (n) {
4685 n[1].e = face;
4686 }
4687 if (ctx->ExecuteFlag) {
4688 CALL_ActiveStencilFaceEXT(ctx->Exec, (face));
4689 }
4690 }
4691
4692
4693 /* GL_EXT_depth_bounds_test */
4694 static void GLAPIENTRY
4695 save_DepthBoundsEXT(GLclampd zmin, GLclampd zmax)
4696 {
4697 GET_CURRENT_CONTEXT(ctx);
4698 Node *n;
4699 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4700 n = ALLOC_INSTRUCTION(ctx, OPCODE_DEPTH_BOUNDS_EXT, 2);
4701 if (n) {
4702 n[1].f = (GLfloat) zmin;
4703 n[2].f = (GLfloat) zmax;
4704 }
4705 if (ctx->ExecuteFlag) {
4706 CALL_DepthBoundsEXT(ctx->Exec, (zmin, zmax));
4707 }
4708 }
4709
4710
4711
4712 #if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
4713
4714 static void GLAPIENTRY
4715 save_ProgramStringARB(GLenum target, GLenum format, GLsizei len,
4716 const GLvoid * string)
4717 {
4718 GET_CURRENT_CONTEXT(ctx);
4719 Node *n;
4720 GLubyte *programCopy;
4721
4722 programCopy = (GLubyte *) _mesa_malloc(len);
4723 if (!programCopy) {
4724 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramStringARB");
4725 return;
4726 }
4727 _mesa_memcpy(programCopy, string, len);
4728
4729 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4730 n = ALLOC_INSTRUCTION(ctx, OPCODE_PROGRAM_STRING_ARB, 4);
4731 if (n) {
4732 n[1].e = target;
4733 n[2].e = format;
4734 n[3].i = len;
4735 n[4].data = programCopy;
4736 }
4737 if (ctx->ExecuteFlag) {
4738 CALL_ProgramStringARB(ctx->Exec, (target, format, len, string));
4739 }
4740 }
4741
4742 #endif /* FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program */
4743
4744
4745 #if FEATURE_ARB_occlusion_query
4746
4747 static void GLAPIENTRY
4748 save_BeginQueryARB(GLenum target, GLuint id)
4749 {
4750 GET_CURRENT_CONTEXT(ctx);
4751 Node *n;
4752 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4753 n = ALLOC_INSTRUCTION(ctx, OPCODE_BEGIN_QUERY_ARB, 2);
4754 if (n) {
4755 n[1].e = target;
4756 n[2].ui = id;
4757 }
4758 if (ctx->ExecuteFlag) {
4759 CALL_BeginQueryARB(ctx->Exec, (target, id));
4760 }
4761 }
4762
4763
4764 static void GLAPIENTRY
4765 save_EndQueryARB(GLenum target)
4766 {
4767 GET_CURRENT_CONTEXT(ctx);
4768 Node *n;
4769 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4770 n = ALLOC_INSTRUCTION(ctx, OPCODE_END_QUERY_ARB, 1);
4771 if (n) {
4772 n[1].e = target;
4773 }
4774 if (ctx->ExecuteFlag) {
4775 CALL_EndQueryARB(ctx->Exec, (target));
4776 }
4777 }
4778
4779 #endif /* FEATURE_ARB_occlusion_query */
4780
4781
4782 static void GLAPIENTRY
4783 save_DrawBuffersARB(GLsizei count, const GLenum * buffers)
4784 {
4785 GET_CURRENT_CONTEXT(ctx);
4786 Node *n;
4787 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4788 n = ALLOC_INSTRUCTION(ctx, OPCODE_DRAW_BUFFERS_ARB, 1 + MAX_DRAW_BUFFERS);
4789 if (n) {
4790 GLint i;
4791 n[1].i = count;
4792 if (count > MAX_DRAW_BUFFERS)
4793 count = MAX_DRAW_BUFFERS;
4794 for (i = 0; i < count; i++) {
4795 n[2 + i].e = buffers[i];
4796 }
4797 }
4798 if (ctx->ExecuteFlag) {
4799 CALL_DrawBuffersARB(ctx->Exec, (count, buffers));
4800 }
4801 }
4802
4803 #if FEATURE_ATI_fragment_shader
4804 static void GLAPIENTRY
4805 save_BindFragmentShaderATI(GLuint id)
4806 {
4807 GET_CURRENT_CONTEXT(ctx);
4808 Node *n;
4809
4810 n = ALLOC_INSTRUCTION(ctx, OPCODE_BIND_FRAGMENT_SHADER_ATI, 1);
4811 if (n) {
4812 n[1].ui = id;
4813 }
4814 if (ctx->ExecuteFlag) {
4815 CALL_BindFragmentShaderATI(ctx->Exec, (id));
4816 }
4817 }
4818
4819 static void GLAPIENTRY
4820 save_SetFragmentShaderConstantATI(GLuint dst, const GLfloat *value)
4821 {
4822 GET_CURRENT_CONTEXT(ctx);
4823 Node *n;
4824
4825 n = ALLOC_INSTRUCTION(ctx, OPCODE_SET_FRAGMENT_SHADER_CONSTANTS_ATI, 5);
4826 if (n) {
4827 n[1].ui = dst;
4828 n[2].f = value[0];
4829 n[3].f = value[1];
4830 n[4].f = value[2];
4831 n[5].f = value[3];
4832 }
4833 if (ctx->ExecuteFlag) {
4834 CALL_SetFragmentShaderConstantATI(ctx->Exec, (dst, value));
4835 }
4836 }
4837 #endif
4838
4839 static void
4840 save_Attr1fNV(GLenum attr, GLfloat x)
4841 {
4842 GET_CURRENT_CONTEXT(ctx);
4843 Node *n;
4844 SAVE_FLUSH_VERTICES(ctx);
4845 n = ALLOC_INSTRUCTION(ctx, OPCODE_ATTR_1F_NV, 2);
4846 if (n) {
4847 n[1].e = attr;
4848 n[2].f = x;
4849 }
4850
4851 ASSERT(attr < MAX_VERTEX_PROGRAM_ATTRIBS);
4852 ctx->ListState.ActiveAttribSize[attr] = 1;
4853 ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1);
4854
4855 if (ctx->ExecuteFlag) {
4856 CALL_VertexAttrib1fNV(ctx->Exec, (attr, x));
4857 }
4858 }
4859
4860 static void
4861 save_Attr2fNV(GLenum attr, GLfloat x, GLfloat y)
4862 {
4863 GET_CURRENT_CONTEXT(ctx);
4864 Node *n;
4865 SAVE_FLUSH_VERTICES(ctx);
4866 n = ALLOC_INSTRUCTION(ctx, OPCODE_ATTR_2F_NV, 3);
4867 if (n) {
4868 n[1].e = attr;
4869 n[2].f = x;
4870 n[3].f = y;
4871 }
4872
4873 ASSERT(attr < MAX_VERTEX_PROGRAM_ATTRIBS);
4874 ctx->ListState.ActiveAttribSize[attr] = 2;
4875 ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, 0, 1);
4876
4877 if (ctx->ExecuteFlag) {
4878 CALL_VertexAttrib2fNV(ctx->Exec, (attr, x, y));
4879 }
4880 }
4881
4882 static void
4883 save_Attr3fNV(GLenum attr, GLfloat x, GLfloat y, GLfloat z)
4884 {
4885 GET_CURRENT_CONTEXT(ctx);
4886 Node *n;
4887 SAVE_FLUSH_VERTICES(ctx);
4888 n = ALLOC_INSTRUCTION(ctx, OPCODE_ATTR_3F_NV, 4);
4889 if (n) {
4890 n[1].e = attr;
4891 n[2].f = x;
4892 n[3].f = y;
4893 n[4].f = z;
4894 }
4895
4896 ASSERT(attr < MAX_VERTEX_PROGRAM_ATTRIBS);
4897 ctx->ListState.ActiveAttribSize[attr] = 3;
4898 ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, 1);
4899
4900 if (ctx->ExecuteFlag) {
4901 CALL_VertexAttrib3fNV(ctx->Exec, (attr, x, y, z));
4902 }
4903 }
4904
4905 static void
4906 save_Attr4fNV(GLenum attr, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
4907 {
4908 GET_CURRENT_CONTEXT(ctx);
4909 Node *n;
4910 SAVE_FLUSH_VERTICES(ctx);
4911 n = ALLOC_INSTRUCTION(ctx, OPCODE_ATTR_4F_NV, 5);
4912 if (n) {
4913 n[1].e = attr;
4914 n[2].f = x;
4915 n[3].f = y;
4916 n[4].f = z;
4917 n[5].f = w;
4918 }
4919
4920 ASSERT(attr < MAX_VERTEX_PROGRAM_ATTRIBS);
4921 ctx->ListState.ActiveAttribSize[attr] = 4;
4922 ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, w);
4923
4924 if (ctx->ExecuteFlag) {
4925 CALL_VertexAttrib4fNV(ctx->Exec, (attr, x, y, z, w));
4926 }
4927 }
4928
4929
4930 static void
4931 save_Attr1fARB(GLenum attr, GLfloat x)
4932 {
4933 GET_CURRENT_CONTEXT(ctx);
4934 Node *n;
4935 SAVE_FLUSH_VERTICES(ctx);
4936 n = ALLOC_INSTRUCTION(ctx, OPCODE_ATTR_1F_ARB, 2);
4937 if (n) {
4938 n[1].e = attr;
4939 n[2].f = x;
4940 }
4941
4942 ASSERT(attr < MAX_VERTEX_ATTRIBS);
4943 ctx->ListState.ActiveAttribSize[attr] = 1;
4944 ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1);
4945
4946 if (ctx->ExecuteFlag) {
4947 CALL_VertexAttrib1fARB(ctx->Exec, (attr, x));
4948 }
4949 }
4950
4951 static void
4952 save_Attr2fARB(GLenum attr, GLfloat x, GLfloat y)
4953 {
4954 GET_CURRENT_CONTEXT(ctx);
4955 Node *n;
4956 SAVE_FLUSH_VERTICES(ctx);
4957 n = ALLOC_INSTRUCTION(ctx, OPCODE_ATTR_2F_ARB, 3);
4958 if (n) {
4959 n[1].e = attr;
4960 n[2].f = x;
4961 n[3].f = y;
4962 }
4963
4964 ASSERT(attr < MAX_VERTEX_ATTRIBS);
4965 ctx->ListState.ActiveAttribSize[attr] = 2;
4966 ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, 0, 1);
4967
4968 if (ctx->ExecuteFlag) {
4969 CALL_VertexAttrib2fARB(ctx->Exec, (attr, x, y));
4970 }
4971 }
4972
4973 static void
4974 save_Attr3fARB(GLenum attr, GLfloat x, GLfloat y, GLfloat z)
4975 {
4976 GET_CURRENT_CONTEXT(ctx);
4977 Node *n;
4978 SAVE_FLUSH_VERTICES(ctx);
4979 n = ALLOC_INSTRUCTION(ctx, OPCODE_ATTR_3F_ARB, 4);
4980 if (n) {
4981 n[1].e = attr;
4982 n[2].f = x;
4983 n[3].f = y;
4984 n[4].f = z;
4985 }
4986
4987 ASSERT(attr < MAX_VERTEX_ATTRIBS);
4988 ctx->ListState.ActiveAttribSize[attr] = 3;
4989 ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, 1);
4990
4991 if (ctx->ExecuteFlag) {
4992 CALL_VertexAttrib3fARB(ctx->Exec, (attr, x, y, z));
4993 }
4994 }
4995
4996 static void
4997 save_Attr4fARB(GLenum attr, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
4998 {
4999 GET_CURRENT_CONTEXT(ctx);
5000 Node *n;
5001 SAVE_FLUSH_VERTICES(ctx);
5002 n = ALLOC_INSTRUCTION(ctx, OPCODE_ATTR_4F_ARB, 5);
5003 if (n) {
5004 n[1].e = attr;
5005 n[2].f = x;
5006 n[3].f = y;
5007 n[4].f = z;
5008 n[5].f = w;
5009 }
5010
5011 ASSERT(attr < MAX_VERTEX_ATTRIBS);
5012 ctx->ListState.ActiveAttribSize[attr] = 4;
5013 ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, w);
5014
5015 if (ctx->ExecuteFlag) {
5016 CALL_VertexAttrib4fARB(ctx->Exec, (attr, x, y, z, w));
5017 }
5018 }
5019
5020
5021 static void GLAPIENTRY
5022 save_EvalCoord1f(GLfloat x)
5023 {
5024 GET_CURRENT_CONTEXT(ctx);
5025 Node *n;
5026 SAVE_FLUSH_VERTICES(ctx);
5027 n = ALLOC_INSTRUCTION(ctx, OPCODE_EVAL_C1, 1);
5028 if (n) {
5029 n[1].f = x;
5030 }
5031 if (ctx->ExecuteFlag) {
5032 CALL_EvalCoord1f(ctx->Exec, (x));
5033 }
5034 }
5035
5036 static void GLAPIENTRY
5037 save_EvalCoord1fv(const GLfloat * v)
5038 {
5039 save_EvalCoord1f(v[0]);
5040 }
5041
5042 static void GLAPIENTRY
5043 save_EvalCoord2f(GLfloat x, GLfloat y)
5044 {
5045 GET_CURRENT_CONTEXT(ctx);
5046 Node *n;
5047 SAVE_FLUSH_VERTICES(ctx);
5048 n = ALLOC_INSTRUCTION(ctx, OPCODE_EVAL_C2, 2);
5049 if (n) {
5050 n[1].f = x;
5051 n[2].f = y;
5052 }
5053 if (ctx->ExecuteFlag) {
5054 CALL_EvalCoord2f(ctx->Exec, (x, y));
5055 }
5056 }
5057
5058 static void GLAPIENTRY
5059 save_EvalCoord2fv(const GLfloat * v)
5060 {
5061 save_EvalCoord2f(v[0], v[1]);
5062 }
5063
5064
5065 static void GLAPIENTRY
5066 save_EvalPoint1(GLint x)
5067 {
5068 GET_CURRENT_CONTEXT(ctx);
5069 Node *n;
5070 SAVE_FLUSH_VERTICES(ctx);
5071 n = ALLOC_INSTRUCTION(ctx, OPCODE_EVAL_P1, 1);
5072 if (n) {
5073 n[1].i = x;
5074 }
5075 if (ctx->ExecuteFlag) {
5076 CALL_EvalPoint1(ctx->Exec, (x));
5077 }
5078 }
5079
5080 static void GLAPIENTRY
5081 save_EvalPoint2(GLint x, GLint y)
5082 {
5083 GET_CURRENT_CONTEXT(ctx);
5084 Node *n;
5085 SAVE_FLUSH_VERTICES(ctx);
5086 n = ALLOC_INSTRUCTION(ctx, OPCODE_EVAL_P2, 2);
5087 if (n) {
5088 n[1].i = x;
5089 n[2].i = y;
5090 }
5091 if (ctx->ExecuteFlag) {
5092 CALL_EvalPoint2(ctx->Exec, (x, y));
5093 }
5094 }
5095
5096 static void GLAPIENTRY
5097 save_Indexf(GLfloat x)
5098 {
5099 save_Attr1fNV(VERT_ATTRIB_COLOR_INDEX, x);
5100 }
5101
5102 static void GLAPIENTRY
5103 save_Indexfv(const GLfloat * v)
5104 {
5105 save_Attr1fNV(VERT_ATTRIB_COLOR_INDEX, v[0]);
5106 }
5107
5108 static void GLAPIENTRY
5109 save_EdgeFlag(GLboolean x)
5110 {
5111 save_Attr1fNV(VERT_ATTRIB_EDGEFLAG, x ? (GLfloat)1.0 : (GLfloat)0.0);
5112 }
5113
5114 static void GLAPIENTRY
5115 save_Materialfv(GLenum face, GLenum pname, const GLfloat * param)
5116 {
5117 GET_CURRENT_CONTEXT(ctx);
5118 Node *n;
5119 int args, i;
5120
5121 SAVE_FLUSH_VERTICES(ctx);
5122
5123 switch (face) {
5124 case GL_BACK:
5125 case GL_FRONT:
5126 case GL_FRONT_AND_BACK:
5127 break;
5128 default:
5129 _mesa_compile_error(ctx, GL_INVALID_ENUM, "material(face)");
5130 return;
5131 }
5132
5133 switch (pname) {
5134 case GL_EMISSION:
5135 case GL_AMBIENT:
5136 case GL_DIFFUSE:
5137 case GL_SPECULAR:
5138 case GL_AMBIENT_AND_DIFFUSE:
5139 args = 4;
5140 break;
5141 case GL_SHININESS:
5142 args = 1;
5143 break;
5144 case GL_COLOR_INDEXES:
5145 args = 3;
5146 break;
5147 default:
5148 _mesa_compile_error(ctx, GL_INVALID_ENUM, "material(pname)");
5149 return;
5150 }
5151
5152 n = ALLOC_INSTRUCTION(ctx, OPCODE_MATERIAL, 6);
5153 if (n) {
5154 n[1].e = face;
5155 n[2].e = pname;
5156 for (i = 0; i < args; i++)
5157 n[3 + i].f = param[i];
5158 }
5159
5160 {
5161 GLuint bitmask = _mesa_material_bitmask(ctx, face, pname, ~0, NULL);
5162 for (i = 0; i < MAT_ATTRIB_MAX; i++)
5163 if (bitmask & (1 << i)) {
5164 ctx->ListState.ActiveMaterialSize[i] = args;
5165 COPY_SZ_4V(ctx->ListState.CurrentMaterial[i], args, param);
5166 }
5167 }
5168
5169 if (ctx->ExecuteFlag) {
5170 CALL_Materialfv(ctx->Exec, (face, pname, param));
5171 }
5172 }
5173
5174 static void GLAPIENTRY
5175 save_Begin(GLenum mode)
5176 {
5177 GET_CURRENT_CONTEXT(ctx);
5178 Node *n;
5179 GLboolean error = GL_FALSE;
5180
5181 if ( /*mode < GL_POINTS || */ mode > GL_POLYGON) {
5182 _mesa_compile_error(ctx, GL_INVALID_ENUM, "Begin (mode)");
5183 error = GL_TRUE;
5184 }
5185 else if (ctx->Driver.CurrentSavePrimitive == PRIM_UNKNOWN) {
5186 /* Typically the first begin. This may raise an error on
5187 * playback, depending on whether CallList is issued from inside
5188 * a begin/end or not.
5189 */
5190 ctx->Driver.CurrentSavePrimitive = PRIM_INSIDE_UNKNOWN_PRIM;
5191 }
5192 else if (ctx->Driver.CurrentSavePrimitive == PRIM_OUTSIDE_BEGIN_END) {
5193 ctx->Driver.CurrentSavePrimitive = mode;
5194 }
5195 else {
5196 _mesa_compile_error(ctx, GL_INVALID_OPERATION, "recursive begin");
5197 error = GL_TRUE;
5198 }
5199
5200 if (!error) {
5201 /* Give the driver an opportunity to hook in an optimized
5202 * display list compiler.
5203 */
5204 if (ctx->Driver.NotifySaveBegin(ctx, mode))
5205 return;
5206
5207 SAVE_FLUSH_VERTICES(ctx);
5208 n = ALLOC_INSTRUCTION(ctx, OPCODE_BEGIN, 1);
5209 if (n) {
5210 n[1].e = mode;
5211 }
5212 }
5213
5214 if (ctx->ExecuteFlag) {
5215 CALL_Begin(ctx->Exec, (mode));
5216 }
5217 }
5218
5219 static void GLAPIENTRY
5220 save_End(void)
5221 {
5222 GET_CURRENT_CONTEXT(ctx);
5223 SAVE_FLUSH_VERTICES(ctx);
5224 (void) ALLOC_INSTRUCTION(ctx, OPCODE_END, 0);
5225 ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;
5226 if (ctx->ExecuteFlag) {
5227 CALL_End(ctx->Exec, ());
5228 }
5229 }
5230
5231 static void GLAPIENTRY
5232 save_Rectf(GLfloat a, GLfloat b, GLfloat c, GLfloat d)
5233 {
5234 GET_CURRENT_CONTEXT(ctx);
5235 Node *n;
5236 SAVE_FLUSH_VERTICES(ctx);
5237 n = ALLOC_INSTRUCTION(ctx, OPCODE_RECTF, 4);
5238 if (n) {
5239 n[1].f = a;
5240 n[2].f = b;
5241 n[3].f = c;
5242 n[4].f = d;
5243 }
5244 if (ctx->ExecuteFlag) {
5245 CALL_Rectf(ctx->Exec, (a, b, c, d));
5246 }
5247 }
5248
5249
5250 static void GLAPIENTRY
5251 save_Vertex2f(GLfloat x, GLfloat y)
5252 {
5253 save_Attr2fNV(VERT_ATTRIB_POS, x, y);
5254 }
5255
5256 static void GLAPIENTRY
5257 save_Vertex2fv(const GLfloat * v)
5258 {
5259 save_Attr2fNV(VERT_ATTRIB_POS, v[0], v[1]);
5260 }
5261
5262 static void GLAPIENTRY
5263 save_Vertex3f(GLfloat x, GLfloat y, GLfloat z)
5264 {
5265 save_Attr3fNV(VERT_ATTRIB_POS, x, y, z);
5266 }
5267
5268 static void GLAPIENTRY
5269 save_Vertex3fv(const GLfloat * v)
5270 {
5271 save_Attr3fNV(VERT_ATTRIB_POS, v[0], v[1], v[2]);
5272 }
5273
5274 static void GLAPIENTRY
5275 save_Vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
5276 {
5277 save_Attr4fNV(VERT_ATTRIB_POS, x, y, z, w);
5278 }
5279
5280 static void GLAPIENTRY
5281 save_Vertex4fv(const GLfloat * v)
5282 {
5283 save_Attr4fNV(VERT_ATTRIB_POS, v[0], v[1], v[2], v[3]);
5284 }
5285
5286 static void GLAPIENTRY
5287 save_TexCoord1f(GLfloat x)
5288 {
5289 save_Attr1fNV(VERT_ATTRIB_TEX0, x);
5290 }
5291
5292 static void GLAPIENTRY
5293 save_TexCoord1fv(const GLfloat * v)
5294 {
5295 save_Attr1fNV(VERT_ATTRIB_TEX0, v[0]);
5296 }
5297
5298 static void GLAPIENTRY
5299 save_TexCoord2f(GLfloat x, GLfloat y)
5300 {
5301 save_Attr2fNV(VERT_ATTRIB_TEX0, x, y);
5302 }
5303
5304 static void GLAPIENTRY
5305 save_TexCoord2fv(const GLfloat * v)
5306 {
5307 save_Attr2fNV(VERT_ATTRIB_TEX0, v[0], v[1]);
5308 }
5309
5310 static void GLAPIENTRY
5311 save_TexCoord3f(GLfloat x, GLfloat y, GLfloat z)
5312 {
5313 save_Attr3fNV(VERT_ATTRIB_TEX0, x, y, z);
5314 }
5315
5316 static void GLAPIENTRY
5317 save_TexCoord3fv(const GLfloat * v)
5318 {
5319 save_Attr3fNV(VERT_ATTRIB_TEX0, v[0], v[1], v[2]);
5320 }
5321
5322 static void GLAPIENTRY
5323 save_TexCoord4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
5324 {
5325 save_Attr4fNV(VERT_ATTRIB_TEX0, x, y, z, w);
5326 }
5327
5328 static void GLAPIENTRY
5329 save_TexCoord4fv(const GLfloat * v)
5330 {
5331 save_Attr4fNV(VERT_ATTRIB_TEX0, v[0], v[1], v[2], v[3]);
5332 }
5333
5334 static void GLAPIENTRY
5335 save_Normal3f(GLfloat x, GLfloat y, GLfloat z)
5336 {
5337 save_Attr3fNV(VERT_ATTRIB_NORMAL, x, y, z);
5338 }
5339
5340 static void GLAPIENTRY
5341 save_Normal3fv(const GLfloat * v)
5342 {
5343 save_Attr3fNV(VERT_ATTRIB_NORMAL, v[0], v[1], v[2]);
5344 }
5345
5346 static void GLAPIENTRY
5347 save_FogCoordfEXT(GLfloat x)
5348 {
5349 save_Attr1fNV(VERT_ATTRIB_FOG, x);
5350 }
5351
5352 static void GLAPIENTRY
5353 save_FogCoordfvEXT(const GLfloat * v)
5354 {
5355 save_Attr1fNV(VERT_ATTRIB_FOG, v[0]);
5356 }
5357
5358 static void GLAPIENTRY
5359 save_Color3f(GLfloat x, GLfloat y, GLfloat z)
5360 {
5361 save_Attr3fNV(VERT_ATTRIB_COLOR0, x, y, z);
5362 }
5363
5364 static void GLAPIENTRY
5365 save_Color3fv(const GLfloat * v)
5366 {
5367 save_Attr3fNV(VERT_ATTRIB_COLOR0, v[0], v[1], v[2]);
5368 }
5369
5370 static void GLAPIENTRY
5371 save_Color4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
5372 {
5373 save_Attr4fNV(VERT_ATTRIB_COLOR0, x, y, z, w);
5374 }
5375
5376 static void GLAPIENTRY
5377 save_Color4fv(const GLfloat * v)
5378 {
5379 save_Attr4fNV(VERT_ATTRIB_COLOR0, v[0], v[1], v[2], v[3]);
5380 }
5381
5382 static void GLAPIENTRY
5383 save_SecondaryColor3fEXT(GLfloat x, GLfloat y, GLfloat z)
5384 {
5385 save_Attr3fNV(VERT_ATTRIB_COLOR1, x, y, z);
5386 }
5387
5388 static void GLAPIENTRY
5389 save_SecondaryColor3fvEXT(const GLfloat * v)
5390 {
5391 save_Attr3fNV(VERT_ATTRIB_COLOR1, v[0], v[1], v[2]);
5392 }
5393
5394
5395 /* Just call the respective ATTR for texcoord
5396 */
5397 static void GLAPIENTRY
5398 save_MultiTexCoord1f(GLenum target, GLfloat x)
5399 {
5400 GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
5401 save_Attr1fNV(attr, x);
5402 }
5403
5404 static void GLAPIENTRY
5405 save_MultiTexCoord1fv(GLenum target, const GLfloat * v)
5406 {
5407 GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
5408 save_Attr1fNV(attr, v[0]);
5409 }
5410
5411 static void GLAPIENTRY
5412 save_MultiTexCoord2f(GLenum target, GLfloat x, GLfloat y)
5413 {
5414 GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
5415 save_Attr2fNV(attr, x, y);
5416 }
5417
5418 static void GLAPIENTRY
5419 save_MultiTexCoord2fv(GLenum target, const GLfloat * v)
5420 {
5421 GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
5422 save_Attr2fNV(attr, v[0], v[1]);
5423 }
5424
5425 static void GLAPIENTRY
5426 save_MultiTexCoord3f(GLenum target, GLfloat x, GLfloat y, GLfloat z)
5427 {
5428 GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
5429 save_Attr3fNV(attr, x, y, z);
5430 }
5431
5432 static void GLAPIENTRY
5433 save_MultiTexCoord3fv(GLenum target, const GLfloat * v)
5434 {
5435 GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
5436 save_Attr3fNV(attr, v[0], v[1], v[2]);
5437 }
5438
5439 static void GLAPIENTRY
5440 save_MultiTexCoord4f(GLenum target, GLfloat x, GLfloat y,
5441 GLfloat z, GLfloat w)
5442 {
5443 GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
5444 save_Attr4fNV(attr, x, y, z, w);
5445 }
5446
5447 static void GLAPIENTRY
5448 save_MultiTexCoord4fv(GLenum target, const GLfloat * v)
5449 {
5450 GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
5451 save_Attr4fNV(attr, v[0], v[1], v[2], v[3]);
5452 }
5453
5454
5455 /**
5456 * Record a GL_INVALID_VALUE error when a invalid vertex attribute
5457 * index is found.
5458 */
5459 static void
5460 index_error(void)
5461 {
5462 GET_CURRENT_CONTEXT(ctx);
5463 _mesa_error(ctx, GL_INVALID_VALUE, "VertexAttribf(index)");
5464 }
5465
5466
5467 /* First level for NV_vertex_program:
5468 *
5469 * Check for errors at compile time?.
5470 */
5471 static void GLAPIENTRY
5472 save_VertexAttrib1fNV(GLuint index, GLfloat x)
5473 {
5474 if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
5475 save_Attr1fNV(index, x);
5476 else
5477 index_error();
5478 }
5479
5480 static void GLAPIENTRY
5481 save_VertexAttrib1fvNV(GLuint index, const GLfloat * v)
5482 {
5483 if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
5484 save_Attr1fNV(index, v[0]);
5485 else
5486 index_error();
5487 }
5488
5489 static void GLAPIENTRY
5490 save_VertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
5491 {
5492 if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
5493 save_Attr2fNV(index, x, y);
5494 else
5495 index_error();
5496 }
5497
5498 static void GLAPIENTRY
5499 save_VertexAttrib2fvNV(GLuint index, const GLfloat * v)
5500 {
5501 if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
5502 save_Attr2fNV(index, v[0], v[1]);
5503 else
5504 index_error();
5505 }
5506
5507 static void GLAPIENTRY
5508 save_VertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
5509 {
5510 if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
5511 save_Attr3fNV(index, x, y, z);
5512 else
5513 index_error();
5514 }
5515
5516 static void GLAPIENTRY
5517 save_VertexAttrib3fvNV(GLuint index, const GLfloat * v)
5518 {
5519 if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
5520 save_Attr3fNV(index, v[0], v[1], v[2]);
5521 else
5522 index_error();
5523 }
5524
5525 static void GLAPIENTRY
5526 save_VertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y,
5527 GLfloat z, GLfloat w)
5528 {
5529 if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
5530 save_Attr4fNV(index, x, y, z, w);
5531 else
5532 index_error();
5533 }
5534
5535 static void GLAPIENTRY
5536 save_VertexAttrib4fvNV(GLuint index, const GLfloat * v)
5537 {
5538 if (index < MAX_VERTEX_PROGRAM_ATTRIBS)
5539 save_Attr4fNV(index, v[0], v[1], v[2], v[3]);
5540 else
5541 index_error();
5542 }
5543
5544
5545
5546
5547 static void GLAPIENTRY
5548 save_VertexAttrib1fARB(GLuint index, GLfloat x)
5549 {
5550 if (index < MAX_VERTEX_ATTRIBS)
5551 save_Attr1fARB(index, x);
5552 else
5553 index_error();
5554 }
5555
5556 static void GLAPIENTRY
5557 save_VertexAttrib1fvARB(GLuint index, const GLfloat * v)
5558 {
5559 if (index < MAX_VERTEX_ATTRIBS)
5560 save_Attr1fARB(index, v[0]);
5561 else
5562 index_error();
5563 }
5564
5565 static void GLAPIENTRY
5566 save_VertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
5567 {
5568 if (index < MAX_VERTEX_ATTRIBS)
5569 save_Attr2fARB(index, x, y);
5570 else
5571 index_error();
5572 }
5573
5574 static void GLAPIENTRY
5575 save_VertexAttrib2fvARB(GLuint index, const GLfloat * v)
5576 {
5577 if (index < MAX_VERTEX_ATTRIBS)
5578 save_Attr2fARB(index, v[0], v[1]);
5579 else
5580 index_error();
5581 }
5582
5583 static void GLAPIENTRY
5584 save_VertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
5585 {
5586 if (index < MAX_VERTEX_ATTRIBS)
5587 save_Attr3fARB(index, x, y, z);
5588 else
5589 index_error();
5590 }
5591
5592 static void GLAPIENTRY
5593 save_VertexAttrib3fvARB(GLuint index, const GLfloat * v)
5594 {
5595 if (index < MAX_VERTEX_ATTRIBS)
5596 save_Attr3fARB(index, v[0], v[1], v[2]);
5597 else
5598 index_error();
5599 }
5600
5601 static void GLAPIENTRY
5602 save_VertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z,
5603 GLfloat w)
5604 {
5605 if (index < MAX_VERTEX_ATTRIBS)
5606 save_Attr4fARB(index, x, y, z, w);
5607 else
5608 index_error();
5609 }
5610
5611 static void GLAPIENTRY
5612 save_VertexAttrib4fvARB(GLuint index, const GLfloat * v)
5613 {
5614 if (index < MAX_VERTEX_ATTRIBS)
5615 save_Attr4fARB(index, v[0], v[1], v[2], v[3]);
5616 else
5617 index_error();
5618 }
5619
5620
5621 /* GL_ARB_shader_objects, GL_ARB_vertex/fragment_shader */
5622
5623 static void GLAPIENTRY
5624 exec_BindAttribLocationARB(GLuint program, GLuint index, const GLchar *name)
5625 {
5626 GET_CURRENT_CONTEXT(ctx);
5627 FLUSH_VERTICES(ctx, 0);
5628 CALL_BindAttribLocationARB(ctx->Exec, (program, index, name));
5629 }
5630
5631 static GLint GLAPIENTRY
5632 exec_GetAttribLocationARB(GLuint program, const GLchar *name)
5633 {
5634 GET_CURRENT_CONTEXT(ctx);
5635 FLUSH_VERTICES(ctx, 0);
5636 return CALL_GetAttribLocationARB(ctx->Exec, (program, name));
5637 }
5638 /* XXX more shader functions needed here */
5639
5640
5641
5642 #if FEATURE_EXT_framebuffer_blit
5643 static void GLAPIENTRY
5644 save_BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
5645 GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
5646 GLbitfield mask, GLenum filter)
5647 {
5648 GET_CURRENT_CONTEXT(ctx);
5649 Node *n;
5650 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5651 n = ALLOC_INSTRUCTION(ctx, OPCODE_BLIT_FRAMEBUFFER, 10);
5652 if (n) {
5653 n[1].i = srcX0;
5654 n[2].i = srcY0;
5655 n[3].i = srcX1;
5656 n[4].i = srcY1;
5657 n[5].i = dstX0;
5658 n[6].i = dstY0;
5659 n[7].i = dstX1;
5660 n[8].i = dstY1;
5661 n[9].i = mask;
5662 n[10].e = filter;
5663 }
5664 if (ctx->ExecuteFlag) {
5665 CALL_BlitFramebufferEXT(ctx->Exec, (srcX0, srcY0, srcX1, srcY1,
5666 dstX0, dstY0, dstX1, dstY1,
5667 mask, filter));
5668 }
5669 }
5670 #endif
5671
5672
5673 /**
5674 * Save an error-generating command into display list.
5675 *
5676 * KW: Will appear in the list before the vertex buffer containing the
5677 * command that provoked the error. I don't see this as a problem.
5678 */
5679 static void
5680 save_error(GLcontext *ctx, GLenum error, const char *s)
5681 {
5682 Node *n;
5683 n = ALLOC_INSTRUCTION(ctx, OPCODE_ERROR, 2);
5684 if (n) {
5685 n[1].e = error;
5686 n[2].data = (void *) s;
5687 }
5688 }
5689
5690
5691 /**
5692 * Compile an error into current display list.
5693 */
5694 void
5695 _mesa_compile_error(GLcontext *ctx, GLenum error, const char *s)
5696 {
5697 if (ctx->CompileFlag)
5698 save_error(ctx, error, s);
5699 if (ctx->ExecuteFlag)
5700 _mesa_error(ctx, error, s);
5701 }
5702
5703
5704 /**
5705 * Test if ID names a display list.
5706 */
5707 static GLboolean
5708 islist(GLcontext *ctx, GLuint list)
5709 {
5710 if (list > 0 && lookup_list(ctx, list)) {
5711 return GL_TRUE;
5712 }
5713 else {
5714 return GL_FALSE;
5715 }
5716 }
5717
5718
5719
5720 /**********************************************************************/
5721 /* Display list execution */
5722 /**********************************************************************/
5723
5724
5725 /*
5726 * Execute a display list. Note that the ListBase offset must have already
5727 * been added before calling this function. I.e. the list argument is
5728 * the absolute list number, not relative to ListBase.
5729 * \param list - display list number
5730 */
5731 static void
5732 execute_list(GLcontext *ctx, GLuint list)
5733 {
5734 struct mesa_display_list *dlist;
5735 Node *n;
5736 GLboolean done;
5737
5738 if (list == 0 || !islist(ctx, list))
5739 return;
5740
5741 if (ctx->ListState.CallDepth == MAX_LIST_NESTING) {
5742 /* raise an error? */
5743 return;
5744 }
5745
5746 dlist = lookup_list(ctx, list);
5747 if (!dlist)
5748 return;
5749
5750 ctx->ListState.CallDepth++;
5751
5752 if (ctx->Driver.BeginCallList)
5753 ctx->Driver.BeginCallList(ctx, dlist);
5754
5755 n = dlist->node;
5756
5757 done = GL_FALSE;
5758 while (!done) {
5759 OpCode opcode = n[0].opcode;
5760 int i = (int) n[0].opcode - (int) OPCODE_EXT_0;
5761
5762 if (i >= 0 && i < (GLint) ctx->ListExt.NumOpcodes) {
5763 /* this is a driver-extended opcode */
5764 ctx->ListExt.Opcode[i].Execute(ctx, &n[1]);
5765 n += ctx->ListExt.Opcode[i].Size;
5766 }
5767 else {
5768 switch (opcode) {
5769 case OPCODE_ERROR:
5770 _mesa_error(ctx, n[1].e, (const char *) n[2].data);
5771 break;
5772 case OPCODE_ACCUM:
5773 CALL_Accum(ctx->Exec, (n[1].e, n[2].f));
5774 break;
5775 case OPCODE_ALPHA_FUNC:
5776 CALL_AlphaFunc(ctx->Exec, (n[1].e, n[2].f));
5777 break;
5778 case OPCODE_BIND_TEXTURE:
5779 CALL_BindTexture(ctx->Exec, (n[1].e, n[2].ui));
5780 break;
5781 case OPCODE_BITMAP:
5782 {
5783 const struct gl_pixelstore_attrib save = ctx->Unpack;
5784 ctx->Unpack = ctx->DefaultPacking;
5785 CALL_Bitmap(ctx->Exec, ((GLsizei) n[1].i, (GLsizei) n[2].i,
5786 n[3].f, n[4].f, n[5].f, n[6].f,
5787 (const GLubyte *) n[7].data));
5788 ctx->Unpack = save; /* restore */
5789 }
5790 break;
5791 case OPCODE_BLEND_COLOR:
5792 CALL_BlendColor(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
5793 break;
5794 case OPCODE_BLEND_EQUATION:
5795 CALL_BlendEquation(ctx->Exec, (n[1].e));
5796 break;
5797 case OPCODE_BLEND_EQUATION_SEPARATE:
5798 CALL_BlendEquationSeparateEXT(ctx->Exec, (n[1].e, n[2].e));
5799 break;
5800 case OPCODE_BLEND_FUNC_SEPARATE:
5801 CALL_BlendFuncSeparateEXT(ctx->Exec,
5802 (n[1].e, n[2].e, n[3].e, n[4].e));
5803 break;
5804 case OPCODE_CALL_LIST:
5805 /* Generated by glCallList(), don't add ListBase */
5806 if (ctx->ListState.CallDepth < MAX_LIST_NESTING) {
5807 execute_list(ctx, n[1].ui);
5808 }
5809 break;
5810 case OPCODE_CALL_LIST_OFFSET:
5811 /* Generated by glCallLists() so we must add ListBase */
5812 if (n[2].b) {
5813 /* user specified a bad data type at compile time */
5814 _mesa_error(ctx, GL_INVALID_ENUM, "glCallLists(type)");
5815 }
5816 else if (ctx->ListState.CallDepth < MAX_LIST_NESTING) {
5817 GLuint list = (GLuint) (ctx->List.ListBase + n[1].i);
5818 execute_list(ctx, list);
5819 }
5820 break;
5821 case OPCODE_CLEAR:
5822 CALL_Clear(ctx->Exec, (n[1].bf));
5823 break;
5824 case OPCODE_CLEAR_COLOR:
5825 CALL_ClearColor(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
5826 break;
5827 case OPCODE_CLEAR_ACCUM:
5828 CALL_ClearAccum(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
5829 break;
5830 case OPCODE_CLEAR_DEPTH:
5831 CALL_ClearDepth(ctx->Exec, ((GLclampd) n[1].f));
5832 break;
5833 case OPCODE_CLEAR_INDEX:
5834 CALL_ClearIndex(ctx->Exec, ((GLfloat) n[1].ui));
5835 break;
5836 case OPCODE_CLEAR_STENCIL:
5837 CALL_ClearStencil(ctx->Exec, (n[1].i));
5838 break;
5839 case OPCODE_CLIP_PLANE:
5840 {
5841 GLdouble eq[4];
5842 eq[0] = n[2].f;
5843 eq[1] = n[3].f;
5844 eq[2] = n[4].f;
5845 eq[3] = n[5].f;
5846 CALL_ClipPlane(ctx->Exec, (n[1].e, eq));
5847 }
5848 break;
5849 case OPCODE_COLOR_MASK:
5850 CALL_ColorMask(ctx->Exec, (n[1].b, n[2].b, n[3].b, n[4].b));
5851 break;
5852 case OPCODE_COLOR_MATERIAL:
5853 CALL_ColorMaterial(ctx->Exec, (n[1].e, n[2].e));
5854 break;
5855 case OPCODE_COLOR_TABLE:
5856 {
5857 const struct gl_pixelstore_attrib save = ctx->Unpack;
5858 ctx->Unpack = ctx->DefaultPacking;
5859 CALL_ColorTable(ctx->Exec, (n[1].e, n[2].e, n[3].i, n[4].e,
5860 n[5].e, n[6].data));
5861 ctx->Unpack = save; /* restore */
5862 }
5863 break;
5864 case OPCODE_COLOR_TABLE_PARAMETER_FV:
5865 {
5866 GLfloat params[4];
5867 params[0] = n[3].f;
5868 params[1] = n[4].f;
5869 params[2] = n[5].f;
5870 params[3] = n[6].f;
5871 CALL_ColorTableParameterfv(ctx->Exec,
5872 (n[1].e, n[2].e, params));
5873 }
5874 break;
5875 case OPCODE_COLOR_TABLE_PARAMETER_IV:
5876 {
5877 GLint params[4];
5878 params[0] = n[3].i;
5879 params[1] = n[4].i;
5880 params[2] = n[5].i;
5881 params[3] = n[6].i;
5882 CALL_ColorTableParameteriv(ctx->Exec,
5883 (n[1].e, n[2].e, params));
5884 }
5885 break;
5886 case OPCODE_COLOR_SUB_TABLE:
5887 {
5888 const struct gl_pixelstore_attrib save = ctx->Unpack;
5889 ctx->Unpack = ctx->DefaultPacking;
5890 CALL_ColorSubTable(ctx->Exec, (n[1].e, n[2].i, n[3].i,
5891 n[4].e, n[5].e, n[6].data));
5892 ctx->Unpack = save; /* restore */
5893 }
5894 break;
5895 case OPCODE_CONVOLUTION_FILTER_1D:
5896 {
5897 const struct gl_pixelstore_attrib save = ctx->Unpack;
5898 ctx->Unpack = ctx->DefaultPacking;
5899 CALL_ConvolutionFilter1D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
5900 n[4].e, n[5].e,
5901 n[6].data));
5902 ctx->Unpack = save; /* restore */
5903 }
5904 break;
5905 case OPCODE_CONVOLUTION_FILTER_2D:
5906 {
5907 const struct gl_pixelstore_attrib save = ctx->Unpack;
5908 ctx->Unpack = ctx->DefaultPacking;
5909 CALL_ConvolutionFilter2D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
5910 n[4].i, n[5].e, n[6].e,
5911 n[7].data));
5912 ctx->Unpack = save; /* restore */
5913 }
5914 break;
5915 case OPCODE_CONVOLUTION_PARAMETER_I:
5916 CALL_ConvolutionParameteri(ctx->Exec, (n[1].e, n[2].e, n[3].i));
5917 break;
5918 case OPCODE_CONVOLUTION_PARAMETER_IV:
5919 {
5920 GLint params[4];
5921 params[0] = n[3].i;
5922 params[1] = n[4].i;
5923 params[2] = n[5].i;
5924 params[3] = n[6].i;
5925 CALL_ConvolutionParameteriv(ctx->Exec,
5926 (n[1].e, n[2].e, params));
5927 }
5928 break;
5929 case OPCODE_CONVOLUTION_PARAMETER_F:
5930 CALL_ConvolutionParameterf(ctx->Exec, (n[1].e, n[2].e, n[3].f));
5931 break;
5932 case OPCODE_CONVOLUTION_PARAMETER_FV:
5933 {
5934 GLfloat params[4];
5935 params[0] = n[3].f;
5936 params[1] = n[4].f;
5937 params[2] = n[5].f;
5938 params[3] = n[6].f;
5939 CALL_ConvolutionParameterfv(ctx->Exec,
5940 (n[1].e, n[2].e, params));
5941 }
5942 break;
5943 case OPCODE_COPY_COLOR_SUB_TABLE:
5944 CALL_CopyColorSubTable(ctx->Exec, (n[1].e, n[2].i,
5945 n[3].i, n[4].i, n[5].i));
5946 break;
5947 case OPCODE_COPY_COLOR_TABLE:
5948 CALL_CopyColorSubTable(ctx->Exec, (n[1].e, n[2].i,
5949 n[3].i, n[4].i, n[5].i));
5950 break;
5951 case OPCODE_COPY_PIXELS:
5952 CALL_CopyPixels(ctx->Exec, (n[1].i, n[2].i,
5953 (GLsizei) n[3].i, (GLsizei) n[4].i,
5954 n[5].e));
5955 break;
5956 case OPCODE_COPY_TEX_IMAGE1D:
5957 CALL_CopyTexImage1D(ctx->Exec, (n[1].e, n[2].i, n[3].e, n[4].i,
5958 n[5].i, n[6].i, n[7].i));
5959 break;
5960 case OPCODE_COPY_TEX_IMAGE2D:
5961 CALL_CopyTexImage2D(ctx->Exec, (n[1].e, n[2].i, n[3].e, n[4].i,
5962 n[5].i, n[6].i, n[7].i, n[8].i));
5963 break;
5964 case OPCODE_COPY_TEX_SUB_IMAGE1D:
5965 CALL_CopyTexSubImage1D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
5966 n[4].i, n[5].i, n[6].i));
5967 break;
5968 case OPCODE_COPY_TEX_SUB_IMAGE2D:
5969 CALL_CopyTexSubImage2D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
5970 n[4].i, n[5].i, n[6].i, n[7].i,
5971 n[8].i));
5972 break;
5973 case OPCODE_COPY_TEX_SUB_IMAGE3D:
5974 CALL_CopyTexSubImage3D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
5975 n[4].i, n[5].i, n[6].i, n[7].i,
5976 n[8].i, n[9].i));
5977 break;
5978 case OPCODE_CULL_FACE:
5979 CALL_CullFace(ctx->Exec, (n[1].e));
5980 break;
5981 case OPCODE_DEPTH_FUNC:
5982 CALL_DepthFunc(ctx->Exec, (n[1].e));
5983 break;
5984 case OPCODE_DEPTH_MASK:
5985 CALL_DepthMask(ctx->Exec, (n[1].b));
5986 break;
5987 case OPCODE_DEPTH_RANGE:
5988 CALL_DepthRange(ctx->Exec,
5989 ((GLclampd) n[1].f, (GLclampd) n[2].f));
5990 break;
5991 case OPCODE_DISABLE:
5992 CALL_Disable(ctx->Exec, (n[1].e));
5993 break;
5994 case OPCODE_DRAW_BUFFER:
5995 CALL_DrawBuffer(ctx->Exec, (n[1].e));
5996 break;
5997 case OPCODE_DRAW_PIXELS:
5998 {
5999 const struct gl_pixelstore_attrib save = ctx->Unpack;
6000 ctx->Unpack = ctx->DefaultPacking;
6001 CALL_DrawPixels(ctx->Exec, (n[1].i, n[2].i, n[3].e, n[4].e,
6002 n[5].data));
6003 ctx->Unpack = save; /* restore */
6004 }
6005 break;
6006 case OPCODE_ENABLE:
6007 CALL_Enable(ctx->Exec, (n[1].e));
6008 break;
6009 case OPCODE_EVALMESH1:
6010 CALL_EvalMesh1(ctx->Exec, (n[1].e, n[2].i, n[3].i));
6011 break;
6012 case OPCODE_EVALMESH2:
6013 CALL_EvalMesh2(ctx->Exec,
6014 (n[1].e, n[2].i, n[3].i, n[4].i, n[5].i));
6015 break;
6016 case OPCODE_FOG:
6017 {
6018 GLfloat p[4];
6019 p[0] = n[2].f;
6020 p[1] = n[3].f;
6021 p[2] = n[4].f;
6022 p[3] = n[5].f;
6023 CALL_Fogfv(ctx->Exec, (n[1].e, p));
6024 }
6025 break;
6026 case OPCODE_FRONT_FACE:
6027 CALL_FrontFace(ctx->Exec, (n[1].e));
6028 break;
6029 case OPCODE_FRUSTUM:
6030 CALL_Frustum(ctx->Exec,
6031 (n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f));
6032 break;
6033 case OPCODE_HINT:
6034 CALL_Hint(ctx->Exec, (n[1].e, n[2].e));
6035 break;
6036 case OPCODE_HISTOGRAM:
6037 CALL_Histogram(ctx->Exec, (n[1].e, n[2].i, n[3].e, n[4].b));
6038 break;
6039 case OPCODE_INDEX_MASK:
6040 CALL_IndexMask(ctx->Exec, (n[1].ui));
6041 break;
6042 case OPCODE_INIT_NAMES:
6043 CALL_InitNames(ctx->Exec, ());
6044 break;
6045 case OPCODE_LIGHT:
6046 {
6047 GLfloat p[4];
6048 p[0] = n[3].f;
6049 p[1] = n[4].f;
6050 p[2] = n[5].f;
6051 p[3] = n[6].f;
6052 CALL_Lightfv(ctx->Exec, (n[1].e, n[2].e, p));
6053 }
6054 break;
6055 case OPCODE_LIGHT_MODEL:
6056 {
6057 GLfloat p[4];
6058 p[0] = n[2].f;
6059 p[1] = n[3].f;
6060 p[2] = n[4].f;
6061 p[3] = n[5].f;
6062 CALL_LightModelfv(ctx->Exec, (n[1].e, p));
6063 }
6064 break;
6065 case OPCODE_LINE_STIPPLE:
6066 CALL_LineStipple(ctx->Exec, (n[1].i, n[2].us));
6067 break;
6068 case OPCODE_LINE_WIDTH:
6069 CALL_LineWidth(ctx->Exec, (n[1].f));
6070 break;
6071 case OPCODE_LIST_BASE:
6072 CALL_ListBase(ctx->Exec, (n[1].ui));
6073 break;
6074 case OPCODE_LOAD_IDENTITY:
6075 CALL_LoadIdentity(ctx->Exec, ());
6076 break;
6077 case OPCODE_LOAD_MATRIX:
6078 if (sizeof(Node) == sizeof(GLfloat)) {
6079 CALL_LoadMatrixf(ctx->Exec, (&n[1].f));
6080 }
6081 else {
6082 GLfloat m[16];
6083 GLuint i;
6084 for (i = 0; i < 16; i++) {
6085 m[i] = n[1 + i].f;
6086 }
6087 CALL_LoadMatrixf(ctx->Exec, (m));
6088 }
6089 break;
6090 case OPCODE_LOAD_NAME:
6091 CALL_LoadName(ctx->Exec, (n[1].ui));
6092 break;
6093 case OPCODE_LOGIC_OP:
6094 CALL_LogicOp(ctx->Exec, (n[1].e));
6095 break;
6096 case OPCODE_MAP1:
6097 {
6098 GLenum target = n[1].e;
6099 GLint ustride = _mesa_evaluator_components(target);
6100 GLint uorder = n[5].i;
6101 GLfloat u1 = n[2].f;
6102 GLfloat u2 = n[3].f;
6103 CALL_Map1f(ctx->Exec, (target, u1, u2, ustride, uorder,
6104 (GLfloat *) n[6].data));
6105 }
6106 break;
6107 case OPCODE_MAP2:
6108 {
6109 GLenum target = n[1].e;
6110 GLfloat u1 = n[2].f;
6111 GLfloat u2 = n[3].f;
6112 GLfloat v1 = n[4].f;
6113 GLfloat v2 = n[5].f;
6114 GLint ustride = n[6].i;
6115 GLint vstride = n[7].i;
6116 GLint uorder = n[8].i;
6117 GLint vorder = n[9].i;
6118 CALL_Map2f(ctx->Exec, (target, u1, u2, ustride, uorder,
6119 v1, v2, vstride, vorder,
6120 (GLfloat *) n[10].data));
6121 }
6122 break;
6123 case OPCODE_MAPGRID1:
6124 CALL_MapGrid1f(ctx->Exec, (n[1].i, n[2].f, n[3].f));
6125 break;
6126 case OPCODE_MAPGRID2:
6127 CALL_MapGrid2f(ctx->Exec,
6128 (n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f));
6129 break;
6130 case OPCODE_MATRIX_MODE:
6131 CALL_MatrixMode(ctx->Exec, (n[1].e));
6132 break;
6133 case OPCODE_MIN_MAX:
6134 CALL_Minmax(ctx->Exec, (n[1].e, n[2].e, n[3].b));
6135 break;
6136 case OPCODE_MULT_MATRIX:
6137 if (sizeof(Node) == sizeof(GLfloat)) {
6138 CALL_MultMatrixf(ctx->Exec, (&n[1].f));
6139 }
6140 else {
6141 GLfloat m[16];
6142 GLuint i;
6143 for (i = 0; i < 16; i++) {
6144 m[i] = n[1 + i].f;
6145 }
6146 CALL_MultMatrixf(ctx->Exec, (m));
6147 }
6148 break;
6149 case OPCODE_ORTHO:
6150 CALL_Ortho(ctx->Exec,
6151 (n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f));
6152 break;
6153 case OPCODE_PASSTHROUGH:
6154 CALL_PassThrough(ctx->Exec, (n[1].f));
6155 break;
6156 case OPCODE_PIXEL_MAP:
6157 CALL_PixelMapfv(ctx->Exec,
6158 (n[1].e, n[2].i, (GLfloat *) n[3].data));
6159 break;
6160 case OPCODE_PIXEL_TRANSFER:
6161 CALL_PixelTransferf(ctx->Exec, (n[1].e, n[2].f));
6162 break;
6163 case OPCODE_PIXEL_ZOOM:
6164 CALL_PixelZoom(ctx->Exec, (n[1].f, n[2].f));
6165 break;
6166 case OPCODE_POINT_SIZE:
6167 CALL_PointSize(ctx->Exec, (n[1].f));
6168 break;
6169 case OPCODE_POINT_PARAMETERS:
6170 {
6171 GLfloat params[3];
6172 params[0] = n[2].f;
6173 params[1] = n[3].f;
6174 params[2] = n[4].f;
6175 CALL_PointParameterfvEXT(ctx->Exec, (n[1].e, params));
6176 }
6177 break;
6178 case OPCODE_POLYGON_MODE:
6179 CALL_PolygonMode(ctx->Exec, (n[1].e, n[2].e));
6180 break;
6181 case OPCODE_POLYGON_STIPPLE:
6182 {
6183 const struct gl_pixelstore_attrib save = ctx->Unpack;
6184 ctx->Unpack = ctx->DefaultPacking;
6185 CALL_PolygonStipple(ctx->Exec, ((GLubyte *) n[1].data));
6186 ctx->Unpack = save; /* restore */
6187 }
6188 break;
6189 case OPCODE_POLYGON_OFFSET:
6190 CALL_PolygonOffset(ctx->Exec, (n[1].f, n[2].f));
6191 break;
6192 case OPCODE_POP_ATTRIB:
6193 CALL_PopAttrib(ctx->Exec, ());
6194 break;
6195 case OPCODE_POP_MATRIX:
6196 CALL_PopMatrix(ctx->Exec, ());
6197 break;
6198 case OPCODE_POP_NAME:
6199 CALL_PopName(ctx->Exec, ());
6200 break;
6201 case OPCODE_PRIORITIZE_TEXTURE:
6202 CALL_PrioritizeTextures(ctx->Exec, (1, &n[1].ui, &n[2].f));
6203 break;
6204 case OPCODE_PUSH_ATTRIB:
6205 CALL_PushAttrib(ctx->Exec, (n[1].bf));
6206 break;
6207 case OPCODE_PUSH_MATRIX:
6208 CALL_PushMatrix(ctx->Exec, ());
6209 break;
6210 case OPCODE_PUSH_NAME:
6211 CALL_PushName(ctx->Exec, (n[1].ui));
6212 break;
6213 case OPCODE_RASTER_POS:
6214 CALL_RasterPos4f(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
6215 break;
6216 case OPCODE_READ_BUFFER:
6217 CALL_ReadBuffer(ctx->Exec, (n[1].e));
6218 break;
6219 case OPCODE_RESET_HISTOGRAM:
6220 CALL_ResetHistogram(ctx->Exec, (n[1].e));
6221 break;
6222 case OPCODE_RESET_MIN_MAX:
6223 CALL_ResetMinmax(ctx->Exec, (n[1].e));
6224 break;
6225 case OPCODE_ROTATE:
6226 CALL_Rotatef(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
6227 break;
6228 case OPCODE_SCALE:
6229 CALL_Scalef(ctx->Exec, (n[1].f, n[2].f, n[3].f));
6230 break;
6231 case OPCODE_SCISSOR:
6232 CALL_Scissor(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));
6233 break;
6234 case OPCODE_SHADE_MODEL:
6235 CALL_ShadeModel(ctx->Exec, (n[1].e));
6236 break;
6237 case OPCODE_STENCIL_FUNC:
6238 CALL_StencilFunc(ctx->Exec, (n[1].e, n[2].i, n[3].ui));
6239 break;
6240 case OPCODE_STENCIL_MASK:
6241 CALL_StencilMask(ctx->Exec, (n[1].ui));
6242 break;
6243 case OPCODE_STENCIL_OP:
6244 CALL_StencilOp(ctx->Exec, (n[1].e, n[2].e, n[3].e));
6245 break;
6246 case OPCODE_STENCIL_FUNC_SEPARATE:
6247 CALL_StencilFuncSeparate(ctx->Exec,
6248 (n[1].e, n[2].e, n[3].i, n[4].ui));
6249 break;
6250 case OPCODE_STENCIL_MASK_SEPARATE:
6251 CALL_StencilMaskSeparate(ctx->Exec, (n[1].e, n[2].ui));
6252 break;
6253 case OPCODE_STENCIL_OP_SEPARATE:
6254 CALL_StencilOpSeparate(ctx->Exec,
6255 (n[1].e, n[2].e, n[3].e, n[4].e));
6256 break;
6257 case OPCODE_TEXENV:
6258 {
6259 GLfloat params[4];
6260 params[0] = n[3].f;
6261 params[1] = n[4].f;
6262 params[2] = n[5].f;
6263 params[3] = n[6].f;
6264 CALL_TexEnvfv(ctx->Exec, (n[1].e, n[2].e, params));
6265 }
6266 break;
6267 case OPCODE_TEXGEN:
6268 {
6269 GLfloat params[4];
6270 params[0] = n[3].f;
6271 params[1] = n[4].f;
6272 params[2] = n[5].f;
6273 params[3] = n[6].f;
6274 CALL_TexGenfv(ctx->Exec, (n[1].e, n[2].e, params));
6275 }
6276 break;
6277 case OPCODE_TEXPARAMETER:
6278 {
6279 GLfloat params[4];
6280 params[0] = n[3].f;
6281 params[1] = n[4].f;
6282 params[2] = n[5].f;
6283 params[3] = n[6].f;
6284 CALL_TexParameterfv(ctx->Exec, (n[1].e, n[2].e, params));
6285 }
6286 break;
6287 case OPCODE_TEX_IMAGE1D:
6288 {
6289 const struct gl_pixelstore_attrib save = ctx->Unpack;
6290 ctx->Unpack = ctx->DefaultPacking;
6291 CALL_TexImage1D(ctx->Exec, (n[1].e, /* target */
6292 n[2].i, /* level */
6293 n[3].i, /* components */
6294 n[4].i, /* width */
6295 n[5].e, /* border */
6296 n[6].e, /* format */
6297 n[7].e, /* type */
6298 n[8].data));
6299 ctx->Unpack = save; /* restore */
6300 }
6301 break;
6302 case OPCODE_TEX_IMAGE2D:
6303 {
6304 const struct gl_pixelstore_attrib save = ctx->Unpack;
6305 ctx->Unpack = ctx->DefaultPacking;
6306 CALL_TexImage2D(ctx->Exec, (n[1].e, /* target */
6307 n[2].i, /* level */
6308 n[3].i, /* components */
6309 n[4].i, /* width */
6310 n[5].i, /* height */
6311 n[6].e, /* border */
6312 n[7].e, /* format */
6313 n[8].e, /* type */
6314 n[9].data));
6315 ctx->Unpack = save; /* restore */
6316 }
6317 break;
6318 case OPCODE_TEX_IMAGE3D:
6319 {
6320 const struct gl_pixelstore_attrib save = ctx->Unpack;
6321 ctx->Unpack = ctx->DefaultPacking;
6322 CALL_TexImage3D(ctx->Exec, (n[1].e, /* target */
6323 n[2].i, /* level */
6324 n[3].i, /* components */
6325 n[4].i, /* width */
6326 n[5].i, /* height */
6327 n[6].i, /* depth */
6328 n[7].e, /* border */
6329 n[8].e, /* format */
6330 n[9].e, /* type */
6331 n[10].data));
6332 ctx->Unpack = save; /* restore */
6333 }
6334 break;
6335 case OPCODE_TEX_SUB_IMAGE1D:
6336 {
6337 const struct gl_pixelstore_attrib save = ctx->Unpack;
6338 ctx->Unpack = ctx->DefaultPacking;
6339 CALL_TexSubImage1D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
6340 n[4].i, n[5].e,
6341 n[6].e, n[7].data));
6342 ctx->Unpack = save; /* restore */
6343 }
6344 break;
6345 case OPCODE_TEX_SUB_IMAGE2D:
6346 {
6347 const struct gl_pixelstore_attrib save = ctx->Unpack;
6348 ctx->Unpack = ctx->DefaultPacking;
6349 CALL_TexSubImage2D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
6350 n[4].i, n[5].e,
6351 n[6].i, n[7].e, n[8].e,
6352 n[9].data));
6353 ctx->Unpack = save; /* restore */
6354 }
6355 break;
6356 case OPCODE_TEX_SUB_IMAGE3D:
6357 {
6358 const struct gl_pixelstore_attrib save = ctx->Unpack;
6359 ctx->Unpack = ctx->DefaultPacking;
6360 CALL_TexSubImage3D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
6361 n[4].i, n[5].i, n[6].i, n[7].i,
6362 n[8].i, n[9].e, n[10].e,
6363 n[11].data));
6364 ctx->Unpack = save; /* restore */
6365 }
6366 break;
6367 case OPCODE_TRANSLATE:
6368 CALL_Translatef(ctx->Exec, (n[1].f, n[2].f, n[3].f));
6369 break;
6370 case OPCODE_VIEWPORT:
6371 CALL_Viewport(ctx->Exec, (n[1].i, n[2].i,
6372 (GLsizei) n[3].i, (GLsizei) n[4].i));
6373 break;
6374 case OPCODE_WINDOW_POS:
6375 CALL_WindowPos4fMESA(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
6376 break;
6377 case OPCODE_ACTIVE_TEXTURE: /* GL_ARB_multitexture */
6378 CALL_ActiveTextureARB(ctx->Exec, (n[1].e));
6379 break;
6380 case OPCODE_COMPRESSED_TEX_IMAGE_1D: /* GL_ARB_texture_compression */
6381 CALL_CompressedTexImage1DARB(ctx->Exec, (n[1].e, n[2].i, n[3].e,
6382 n[4].i, n[5].i, n[6].i,
6383 n[7].data));
6384 break;
6385 case OPCODE_COMPRESSED_TEX_IMAGE_2D: /* GL_ARB_texture_compression */
6386 CALL_CompressedTexImage2DARB(ctx->Exec, (n[1].e, n[2].i, n[3].e,
6387 n[4].i, n[5].i, n[6].i,
6388 n[7].i, n[8].data));
6389 break;
6390 case OPCODE_COMPRESSED_TEX_IMAGE_3D: /* GL_ARB_texture_compression */
6391 CALL_CompressedTexImage3DARB(ctx->Exec, (n[1].e, n[2].i, n[3].e,
6392 n[4].i, n[5].i, n[6].i,
6393 n[7].i, n[8].i,
6394 n[9].data));
6395 break;
6396 case OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D: /* GL_ARB_texture_compress */
6397 CALL_CompressedTexSubImage1DARB(ctx->Exec,
6398 (n[1].e, n[2].i, n[3].i, n[4].i,
6399 n[5].e, n[6].i, n[7].data));
6400 break;
6401 case OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D: /* GL_ARB_texture_compress */
6402 CALL_CompressedTexSubImage2DARB(ctx->Exec,
6403 (n[1].e, n[2].i, n[3].i, n[4].i,
6404 n[5].i, n[6].i, n[7].e, n[8].i,
6405 n[9].data));
6406 break;
6407 case OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D: /* GL_ARB_texture_compress */
6408 CALL_CompressedTexSubImage3DARB(ctx->Exec,
6409 (n[1].e, n[2].i, n[3].i, n[4].i,
6410 n[5].i, n[6].i, n[7].i, n[8].i,
6411 n[9].e, n[10].i, n[11].data));
6412 break;
6413 case OPCODE_SAMPLE_COVERAGE: /* GL_ARB_multisample */
6414 CALL_SampleCoverageARB(ctx->Exec, (n[1].f, n[2].b));
6415 break;
6416 case OPCODE_WINDOW_POS_ARB: /* GL_ARB_window_pos */
6417 CALL_WindowPos3fMESA(ctx->Exec, (n[1].f, n[2].f, n[3].f));
6418 break;
6419 #if FEATURE_NV_vertex_program || FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
6420 case OPCODE_BIND_PROGRAM_NV: /* GL_NV_vertex_program */
6421 CALL_BindProgramNV(ctx->Exec, (n[1].e, n[2].ui));
6422 break;
6423 #endif
6424 #if FEATURE_NV_vertex_program
6425 case OPCODE_EXECUTE_PROGRAM_NV:
6426 {
6427 GLfloat v[4];
6428 v[0] = n[3].f;
6429 v[1] = n[4].f;
6430 v[2] = n[5].f;
6431 v[3] = n[6].f;
6432 CALL_ExecuteProgramNV(ctx->Exec, (n[1].e, n[2].ui, v));
6433 }
6434 break;
6435 case OPCODE_REQUEST_RESIDENT_PROGRAMS_NV:
6436 CALL_RequestResidentProgramsNV(ctx->Exec, (n[1].ui,
6437 (GLuint *) n[2].data));
6438 break;
6439 case OPCODE_LOAD_PROGRAM_NV:
6440 CALL_LoadProgramNV(ctx->Exec, (n[1].e, n[2].ui, n[3].i,
6441 (const GLubyte *) n[4].data));
6442 break;
6443 case OPCODE_TRACK_MATRIX_NV:
6444 CALL_TrackMatrixNV(ctx->Exec, (n[1].e, n[2].ui, n[3].e, n[4].e));
6445 break;
6446 #endif
6447
6448 #if FEATURE_NV_fragment_program
6449 case OPCODE_PROGRAM_LOCAL_PARAMETER_ARB:
6450 CALL_ProgramLocalParameter4fARB(ctx->Exec,
6451 (n[1].e, n[2].ui, n[3].f, n[4].f,
6452 n[5].f, n[6].f));
6453 break;
6454 case OPCODE_PROGRAM_NAMED_PARAMETER_NV:
6455 CALL_ProgramNamedParameter4fNV(ctx->Exec, (n[1].ui, n[2].i,
6456 (const GLubyte *) n[3].
6457 data, n[4].f, n[5].f,
6458 n[6].f, n[7].f));
6459 break;
6460 #endif
6461
6462 case OPCODE_ACTIVE_STENCIL_FACE_EXT:
6463 CALL_ActiveStencilFaceEXT(ctx->Exec, (n[1].e));
6464 break;
6465 case OPCODE_DEPTH_BOUNDS_EXT:
6466 CALL_DepthBoundsEXT(ctx->Exec, (n[1].f, n[2].f));
6467 break;
6468 #if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
6469 case OPCODE_PROGRAM_STRING_ARB:
6470 CALL_ProgramStringARB(ctx->Exec,
6471 (n[1].e, n[2].e, n[3].i, n[4].data));
6472 break;
6473 #endif
6474 #if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program || FEATURE_NV_vertex_program
6475 case OPCODE_PROGRAM_ENV_PARAMETER_ARB:
6476 CALL_ProgramEnvParameter4fARB(ctx->Exec, (n[1].e, n[2].ui, n[3].f,
6477 n[4].f, n[5].f,
6478 n[6].f));
6479 break;
6480 #endif
6481 #if FEATURE_ARB_occlusion_query
6482 case OPCODE_BEGIN_QUERY_ARB:
6483 CALL_BeginQueryARB(ctx->Exec, (n[1].e, n[2].ui));
6484 break;
6485 case OPCODE_END_QUERY_ARB:
6486 CALL_EndQueryARB(ctx->Exec, (n[1].e));
6487 break;
6488 #endif
6489 case OPCODE_DRAW_BUFFERS_ARB:
6490 {
6491 GLenum buffers[MAX_DRAW_BUFFERS];
6492 GLint i, count = MIN2(n[1].i, MAX_DRAW_BUFFERS);
6493 for (i = 0; i < count; i++)
6494 buffers[i] = n[2 + i].e;
6495 CALL_DrawBuffersARB(ctx->Exec, (n[1].i, buffers));
6496 }
6497 break;
6498 #if FEATURE_EXT_framebuffer_blit
6499 case OPCODE_BLIT_FRAMEBUFFER:
6500 CALL_BlitFramebufferEXT(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i,
6501 n[5].i, n[6].i, n[7].i, n[8].i,
6502 n[9].i, n[10].e));
6503 break;
6504 #endif
6505 #if FEATURE_ATI_fragment_shader
6506 case OPCODE_BIND_FRAGMENT_SHADER_ATI:
6507 CALL_BindFragmentShaderATI(ctx->Exec, (n[1].i));
6508 break;
6509 case OPCODE_SET_FRAGMENT_SHADER_CONSTANTS_ATI:
6510 {
6511 GLfloat values[4];
6512 GLuint i, dst = n[1].ui;
6513
6514 for (i = 0; i < 4; i++)
6515 values[i] = n[1 + i].f;
6516 CALL_SetFragmentShaderConstantATI(ctx->Exec, (dst, values));
6517 }
6518 break;
6519 #endif
6520 case OPCODE_ATTR_1F_NV:
6521 CALL_VertexAttrib1fNV(ctx->Exec, (n[1].e, n[2].f));
6522 break;
6523 case OPCODE_ATTR_2F_NV:
6524 /* Really shouldn't have to do this - the Node structure
6525 * is convenient, but it would be better to store the data
6526 * packed appropriately so that it can be sent directly
6527 * on. With x86_64 becoming common, this will start to
6528 * matter more.
6529 */
6530 if (sizeof(Node) == sizeof(GLfloat))
6531 CALL_VertexAttrib2fvNV(ctx->Exec, (n[1].e, &n[2].f));
6532 else
6533 CALL_VertexAttrib2fNV(ctx->Exec, (n[1].e, n[2].f, n[3].f));
6534 break;
6535 case OPCODE_ATTR_3F_NV:
6536 if (sizeof(Node) == sizeof(GLfloat))
6537 CALL_VertexAttrib3fvNV(ctx->Exec, (n[1].e, &n[2].f));
6538 else
6539 CALL_VertexAttrib3fNV(ctx->Exec, (n[1].e, n[2].f, n[3].f,
6540 n[4].f));
6541 break;
6542 case OPCODE_ATTR_4F_NV:
6543 if (sizeof(Node) == sizeof(GLfloat))
6544 CALL_VertexAttrib4fvNV(ctx->Exec, (n[1].e, &n[2].f));
6545 else
6546 CALL_VertexAttrib4fNV(ctx->Exec, (n[1].e, n[2].f, n[3].f,
6547 n[4].f, n[5].f));
6548 break;
6549 case OPCODE_ATTR_1F_ARB:
6550 CALL_VertexAttrib1fARB(ctx->Exec, (n[1].e, n[2].f));
6551 break;
6552 case OPCODE_ATTR_2F_ARB:
6553 /* Really shouldn't have to do this - the Node structure
6554 * is convenient, but it would be better to store the data
6555 * packed appropriately so that it can be sent directly
6556 * on. With x86_64 becoming common, this will start to
6557 * matter more.
6558 */
6559 if (sizeof(Node) == sizeof(GLfloat))
6560 CALL_VertexAttrib2fvARB(ctx->Exec, (n[1].e, &n[2].f));
6561 else
6562 CALL_VertexAttrib2fARB(ctx->Exec, (n[1].e, n[2].f, n[3].f));
6563 break;
6564 case OPCODE_ATTR_3F_ARB:
6565 if (sizeof(Node) == sizeof(GLfloat))
6566 CALL_VertexAttrib3fvARB(ctx->Exec, (n[1].e, &n[2].f));
6567 else
6568 CALL_VertexAttrib3fARB(ctx->Exec, (n[1].e, n[2].f, n[3].f,
6569 n[4].f));
6570 break;
6571 case OPCODE_ATTR_4F_ARB:
6572 if (sizeof(Node) == sizeof(GLfloat))
6573 CALL_VertexAttrib4fvARB(ctx->Exec, (n[1].e, &n[2].f));
6574 else
6575 CALL_VertexAttrib4fARB(ctx->Exec, (n[1].e, n[2].f, n[3].f,
6576 n[4].f, n[5].f));
6577 break;
6578 case OPCODE_MATERIAL:
6579 if (sizeof(Node) == sizeof(GLfloat))
6580 CALL_Materialfv(ctx->Exec, (n[1].e, n[2].e, &n[3].f));
6581 else {
6582 GLfloat f[4];
6583 f[0] = n[3].f;
6584 f[1] = n[4].f;
6585 f[2] = n[5].f;
6586 f[3] = n[6].f;
6587 CALL_Materialfv(ctx->Exec, (n[1].e, n[2].e, f));
6588 }
6589 break;
6590 case OPCODE_BEGIN:
6591 CALL_Begin(ctx->Exec, (n[1].e));
6592 break;
6593 case OPCODE_END:
6594 CALL_End(ctx->Exec, ());
6595 break;
6596 case OPCODE_RECTF:
6597 CALL_Rectf(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
6598 break;
6599 case OPCODE_EVAL_C1:
6600 CALL_EvalCoord1f(ctx->Exec, (n[1].f));
6601 break;
6602 case OPCODE_EVAL_C2:
6603 CALL_EvalCoord2f(ctx->Exec, (n[1].f, n[2].f));
6604 break;
6605 case OPCODE_EVAL_P1:
6606 CALL_EvalPoint1(ctx->Exec, (n[1].i));
6607 break;
6608 case OPCODE_EVAL_P2:
6609 CALL_EvalPoint2(ctx->Exec, (n[1].i, n[2].i));
6610 break;
6611
6612 case OPCODE_CONTINUE:
6613 n = (Node *) n[1].next;
6614 break;
6615 case OPCODE_END_OF_LIST:
6616 done = GL_TRUE;
6617 break;
6618 default:
6619 {
6620 char msg[1000];
6621 _mesa_sprintf(msg, "Error in execute_list: opcode=%d",
6622 (int) opcode);
6623 _mesa_problem(ctx, msg);
6624 }
6625 done = GL_TRUE;
6626 }
6627
6628 /* increment n to point to next compiled command */
6629 if (opcode != OPCODE_CONTINUE) {
6630 n += InstSize[opcode];
6631 }
6632 }
6633 }
6634
6635 if (ctx->Driver.EndCallList)
6636 ctx->Driver.EndCallList(ctx);
6637
6638 ctx->ListState.CallDepth--;
6639 }
6640
6641
6642
6643 /**********************************************************************/
6644 /* GL functions */
6645 /**********************************************************************/
6646
6647 /**
6648 * Test if a display list number is valid.
6649 */
6650 GLboolean GLAPIENTRY
6651 _mesa_IsList(GLuint list)
6652 {
6653 GET_CURRENT_CONTEXT(ctx);
6654 FLUSH_VERTICES(ctx, 0); /* must be called before assert */
6655 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
6656 return islist(ctx, list);
6657 }
6658
6659
6660 /**
6661 * Delete a sequence of consecutive display lists.
6662 */
6663 void GLAPIENTRY
6664 _mesa_DeleteLists(GLuint list, GLsizei range)
6665 {
6666 GET_CURRENT_CONTEXT(ctx);
6667 GLuint i;
6668 FLUSH_VERTICES(ctx, 0); /* must be called before assert */
6669 ASSERT_OUTSIDE_BEGIN_END(ctx);
6670
6671 if (range < 0) {
6672 _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteLists");
6673 return;
6674 }
6675 for (i = list; i < list + range; i++) {
6676 destroy_list(ctx, i);
6677 }
6678 }
6679
6680
6681 /**
6682 * Return a display list number, n, such that lists n through n+range-1
6683 * are free.
6684 */
6685 GLuint GLAPIENTRY
6686 _mesa_GenLists(GLsizei range)
6687 {
6688 GET_CURRENT_CONTEXT(ctx);
6689 GLuint base;
6690 FLUSH_VERTICES(ctx, 0); /* must be called before assert */
6691 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
6692
6693 if (range < 0) {
6694 _mesa_error(ctx, GL_INVALID_VALUE, "glGenLists");
6695 return 0;
6696 }
6697 if (range == 0) {
6698 return 0;
6699 }
6700
6701 /*
6702 * Make this an atomic operation
6703 */
6704 _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
6705
6706 base = _mesa_HashFindFreeKeyBlock(ctx->Shared->DisplayList, range);
6707 if (base) {
6708 /* reserve the list IDs by with empty/dummy lists */
6709 GLint i;
6710 for (i = 0; i < range; i++) {
6711 _mesa_HashInsert(ctx->Shared->DisplayList, base + i,
6712 make_list(base + i, 1));
6713 }
6714 }
6715
6716 _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
6717
6718 return base;
6719 }
6720
6721
6722 /**
6723 * Begin a new display list.
6724 */
6725 void GLAPIENTRY
6726 _mesa_NewList(GLuint list, GLenum mode)
6727 {
6728 GET_CURRENT_CONTEXT(ctx);
6729 GLint i;
6730
6731 FLUSH_CURRENT(ctx, 0); /* must be called before assert */
6732 ASSERT_OUTSIDE_BEGIN_END(ctx);
6733
6734 if (MESA_VERBOSE & VERBOSE_API)
6735 _mesa_debug(ctx, "glNewList %u %s\n", list,
6736 _mesa_lookup_enum_by_nr(mode));
6737
6738 if (list == 0) {
6739 _mesa_error(ctx, GL_INVALID_VALUE, "glNewList");
6740 return;
6741 }
6742
6743 if (mode != GL_COMPILE && mode != GL_COMPILE_AND_EXECUTE) {
6744 _mesa_error(ctx, GL_INVALID_ENUM, "glNewList");
6745 return;
6746 }
6747
6748 if (ctx->ListState.CurrentListPtr) {
6749 /* already compiling a display list */
6750 _mesa_error(ctx, GL_INVALID_OPERATION, "glNewList");
6751 return;
6752 }
6753
6754 ctx->CompileFlag = GL_TRUE;
6755 ctx->ExecuteFlag = (mode == GL_COMPILE_AND_EXECUTE);
6756
6757 /* Allocate new display list */
6758 ctx->ListState.CurrentListNum = list;
6759 ctx->ListState.CurrentList = make_list(list, BLOCK_SIZE);
6760 ctx->ListState.CurrentBlock = ctx->ListState.CurrentList->node;
6761 ctx->ListState.CurrentListPtr = ctx->ListState.CurrentBlock;
6762 ctx->ListState.CurrentPos = 0;
6763
6764 /* Reset acumulated list state:
6765 */
6766 for (i = 0; i < VERT_ATTRIB_MAX; i++)
6767 ctx->ListState.ActiveAttribSize[i] = 0;
6768
6769 for (i = 0; i < MAT_ATTRIB_MAX; i++)
6770 ctx->ListState.ActiveMaterialSize[i] = 0;
6771
6772 ctx->Driver.CurrentSavePrimitive = PRIM_UNKNOWN;
6773 ctx->Driver.NewList(ctx, list, mode);
6774
6775 ctx->CurrentDispatch = ctx->Save;
6776 _glapi_set_dispatch(ctx->CurrentDispatch);
6777 }
6778
6779
6780 /**
6781 * End definition of current display list.
6782 */
6783 void GLAPIENTRY
6784 _mesa_EndList(void)
6785 {
6786 GET_CURRENT_CONTEXT(ctx);
6787 SAVE_FLUSH_VERTICES(ctx);
6788 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
6789
6790 if (MESA_VERBOSE & VERBOSE_API)
6791 _mesa_debug(ctx, "glEndList\n");
6792
6793 /* Check that a list is under construction */
6794 if (!ctx->ListState.CurrentListPtr) {
6795 _mesa_error(ctx, GL_INVALID_OPERATION, "glEndList");
6796 return;
6797 }
6798
6799 /* Call before emitting END_OF_LIST, in case the driver wants to
6800 * emit opcodes itself.
6801 */
6802 ctx->Driver.EndList(ctx);
6803
6804 (void) ALLOC_INSTRUCTION(ctx, OPCODE_END_OF_LIST, 0);
6805
6806 /* Destroy old list, if any */
6807 destroy_list(ctx, ctx->ListState.CurrentListNum);
6808 /* Install the list */
6809 _mesa_HashInsert(ctx->Shared->DisplayList, ctx->ListState.CurrentListNum,
6810 ctx->ListState.CurrentList);
6811
6812
6813 if (MESA_VERBOSE & VERBOSE_DISPLAY_LIST)
6814 mesa_print_display_list(ctx->ListState.CurrentListNum);
6815
6816 ctx->ListState.CurrentList = NULL;
6817 ctx->ListState.CurrentListNum = 0;
6818 ctx->ListState.CurrentListPtr = NULL;
6819 ctx->ExecuteFlag = GL_TRUE;
6820 ctx->CompileFlag = GL_FALSE;
6821
6822 ctx->CurrentDispatch = ctx->Exec;
6823 _glapi_set_dispatch(ctx->CurrentDispatch);
6824 }
6825
6826
6827 void GLAPIENTRY
6828 _mesa_CallList(GLuint list)
6829 {
6830 GLboolean save_compile_flag;
6831 GET_CURRENT_CONTEXT(ctx);
6832 FLUSH_CURRENT(ctx, 0);
6833 /* VERY IMPORTANT: Save the CompileFlag status, turn it off, */
6834 /* execute the display list, and restore the CompileFlag. */
6835
6836 if (MESA_VERBOSE & VERBOSE_API)
6837 _mesa_debug(ctx, "glCallList %d\n", list);
6838
6839 if (list == 0) {
6840 _mesa_error(ctx, GL_INVALID_VALUE, "glCallList(list==0)");
6841 return;
6842 }
6843
6844 /* mesa_print_display_list( list ); */
6845
6846 save_compile_flag = ctx->CompileFlag;
6847 if (save_compile_flag) {
6848 ctx->CompileFlag = GL_FALSE;
6849 }
6850
6851 execute_list(ctx, list);
6852 ctx->CompileFlag = save_compile_flag;
6853
6854 /* also restore API function pointers to point to "save" versions */
6855 if (save_compile_flag) {
6856 ctx->CurrentDispatch = ctx->Save;
6857 _glapi_set_dispatch(ctx->CurrentDispatch);
6858 }
6859 }
6860
6861
6862 /**
6863 * Execute glCallLists: call multiple display lists.
6864 */
6865 void GLAPIENTRY
6866 _mesa_CallLists(GLsizei n, GLenum type, const GLvoid * lists)
6867 {
6868 GET_CURRENT_CONTEXT(ctx);
6869 GLint i;
6870 GLboolean save_compile_flag;
6871
6872 if (MESA_VERBOSE & VERBOSE_API)
6873 _mesa_debug(ctx, "glCallLists %d\n", n);
6874
6875 switch (type) {
6876 case GL_BYTE:
6877 case GL_UNSIGNED_BYTE:
6878 case GL_SHORT:
6879 case GL_UNSIGNED_SHORT:
6880 case GL_INT:
6881 case GL_UNSIGNED_INT:
6882 case GL_FLOAT:
6883 case GL_2_BYTES:
6884 case GL_3_BYTES:
6885 case GL_4_BYTES:
6886 /* OK */
6887 break;
6888 default:
6889 _mesa_error(ctx, GL_INVALID_ENUM, "glCallLists(type)");
6890 return;
6891 }
6892
6893 /* Save the CompileFlag status, turn it off, execute display list,
6894 * and restore the CompileFlag.
6895 */
6896 save_compile_flag = ctx->CompileFlag;
6897 ctx->CompileFlag = GL_FALSE;
6898
6899 for (i = 0; i < n; i++) {
6900 GLuint list = (GLuint) (ctx->List.ListBase + translate_id(i, type, lists));
6901 execute_list(ctx, list);
6902 }
6903
6904 ctx->CompileFlag = save_compile_flag;
6905
6906 /* also restore API function pointers to point to "save" versions */
6907 if (save_compile_flag) {
6908 ctx->CurrentDispatch = ctx->Save;
6909 _glapi_set_dispatch(ctx->CurrentDispatch);
6910 }
6911 }
6912
6913
6914 /**
6915 * Set the offset added to list numbers in glCallLists.
6916 */
6917 void GLAPIENTRY
6918 _mesa_ListBase(GLuint base)
6919 {
6920 GET_CURRENT_CONTEXT(ctx);
6921 FLUSH_VERTICES(ctx, 0); /* must be called before assert */
6922 ASSERT_OUTSIDE_BEGIN_END(ctx);
6923 ctx->List.ListBase = base;
6924 }
6925
6926
6927 /* Can no longer assume ctx->Exec->Func is equal to _mesa_Func.
6928 */
6929 static void GLAPIENTRY
6930 exec_Finish(void)
6931 {
6932 GET_CURRENT_CONTEXT(ctx);
6933 FLUSH_VERTICES(ctx, 0);
6934 CALL_Finish(ctx->Exec, ());
6935 }
6936
6937 static void GLAPIENTRY
6938 exec_Flush(void)
6939 {
6940 GET_CURRENT_CONTEXT(ctx);
6941 FLUSH_VERTICES(ctx, 0);
6942 CALL_Flush(ctx->Exec, ());
6943 }
6944
6945 static void GLAPIENTRY
6946 exec_GetBooleanv(GLenum pname, GLboolean *params)
6947 {
6948 GET_CURRENT_CONTEXT(ctx);
6949 FLUSH_VERTICES(ctx, 0);
6950 CALL_GetBooleanv(ctx->Exec, (pname, params));
6951 }
6952
6953 static void GLAPIENTRY
6954 exec_GetClipPlane(GLenum plane, GLdouble * equation)
6955 {
6956 GET_CURRENT_CONTEXT(ctx);
6957 FLUSH_VERTICES(ctx, 0);
6958 CALL_GetClipPlane(ctx->Exec, (plane, equation));
6959 }
6960
6961 static void GLAPIENTRY
6962 exec_GetDoublev(GLenum pname, GLdouble *params)
6963 {
6964 GET_CURRENT_CONTEXT(ctx);
6965 FLUSH_VERTICES(ctx, 0);
6966 CALL_GetDoublev(ctx->Exec, (pname, params));
6967 }
6968
6969 static GLenum GLAPIENTRY
6970 exec_GetError(void)
6971 {
6972 GET_CURRENT_CONTEXT(ctx);
6973 FLUSH_VERTICES(ctx, 0);
6974 return CALL_GetError(ctx->Exec, ());
6975 }
6976
6977 static void GLAPIENTRY
6978 exec_GetFloatv(GLenum pname, GLfloat *params)
6979 {
6980 GET_CURRENT_CONTEXT(ctx);
6981 FLUSH_VERTICES(ctx, 0);
6982 CALL_GetFloatv(ctx->Exec, (pname, params));
6983 }
6984
6985 static void GLAPIENTRY
6986 exec_GetIntegerv(GLenum pname, GLint *params)
6987 {
6988 GET_CURRENT_CONTEXT(ctx);
6989 FLUSH_VERTICES(ctx, 0);
6990 CALL_GetIntegerv(ctx->Exec, (pname, params));
6991 }
6992
6993 static void GLAPIENTRY
6994 exec_GetLightfv(GLenum light, GLenum pname, GLfloat *params)
6995 {
6996 GET_CURRENT_CONTEXT(ctx);
6997 FLUSH_VERTICES(ctx, 0);
6998 CALL_GetLightfv(ctx->Exec, (light, pname, params));
6999 }
7000
7001 static void GLAPIENTRY
7002 exec_GetLightiv(GLenum light, GLenum pname, GLint *params)
7003 {
7004 GET_CURRENT_CONTEXT(ctx);
7005 FLUSH_VERTICES(ctx, 0);
7006 CALL_GetLightiv(ctx->Exec, (light, pname, params));
7007 }
7008
7009 static void GLAPIENTRY
7010 exec_GetMapdv(GLenum target, GLenum query, GLdouble * v)
7011 {
7012 GET_CURRENT_CONTEXT(ctx);
7013 FLUSH_VERTICES(ctx, 0);
7014 CALL_GetMapdv(ctx->Exec, (target, query, v));
7015 }
7016
7017 static void GLAPIENTRY
7018 exec_GetMapfv(GLenum target, GLenum query, GLfloat * v)
7019 {
7020 GET_CURRENT_CONTEXT(ctx);
7021 FLUSH_VERTICES(ctx, 0);
7022 CALL_GetMapfv(ctx->Exec, (target, query, v));
7023 }
7024
7025 static void GLAPIENTRY
7026 exec_GetMapiv(GLenum target, GLenum query, GLint * v)
7027 {
7028 GET_CURRENT_CONTEXT(ctx);
7029 FLUSH_VERTICES(ctx, 0);
7030 CALL_GetMapiv(ctx->Exec, (target, query, v));
7031 }
7032
7033 static void GLAPIENTRY
7034 exec_GetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
7035 {
7036 GET_CURRENT_CONTEXT(ctx);
7037 FLUSH_VERTICES(ctx, 0);
7038 CALL_GetMaterialfv(ctx->Exec, (face, pname, params));
7039 }
7040
7041 static void GLAPIENTRY
7042 exec_GetMaterialiv(GLenum face, GLenum pname, GLint *params)
7043 {
7044 GET_CURRENT_CONTEXT(ctx);
7045 FLUSH_VERTICES(ctx, 0);
7046 CALL_GetMaterialiv(ctx->Exec, (face, pname, params));
7047 }
7048
7049 static void GLAPIENTRY
7050 exec_GetPixelMapfv(GLenum map, GLfloat *values)
7051 {
7052 GET_CURRENT_CONTEXT(ctx);
7053 FLUSH_VERTICES(ctx, 0);
7054 CALL_GetPixelMapfv(ctx->Exec, (map, values));
7055 }
7056
7057 static void GLAPIENTRY
7058 exec_GetPixelMapuiv(GLenum map, GLuint *values)
7059 {
7060 GET_CURRENT_CONTEXT(ctx);
7061 FLUSH_VERTICES(ctx, 0);
7062 CALL_GetPixelMapuiv(ctx->Exec, (map, values));
7063 }
7064
7065 static void GLAPIENTRY
7066 exec_GetPixelMapusv(GLenum map, GLushort *values)
7067 {
7068 GET_CURRENT_CONTEXT(ctx);
7069 FLUSH_VERTICES(ctx, 0);
7070 CALL_GetPixelMapusv(ctx->Exec, (map, values));
7071 }
7072
7073 static void GLAPIENTRY
7074 exec_GetPolygonStipple(GLubyte * dest)
7075 {
7076 GET_CURRENT_CONTEXT(ctx);
7077 FLUSH_VERTICES(ctx, 0);
7078 CALL_GetPolygonStipple(ctx->Exec, (dest));
7079 }
7080
7081 static const GLubyte *GLAPIENTRY
7082 exec_GetString(GLenum name)
7083 {
7084 GET_CURRENT_CONTEXT(ctx);
7085 FLUSH_VERTICES(ctx, 0);
7086 return CALL_GetString(ctx->Exec, (name));
7087 }
7088
7089 static void GLAPIENTRY
7090 exec_GetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
7091 {
7092 GET_CURRENT_CONTEXT(ctx);
7093 FLUSH_VERTICES(ctx, 0);
7094 CALL_GetTexEnvfv(ctx->Exec, (target, pname, params));
7095 }
7096
7097 static void GLAPIENTRY
7098 exec_GetTexEnviv(GLenum target, GLenum pname, GLint *params)
7099 {
7100 GET_CURRENT_CONTEXT(ctx);
7101 FLUSH_VERTICES(ctx, 0);
7102 CALL_GetTexEnviv(ctx->Exec, (target, pname, params));
7103 }
7104
7105 static void GLAPIENTRY
7106 exec_GetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
7107 {
7108 GET_CURRENT_CONTEXT(ctx);
7109 FLUSH_VERTICES(ctx, 0);
7110 CALL_GetTexGendv(ctx->Exec, (coord, pname, params));
7111 }
7112
7113 static void GLAPIENTRY
7114 exec_GetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
7115 {
7116 GET_CURRENT_CONTEXT(ctx);
7117 FLUSH_VERTICES(ctx, 0);
7118 CALL_GetTexGenfv(ctx->Exec, (coord, pname, params));
7119 }
7120
7121 static void GLAPIENTRY
7122 exec_GetTexGeniv(GLenum coord, GLenum pname, GLint *params)
7123 {
7124 GET_CURRENT_CONTEXT(ctx);
7125 FLUSH_VERTICES(ctx, 0);
7126 CALL_GetTexGeniv(ctx->Exec, (coord, pname, params));
7127 }
7128
7129 static void GLAPIENTRY
7130 exec_GetTexImage(GLenum target, GLint level, GLenum format,
7131 GLenum type, GLvoid * pixels)
7132 {
7133 GET_CURRENT_CONTEXT(ctx);
7134 FLUSH_VERTICES(ctx, 0);
7135 CALL_GetTexImage(ctx->Exec, (target, level, format, type, pixels));
7136 }
7137
7138 static void GLAPIENTRY
7139 exec_GetTexLevelParameterfv(GLenum target, GLint level,
7140 GLenum pname, GLfloat *params)
7141 {
7142 GET_CURRENT_CONTEXT(ctx);
7143 FLUSH_VERTICES(ctx, 0);
7144 CALL_GetTexLevelParameterfv(ctx->Exec, (target, level, pname, params));
7145 }
7146
7147 static void GLAPIENTRY
7148 exec_GetTexLevelParameteriv(GLenum target, GLint level,
7149 GLenum pname, GLint *params)
7150 {
7151 GET_CURRENT_CONTEXT(ctx);
7152 FLUSH_VERTICES(ctx, 0);
7153 CALL_GetTexLevelParameteriv(ctx->Exec, (target, level, pname, params));
7154 }
7155
7156 static void GLAPIENTRY
7157 exec_GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
7158 {
7159 GET_CURRENT_CONTEXT(ctx);
7160 FLUSH_VERTICES(ctx, 0);
7161 CALL_GetTexParameterfv(ctx->Exec, (target, pname, params));
7162 }
7163
7164 static void GLAPIENTRY
7165 exec_GetTexParameteriv(GLenum target, GLenum pname, GLint *params)
7166 {
7167 GET_CURRENT_CONTEXT(ctx);
7168 FLUSH_VERTICES(ctx, 0);
7169 CALL_GetTexParameteriv(ctx->Exec, (target, pname, params));
7170 }
7171
7172 static GLboolean GLAPIENTRY
7173 exec_IsEnabled(GLenum cap)
7174 {
7175 GET_CURRENT_CONTEXT(ctx);
7176 FLUSH_VERTICES(ctx, 0);
7177 return CALL_IsEnabled(ctx->Exec, (cap));
7178 }
7179
7180 static void GLAPIENTRY
7181 exec_PixelStoref(GLenum pname, GLfloat param)
7182 {
7183 GET_CURRENT_CONTEXT(ctx);
7184 FLUSH_VERTICES(ctx, 0);
7185 CALL_PixelStoref(ctx->Exec, (pname, param));
7186 }
7187
7188 static void GLAPIENTRY
7189 exec_PixelStorei(GLenum pname, GLint param)
7190 {
7191 GET_CURRENT_CONTEXT(ctx);
7192 FLUSH_VERTICES(ctx, 0);
7193 CALL_PixelStorei(ctx->Exec, (pname, param));
7194 }
7195
7196 static void GLAPIENTRY
7197 exec_ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
7198 GLenum format, GLenum type, GLvoid * pixels)
7199 {
7200 GET_CURRENT_CONTEXT(ctx);
7201 FLUSH_VERTICES(ctx, 0);
7202 CALL_ReadPixels(ctx->Exec, (x, y, width, height, format, type, pixels));
7203 }
7204
7205 static GLint GLAPIENTRY
7206 exec_RenderMode(GLenum mode)
7207 {
7208 GET_CURRENT_CONTEXT(ctx);
7209 FLUSH_VERTICES(ctx, 0);
7210 return CALL_RenderMode(ctx->Exec, (mode));
7211 }
7212
7213 static void GLAPIENTRY
7214 exec_FeedbackBuffer(GLsizei size, GLenum type, GLfloat * buffer)
7215 {
7216 GET_CURRENT_CONTEXT(ctx);
7217 FLUSH_VERTICES(ctx, 0);
7218 CALL_FeedbackBuffer(ctx->Exec, (size, type, buffer));
7219 }
7220
7221 static void GLAPIENTRY
7222 exec_SelectBuffer(GLsizei size, GLuint * buffer)
7223 {
7224 GET_CURRENT_CONTEXT(ctx);
7225 FLUSH_VERTICES(ctx, 0);
7226 CALL_SelectBuffer(ctx->Exec, (size, buffer));
7227 }
7228
7229 static GLboolean GLAPIENTRY
7230 exec_AreTexturesResident(GLsizei n, const GLuint * texName,
7231 GLboolean * residences)
7232 {
7233 GET_CURRENT_CONTEXT(ctx);
7234 FLUSH_VERTICES(ctx, 0);
7235 return CALL_AreTexturesResident(ctx->Exec, (n, texName, residences));
7236 }
7237
7238 static void GLAPIENTRY
7239 exec_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
7240 {
7241 GET_CURRENT_CONTEXT(ctx);
7242 FLUSH_VERTICES(ctx, 0);
7243 CALL_ColorPointer(ctx->Exec, (size, type, stride, ptr));
7244 }
7245
7246 static void GLAPIENTRY
7247 exec_DeleteTextures(GLsizei n, const GLuint * texName)
7248 {
7249 GET_CURRENT_CONTEXT(ctx);
7250 FLUSH_VERTICES(ctx, 0);
7251 CALL_DeleteTextures(ctx->Exec, (n, texName));
7252 }
7253
7254 static void GLAPIENTRY
7255 exec_DisableClientState(GLenum cap)
7256 {
7257 GET_CURRENT_CONTEXT(ctx);
7258 FLUSH_VERTICES(ctx, 0);
7259 CALL_DisableClientState(ctx->Exec, (cap));
7260 }
7261
7262 static void GLAPIENTRY
7263 exec_EdgeFlagPointer(GLsizei stride, const GLvoid * vptr)
7264 {
7265 GET_CURRENT_CONTEXT(ctx);
7266 FLUSH_VERTICES(ctx, 0);
7267 CALL_EdgeFlagPointer(ctx->Exec, (stride, vptr));
7268 }
7269
7270 static void GLAPIENTRY
7271 exec_EnableClientState(GLenum cap)
7272 {
7273 GET_CURRENT_CONTEXT(ctx);
7274 FLUSH_VERTICES(ctx, 0);
7275 CALL_EnableClientState(ctx->Exec, (cap));
7276 }
7277
7278 static void GLAPIENTRY
7279 exec_GenTextures(GLsizei n, GLuint * texName)
7280 {
7281 GET_CURRENT_CONTEXT(ctx);
7282 FLUSH_VERTICES(ctx, 0);
7283 CALL_GenTextures(ctx->Exec, (n, texName));
7284 }
7285
7286 static void GLAPIENTRY
7287 exec_GetPointerv(GLenum pname, GLvoid **params)
7288 {
7289 GET_CURRENT_CONTEXT(ctx);
7290 FLUSH_VERTICES(ctx, 0);
7291 CALL_GetPointerv(ctx->Exec, (pname, params));
7292 }
7293
7294 static void GLAPIENTRY
7295 exec_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
7296 {
7297 GET_CURRENT_CONTEXT(ctx);
7298 FLUSH_VERTICES(ctx, 0);
7299 CALL_IndexPointer(ctx->Exec, (type, stride, ptr));
7300 }
7301
7302 static void GLAPIENTRY
7303 exec_InterleavedArrays(GLenum format, GLsizei stride, const GLvoid * pointer)
7304 {
7305 GET_CURRENT_CONTEXT(ctx);
7306 FLUSH_VERTICES(ctx, 0);
7307 CALL_InterleavedArrays(ctx->Exec, (format, stride, pointer));
7308 }
7309
7310 static GLboolean GLAPIENTRY
7311 exec_IsTexture(GLuint texture)
7312 {
7313 GET_CURRENT_CONTEXT(ctx);
7314 FLUSH_VERTICES(ctx, 0);
7315 return CALL_IsTexture(ctx->Exec, (texture));
7316 }
7317
7318 static void GLAPIENTRY
7319 exec_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
7320 {
7321 GET_CURRENT_CONTEXT(ctx);
7322 FLUSH_VERTICES(ctx, 0);
7323 CALL_NormalPointer(ctx->Exec, (type, stride, ptr));
7324 }
7325
7326 static void GLAPIENTRY
7327 exec_PopClientAttrib(void)
7328 {
7329 GET_CURRENT_CONTEXT(ctx);
7330 FLUSH_VERTICES(ctx, 0);
7331 CALL_PopClientAttrib(ctx->Exec, ());
7332 }
7333
7334 static void GLAPIENTRY
7335 exec_PushClientAttrib(GLbitfield mask)
7336 {
7337 GET_CURRENT_CONTEXT(ctx);
7338 FLUSH_VERTICES(ctx, 0);
7339 CALL_PushClientAttrib(ctx->Exec, (mask));
7340 }
7341
7342 static void GLAPIENTRY
7343 exec_TexCoordPointer(GLint size, GLenum type, GLsizei stride,
7344 const GLvoid *ptr)
7345 {
7346 GET_CURRENT_CONTEXT(ctx);
7347 FLUSH_VERTICES(ctx, 0);
7348 CALL_TexCoordPointer(ctx->Exec, (size, type, stride, ptr));
7349 }
7350
7351 static void GLAPIENTRY
7352 exec_GetCompressedTexImageARB(GLenum target, GLint level, GLvoid * img)
7353 {
7354 GET_CURRENT_CONTEXT(ctx);
7355 FLUSH_VERTICES(ctx, 0);
7356 CALL_GetCompressedTexImageARB(ctx->Exec, (target, level, img));
7357 }
7358
7359 static void GLAPIENTRY
7360 exec_VertexPointer(GLint size, GLenum type, GLsizei stride,
7361 const GLvoid *ptr)
7362 {
7363 GET_CURRENT_CONTEXT(ctx);
7364 FLUSH_VERTICES(ctx, 0);
7365 CALL_VertexPointer(ctx->Exec, (size, type, stride, ptr));
7366 }
7367
7368 static void GLAPIENTRY
7369 exec_CopyConvolutionFilter1D(GLenum target, GLenum internalFormat,
7370 GLint x, GLint y, GLsizei width)
7371 {
7372 GET_CURRENT_CONTEXT(ctx);
7373 FLUSH_VERTICES(ctx, 0);
7374 CALL_CopyConvolutionFilter1D(ctx->Exec,
7375 (target, internalFormat, x, y, width));
7376 }
7377
7378 static void GLAPIENTRY
7379 exec_CopyConvolutionFilter2D(GLenum target, GLenum internalFormat,
7380 GLint x, GLint y, GLsizei width, GLsizei height)
7381 {
7382 GET_CURRENT_CONTEXT(ctx);
7383 FLUSH_VERTICES(ctx, 0);
7384 CALL_CopyConvolutionFilter2D(ctx->Exec,
7385 (target, internalFormat, x, y, width,
7386 height));
7387 }
7388
7389 static void GLAPIENTRY
7390 exec_GetColorTable(GLenum target, GLenum format, GLenum type, GLvoid * data)
7391 {
7392 GET_CURRENT_CONTEXT(ctx);
7393 FLUSH_VERTICES(ctx, 0);
7394 CALL_GetColorTable(ctx->Exec, (target, format, type, data));
7395 }
7396
7397 static void GLAPIENTRY
7398 exec_GetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
7399 {
7400 GET_CURRENT_CONTEXT(ctx);
7401 FLUSH_VERTICES(ctx, 0);
7402 CALL_GetColorTableParameterfv(ctx->Exec, (target, pname, params));
7403 }
7404
7405 static void GLAPIENTRY
7406 exec_GetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
7407 {
7408 GET_CURRENT_CONTEXT(ctx);
7409 FLUSH_VERTICES(ctx, 0);
7410 CALL_GetColorTableParameteriv(ctx->Exec, (target, pname, params));
7411 }
7412
7413 static void GLAPIENTRY
7414 exec_GetConvolutionFilter(GLenum target, GLenum format, GLenum type,
7415 GLvoid * image)
7416 {
7417 GET_CURRENT_CONTEXT(ctx);
7418 FLUSH_VERTICES(ctx, 0);
7419 CALL_GetConvolutionFilter(ctx->Exec, (target, format, type, image));
7420 }
7421
7422 static void GLAPIENTRY
7423 exec_GetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
7424 {
7425 GET_CURRENT_CONTEXT(ctx);
7426 FLUSH_VERTICES(ctx, 0);
7427 CALL_GetConvolutionParameterfv(ctx->Exec, (target, pname, params));
7428 }
7429
7430 static void GLAPIENTRY
7431 exec_GetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
7432 {
7433 GET_CURRENT_CONTEXT(ctx);
7434 FLUSH_VERTICES(ctx, 0);
7435 CALL_GetConvolutionParameteriv(ctx->Exec, (target, pname, params));
7436 }
7437
7438 static void GLAPIENTRY
7439 exec_GetHistogram(GLenum target, GLboolean reset, GLenum format,
7440 GLenum type, GLvoid *values)
7441 {
7442 GET_CURRENT_CONTEXT(ctx);
7443 FLUSH_VERTICES(ctx, 0);
7444 CALL_GetHistogram(ctx->Exec, (target, reset, format, type, values));
7445 }
7446
7447 static void GLAPIENTRY
7448 exec_GetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
7449 {
7450 GET_CURRENT_CONTEXT(ctx);
7451 FLUSH_VERTICES(ctx, 0);
7452 CALL_GetHistogramParameterfv(ctx->Exec, (target, pname, params));
7453 }
7454
7455 static void GLAPIENTRY
7456 exec_GetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
7457 {
7458 GET_CURRENT_CONTEXT(ctx);
7459 FLUSH_VERTICES(ctx, 0);
7460 CALL_GetHistogramParameteriv(ctx->Exec, (target, pname, params));
7461 }
7462
7463 static void GLAPIENTRY
7464 exec_GetMinmax(GLenum target, GLboolean reset, GLenum format,
7465 GLenum type, GLvoid *values)
7466 {
7467 GET_CURRENT_CONTEXT(ctx);
7468 FLUSH_VERTICES(ctx, 0);
7469 CALL_GetMinmax(ctx->Exec, (target, reset, format, type, values));
7470 }
7471
7472 static void GLAPIENTRY
7473 exec_GetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
7474 {
7475 GET_CURRENT_CONTEXT(ctx);
7476 FLUSH_VERTICES(ctx, 0);
7477 CALL_GetMinmaxParameterfv(ctx->Exec, (target, pname, params));
7478 }
7479
7480 static void GLAPIENTRY
7481 exec_GetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
7482 {
7483 GET_CURRENT_CONTEXT(ctx);
7484 FLUSH_VERTICES(ctx, 0);
7485 CALL_GetMinmaxParameteriv(ctx->Exec, (target, pname, params));
7486 }
7487
7488 static void GLAPIENTRY
7489 exec_GetSeparableFilter(GLenum target, GLenum format, GLenum type,
7490 GLvoid *row, GLvoid *column, GLvoid *span)
7491 {
7492 GET_CURRENT_CONTEXT(ctx);
7493 FLUSH_VERTICES(ctx, 0);
7494 CALL_GetSeparableFilter(ctx->Exec,
7495 (target, format, type, row, column, span));
7496 }
7497
7498 static void GLAPIENTRY
7499 exec_SeparableFilter2D(GLenum target, GLenum internalFormat,
7500 GLsizei width, GLsizei height, GLenum format,
7501 GLenum type, const GLvoid *row, const GLvoid *column)
7502 {
7503 GET_CURRENT_CONTEXT(ctx);
7504 FLUSH_VERTICES(ctx, 0);
7505 CALL_SeparableFilter2D(ctx->Exec,
7506 (target, internalFormat, width, height, format,
7507 type, row, column));
7508 }
7509
7510 static void GLAPIENTRY
7511 exec_ColorPointerEXT(GLint size, GLenum type, GLsizei stride,
7512 GLsizei count, const GLvoid *ptr)
7513 {
7514 GET_CURRENT_CONTEXT(ctx);
7515 FLUSH_VERTICES(ctx, 0);
7516 CALL_ColorPointerEXT(ctx->Exec, (size, type, stride, count, ptr));
7517 }
7518
7519 static void GLAPIENTRY
7520 exec_EdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *ptr)
7521 {
7522 GET_CURRENT_CONTEXT(ctx);
7523 FLUSH_VERTICES(ctx, 0);
7524 CALL_EdgeFlagPointerEXT(ctx->Exec, (stride, count, ptr));
7525 }
7526
7527 static void GLAPIENTRY
7528 exec_IndexPointerEXT(GLenum type, GLsizei stride, GLsizei count,
7529 const GLvoid *ptr)
7530 {
7531 GET_CURRENT_CONTEXT(ctx);
7532 FLUSH_VERTICES(ctx, 0);
7533 CALL_IndexPointerEXT(ctx->Exec, (type, stride, count, ptr));
7534 }
7535
7536 static void GLAPIENTRY
7537 exec_NormalPointerEXT(GLenum type, GLsizei stride, GLsizei count,
7538 const GLvoid *ptr)
7539 {
7540 GET_CURRENT_CONTEXT(ctx);
7541 FLUSH_VERTICES(ctx, 0);
7542 CALL_NormalPointerEXT(ctx->Exec, (type, stride, count, ptr));
7543 }
7544
7545 static void GLAPIENTRY
7546 exec_TexCoordPointerEXT(GLint size, GLenum type, GLsizei stride,
7547 GLsizei count, const GLvoid *ptr)
7548 {
7549 GET_CURRENT_CONTEXT(ctx);
7550 FLUSH_VERTICES(ctx, 0);
7551 CALL_TexCoordPointerEXT(ctx->Exec, (size, type, stride, count, ptr));
7552 }
7553
7554 static void GLAPIENTRY
7555 exec_VertexPointerEXT(GLint size, GLenum type, GLsizei stride,
7556 GLsizei count, const GLvoid *ptr)
7557 {
7558 GET_CURRENT_CONTEXT(ctx);
7559 FLUSH_VERTICES(ctx, 0);
7560 CALL_VertexPointerEXT(ctx->Exec, (size, type, stride, count, ptr));
7561 }
7562
7563 static void GLAPIENTRY
7564 exec_LockArraysEXT(GLint first, GLsizei count)
7565 {
7566 GET_CURRENT_CONTEXT(ctx);
7567 FLUSH_VERTICES(ctx, 0);
7568 CALL_LockArraysEXT(ctx->Exec, (first, count));
7569 }
7570
7571 static void GLAPIENTRY
7572 exec_UnlockArraysEXT(void)
7573 {
7574 GET_CURRENT_CONTEXT(ctx);
7575 FLUSH_VERTICES(ctx, 0);
7576 CALL_UnlockArraysEXT(ctx->Exec, ());
7577 }
7578
7579 static void GLAPIENTRY
7580 exec_ClientActiveTextureARB(GLenum target)
7581 {
7582 GET_CURRENT_CONTEXT(ctx);
7583 FLUSH_VERTICES(ctx, 0);
7584 CALL_ClientActiveTextureARB(ctx->Exec, (target));
7585 }
7586
7587 static void GLAPIENTRY
7588 exec_SecondaryColorPointerEXT(GLint size, GLenum type,
7589 GLsizei stride, const GLvoid *ptr)
7590 {
7591 GET_CURRENT_CONTEXT(ctx);
7592 FLUSH_VERTICES(ctx, 0);
7593 CALL_SecondaryColorPointerEXT(ctx->Exec, (size, type, stride, ptr));
7594 }
7595
7596 static void GLAPIENTRY
7597 exec_FogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid *ptr)
7598 {
7599 GET_CURRENT_CONTEXT(ctx);
7600 FLUSH_VERTICES(ctx, 0);
7601 CALL_FogCoordPointerEXT(ctx->Exec, (type, stride, ptr));
7602 }
7603
7604 /* GL_EXT_multi_draw_arrays */
7605 static void GLAPIENTRY
7606 exec_MultiDrawArraysEXT(GLenum mode, GLint * first,
7607 GLsizei * count, GLsizei primcount)
7608 {
7609 GET_CURRENT_CONTEXT(ctx);
7610 FLUSH_VERTICES(ctx, 0);
7611 CALL_MultiDrawArraysEXT(ctx->Exec, (mode, first, count, primcount));
7612 }
7613
7614 /* GL_EXT_multi_draw_arrays */
7615 static void GLAPIENTRY
7616 exec_MultiDrawElementsEXT(GLenum mode, const GLsizei * count,
7617 GLenum type, const GLvoid ** indices,
7618 GLsizei primcount)
7619 {
7620 GET_CURRENT_CONTEXT(ctx);
7621 FLUSH_VERTICES(ctx, 0);
7622 CALL_MultiDrawElementsEXT(ctx->Exec,
7623 (mode, count, type, indices, primcount));
7624 }
7625
7626 /* GL_IBM_multimode_draw_arrays */
7627 static void GLAPIENTRY
7628 exec_MultiModeDrawArraysIBM(const GLenum * mode, const GLint * first,
7629 const GLsizei * count, GLsizei primcount,
7630 GLint modestride)
7631 {
7632 GET_CURRENT_CONTEXT(ctx);
7633 FLUSH_VERTICES(ctx, 0);
7634 CALL_MultiModeDrawArraysIBM(ctx->Exec,
7635 (mode, first, count, primcount, modestride));
7636 }
7637
7638 /* GL_IBM_multimode_draw_arrays */
7639 static void GLAPIENTRY
7640 exec_MultiModeDrawElementsIBM(const GLenum * mode,
7641 const GLsizei * count,
7642 GLenum type,
7643 const GLvoid * const *indices,
7644 GLsizei primcount, GLint modestride)
7645 {
7646 GET_CURRENT_CONTEXT(ctx);
7647 FLUSH_VERTICES(ctx, 0);
7648 CALL_MultiModeDrawElementsIBM(ctx->Exec,
7649 (mode, count, type, indices, primcount,
7650 modestride));
7651 }
7652
7653
7654
7655 /**
7656 * Setup the given dispatch table to point to Mesa's display list
7657 * building functions.
7658 *
7659 * This does not include any of the tnl functions - they are
7660 * initialized from _mesa_init_api_defaults and from the active vtxfmt
7661 * struct.
7662 */
7663 void
7664 _mesa_init_dlist_table(struct _glapi_table *table)
7665 {
7666 _mesa_loopback_init_api_table(table);
7667
7668 /* GL 1.0 */
7669 SET_Accum(table, save_Accum);
7670 SET_AlphaFunc(table, save_AlphaFunc);
7671 SET_Bitmap(table, save_Bitmap);
7672 SET_BlendFunc(table, save_BlendFunc);
7673 SET_CallList(table, _mesa_save_CallList);
7674 SET_CallLists(table, _mesa_save_CallLists);
7675 SET_Clear(table, save_Clear);
7676 SET_ClearAccum(table, save_ClearAccum);
7677 SET_ClearColor(table, save_ClearColor);
7678 SET_ClearDepth(table, save_ClearDepth);
7679 SET_ClearIndex(table, save_ClearIndex);
7680 SET_ClearStencil(table, save_ClearStencil);
7681 SET_ClipPlane(table, save_ClipPlane);
7682 SET_ColorMask(table, save_ColorMask);
7683 SET_ColorMaterial(table, save_ColorMaterial);
7684 SET_CopyPixels(table, save_CopyPixels);
7685 SET_CullFace(table, save_CullFace);
7686 SET_DeleteLists(table, _mesa_DeleteLists);
7687 SET_DepthFunc(table, save_DepthFunc);
7688 SET_DepthMask(table, save_DepthMask);
7689 SET_DepthRange(table, save_DepthRange);
7690 SET_Disable(table, save_Disable);
7691 SET_DrawBuffer(table, save_DrawBuffer);
7692 SET_DrawPixels(table, save_DrawPixels);
7693 SET_Enable(table, save_Enable);
7694 SET_EndList(table, _mesa_EndList);
7695 SET_EvalMesh1(table, _mesa_save_EvalMesh1);
7696 SET_EvalMesh2(table, _mesa_save_EvalMesh2);
7697 SET_Finish(table, exec_Finish);
7698 SET_Flush(table, exec_Flush);
7699 SET_Fogf(table, save_Fogf);
7700 SET_Fogfv(table, save_Fogfv);
7701 SET_Fogi(table, save_Fogi);
7702 SET_Fogiv(table, save_Fogiv);
7703 SET_FrontFace(table, save_FrontFace);
7704 SET_Frustum(table, save_Frustum);
7705 SET_GenLists(table, _mesa_GenLists);
7706 SET_GetBooleanv(table, exec_GetBooleanv);
7707 SET_GetClipPlane(table, exec_GetClipPlane);
7708 SET_GetDoublev(table, exec_GetDoublev);
7709 SET_GetError(table, exec_GetError);
7710 SET_GetFloatv(table, exec_GetFloatv);
7711 SET_GetIntegerv(table, exec_GetIntegerv);
7712 SET_GetLightfv(table, exec_GetLightfv);
7713 SET_GetLightiv(table, exec_GetLightiv);
7714 SET_GetMapdv(table, exec_GetMapdv);
7715 SET_GetMapfv(table, exec_GetMapfv);
7716 SET_GetMapiv(table, exec_GetMapiv);
7717 SET_GetMaterialfv(table, exec_GetMaterialfv);
7718 SET_GetMaterialiv(table, exec_GetMaterialiv);
7719 SET_GetPixelMapfv(table, exec_GetPixelMapfv);
7720 SET_GetPixelMapuiv(table, exec_GetPixelMapuiv);
7721 SET_GetPixelMapusv(table, exec_GetPixelMapusv);
7722 SET_GetPolygonStipple(table, exec_GetPolygonStipple);
7723 SET_GetString(table, exec_GetString);
7724 SET_GetTexEnvfv(table, exec_GetTexEnvfv);
7725 SET_GetTexEnviv(table, exec_GetTexEnviv);
7726 SET_GetTexGendv(table, exec_GetTexGendv);
7727 SET_GetTexGenfv(table, exec_GetTexGenfv);
7728 SET_GetTexGeniv(table, exec_GetTexGeniv);
7729 SET_GetTexImage(table, exec_GetTexImage);
7730 SET_GetTexLevelParameterfv(table, exec_GetTexLevelParameterfv);
7731 SET_GetTexLevelParameteriv(table, exec_GetTexLevelParameteriv);
7732 SET_GetTexParameterfv(table, exec_GetTexParameterfv);
7733 SET_GetTexParameteriv(table, exec_GetTexParameteriv);
7734 SET_Hint(table, save_Hint);
7735 SET_IndexMask(table, save_IndexMask);
7736 SET_InitNames(table, save_InitNames);
7737 SET_IsEnabled(table, exec_IsEnabled);
7738 SET_IsList(table, _mesa_IsList);
7739 SET_LightModelf(table, save_LightModelf);
7740 SET_LightModelfv(table, save_LightModelfv);
7741 SET_LightModeli(table, save_LightModeli);
7742 SET_LightModeliv(table, save_LightModeliv);
7743 SET_Lightf(table, save_Lightf);
7744 SET_Lightfv(table, save_Lightfv);
7745 SET_Lighti(table, save_Lighti);
7746 SET_Lightiv(table, save_Lightiv);
7747 SET_LineStipple(table, save_LineStipple);
7748 SET_LineWidth(table, save_LineWidth);
7749 SET_ListBase(table, save_ListBase);
7750 SET_LoadIdentity(table, save_LoadIdentity);
7751 SET_LoadMatrixd(table, save_LoadMatrixd);
7752 SET_LoadMatrixf(table, save_LoadMatrixf);
7753 SET_LoadName(table, save_LoadName);
7754 SET_LogicOp(table, save_LogicOp);
7755 SET_Map1d(table, save_Map1d);
7756 SET_Map1f(table, save_Map1f);
7757 SET_Map2d(table, save_Map2d);
7758 SET_Map2f(table, save_Map2f);
7759 SET_MapGrid1d(table, save_MapGrid1d);
7760 SET_MapGrid1f(table, save_MapGrid1f);
7761 SET_MapGrid2d(table, save_MapGrid2d);
7762 SET_MapGrid2f(table, save_MapGrid2f);
7763 SET_MatrixMode(table, save_MatrixMode);
7764 SET_MultMatrixd(table, save_MultMatrixd);
7765 SET_MultMatrixf(table, save_MultMatrixf);
7766 SET_NewList(table, save_NewList);
7767 SET_Ortho(table, save_Ortho);
7768 SET_PassThrough(table, save_PassThrough);
7769 SET_PixelMapfv(table, save_PixelMapfv);
7770 SET_PixelMapuiv(table, save_PixelMapuiv);
7771 SET_PixelMapusv(table, save_PixelMapusv);
7772 SET_PixelStoref(table, exec_PixelStoref);
7773 SET_PixelStorei(table, exec_PixelStorei);
7774 SET_PixelTransferf(table, save_PixelTransferf);
7775 SET_PixelTransferi(table, save_PixelTransferi);
7776 SET_PixelZoom(table, save_PixelZoom);
7777 SET_PointSize(table, save_PointSize);
7778 SET_PolygonMode(table, save_PolygonMode);
7779 SET_PolygonOffset(table, save_PolygonOffset);
7780 SET_PolygonStipple(table, save_PolygonStipple);
7781 SET_PopAttrib(table, save_PopAttrib);
7782 SET_PopMatrix(table, save_PopMatrix);
7783 SET_PopName(table, save_PopName);
7784 SET_PushAttrib(table, save_PushAttrib);
7785 SET_PushMatrix(table, save_PushMatrix);
7786 SET_PushName(table, save_PushName);
7787 SET_RasterPos2d(table, save_RasterPos2d);
7788 SET_RasterPos2dv(table, save_RasterPos2dv);
7789 SET_RasterPos2f(table, save_RasterPos2f);
7790 SET_RasterPos2fv(table, save_RasterPos2fv);
7791 SET_RasterPos2i(table, save_RasterPos2i);
7792 SET_RasterPos2iv(table, save_RasterPos2iv);
7793 SET_RasterPos2s(table, save_RasterPos2s);
7794 SET_RasterPos2sv(table, save_RasterPos2sv);
7795 SET_RasterPos3d(table, save_RasterPos3d);
7796 SET_RasterPos3dv(table, save_RasterPos3dv);
7797 SET_RasterPos3f(table, save_RasterPos3f);
7798 SET_RasterPos3fv(table, save_RasterPos3fv);
7799 SET_RasterPos3i(table, save_RasterPos3i);
7800 SET_RasterPos3iv(table, save_RasterPos3iv);
7801 SET_RasterPos3s(table, save_RasterPos3s);
7802 SET_RasterPos3sv(table, save_RasterPos3sv);
7803 SET_RasterPos4d(table, save_RasterPos4d);
7804 SET_RasterPos4dv(table, save_RasterPos4dv);
7805 SET_RasterPos4f(table, save_RasterPos4f);
7806 SET_RasterPos4fv(table, save_RasterPos4fv);
7807 SET_RasterPos4i(table, save_RasterPos4i);
7808 SET_RasterPos4iv(table, save_RasterPos4iv);
7809 SET_RasterPos4s(table, save_RasterPos4s);
7810 SET_RasterPos4sv(table, save_RasterPos4sv);
7811 SET_ReadBuffer(table, save_ReadBuffer);
7812 SET_ReadPixels(table, exec_ReadPixels);
7813 SET_RenderMode(table, exec_RenderMode);
7814 SET_Rotated(table, save_Rotated);
7815 SET_Rotatef(table, save_Rotatef);
7816 SET_Scaled(table, save_Scaled);
7817 SET_Scalef(table, save_Scalef);
7818 SET_Scissor(table, save_Scissor);
7819 SET_FeedbackBuffer(table, exec_FeedbackBuffer);
7820 SET_SelectBuffer(table, exec_SelectBuffer);
7821 SET_ShadeModel(table, save_ShadeModel);
7822 SET_StencilFunc(table, save_StencilFunc);
7823 SET_StencilMask(table, save_StencilMask);
7824 SET_StencilOp(table, save_StencilOp);
7825 SET_TexEnvf(table, save_TexEnvf);
7826 SET_TexEnvfv(table, save_TexEnvfv);
7827 SET_TexEnvi(table, save_TexEnvi);
7828 SET_TexEnviv(table, save_TexEnviv);
7829 SET_TexGend(table, save_TexGend);
7830 SET_TexGendv(table, save_TexGendv);
7831 SET_TexGenf(table, save_TexGenf);
7832 SET_TexGenfv(table, save_TexGenfv);
7833 SET_TexGeni(table, save_TexGeni);
7834 SET_TexGeniv(table, save_TexGeniv);
7835 SET_TexImage1D(table, save_TexImage1D);
7836 SET_TexImage2D(table, save_TexImage2D);
7837 SET_TexParameterf(table, save_TexParameterf);
7838 SET_TexParameterfv(table, save_TexParameterfv);
7839 SET_TexParameteri(table, save_TexParameteri);
7840 SET_TexParameteriv(table, save_TexParameteriv);
7841 SET_Translated(table, save_Translated);
7842 SET_Translatef(table, save_Translatef);
7843 SET_Viewport(table, save_Viewport);
7844
7845 /* GL 1.1 */
7846 SET_AreTexturesResident(table, exec_AreTexturesResident);
7847 SET_BindTexture(table, save_BindTexture);
7848 SET_ColorPointer(table, exec_ColorPointer);
7849 SET_CopyTexImage1D(table, save_CopyTexImage1D);
7850 SET_CopyTexImage2D(table, save_CopyTexImage2D);
7851 SET_CopyTexSubImage1D(table, save_CopyTexSubImage1D);
7852 SET_CopyTexSubImage2D(table, save_CopyTexSubImage2D);
7853 SET_DeleteTextures(table, exec_DeleteTextures);
7854 SET_DisableClientState(table, exec_DisableClientState);
7855 SET_EdgeFlagPointer(table, exec_EdgeFlagPointer);
7856 SET_EnableClientState(table, exec_EnableClientState);
7857 SET_GenTextures(table, exec_GenTextures);
7858 SET_GetPointerv(table, exec_GetPointerv);
7859 SET_IndexPointer(table, exec_IndexPointer);
7860 SET_InterleavedArrays(table, exec_InterleavedArrays);
7861 SET_IsTexture(table, exec_IsTexture);
7862 SET_NormalPointer(table, exec_NormalPointer);
7863 SET_PopClientAttrib(table, exec_PopClientAttrib);
7864 SET_PrioritizeTextures(table, save_PrioritizeTextures);
7865 SET_PushClientAttrib(table, exec_PushClientAttrib);
7866 SET_TexCoordPointer(table, exec_TexCoordPointer);
7867 SET_TexSubImage1D(table, save_TexSubImage1D);
7868 SET_TexSubImage2D(table, save_TexSubImage2D);
7869 SET_VertexPointer(table, exec_VertexPointer);
7870
7871 /* GL 1.2 */
7872 SET_CopyTexSubImage3D(table, save_CopyTexSubImage3D);
7873 SET_TexImage3D(table, save_TexImage3D);
7874 SET_TexSubImage3D(table, save_TexSubImage3D);
7875
7876 /* GL 2.0 */
7877 SET_StencilFuncSeparate(table, save_StencilFuncSeparate);
7878 SET_StencilMaskSeparate(table, save_StencilMaskSeparate);
7879 SET_StencilOpSeparate(table, save_StencilOpSeparate);
7880
7881 /* ATI_separate_stencil */
7882 SET_StencilFuncSeparateATI(table, save_StencilFuncSeparateATI);
7883
7884 /* GL_ARB_imaging */
7885 /* Not all are supported */
7886 SET_BlendColor(table, save_BlendColor);
7887 SET_BlendEquation(table, save_BlendEquation);
7888 SET_ColorSubTable(table, save_ColorSubTable);
7889 SET_ColorTable(table, save_ColorTable);
7890 SET_ColorTableParameterfv(table, save_ColorTableParameterfv);
7891 SET_ColorTableParameteriv(table, save_ColorTableParameteriv);
7892 SET_ConvolutionFilter1D(table, save_ConvolutionFilter1D);
7893 SET_ConvolutionFilter2D(table, save_ConvolutionFilter2D);
7894 SET_ConvolutionParameterf(table, save_ConvolutionParameterf);
7895 SET_ConvolutionParameterfv(table, save_ConvolutionParameterfv);
7896 SET_ConvolutionParameteri(table, save_ConvolutionParameteri);
7897 SET_ConvolutionParameteriv(table, save_ConvolutionParameteriv);
7898 SET_CopyColorSubTable(table, save_CopyColorSubTable);
7899 SET_CopyColorTable(table, save_CopyColorTable);
7900 SET_CopyConvolutionFilter1D(table, exec_CopyConvolutionFilter1D);
7901 SET_CopyConvolutionFilter2D(table, exec_CopyConvolutionFilter2D);
7902 SET_GetColorTable(table, exec_GetColorTable);
7903 SET_GetColorTableParameterfv(table, exec_GetColorTableParameterfv);
7904 SET_GetColorTableParameteriv(table, exec_GetColorTableParameteriv);
7905 SET_GetConvolutionFilter(table, exec_GetConvolutionFilter);
7906 SET_GetConvolutionParameterfv(table, exec_GetConvolutionParameterfv);
7907 SET_GetConvolutionParameteriv(table, exec_GetConvolutionParameteriv);
7908 SET_GetHistogram(table, exec_GetHistogram);
7909 SET_GetHistogramParameterfv(table, exec_GetHistogramParameterfv);
7910 SET_GetHistogramParameteriv(table, exec_GetHistogramParameteriv);
7911 SET_GetMinmax(table, exec_GetMinmax);
7912 SET_GetMinmaxParameterfv(table, exec_GetMinmaxParameterfv);
7913 SET_GetMinmaxParameteriv(table, exec_GetMinmaxParameteriv);
7914 SET_GetSeparableFilter(table, exec_GetSeparableFilter);
7915 SET_Histogram(table, save_Histogram);
7916 SET_Minmax(table, save_Minmax);
7917 SET_ResetHistogram(table, save_ResetHistogram);
7918 SET_ResetMinmax(table, save_ResetMinmax);
7919 SET_SeparableFilter2D(table, exec_SeparableFilter2D);
7920
7921 /* 2. GL_EXT_blend_color */
7922 #if 0
7923 SET_BlendColorEXT(table, save_BlendColorEXT);
7924 #endif
7925
7926 /* 3. GL_EXT_polygon_offset */
7927 SET_PolygonOffsetEXT(table, save_PolygonOffsetEXT);
7928
7929 /* 6. GL_EXT_texture3d */
7930 #if 0
7931 SET_CopyTexSubImage3DEXT(table, save_CopyTexSubImage3D);
7932 SET_TexImage3DEXT(table, save_TexImage3DEXT);
7933 SET_TexSubImage3DEXT(table, save_TexSubImage3D);
7934 #endif
7935
7936 /* 14. GL_SGI_color_table */
7937 #if 0
7938 SET_ColorTableSGI(table, save_ColorTable);
7939 SET_ColorSubTableSGI(table, save_ColorSubTable);
7940 SET_GetColorTableSGI(table, exec_GetColorTable);
7941 SET_GetColorTableParameterfvSGI(table, exec_GetColorTableParameterfv);
7942 SET_GetColorTableParameterivSGI(table, exec_GetColorTableParameteriv);
7943 #endif
7944
7945 /* 30. GL_EXT_vertex_array */
7946 SET_ColorPointerEXT(table, exec_ColorPointerEXT);
7947 SET_EdgeFlagPointerEXT(table, exec_EdgeFlagPointerEXT);
7948 SET_IndexPointerEXT(table, exec_IndexPointerEXT);
7949 SET_NormalPointerEXT(table, exec_NormalPointerEXT);
7950 SET_TexCoordPointerEXT(table, exec_TexCoordPointerEXT);
7951 SET_VertexPointerEXT(table, exec_VertexPointerEXT);
7952
7953 /* 37. GL_EXT_blend_minmax */
7954 #if 0
7955 SET_BlendEquationEXT(table, save_BlendEquationEXT);
7956 #endif
7957
7958 /* 54. GL_EXT_point_parameters */
7959 SET_PointParameterfEXT(table, save_PointParameterfEXT);
7960 SET_PointParameterfvEXT(table, save_PointParameterfvEXT);
7961
7962 /* 97. GL_EXT_compiled_vertex_array */
7963 SET_LockArraysEXT(table, exec_LockArraysEXT);
7964 SET_UnlockArraysEXT(table, exec_UnlockArraysEXT);
7965
7966 /* 145. GL_EXT_secondary_color */
7967 SET_SecondaryColorPointerEXT(table, exec_SecondaryColorPointerEXT);
7968
7969 /* 148. GL_EXT_multi_draw_arrays */
7970 SET_MultiDrawArraysEXT(table, exec_MultiDrawArraysEXT);
7971 SET_MultiDrawElementsEXT(table, exec_MultiDrawElementsEXT);
7972
7973 /* 149. GL_EXT_fog_coord */
7974 SET_FogCoordPointerEXT(table, exec_FogCoordPointerEXT);
7975
7976 /* 173. GL_EXT_blend_func_separate */
7977 SET_BlendFuncSeparateEXT(table, save_BlendFuncSeparateEXT);
7978
7979 /* 196. GL_MESA_resize_buffers */
7980 SET_ResizeBuffersMESA(table, _mesa_ResizeBuffersMESA);
7981
7982 /* 197. GL_MESA_window_pos */
7983 SET_WindowPos2dMESA(table, save_WindowPos2dMESA);
7984 SET_WindowPos2dvMESA(table, save_WindowPos2dvMESA);
7985 SET_WindowPos2fMESA(table, save_WindowPos2fMESA);
7986 SET_WindowPos2fvMESA(table, save_WindowPos2fvMESA);
7987 SET_WindowPos2iMESA(table, save_WindowPos2iMESA);
7988 SET_WindowPos2ivMESA(table, save_WindowPos2ivMESA);
7989 SET_WindowPos2sMESA(table, save_WindowPos2sMESA);
7990 SET_WindowPos2svMESA(table, save_WindowPos2svMESA);
7991 SET_WindowPos3dMESA(table, save_WindowPos3dMESA);
7992 SET_WindowPos3dvMESA(table, save_WindowPos3dvMESA);
7993 SET_WindowPos3fMESA(table, save_WindowPos3fMESA);
7994 SET_WindowPos3fvMESA(table, save_WindowPos3fvMESA);
7995 SET_WindowPos3iMESA(table, save_WindowPos3iMESA);
7996 SET_WindowPos3ivMESA(table, save_WindowPos3ivMESA);
7997 SET_WindowPos3sMESA(table, save_WindowPos3sMESA);
7998 SET_WindowPos3svMESA(table, save_WindowPos3svMESA);
7999 SET_WindowPos4dMESA(table, save_WindowPos4dMESA);
8000 SET_WindowPos4dvMESA(table, save_WindowPos4dvMESA);
8001 SET_WindowPos4fMESA(table, save_WindowPos4fMESA);
8002 SET_WindowPos4fvMESA(table, save_WindowPos4fvMESA);
8003 SET_WindowPos4iMESA(table, save_WindowPos4iMESA);
8004 SET_WindowPos4ivMESA(table, save_WindowPos4ivMESA);
8005 SET_WindowPos4sMESA(table, save_WindowPos4sMESA);
8006 SET_WindowPos4svMESA(table, save_WindowPos4svMESA);
8007
8008 /* 200. GL_IBM_multimode_draw_arrays */
8009 SET_MultiModeDrawArraysIBM(table, exec_MultiModeDrawArraysIBM);
8010 SET_MultiModeDrawElementsIBM(table, exec_MultiModeDrawElementsIBM);
8011
8012 #if FEATURE_NV_vertex_program
8013 /* 233. GL_NV_vertex_program */
8014 /* The following commands DO NOT go into display lists:
8015 * AreProgramsResidentNV, IsProgramNV, GenProgramsNV, DeleteProgramsNV,
8016 * VertexAttribPointerNV, GetProgram*, GetVertexAttrib*
8017 */
8018 SET_BindProgramNV(table, save_BindProgramNV);
8019 SET_DeleteProgramsNV(table, _mesa_DeletePrograms);
8020 SET_ExecuteProgramNV(table, save_ExecuteProgramNV);
8021 SET_GenProgramsNV(table, _mesa_GenPrograms);
8022 SET_AreProgramsResidentNV(table, _mesa_AreProgramsResidentNV);
8023 SET_RequestResidentProgramsNV(table, save_RequestResidentProgramsNV);
8024 SET_GetProgramParameterfvNV(table, _mesa_GetProgramParameterfvNV);
8025 SET_GetProgramParameterdvNV(table, _mesa_GetProgramParameterdvNV);
8026 SET_GetProgramivNV(table, _mesa_GetProgramivNV);
8027 SET_GetProgramStringNV(table, _mesa_GetProgramStringNV);
8028 SET_GetTrackMatrixivNV(table, _mesa_GetTrackMatrixivNV);
8029 SET_GetVertexAttribdvNV(table, _mesa_GetVertexAttribdvNV);
8030 SET_GetVertexAttribfvNV(table, _mesa_GetVertexAttribfvNV);
8031 SET_GetVertexAttribivNV(table, _mesa_GetVertexAttribivNV);
8032 SET_GetVertexAttribPointervNV(table, _mesa_GetVertexAttribPointervNV);
8033 SET_IsProgramNV(table, _mesa_IsProgramARB);
8034 SET_LoadProgramNV(table, save_LoadProgramNV);
8035 SET_ProgramEnvParameter4dARB(table, save_ProgramEnvParameter4dARB);
8036 SET_ProgramEnvParameter4dvARB(table, save_ProgramEnvParameter4dvARB);
8037 SET_ProgramEnvParameter4fARB(table, save_ProgramEnvParameter4fARB);
8038 SET_ProgramEnvParameter4fvARB(table, save_ProgramEnvParameter4fvARB);
8039 SET_ProgramParameters4dvNV(table, save_ProgramParameters4dvNV);
8040 SET_ProgramParameters4fvNV(table, save_ProgramParameters4fvNV);
8041 SET_TrackMatrixNV(table, save_TrackMatrixNV);
8042 SET_VertexAttribPointerNV(table, _mesa_VertexAttribPointerNV);
8043 #endif
8044
8045 /* 245. GL_ATI_fragment_shader */
8046 #if FEATURE_ATI_fragment_shader
8047 SET_BindFragmentShaderATI(table, save_BindFragmentShaderATI);
8048 SET_SetFragmentShaderConstantATI(table, save_SetFragmentShaderConstantATI);
8049 #endif
8050
8051 /* 282. GL_NV_fragment_program */
8052 #if FEATURE_NV_fragment_program
8053 SET_ProgramNamedParameter4fNV(table, save_ProgramNamedParameter4fNV);
8054 SET_ProgramNamedParameter4dNV(table, save_ProgramNamedParameter4dNV);
8055 SET_ProgramNamedParameter4fvNV(table, save_ProgramNamedParameter4fvNV);
8056 SET_ProgramNamedParameter4dvNV(table, save_ProgramNamedParameter4dvNV);
8057 SET_GetProgramNamedParameterfvNV(table,
8058 _mesa_GetProgramNamedParameterfvNV);
8059 SET_GetProgramNamedParameterdvNV(table,
8060 _mesa_GetProgramNamedParameterdvNV);
8061 SET_ProgramLocalParameter4dARB(table, save_ProgramLocalParameter4dARB);
8062 SET_ProgramLocalParameter4dvARB(table, save_ProgramLocalParameter4dvARB);
8063 SET_ProgramLocalParameter4fARB(table, save_ProgramLocalParameter4fARB);
8064 SET_ProgramLocalParameter4fvARB(table, save_ProgramLocalParameter4fvARB);
8065 SET_GetProgramLocalParameterdvARB(table,
8066 _mesa_GetProgramLocalParameterdvARB);
8067 SET_GetProgramLocalParameterfvARB(table,
8068 _mesa_GetProgramLocalParameterfvARB);
8069 #endif
8070
8071 /* 262. GL_NV_point_sprite */
8072 SET_PointParameteriNV(table, save_PointParameteriNV);
8073 SET_PointParameterivNV(table, save_PointParameterivNV);
8074
8075 /* 268. GL_EXT_stencil_two_side */
8076 SET_ActiveStencilFaceEXT(table, save_ActiveStencilFaceEXT);
8077
8078 /* 273. GL_APPLE_vertex_array_object */
8079 SET_BindVertexArrayAPPLE(table, _mesa_BindVertexArrayAPPLE);
8080 SET_DeleteVertexArraysAPPLE(table, _mesa_DeleteVertexArraysAPPLE);
8081 SET_GenVertexArraysAPPLE(table, _mesa_GenVertexArraysAPPLE);
8082 SET_IsVertexArrayAPPLE(table, _mesa_IsVertexArrayAPPLE);
8083
8084 /* ???. GL_EXT_depth_bounds_test */
8085 SET_DepthBoundsEXT(table, save_DepthBoundsEXT);
8086
8087 /* ARB 1. GL_ARB_multitexture */
8088 SET_ActiveTextureARB(table, save_ActiveTextureARB);
8089 SET_ClientActiveTextureARB(table, exec_ClientActiveTextureARB);
8090
8091 /* ARB 3. GL_ARB_transpose_matrix */
8092 SET_LoadTransposeMatrixdARB(table, save_LoadTransposeMatrixdARB);
8093 SET_LoadTransposeMatrixfARB(table, save_LoadTransposeMatrixfARB);
8094 SET_MultTransposeMatrixdARB(table, save_MultTransposeMatrixdARB);
8095 SET_MultTransposeMatrixfARB(table, save_MultTransposeMatrixfARB);
8096
8097 /* ARB 5. GL_ARB_multisample */
8098 SET_SampleCoverageARB(table, save_SampleCoverageARB);
8099
8100 /* ARB 12. GL_ARB_texture_compression */
8101 SET_CompressedTexImage3DARB(table, save_CompressedTexImage3DARB);
8102 SET_CompressedTexImage2DARB(table, save_CompressedTexImage2DARB);
8103 SET_CompressedTexImage1DARB(table, save_CompressedTexImage1DARB);
8104 SET_CompressedTexSubImage3DARB(table, save_CompressedTexSubImage3DARB);
8105 SET_CompressedTexSubImage2DARB(table, save_CompressedTexSubImage2DARB);
8106 SET_CompressedTexSubImage1DARB(table, save_CompressedTexSubImage1DARB);
8107 SET_GetCompressedTexImageARB(table, exec_GetCompressedTexImageARB);
8108
8109 /* ARB 14. GL_ARB_point_parameters */
8110 /* aliased with EXT_point_parameters functions */
8111
8112 /* ARB 25. GL_ARB_window_pos */
8113 /* aliased with MESA_window_pos functions */
8114
8115 /* ARB 26. GL_ARB_vertex_program */
8116 /* ARB 27. GL_ARB_fragment_program */
8117 #if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
8118 /* glVertexAttrib* functions alias the NV ones, handled elsewhere */
8119 SET_VertexAttribPointerARB(table, _mesa_VertexAttribPointerARB);
8120 SET_EnableVertexAttribArrayARB(table, _mesa_EnableVertexAttribArrayARB);
8121 SET_DisableVertexAttribArrayARB(table, _mesa_DisableVertexAttribArrayARB);
8122 SET_ProgramStringARB(table, save_ProgramStringARB);
8123 SET_BindProgramNV(table, save_BindProgramNV);
8124 SET_DeleteProgramsNV(table, _mesa_DeletePrograms);
8125 SET_GenProgramsNV(table, _mesa_GenPrograms);
8126 SET_IsProgramNV(table, _mesa_IsProgramARB);
8127 SET_GetVertexAttribdvNV(table, _mesa_GetVertexAttribdvNV);
8128 SET_GetVertexAttribfvNV(table, _mesa_GetVertexAttribfvNV);
8129 SET_GetVertexAttribivNV(table, _mesa_GetVertexAttribivNV);
8130 SET_GetVertexAttribPointervNV(table, _mesa_GetVertexAttribPointervNV);
8131 SET_ProgramEnvParameter4dARB(table, save_ProgramEnvParameter4dARB);
8132 SET_ProgramEnvParameter4dvARB(table, save_ProgramEnvParameter4dvARB);
8133 SET_ProgramEnvParameter4fARB(table, save_ProgramEnvParameter4fARB);
8134 SET_ProgramEnvParameter4fvARB(table, save_ProgramEnvParameter4fvARB);
8135 SET_ProgramLocalParameter4dARB(table, save_ProgramLocalParameter4dARB);
8136 SET_ProgramLocalParameter4dvARB(table, save_ProgramLocalParameter4dvARB);
8137 SET_ProgramLocalParameter4fARB(table, save_ProgramLocalParameter4fARB);
8138 SET_ProgramLocalParameter4fvARB(table, save_ProgramLocalParameter4fvARB);
8139 SET_GetProgramEnvParameterdvARB(table, _mesa_GetProgramEnvParameterdvARB);
8140 SET_GetProgramEnvParameterfvARB(table, _mesa_GetProgramEnvParameterfvARB);
8141 SET_GetProgramLocalParameterdvARB(table,
8142 _mesa_GetProgramLocalParameterdvARB);
8143 SET_GetProgramLocalParameterfvARB(table,
8144 _mesa_GetProgramLocalParameterfvARB);
8145 SET_GetProgramivARB(table, _mesa_GetProgramivARB);
8146 SET_GetProgramStringARB(table, _mesa_GetProgramStringARB);
8147 #endif
8148
8149 /* ARB 28. GL_ARB_vertex_buffer_object */
8150 #if FEATURE_ARB_vertex_buffer_object
8151 /* None of the extension's functions get compiled */
8152 SET_BindBufferARB(table, _mesa_BindBufferARB);
8153 SET_BufferDataARB(table, _mesa_BufferDataARB);
8154 SET_BufferSubDataARB(table, _mesa_BufferSubDataARB);
8155 SET_DeleteBuffersARB(table, _mesa_DeleteBuffersARB);
8156 SET_GenBuffersARB(table, _mesa_GenBuffersARB);
8157 SET_GetBufferParameterivARB(table, _mesa_GetBufferParameterivARB);
8158 SET_GetBufferPointervARB(table, _mesa_GetBufferPointervARB);
8159 SET_GetBufferSubDataARB(table, _mesa_GetBufferSubDataARB);
8160 SET_IsBufferARB(table, _mesa_IsBufferARB);
8161 SET_MapBufferARB(table, _mesa_MapBufferARB);
8162 SET_UnmapBufferARB(table, _mesa_UnmapBufferARB);
8163 #endif
8164
8165 #if FEATURE_ARB_occlusion_query
8166 SET_BeginQueryARB(table, save_BeginQueryARB);
8167 SET_EndQueryARB(table, save_EndQueryARB);
8168 SET_GenQueriesARB(table, _mesa_GenQueriesARB);
8169 SET_DeleteQueriesARB(table, _mesa_DeleteQueriesARB);
8170 SET_IsQueryARB(table, _mesa_IsQueryARB);
8171 SET_GetQueryivARB(table, _mesa_GetQueryivARB);
8172 SET_GetQueryObjectivARB(table, _mesa_GetQueryObjectivARB);
8173 SET_GetQueryObjectuivARB(table, _mesa_GetQueryObjectuivARB);
8174 #endif
8175 SET_DrawBuffersARB(table, save_DrawBuffersARB);
8176
8177 #if FEATURE_EXT_framebuffer_blit
8178 SET_BlitFramebufferEXT(table, save_BlitFramebufferEXT);
8179 #endif
8180
8181 /* ARB 30/31/32. GL_ARB_shader_objects, GL_ARB_vertex/fragment_shader */
8182 SET_BindAttribLocationARB(table, exec_BindAttribLocationARB);
8183 SET_GetAttribLocationARB(table, exec_GetAttribLocationARB);
8184 /* XXX additional functions need to be implemented here! */
8185
8186 /* 299. GL_EXT_blend_equation_separate */
8187 SET_BlendEquationSeparateEXT(table, save_BlendEquationSeparateEXT);
8188
8189 /* GL_EXT_gpu_program_parmaeters */
8190 #if FEATURE_ARB_vertex_program || FEATURE_ARB_fragment_program
8191 SET_ProgramEnvParameters4fvEXT(table, save_ProgramEnvParameters4fvEXT);
8192 SET_ProgramLocalParameters4fvEXT(table, save_ProgramLocalParameters4fvEXT);
8193 #endif
8194 }
8195
8196
8197
8198 static const char *
8199 enum_string(GLenum k)
8200 {
8201 return _mesa_lookup_enum_by_nr(k);
8202 }
8203
8204
8205 /**
8206 * Print the commands in a display list. For debugging only.
8207 * TODO: many commands aren't handled yet.
8208 */
8209 static void GLAPIENTRY
8210 print_list(GLcontext *ctx, GLuint list)
8211 {
8212 struct mesa_display_list *dlist;
8213 Node *n;
8214 GLboolean done;
8215
8216 if (!islist(ctx, list)) {
8217 _mesa_printf("%u is not a display list ID\n", list);
8218 return;
8219 }
8220
8221 dlist = lookup_list(ctx, list);
8222 if (!dlist)
8223 return;
8224
8225 n = dlist->node;
8226
8227 _mesa_printf("START-LIST %u, address %p\n", list, (void *) n);
8228
8229 done = n ? GL_FALSE : GL_TRUE;
8230 while (!done) {
8231 OpCode opcode = n[0].opcode;
8232 GLint i = (GLint) n[0].opcode - (GLint) OPCODE_EXT_0;
8233
8234 if (i >= 0 && i < (GLint) ctx->ListExt.NumOpcodes) {
8235 /* this is a driver-extended opcode */
8236 ctx->ListExt.Opcode[i].Print(ctx, &n[1]);
8237 n += ctx->ListExt.Opcode[i].Size;
8238 }
8239 else {
8240 switch (opcode) {
8241 case OPCODE_ACCUM:
8242 _mesa_printf("Accum %s %g\n", enum_string(n[1].e), n[2].f);
8243 break;
8244 case OPCODE_BITMAP:
8245 _mesa_printf("Bitmap %d %d %g %g %g %g %p\n", n[1].i, n[2].i,
8246 n[3].f, n[4].f, n[5].f, n[6].f, (void *) n[7].data);
8247 break;
8248 case OPCODE_CALL_LIST:
8249 _mesa_printf("CallList %d\n", (int) n[1].ui);
8250 break;
8251 case OPCODE_CALL_LIST_OFFSET:
8252 _mesa_printf("CallList %d + offset %u = %u\n", (int) n[1].ui,
8253 ctx->List.ListBase, ctx->List.ListBase + n[1].ui);
8254 break;
8255 case OPCODE_COLOR_TABLE_PARAMETER_FV:
8256 _mesa_printf("ColorTableParameterfv %s %s %f %f %f %f\n",
8257 enum_string(n[1].e), enum_string(n[2].e),
8258 n[3].f, n[4].f, n[5].f, n[6].f);
8259 break;
8260 case OPCODE_COLOR_TABLE_PARAMETER_IV:
8261 _mesa_printf("ColorTableParameteriv %s %s %d %d %d %d\n",
8262 enum_string(n[1].e), enum_string(n[2].e),
8263 n[3].i, n[4].i, n[5].i, n[6].i);
8264 break;
8265 case OPCODE_DISABLE:
8266 _mesa_printf("Disable %s\n", enum_string(n[1].e));
8267 break;
8268 case OPCODE_ENABLE:
8269 _mesa_printf("Enable %s\n", enum_string(n[1].e));
8270 break;
8271 case OPCODE_FRUSTUM:
8272 _mesa_printf("Frustum %g %g %g %g %g %g\n",
8273 n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f);
8274 break;
8275 case OPCODE_LINE_STIPPLE:
8276 _mesa_printf("LineStipple %d %x\n", n[1].i, (int) n[2].us);
8277 break;
8278 case OPCODE_LOAD_IDENTITY:
8279 _mesa_printf("LoadIdentity\n");
8280 break;
8281 case OPCODE_LOAD_MATRIX:
8282 _mesa_printf("LoadMatrix\n");
8283 _mesa_printf(" %8f %8f %8f %8f\n",
8284 n[1].f, n[5].f, n[9].f, n[13].f);
8285 _mesa_printf(" %8f %8f %8f %8f\n",
8286 n[2].f, n[6].f, n[10].f, n[14].f);
8287 _mesa_printf(" %8f %8f %8f %8f\n",
8288 n[3].f, n[7].f, n[11].f, n[15].f);
8289 _mesa_printf(" %8f %8f %8f %8f\n",
8290 n[4].f, n[8].f, n[12].f, n[16].f);
8291 break;
8292 case OPCODE_MULT_MATRIX:
8293 _mesa_printf("MultMatrix (or Rotate)\n");
8294 _mesa_printf(" %8f %8f %8f %8f\n",
8295 n[1].f, n[5].f, n[9].f, n[13].f);
8296 _mesa_printf(" %8f %8f %8f %8f\n",
8297 n[2].f, n[6].f, n[10].f, n[14].f);
8298 _mesa_printf(" %8f %8f %8f %8f\n",
8299 n[3].f, n[7].f, n[11].f, n[15].f);
8300 _mesa_printf(" %8f %8f %8f %8f\n",
8301 n[4].f, n[8].f, n[12].f, n[16].f);
8302 break;
8303 case OPCODE_ORTHO:
8304 _mesa_printf("Ortho %g %g %g %g %g %g\n",
8305 n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f);
8306 break;
8307 case OPCODE_POP_ATTRIB:
8308 _mesa_printf("PopAttrib\n");
8309 break;
8310 case OPCODE_POP_MATRIX:
8311 _mesa_printf("PopMatrix\n");
8312 break;
8313 case OPCODE_POP_NAME:
8314 _mesa_printf("PopName\n");
8315 break;
8316 case OPCODE_PUSH_ATTRIB:
8317 _mesa_printf("PushAttrib %x\n", n[1].bf);
8318 break;
8319 case OPCODE_PUSH_MATRIX:
8320 _mesa_printf("PushMatrix\n");
8321 break;
8322 case OPCODE_PUSH_NAME:
8323 _mesa_printf("PushName %d\n", (int) n[1].ui);
8324 break;
8325 case OPCODE_RASTER_POS:
8326 _mesa_printf("RasterPos %g %g %g %g\n",
8327 n[1].f, n[2].f, n[3].f, n[4].f);
8328 break;
8329 case OPCODE_ROTATE:
8330 _mesa_printf("Rotate %g %g %g %g\n",
8331 n[1].f, n[2].f, n[3].f, n[4].f);
8332 break;
8333 case OPCODE_SCALE:
8334 _mesa_printf("Scale %g %g %g\n", n[1].f, n[2].f, n[3].f);
8335 break;
8336 case OPCODE_TRANSLATE:
8337 _mesa_printf("Translate %g %g %g\n", n[1].f, n[2].f, n[3].f);
8338 break;
8339 case OPCODE_BIND_TEXTURE:
8340 _mesa_printf("BindTexture %s %d\n",
8341 _mesa_lookup_enum_by_nr(n[1].ui), n[2].ui);
8342 break;
8343 case OPCODE_SHADE_MODEL:
8344 _mesa_printf("ShadeModel %s\n", _mesa_lookup_enum_by_nr(n[1].ui));
8345 break;
8346 case OPCODE_MAP1:
8347 _mesa_printf("Map1 %s %.3f %.3f %d %d\n",
8348 _mesa_lookup_enum_by_nr(n[1].ui),
8349 n[2].f, n[3].f, n[4].i, n[5].i);
8350 break;
8351 case OPCODE_MAP2:
8352 _mesa_printf("Map2 %s %.3f %.3f %.3f %.3f %d %d %d %d\n",
8353 _mesa_lookup_enum_by_nr(n[1].ui),
8354 n[2].f, n[3].f, n[4].f, n[5].f,
8355 n[6].i, n[7].i, n[8].i, n[9].i);
8356 break;
8357 case OPCODE_MAPGRID1:
8358 _mesa_printf("MapGrid1 %d %.3f %.3f\n", n[1].i, n[2].f, n[3].f);
8359 break;
8360 case OPCODE_MAPGRID2:
8361 _mesa_printf("MapGrid2 %d %.3f %.3f, %d %.3f %.3f\n",
8362 n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f);
8363 break;
8364 case OPCODE_EVALMESH1:
8365 _mesa_printf("EvalMesh1 %d %d\n", n[1].i, n[2].i);
8366 break;
8367 case OPCODE_EVALMESH2:
8368 _mesa_printf("EvalMesh2 %d %d %d %d\n",
8369 n[1].i, n[2].i, n[3].i, n[4].i);
8370 break;
8371
8372 case OPCODE_ATTR_1F_NV:
8373 _mesa_printf("ATTR_1F_NV attr %d: %f\n", n[1].i, n[2].f);
8374 break;
8375 case OPCODE_ATTR_2F_NV:
8376 _mesa_printf("ATTR_2F_NV attr %d: %f %f\n",
8377 n[1].i, n[2].f, n[3].f);
8378 break;
8379 case OPCODE_ATTR_3F_NV:
8380 _mesa_printf("ATTR_3F_NV attr %d: %f %f %f\n",
8381 n[1].i, n[2].f, n[3].f, n[4].f);
8382 break;
8383 case OPCODE_ATTR_4F_NV:
8384 _mesa_printf("ATTR_4F_NV attr %d: %f %f %f %f\n",
8385 n[1].i, n[2].f, n[3].f, n[4].f, n[5].f);
8386 break;
8387 case OPCODE_ATTR_1F_ARB:
8388 _mesa_printf("ATTR_1F_ARB attr %d: %f\n", n[1].i, n[2].f);
8389 break;
8390 case OPCODE_ATTR_2F_ARB:
8391 _mesa_printf("ATTR_2F_ARB attr %d: %f %f\n",
8392 n[1].i, n[2].f, n[3].f);
8393 break;
8394 case OPCODE_ATTR_3F_ARB:
8395 _mesa_printf("ATTR_3F_ARB attr %d: %f %f %f\n",
8396 n[1].i, n[2].f, n[3].f, n[4].f);
8397 break;
8398 case OPCODE_ATTR_4F_ARB:
8399 _mesa_printf("ATTR_4F_ARB attr %d: %f %f %f %f\n",
8400 n[1].i, n[2].f, n[3].f, n[4].f, n[5].f);
8401 break;
8402
8403 case OPCODE_MATERIAL:
8404 _mesa_printf("MATERIAL %x %x: %f %f %f %f\n",
8405 n[1].i, n[2].i, n[3].f, n[4].f, n[5].f, n[6].f);
8406 break;
8407 case OPCODE_BEGIN:
8408 _mesa_printf("BEGIN %x\n", n[1].i);
8409 break;
8410 case OPCODE_END:
8411 _mesa_printf("END\n");
8412 break;
8413 case OPCODE_RECTF:
8414 _mesa_printf("RECTF %f %f %f %f\n", n[1].f, n[2].f, n[3].f,
8415 n[4].f);
8416 break;
8417 case OPCODE_EVAL_C1:
8418 _mesa_printf("EVAL_C1 %f\n", n[1].f);
8419 break;
8420 case OPCODE_EVAL_C2:
8421 _mesa_printf("EVAL_C2 %f %f\n", n[1].f, n[2].f);
8422 break;
8423 case OPCODE_EVAL_P1:
8424 _mesa_printf("EVAL_P1 %d\n", n[1].i);
8425 break;
8426 case OPCODE_EVAL_P2:
8427 _mesa_printf("EVAL_P2 %d %d\n", n[1].i, n[2].i);
8428 break;
8429
8430 /*
8431 * meta opcodes/commands
8432 */
8433 case OPCODE_ERROR:
8434 _mesa_printf("Error: %s %s\n",
8435 enum_string(n[1].e), (const char *) n[2].data);
8436 break;
8437 case OPCODE_CONTINUE:
8438 _mesa_printf("DISPLAY-LIST-CONTINUE\n");
8439 n = (Node *) n[1].next;
8440 break;
8441 case OPCODE_END_OF_LIST:
8442 _mesa_printf("END-LIST %u\n", list);
8443 done = GL_TRUE;
8444 break;
8445 default:
8446 if (opcode < 0 || opcode > OPCODE_END_OF_LIST) {
8447 _mesa_printf
8448 ("ERROR IN DISPLAY LIST: opcode = %d, address = %p\n",
8449 opcode, (void *) n);
8450 return;
8451 }
8452 else {
8453 _mesa_printf("command %d, %u operands\n", opcode,
8454 InstSize[opcode]);
8455 }
8456 }
8457 /* increment n to point to next compiled command */
8458 if (opcode != OPCODE_CONTINUE) {
8459 n += InstSize[opcode];
8460 }
8461 }
8462 }
8463 }
8464
8465
8466
8467 /**
8468 * Clients may call this function to help debug display list problems.
8469 * This function is _ONLY_FOR_DEBUGGING_PURPOSES_. It may be removed,
8470 * changed, or break in the future without notice.
8471 */
8472 void
8473 mesa_print_display_list(GLuint list)
8474 {
8475 GET_CURRENT_CONTEXT(ctx);
8476 print_list(ctx, list);
8477 }
8478
8479
8480 /**********************************************************************/
8481 /***** Initialization *****/
8482 /**********************************************************************/
8483
8484 void
8485 _mesa_save_vtxfmt_init(GLvertexformat * vfmt)
8486 {
8487 vfmt->ArrayElement = _ae_loopback_array_elt; /* generic helper */
8488 vfmt->Begin = save_Begin;
8489 vfmt->CallList = _mesa_save_CallList;
8490 vfmt->CallLists = _mesa_save_CallLists;
8491 vfmt->Color3f = save_Color3f;
8492 vfmt->Color3fv = save_Color3fv;
8493 vfmt->Color4f = save_Color4f;
8494 vfmt->Color4fv = save_Color4fv;
8495 vfmt->EdgeFlag = save_EdgeFlag;
8496 vfmt->End = save_End;
8497 vfmt->EvalCoord1f = save_EvalCoord1f;
8498 vfmt->EvalCoord1fv = save_EvalCoord1fv;
8499 vfmt->EvalCoord2f = save_EvalCoord2f;
8500 vfmt->EvalCoord2fv = save_EvalCoord2fv;
8501 vfmt->EvalPoint1 = save_EvalPoint1;
8502 vfmt->EvalPoint2 = save_EvalPoint2;
8503 vfmt->FogCoordfEXT = save_FogCoordfEXT;
8504 vfmt->FogCoordfvEXT = save_FogCoordfvEXT;
8505 vfmt->Indexf = save_Indexf;
8506 vfmt->Indexfv = save_Indexfv;
8507 vfmt->Materialfv = save_Materialfv;
8508 vfmt->MultiTexCoord1fARB = save_MultiTexCoord1f;
8509 vfmt->MultiTexCoord1fvARB = save_MultiTexCoord1fv;
8510 vfmt->MultiTexCoord2fARB = save_MultiTexCoord2f;
8511 vfmt->MultiTexCoord2fvARB = save_MultiTexCoord2fv;
8512 vfmt->MultiTexCoord3fARB = save_MultiTexCoord3f;
8513 vfmt->MultiTexCoord3fvARB = save_MultiTexCoord3fv;
8514 vfmt->MultiTexCoord4fARB = save_MultiTexCoord4f;
8515 vfmt->MultiTexCoord4fvARB = save_MultiTexCoord4fv;
8516 vfmt->Normal3f = save_Normal3f;
8517 vfmt->Normal3fv = save_Normal3fv;
8518 vfmt->SecondaryColor3fEXT = save_SecondaryColor3fEXT;
8519 vfmt->SecondaryColor3fvEXT = save_SecondaryColor3fvEXT;
8520 vfmt->TexCoord1f = save_TexCoord1f;
8521 vfmt->TexCoord1fv = save_TexCoord1fv;
8522 vfmt->TexCoord2f = save_TexCoord2f;
8523 vfmt->TexCoord2fv = save_TexCoord2fv;
8524 vfmt->TexCoord3f = save_TexCoord3f;
8525 vfmt->TexCoord3fv = save_TexCoord3fv;
8526 vfmt->TexCoord4f = save_TexCoord4f;
8527 vfmt->TexCoord4fv = save_TexCoord4fv;
8528 vfmt->Vertex2f = save_Vertex2f;
8529 vfmt->Vertex2fv = save_Vertex2fv;
8530 vfmt->Vertex3f = save_Vertex3f;
8531 vfmt->Vertex3fv = save_Vertex3fv;
8532 vfmt->Vertex4f = save_Vertex4f;
8533 vfmt->Vertex4fv = save_Vertex4fv;
8534 vfmt->VertexAttrib1fNV = save_VertexAttrib1fNV;
8535 vfmt->VertexAttrib1fvNV = save_VertexAttrib1fvNV;
8536 vfmt->VertexAttrib2fNV = save_VertexAttrib2fNV;
8537 vfmt->VertexAttrib2fvNV = save_VertexAttrib2fvNV;
8538 vfmt->VertexAttrib3fNV = save_VertexAttrib3fNV;
8539 vfmt->VertexAttrib3fvNV = save_VertexAttrib3fvNV;
8540 vfmt->VertexAttrib4fNV = save_VertexAttrib4fNV;
8541 vfmt->VertexAttrib4fvNV = save_VertexAttrib4fvNV;
8542 vfmt->VertexAttrib1fARB = save_VertexAttrib1fARB;
8543 vfmt->VertexAttrib1fvARB = save_VertexAttrib1fvARB;
8544 vfmt->VertexAttrib2fARB = save_VertexAttrib2fARB;
8545 vfmt->VertexAttrib2fvARB = save_VertexAttrib2fvARB;
8546 vfmt->VertexAttrib3fARB = save_VertexAttrib3fARB;
8547 vfmt->VertexAttrib3fvARB = save_VertexAttrib3fvARB;
8548 vfmt->VertexAttrib4fARB = save_VertexAttrib4fARB;
8549 vfmt->VertexAttrib4fvARB = save_VertexAttrib4fvARB;
8550
8551 vfmt->EvalMesh1 = _mesa_save_EvalMesh1;
8552 vfmt->EvalMesh2 = _mesa_save_EvalMesh2;
8553 vfmt->Rectf = save_Rectf;
8554
8555 /* The driver is required to implement these as
8556 * 1) They can probably do a better job.
8557 * 2) A lot of new mechanisms would have to be added to this module
8558 * to support it. That code would probably never get used,
8559 * because of (1).
8560 */
8561 #if 0
8562 vfmt->DrawArrays = 0;
8563 vfmt->DrawElements = 0;
8564 vfmt->DrawRangeElements = 0;
8565 #endif
8566 }
8567
8568
8569 /**
8570 * Initialize display list state for given context.
8571 */
8572 void
8573 _mesa_init_display_list(GLcontext *ctx)
8574 {
8575 static GLboolean tableInitialized = GL_FALSE;
8576
8577 /* zero-out the instruction size table, just once */
8578 if (!tableInitialized) {
8579 _mesa_bzero(InstSize, sizeof(InstSize));
8580 tableInitialized = GL_TRUE;
8581 }
8582
8583 /* Display list */
8584 ctx->ListState.CallDepth = 0;
8585 ctx->ExecuteFlag = GL_TRUE;
8586 ctx->CompileFlag = GL_FALSE;
8587 ctx->ListState.CurrentListPtr = NULL;
8588 ctx->ListState.CurrentBlock = NULL;
8589 ctx->ListState.CurrentListNum = 0;
8590 ctx->ListState.CurrentPos = 0;
8591
8592 /* Display List group */
8593 ctx->List.ListBase = 0;
8594
8595 _mesa_save_vtxfmt_init(&ctx->ListState.ListVtxfmt);
8596 }