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