projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
mesa: Implement GL_ARB_polygon_offset_clamp
[mesa.git] / src / mesa / main / dlist.c
1 /*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
5 * Copyright (C) 2009 VMware, Inc. 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 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23 * OTHER DEALINGS IN THE SOFTWARE.
24 */
25
26
27 /**
28 * \file dlist.c
29 * Display lists management functions.
30 */
31
32 #include "c99_math.h"
33 #include "glheader.h"
34 #include "imports.h"
35 #include "api_arrayelt.h"
36 #include "api_exec.h"
37 #include "api_loopback.h"
38 #include "api_validate.h"
39 #include "atifragshader.h"
40 #include "config.h"
41 #include "bufferobj.h"
42 #include "arrayobj.h"
43 #include "context.h"
44 #include "dlist.h"
45 #include "enums.h"
46 #include "eval.h"
47 #include "fbobject.h"
48 #include "framebuffer.h"
49 #include "glapi/glapi.h"
50 #include "glformats.h"
51 #include "hash.h"
52 #include "image.h"
53 #include "light.h"
54 #include "macros.h"
55 #include "pack.h"
56 #include "pbo.h"
57 #include "queryobj.h"
58 #include "samplerobj.h"
59 #include "shaderapi.h"
60 #include "syncobj.h"
61 #include "teximage.h"
62 #include "texstorage.h"
63 #include "mtypes.h"
64 #include "varray.h"
65 #include "arbprogram.h"
66 #include "transformfeedback.h"
67
68 #include "math/m_matrix.h"
69
70 #include "main/dispatch.h"
71
72 #include "vbo/vbo.h"
73
74
75 #define USE_BITMAP_ATLAS 1
76
77
78
79 /**
80 * Other parts of Mesa (such as the VBO module) can plug into the display
81 * list system. This structure describes new display list instructions.
82 */
83 struct gl_list_instruction
84 {
85 GLuint Size;
86 void (*Execute)( struct gl_context *ctx, void *data );
87 void (*Destroy)( struct gl_context *ctx, void *data );
88 void (*Print)( struct gl_context *ctx, void *data, FILE *f );
89 };
90
91
92 #define MAX_DLIST_EXT_OPCODES 16
93
94 /**
95 * Used by device drivers to hook new commands into display lists.
96 */
97 struct gl_list_extensions
98 {
99 struct gl_list_instruction Opcode[MAX_DLIST_EXT_OPCODES];
100 GLuint NumOpcodes;
101 };
102
103
104
105 /**
106 * Flush vertices.
107 *
108 * \param ctx GL context.
109 *
110 * Checks if dd_function_table::SaveNeedFlush is marked to flush
111 * stored (save) vertices, and calls vbo_save_SaveFlushVertices if so.
112 */
113 #define SAVE_FLUSH_VERTICES(ctx) \
114 do { \
115 if (ctx->Driver.SaveNeedFlush) \
116 vbo_save_SaveFlushVertices(ctx); \
117 } while (0)
118
119
120 /**
121 * Macro to assert that the API call was made outside the
122 * glBegin()/glEnd() pair, with return value.
123 *
124 * \param ctx GL context.
125 * \param retval value to return value in case the assertion fails.
126 */
127 #define ASSERT_OUTSIDE_SAVE_BEGIN_END_WITH_RETVAL(ctx, retval) \
128 do { \
129 if (ctx->Driver.CurrentSavePrimitive <= PRIM_MAX) { \
130 _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glBegin/End" ); \
131 return retval; \
132 } \
133 } while (0)
134
135 /**
136 * Macro to assert that the API call was made outside the
137 * glBegin()/glEnd() pair.
138 *
139 * \param ctx GL context.
140 */
141 #define ASSERT_OUTSIDE_SAVE_BEGIN_END(ctx) \
142 do { \
143 if (ctx->Driver.CurrentSavePrimitive <= PRIM_MAX) { \
144 _mesa_compile_error( ctx, GL_INVALID_OPERATION, "glBegin/End" ); \
145 return; \
146 } \
147 } while (0)
148
149 /**
150 * Macro to assert that the API call was made outside the
151 * glBegin()/glEnd() pair and flush the vertices.
152 *
153 * \param ctx GL context.
154 */
155 #define ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx) \
156 do { \
157 ASSERT_OUTSIDE_SAVE_BEGIN_END(ctx); \
158 SAVE_FLUSH_VERTICES(ctx); \
159 } while (0)
160
161 /**
162 * Macro to assert that the API call was made outside the
163 * glBegin()/glEnd() pair and flush the vertices, with return value.
164 *
165 * \param ctx GL context.
166 * \param retval value to return value in case the assertion fails.
167 */
168 #define ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH_WITH_RETVAL(ctx, retval) \
169 do { \
170 ASSERT_OUTSIDE_SAVE_BEGIN_END_WITH_RETVAL(ctx, retval); \
171 SAVE_FLUSH_VERTICES(ctx); \
172 } while (0)
173
174
175 /**
176 * Display list opcodes.
177 *
178 * The fact that these identifiers are assigned consecutive
179 * integer values starting at 0 is very important, see InstSize array usage)
180 */
181 typedef enum
182 {
183 OPCODE_INVALID = -1, /* Force signed enum */
184 OPCODE_ACCUM,
185 OPCODE_ALPHA_FUNC,
186 OPCODE_BIND_TEXTURE,
187 OPCODE_BITMAP,
188 OPCODE_BLEND_COLOR,
189 OPCODE_BLEND_EQUATION,
190 OPCODE_BLEND_EQUATION_SEPARATE,
191 OPCODE_BLEND_FUNC_SEPARATE,
192
193 OPCODE_BLEND_EQUATION_I,
194 OPCODE_BLEND_EQUATION_SEPARATE_I,
195 OPCODE_BLEND_FUNC_I,
196 OPCODE_BLEND_FUNC_SEPARATE_I,
197
198 OPCODE_CALL_LIST,
199 OPCODE_CALL_LISTS,
200 OPCODE_CLEAR,
201 OPCODE_CLEAR_ACCUM,
202 OPCODE_CLEAR_COLOR,
203 OPCODE_CLEAR_DEPTH,
204 OPCODE_CLEAR_INDEX,
205 OPCODE_CLEAR_STENCIL,
206 OPCODE_CLEAR_BUFFER_IV,
207 OPCODE_CLEAR_BUFFER_UIV,
208 OPCODE_CLEAR_BUFFER_FV,
209 OPCODE_CLEAR_BUFFER_FI,
210 OPCODE_CLIP_PLANE,
211 OPCODE_COLOR_MASK,
212 OPCODE_COLOR_MASK_INDEXED,
213 OPCODE_COLOR_MATERIAL,
214 OPCODE_COPY_PIXELS,
215 OPCODE_COPY_TEX_IMAGE1D,
216 OPCODE_COPY_TEX_IMAGE2D,
217 OPCODE_COPY_TEX_SUB_IMAGE1D,
218 OPCODE_COPY_TEX_SUB_IMAGE2D,
219 OPCODE_COPY_TEX_SUB_IMAGE3D,
220 OPCODE_CULL_FACE,
221 OPCODE_DEPTH_FUNC,
222 OPCODE_DEPTH_MASK,
223 OPCODE_DEPTH_RANGE,
224 OPCODE_DISABLE,
225 OPCODE_DISABLE_INDEXED,
226 OPCODE_DRAW_BUFFER,
227 OPCODE_DRAW_PIXELS,
228 OPCODE_ENABLE,
229 OPCODE_ENABLE_INDEXED,
230 OPCODE_EVALMESH1,
231 OPCODE_EVALMESH2,
232 OPCODE_FOG,
233 OPCODE_FRONT_FACE,
234 OPCODE_FRUSTUM,
235 OPCODE_HINT,
236 OPCODE_INDEX_MASK,
237 OPCODE_INIT_NAMES,
238 OPCODE_LIGHT,
239 OPCODE_LIGHT_MODEL,
240 OPCODE_LINE_STIPPLE,
241 OPCODE_LINE_WIDTH,
242 OPCODE_LIST_BASE,
243 OPCODE_LOAD_IDENTITY,
244 OPCODE_LOAD_MATRIX,
245 OPCODE_LOAD_NAME,
246 OPCODE_LOGIC_OP,
247 OPCODE_MAP1,
248 OPCODE_MAP2,
249 OPCODE_MAPGRID1,
250 OPCODE_MAPGRID2,
251 OPCODE_MATRIX_MODE,
252 OPCODE_MULT_MATRIX,
253 OPCODE_ORTHO,
254 OPCODE_PASSTHROUGH,
255 OPCODE_PIXEL_MAP,
256 OPCODE_PIXEL_TRANSFER,
257 OPCODE_PIXEL_ZOOM,
258 OPCODE_POINT_SIZE,
259 OPCODE_POINT_PARAMETERS,
260 OPCODE_POLYGON_MODE,
261 OPCODE_POLYGON_STIPPLE,
262 OPCODE_POLYGON_OFFSET,
263 OPCODE_POP_ATTRIB,
264 OPCODE_POP_MATRIX,
265 OPCODE_POP_NAME,
266 OPCODE_PRIORITIZE_TEXTURE,
267 OPCODE_PUSH_ATTRIB,
268 OPCODE_PUSH_MATRIX,
269 OPCODE_PUSH_NAME,
270 OPCODE_RASTER_POS,
271 OPCODE_READ_BUFFER,
272 OPCODE_ROTATE,
273 OPCODE_SCALE,
274 OPCODE_SCISSOR,
275 OPCODE_SELECT_TEXTURE_SGIS,
276 OPCODE_SELECT_TEXTURE_COORD_SET,
277 OPCODE_SHADE_MODEL,
278 OPCODE_STENCIL_FUNC,
279 OPCODE_STENCIL_MASK,
280 OPCODE_STENCIL_OP,
281 OPCODE_TEXENV,
282 OPCODE_TEXGEN,
283 OPCODE_TEXPARAMETER,
284 OPCODE_TEX_IMAGE1D,
285 OPCODE_TEX_IMAGE2D,
286 OPCODE_TEX_IMAGE3D,
287 OPCODE_TEX_SUB_IMAGE1D,
288 OPCODE_TEX_SUB_IMAGE2D,
289 OPCODE_TEX_SUB_IMAGE3D,
290 OPCODE_TRANSLATE,
291 OPCODE_VIEWPORT,
292 OPCODE_WINDOW_POS,
293 /* GL_ARB_multitexture */
294 OPCODE_ACTIVE_TEXTURE,
295 /* GL_ARB_texture_compression */
296 OPCODE_COMPRESSED_TEX_IMAGE_1D,
297 OPCODE_COMPRESSED_TEX_IMAGE_2D,
298 OPCODE_COMPRESSED_TEX_IMAGE_3D,
299 OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D,
300 OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D,
301 OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D,
302 /* GL_ARB_multisample */
303 OPCODE_SAMPLE_COVERAGE,
304 /* GL_ARB_window_pos */
305 OPCODE_WINDOW_POS_ARB,
306 /* GL_ARB_vertex_program */
307 OPCODE_BIND_PROGRAM_ARB,
308 OPCODE_PROGRAM_LOCAL_PARAMETER_ARB,
309 /* GL_EXT_stencil_two_side */
310 OPCODE_ACTIVE_STENCIL_FACE_EXT,
311 /* GL_EXT_depth_bounds_test */
312 OPCODE_DEPTH_BOUNDS_EXT,
313 /* GL_ARB_vertex/fragment_program */
314 OPCODE_PROGRAM_STRING_ARB,
315 OPCODE_PROGRAM_ENV_PARAMETER_ARB,
316 /* GL_ARB_occlusion_query */
317 OPCODE_BEGIN_QUERY_ARB,
318 OPCODE_END_QUERY_ARB,
319 /* GL_ARB_draw_buffers */
320 OPCODE_DRAW_BUFFERS_ARB,
321 /* GL_ATI_fragment_shader */
322 OPCODE_BIND_FRAGMENT_SHADER_ATI,
323 OPCODE_SET_FRAGMENT_SHADER_CONSTANTS_ATI,
324 /* OpenGL 2.0 */
325 OPCODE_STENCIL_FUNC_SEPARATE,
326 OPCODE_STENCIL_OP_SEPARATE,
327 OPCODE_STENCIL_MASK_SEPARATE,
328 /* GL_NV_primitive_restart */
329 OPCODE_PRIMITIVE_RESTART_NV,
330 /* GL_ARB_shader_objects */
331 OPCODE_USE_PROGRAM,
332 OPCODE_UNIFORM_1F,
333 OPCODE_UNIFORM_2F,
334 OPCODE_UNIFORM_3F,
335 OPCODE_UNIFORM_4F,
336 OPCODE_UNIFORM_1FV,
337 OPCODE_UNIFORM_2FV,
338 OPCODE_UNIFORM_3FV,
339 OPCODE_UNIFORM_4FV,
340 OPCODE_UNIFORM_1I,
341 OPCODE_UNIFORM_2I,
342 OPCODE_UNIFORM_3I,
343 OPCODE_UNIFORM_4I,
344 OPCODE_UNIFORM_1IV,
345 OPCODE_UNIFORM_2IV,
346 OPCODE_UNIFORM_3IV,
347 OPCODE_UNIFORM_4IV,
348 OPCODE_UNIFORM_MATRIX22,
349 OPCODE_UNIFORM_MATRIX33,
350 OPCODE_UNIFORM_MATRIX44,
351 OPCODE_UNIFORM_MATRIX23,
352 OPCODE_UNIFORM_MATRIX32,
353 OPCODE_UNIFORM_MATRIX24,
354 OPCODE_UNIFORM_MATRIX42,
355 OPCODE_UNIFORM_MATRIX34,
356 OPCODE_UNIFORM_MATRIX43,
357
358 /* OpenGL 3.0 */
359 OPCODE_UNIFORM_1UI,
360 OPCODE_UNIFORM_2UI,
361 OPCODE_UNIFORM_3UI,
362 OPCODE_UNIFORM_4UI,
363 OPCODE_UNIFORM_1UIV,
364 OPCODE_UNIFORM_2UIV,
365 OPCODE_UNIFORM_3UIV,
366 OPCODE_UNIFORM_4UIV,
367
368 /* OpenGL 4.2 / GL_ARB_separate_shader_objects */
369 OPCODE_USE_PROGRAM_STAGES,
370 OPCODE_PROGRAM_UNIFORM_1F,
371 OPCODE_PROGRAM_UNIFORM_2F,
372 OPCODE_PROGRAM_UNIFORM_3F,
373 OPCODE_PROGRAM_UNIFORM_4F,
374 OPCODE_PROGRAM_UNIFORM_1FV,
375 OPCODE_PROGRAM_UNIFORM_2FV,
376 OPCODE_PROGRAM_UNIFORM_3FV,
377 OPCODE_PROGRAM_UNIFORM_4FV,
378 OPCODE_PROGRAM_UNIFORM_1I,
379 OPCODE_PROGRAM_UNIFORM_2I,
380 OPCODE_PROGRAM_UNIFORM_3I,
381 OPCODE_PROGRAM_UNIFORM_4I,
382 OPCODE_PROGRAM_UNIFORM_1IV,
383 OPCODE_PROGRAM_UNIFORM_2IV,
384 OPCODE_PROGRAM_UNIFORM_3IV,
385 OPCODE_PROGRAM_UNIFORM_4IV,
386 OPCODE_PROGRAM_UNIFORM_1UI,
387 OPCODE_PROGRAM_UNIFORM_2UI,
388 OPCODE_PROGRAM_UNIFORM_3UI,
389 OPCODE_PROGRAM_UNIFORM_4UI,
390 OPCODE_PROGRAM_UNIFORM_1UIV,
391 OPCODE_PROGRAM_UNIFORM_2UIV,
392 OPCODE_PROGRAM_UNIFORM_3UIV,
393 OPCODE_PROGRAM_UNIFORM_4UIV,
394 OPCODE_PROGRAM_UNIFORM_MATRIX22F,
395 OPCODE_PROGRAM_UNIFORM_MATRIX33F,
396 OPCODE_PROGRAM_UNIFORM_MATRIX44F,
397 OPCODE_PROGRAM_UNIFORM_MATRIX23F,
398 OPCODE_PROGRAM_UNIFORM_MATRIX32F,
399 OPCODE_PROGRAM_UNIFORM_MATRIX24F,
400 OPCODE_PROGRAM_UNIFORM_MATRIX42F,
401 OPCODE_PROGRAM_UNIFORM_MATRIX34F,
402 OPCODE_PROGRAM_UNIFORM_MATRIX43F,
403
404 /* GL_ARB_clip_control */
405 OPCODE_CLIP_CONTROL,
406
407 /* GL_ARB_color_buffer_float */
408 OPCODE_CLAMP_COLOR,
409
410 /* GL_EXT_framebuffer_blit */
411 OPCODE_BLIT_FRAMEBUFFER,
412
413 /* Vertex attributes -- fallback for when optimized display
414 * list build isn't active.
415 */
416 OPCODE_ATTR_1F_NV,
417 OPCODE_ATTR_2F_NV,
418 OPCODE_ATTR_3F_NV,
419 OPCODE_ATTR_4F_NV,
420 OPCODE_ATTR_1F_ARB,
421 OPCODE_ATTR_2F_ARB,
422 OPCODE_ATTR_3F_ARB,
423 OPCODE_ATTR_4F_ARB,
424 OPCODE_MATERIAL,
425 OPCODE_BEGIN,
426 OPCODE_END,
427 OPCODE_RECTF,
428 OPCODE_EVAL_C1,
429 OPCODE_EVAL_C2,
430 OPCODE_EVAL_P1,
431 OPCODE_EVAL_P2,
432
433 /* GL_EXT_provoking_vertex */
434 OPCODE_PROVOKING_VERTEX,
435
436 /* GL_EXT_transform_feedback */
437 OPCODE_BEGIN_TRANSFORM_FEEDBACK,
438 OPCODE_END_TRANSFORM_FEEDBACK,
439 OPCODE_BIND_TRANSFORM_FEEDBACK,
440 OPCODE_PAUSE_TRANSFORM_FEEDBACK,
441 OPCODE_RESUME_TRANSFORM_FEEDBACK,
442 OPCODE_DRAW_TRANSFORM_FEEDBACK,
443
444 /* GL_EXT_texture_integer */
445 OPCODE_CLEARCOLOR_I,
446 OPCODE_CLEARCOLOR_UI,
447 OPCODE_TEXPARAMETER_I,
448 OPCODE_TEXPARAMETER_UI,
449
450 /* GL_ARB_instanced_arrays */
451 OPCODE_VERTEX_ATTRIB_DIVISOR,
452
453 /* GL_NV_texture_barrier */
454 OPCODE_TEXTURE_BARRIER_NV,
455
456 /* GL_ARB_sampler_object */
457 OPCODE_BIND_SAMPLER,
458 OPCODE_SAMPLER_PARAMETERIV,
459 OPCODE_SAMPLER_PARAMETERFV,
460 OPCODE_SAMPLER_PARAMETERIIV,
461 OPCODE_SAMPLER_PARAMETERUIV,
462
463 /* GL_ARB_sync */
464 OPCODE_WAIT_SYNC,
465
466 /* GL_NV_conditional_render */
467 OPCODE_BEGIN_CONDITIONAL_RENDER,
468 OPCODE_END_CONDITIONAL_RENDER,
469
470 /* ARB_timer_query */
471 OPCODE_QUERY_COUNTER,
472
473 /* ARB_transform_feedback3 */
474 OPCODE_BEGIN_QUERY_INDEXED,
475 OPCODE_END_QUERY_INDEXED,
476 OPCODE_DRAW_TRANSFORM_FEEDBACK_STREAM,
477
478 /* ARB_transform_feedback_instanced */
479 OPCODE_DRAW_TRANSFORM_FEEDBACK_INSTANCED,
480 OPCODE_DRAW_TRANSFORM_FEEDBACK_STREAM_INSTANCED,
481
482 /* ARB_uniform_buffer_object */
483 OPCODE_UNIFORM_BLOCK_BINDING,
484
485 /* EXT_polygon_offset_clamp */
486 OPCODE_POLYGON_OFFSET_CLAMP,
487
488 /* EXT_window_rectangles */
489 OPCODE_WINDOW_RECTANGLES,
490
491 /* The following three are meta instructions */
492 OPCODE_ERROR, /* raise compiled-in error */
493 OPCODE_CONTINUE,
494 OPCODE_NOP, /* No-op (used for 8-byte alignment */
495 OPCODE_END_OF_LIST,
496 OPCODE_EXT_0
497 } OpCode;
498
499
500
501 /**
502 * Display list node.
503 *
504 * Display list instructions are stored as sequences of "nodes". Nodes
505 * are allocated in blocks. Each block has BLOCK_SIZE nodes. Blocks
506 * are linked together with a pointer.
507 *
508 * Each instruction in the display list is stored as a sequence of
509 * contiguous nodes in memory.
510 * Each node is the union of a variety of data types.
511 *
512 * Note, all of these members should be 4 bytes in size or less for the
513 * sake of compact display lists. We store 8-byte pointers in a pair of
514 * these nodes using the save/get_pointer() functions below.
515 */
516 union gl_dlist_node
517 {
518 OpCode opcode;
519 GLboolean b;
520 GLbitfield bf;
521 GLubyte ub;
522 GLshort s;
523 GLushort us;
524 GLint i;
525 GLuint ui;
526 GLenum e;
527 GLfloat f;
528 GLsizei si;
529 };
530
531
532 typedef union gl_dlist_node Node;
533
534
535 /** How many 4-byte dwords to store a pointer */
536 #define POINTER_DWORDS (sizeof(void *) / 4)
537
538 /* We want to keep sizeof(union gl_dlist_node) == 4 to minimize
539 * space for display lists. The following types and functions are
540 * used to help store 4- and 8-byte pointers in 1 or 2 dlist_nodes.
541 */
542 union pointer
543 {
544 void *ptr;
545 GLuint dwords[POINTER_DWORDS];
546 };
547
548
549 /**
550 * Save a 4 or 8-byte pointer at dest (and dest+1).
551 */
552 static inline void
553 save_pointer(Node *dest, void *src)
554 {
555 union pointer p;
556 unsigned i;
557
558 STATIC_ASSERT(POINTER_DWORDS == 1 || POINTER_DWORDS == 2);
559 STATIC_ASSERT(sizeof(Node) == 4);
560
561 p.ptr = src;
562
563 for (i = 0; i < POINTER_DWORDS; i++)
564 dest[i].ui = p.dwords[i];
565 }
566
567
568 /**
569 * Retrieve a 4 or 8-byte pointer from node (node+1).
570 */
571 static inline void *
572 get_pointer(const Node *node)
573 {
574 union pointer p;
575 unsigned i;
576
577 for (i = 0; i < POINTER_DWORDS; i++)
578 p.dwords[i] = node[i].ui;
579
580 return p.ptr;
581 }
582
583
584 /**
585 * Used to store a 64-bit uint in a pair of "Nodes" for the sake of 32-bit
586 * environment.
587 */
588 union uint64_pair
589 {
590 GLuint64 uint64;
591 GLuint uint32[2];
592 };
593
594
595 /**
596 * How many nodes to allocate at a time. Note that bulk vertex data
597 * from glBegin/glVertex/glEnd primitives will typically wind up in
598 * a VBO, and not directly in the display list itself.
599 */
600 #define BLOCK_SIZE 256
601
602
603
604 /**
605 * Number of nodes of storage needed for each instruction.
606 * Sizes for dynamically allocated opcodes are stored in the context struct.
607 */
608 static GLuint InstSize[OPCODE_END_OF_LIST + 1];
609
610
611 void mesa_print_display_list(GLuint list);
612
613
614 /**
615 * Does the given display list only contain a single glBitmap call?
616 */
617 static bool
618 is_bitmap_list(const struct gl_display_list *dlist)
619 {
620 const Node *n = dlist->Head;
621 if (n[0].opcode == OPCODE_BITMAP) {
622 n += InstSize[OPCODE_BITMAP];
623 if (n[0].opcode == OPCODE_END_OF_LIST)
624 return true;
625 }
626 return false;
627 }
628
629
630 /**
631 * Is the given display list an empty list?
632 */
633 static bool
634 is_empty_list(const struct gl_display_list *dlist)
635 {
636 const Node *n = dlist->Head;
637 return n[0].opcode == OPCODE_END_OF_LIST;
638 }
639
640
641 /**
642 * Delete/free a gl_bitmap_atlas. Called during context tear-down.
643 */
644 void
645 _mesa_delete_bitmap_atlas(struct gl_context *ctx, struct gl_bitmap_atlas *atlas)
646 {
647 if (atlas->texObj) {
648 ctx->Driver.DeleteTexture(ctx, atlas->texObj);
649 }
650 free(atlas->glyphs);
651 }
652
653
654 /**
655 * Lookup a gl_bitmap_atlas by listBase ID.
656 */
657 static struct gl_bitmap_atlas *
658 lookup_bitmap_atlas(struct gl_context *ctx, GLuint listBase)
659 {
660 struct gl_bitmap_atlas *atlas;
661
662 assert(listBase > 0);
663 atlas = _mesa_HashLookup(ctx->Shared->BitmapAtlas, listBase);
664 return atlas;
665 }
666
667
668 /**
669 * Create new bitmap atlas and insert into hash table.
670 */
671 static struct gl_bitmap_atlas *
672 alloc_bitmap_atlas(struct gl_context *ctx, GLuint listBase)
673 {
674 struct gl_bitmap_atlas *atlas;
675
676 assert(listBase > 0);
677 assert(_mesa_HashLookup(ctx->Shared->BitmapAtlas, listBase) == NULL);
678
679 atlas = calloc(1, sizeof(*atlas));
680 if (atlas) {
681 _mesa_HashInsert(ctx->Shared->BitmapAtlas, listBase, atlas);
682 }
683
684 return atlas;
685 }
686
687
688 /**
689 * Try to build a bitmap atlas. This involves examining a sequence of
690 * display lists which contain glBitmap commands and putting the bitmap
691 * images into a texture map (the atlas).
692 * If we succeed, gl_bitmap_atlas::complete will be set to true.
693 * If we fail, gl_bitmap_atlas::incomplete will be set to true.
694 */
695 static void
696 build_bitmap_atlas(struct gl_context *ctx, struct gl_bitmap_atlas *atlas,
697 GLuint listBase)
698 {
699 unsigned i, row_height = 0, xpos = 0, ypos = 0;
700 GLubyte *map;
701 GLint map_stride;
702
703 assert(atlas);
704 assert(!atlas->complete);
705 assert(atlas->numBitmaps > 0);
706
707 /* We use a rectangle texture (non-normalized coords) for the atlas */
708 assert(ctx->Extensions.NV_texture_rectangle);
709 assert(ctx->Const.MaxTextureRectSize >= 1024);
710
711 atlas->texWidth = 1024;
712 atlas->texHeight = 0; /* determined below */
713
714 atlas->glyphs = malloc(atlas->numBitmaps * sizeof(atlas->glyphs[0]));
715 if (!atlas->glyphs) {
716 /* give up */
717 atlas->incomplete = true;
718 return;
719 }
720
721 /* Loop over the display lists. They should all contain a single glBitmap
722 * call. If not, bail out. Also, compute the position and sizes of each
723 * bitmap in the atlas to determine the texture atlas size.
724 */
725 for (i = 0; i < atlas->numBitmaps; i++) {
726 const struct gl_display_list *list = _mesa_lookup_list(ctx, listBase + i);
727 const Node *n;
728 struct gl_bitmap_glyph *g = &atlas->glyphs[i];
729 unsigned bitmap_width, bitmap_height;
730 float bitmap_xmove, bitmap_ymove, bitmap_xorig, bitmap_yorig;
731
732 if (!list || is_empty_list(list)) {
733 /* stop here */
734 atlas->numBitmaps = i;
735 break;
736 }
737
738 if (!is_bitmap_list(list)) {
739 /* This list does not contain exactly one glBitmap command. Give up. */
740 atlas->incomplete = true;
741 return;
742 }
743
744 /* get bitmap info from the display list command */
745 n = list->Head;
746 assert(n[0].opcode == OPCODE_BITMAP);
747 bitmap_width = n[1].i;
748 bitmap_height = n[2].i;
749 bitmap_xorig = n[3].f;
750 bitmap_yorig = n[4].f;
751 bitmap_xmove = n[5].f;
752 bitmap_ymove = n[6].f;
753
754 if (xpos + bitmap_width > atlas->texWidth) {
755 /* advance to the next row of the texture */
756 xpos = 0;
757 ypos += row_height;
758 row_height = 0;
759 }
760
761 /* save the bitmap's position in the atlas */
762 g->x = xpos;
763 g->y = ypos;
764 g->w = bitmap_width;
765 g->h = bitmap_height;
766 g->xorig = bitmap_xorig;
767 g->yorig = bitmap_yorig;
768 g->xmove = bitmap_xmove;
769 g->ymove = bitmap_ymove;
770
771 xpos += bitmap_width;
772
773 /* keep track of tallest bitmap in the row */
774 row_height = MAX2(row_height, bitmap_height);
775 }
776
777 /* Now we know the texture height */
778 atlas->texHeight = ypos + row_height;
779
780 if (atlas->texHeight == 0) {
781 /* no glyphs found, give up */
782 goto fail;
783 }
784 else if (atlas->texHeight > ctx->Const.MaxTextureRectSize) {
785 /* too large, give up */
786 goto fail;
787 }
788
789 /* Create atlas texture (texture ID is irrelevant) */
790 atlas->texObj = ctx->Driver.NewTextureObject(ctx, 999, GL_TEXTURE_RECTANGLE);
791 if (!atlas->texObj) {
792 goto out_of_memory;
793 }
794
795 atlas->texObj->Sampler.MinFilter = GL_NEAREST;
796 atlas->texObj->Sampler.MagFilter = GL_NEAREST;
797 atlas->texObj->MaxLevel = 0;
798 atlas->texObj->Immutable = GL_TRUE;
799
800 atlas->texImage = _mesa_get_tex_image(ctx, atlas->texObj,
801 GL_TEXTURE_RECTANGLE, 0);
802 if (!atlas->texImage) {
803 goto out_of_memory;
804 }
805
806 _mesa_init_teximage_fields(ctx, atlas->texImage,
807 atlas->texWidth, atlas->texHeight, 1, 0,
808 GL_ALPHA, MESA_FORMAT_A_UNORM8);
809
810 /* alloc image storage */
811 if (!ctx->Driver.AllocTextureImageBuffer(ctx, atlas->texImage)) {
812 goto out_of_memory;
813 }
814
815 /* map teximage, load with bitmap glyphs */
816 ctx->Driver.MapTextureImage(ctx, atlas->texImage, 0,
817 0, 0, atlas->texWidth, atlas->texHeight,
818 GL_MAP_WRITE_BIT, &map, &map_stride);
819 if (!map) {
820 goto out_of_memory;
821 }
822
823 /* Background/clear pixels are 0xff, foreground/set pixels are 0x0 */
824 memset(map, 0xff, map_stride * atlas->texHeight);
825
826 for (i = 0; i < atlas->numBitmaps; i++) {
827 const struct gl_display_list *list = _mesa_lookup_list(ctx, listBase + i);
828 const Node *n = list->Head;
829
830 assert(n[0].opcode == OPCODE_BITMAP ||
831 n[0].opcode == OPCODE_END_OF_LIST);
832
833 if (n[0].opcode == OPCODE_BITMAP) {
834 unsigned bitmap_width = n[1].i;
835 unsigned bitmap_height = n[2].i;
836 unsigned xpos = atlas->glyphs[i].x;
837 unsigned ypos = atlas->glyphs[i].y;
838 const void *bitmap_image = get_pointer(&n[7]);
839
840 assert(atlas->glyphs[i].w == bitmap_width);
841 assert(atlas->glyphs[i].h == bitmap_height);
842
843 /* put the bitmap image into the texture image */
844 _mesa_expand_bitmap(bitmap_width, bitmap_height,
845 &ctx->DefaultPacking, bitmap_image,
846 map + map_stride * ypos + xpos, /* dest addr */
847 map_stride, 0x0);
848 }
849 }
850
851 ctx->Driver.UnmapTextureImage(ctx, atlas->texImage, 0);
852
853 atlas->complete = true;
854
855 return;
856
857 out_of_memory:
858 _mesa_error(ctx, GL_OUT_OF_MEMORY, "Display list bitmap atlas");
859 fail:
860 if (atlas->texObj) {
861 ctx->Driver.DeleteTexture(ctx, atlas->texObj);
862 }
863 free(atlas->glyphs);
864 atlas->glyphs = NULL;
865 atlas->incomplete = true;
866 }
867
868
869 /**
870 * Allocate a gl_display_list object with an initial block of storage.
871 * \param count how many display list nodes/tokens to allocate
872 */
873 static struct gl_display_list *
874 make_list(GLuint name, GLuint count)
875 {
876 struct gl_display_list *dlist = CALLOC_STRUCT(gl_display_list);
877 dlist->Name = name;
878 dlist->Head = malloc(sizeof(Node) * count);
879 dlist->Head[0].opcode = OPCODE_END_OF_LIST;
880 return dlist;
881 }
882
883
884 /**
885 * Lookup function to just encapsulate casting.
886 */
887 struct gl_display_list *
888 _mesa_lookup_list(struct gl_context *ctx, GLuint list)
889 {
890 return (struct gl_display_list *)
891 _mesa_HashLookup(ctx->Shared->DisplayList, list);
892 }
893
894
895 /** Is the given opcode an extension code? */
896 static inline GLboolean
897 is_ext_opcode(OpCode opcode)
898 {
899 return (opcode >= OPCODE_EXT_0);
900 }
901
902
903 /** Destroy an extended opcode instruction */
904 static GLint
905 ext_opcode_destroy(struct gl_context *ctx, Node *node)
906 {
907 const GLint i = node[0].opcode - OPCODE_EXT_0;
908 GLint step;
909 ctx->ListExt->Opcode[i].Destroy(ctx, &node[1]);
910 step = ctx->ListExt->Opcode[i].Size;
911 return step;
912 }
913
914
915 /** Execute an extended opcode instruction */
916 static GLint
917 ext_opcode_execute(struct gl_context *ctx, Node *node)
918 {
919 const GLint i = node[0].opcode - OPCODE_EXT_0;
920 GLint step;
921 ctx->ListExt->Opcode[i].Execute(ctx, &node[1]);
922 step = ctx->ListExt->Opcode[i].Size;
923 return step;
924 }
925
926
927 /** Print an extended opcode instruction */
928 static GLint
929 ext_opcode_print(struct gl_context *ctx, Node *node, FILE *f)
930 {
931 const GLint i = node[0].opcode - OPCODE_EXT_0;
932 GLint step;
933 ctx->ListExt->Opcode[i].Print(ctx, &node[1], f);
934 step = ctx->ListExt->Opcode[i].Size;
935 return step;
936 }
937
938
939 /**
940 * Delete the named display list, but don't remove from hash table.
941 * \param dlist - display list pointer
942 */
943 void
944 _mesa_delete_list(struct gl_context *ctx, struct gl_display_list *dlist)
945 {
946 Node *n, *block;
947 GLboolean done;
948
949 n = block = dlist->Head;
950
951 done = block ? GL_FALSE : GL_TRUE;
952 while (!done) {
953 const OpCode opcode = n[0].opcode;
954
955 /* check for extension opcodes first */
956 if (is_ext_opcode(opcode)) {
957 n += ext_opcode_destroy(ctx, n);
958 }
959 else {
960 switch (opcode) {
961 /* for some commands, we need to free malloc'd memory */
962 case OPCODE_MAP1:
963 free(get_pointer(&n[6]));
964 n += InstSize[n[0].opcode];
965 break;
966 case OPCODE_MAP2:
967 free(get_pointer(&n[10]));
968 n += InstSize[n[0].opcode];
969 break;
970 case OPCODE_CALL_LISTS:
971 free(get_pointer(&n[3]));
972 n += InstSize[n[0].opcode];
973 break;
974 case OPCODE_DRAW_PIXELS:
975 free(get_pointer(&n[5]));
976 n += InstSize[n[0].opcode];
977 break;
978 case OPCODE_BITMAP:
979 free(get_pointer(&n[7]));
980 n += InstSize[n[0].opcode];
981 break;
982 case OPCODE_POLYGON_STIPPLE:
983 free(get_pointer(&n[1]));
984 n += InstSize[n[0].opcode];
985 break;
986 case OPCODE_TEX_IMAGE1D:
987 free(get_pointer(&n[8]));
988 n += InstSize[n[0].opcode];
989 break;
990 case OPCODE_TEX_IMAGE2D:
991 free(get_pointer(&n[9]));
992 n += InstSize[n[0].opcode];
993 break;
994 case OPCODE_TEX_IMAGE3D:
995 free(get_pointer(&n[10]));
996 n += InstSize[n[0].opcode];
997 break;
998 case OPCODE_TEX_SUB_IMAGE1D:
999 free(get_pointer(&n[7]));
1000 n += InstSize[n[0].opcode];
1001 break;
1002 case OPCODE_TEX_SUB_IMAGE2D:
1003 free(get_pointer(&n[9]));
1004 n += InstSize[n[0].opcode];
1005 break;
1006 case OPCODE_TEX_SUB_IMAGE3D:
1007 free(get_pointer(&n[11]));
1008 n += InstSize[n[0].opcode];
1009 break;
1010 case OPCODE_COMPRESSED_TEX_IMAGE_1D:
1011 free(get_pointer(&n[7]));
1012 n += InstSize[n[0].opcode];
1013 break;
1014 case OPCODE_COMPRESSED_TEX_IMAGE_2D:
1015 free(get_pointer(&n[8]));
1016 n += InstSize[n[0].opcode];
1017 break;
1018 case OPCODE_COMPRESSED_TEX_IMAGE_3D:
1019 free(get_pointer(&n[9]));
1020 n += InstSize[n[0].opcode];
1021 break;
1022 case OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D:
1023 free(get_pointer(&n[7]));
1024 n += InstSize[n[0].opcode];
1025 break;
1026 case OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D:
1027 free(get_pointer(&n[9]));
1028 n += InstSize[n[0].opcode];
1029 break;
1030 case OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D:
1031 free(get_pointer(&n[11]));
1032 n += InstSize[n[0].opcode];
1033 break;
1034 case OPCODE_PROGRAM_STRING_ARB:
1035 free(get_pointer(&n[4])); /* program string */
1036 n += InstSize[n[0].opcode];
1037 break;
1038 case OPCODE_UNIFORM_1FV:
1039 case OPCODE_UNIFORM_2FV:
1040 case OPCODE_UNIFORM_3FV:
1041 case OPCODE_UNIFORM_4FV:
1042 case OPCODE_UNIFORM_1IV:
1043 case OPCODE_UNIFORM_2IV:
1044 case OPCODE_UNIFORM_3IV:
1045 case OPCODE_UNIFORM_4IV:
1046 case OPCODE_UNIFORM_1UIV:
1047 case OPCODE_UNIFORM_2UIV:
1048 case OPCODE_UNIFORM_3UIV:
1049 case OPCODE_UNIFORM_4UIV:
1050 free(get_pointer(&n[3]));
1051 n += InstSize[n[0].opcode];
1052 break;
1053 case OPCODE_UNIFORM_MATRIX22:
1054 case OPCODE_UNIFORM_MATRIX33:
1055 case OPCODE_UNIFORM_MATRIX44:
1056 case OPCODE_UNIFORM_MATRIX24:
1057 case OPCODE_UNIFORM_MATRIX42:
1058 case OPCODE_UNIFORM_MATRIX23:
1059 case OPCODE_UNIFORM_MATRIX32:
1060 case OPCODE_UNIFORM_MATRIX34:
1061 case OPCODE_UNIFORM_MATRIX43:
1062 free(get_pointer(&n[4]));
1063 n += InstSize[n[0].opcode];
1064 break;
1065 case OPCODE_PROGRAM_UNIFORM_1FV:
1066 case OPCODE_PROGRAM_UNIFORM_2FV:
1067 case OPCODE_PROGRAM_UNIFORM_3FV:
1068 case OPCODE_PROGRAM_UNIFORM_4FV:
1069 case OPCODE_PROGRAM_UNIFORM_1IV:
1070 case OPCODE_PROGRAM_UNIFORM_2IV:
1071 case OPCODE_PROGRAM_UNIFORM_3IV:
1072 case OPCODE_PROGRAM_UNIFORM_4IV:
1073 case OPCODE_PROGRAM_UNIFORM_1UIV:
1074 case OPCODE_PROGRAM_UNIFORM_2UIV:
1075 case OPCODE_PROGRAM_UNIFORM_3UIV:
1076 case OPCODE_PROGRAM_UNIFORM_4UIV:
1077 free(get_pointer(&n[4]));
1078 n += InstSize[n[0].opcode];
1079 break;
1080 case OPCODE_PROGRAM_UNIFORM_MATRIX22F:
1081 case OPCODE_PROGRAM_UNIFORM_MATRIX33F:
1082 case OPCODE_PROGRAM_UNIFORM_MATRIX44F:
1083 case OPCODE_PROGRAM_UNIFORM_MATRIX24F:
1084 case OPCODE_PROGRAM_UNIFORM_MATRIX42F:
1085 case OPCODE_PROGRAM_UNIFORM_MATRIX23F:
1086 case OPCODE_PROGRAM_UNIFORM_MATRIX32F:
1087 case OPCODE_PROGRAM_UNIFORM_MATRIX34F:
1088 case OPCODE_PROGRAM_UNIFORM_MATRIX43F:
1089 free(get_pointer(&n[5]));
1090 n += InstSize[n[0].opcode];
1091 break;
1092 case OPCODE_PIXEL_MAP:
1093 free(get_pointer(&n[3]));
1094 n += InstSize[n[0].opcode];
1095 break;
1096 case OPCODE_WINDOW_RECTANGLES:
1097 free(get_pointer(&n[3]));
1098 n += InstSize[n[0].opcode];
1099 break;
1100 case OPCODE_CONTINUE:
1101 n = (Node *) get_pointer(&n[1]);
1102 free(block);
1103 block = n;
1104 break;
1105 case OPCODE_END_OF_LIST:
1106 free(block);
1107 done = GL_TRUE;
1108 break;
1109 default:
1110 /* Most frequent case */
1111 n += InstSize[n[0].opcode];
1112 break;
1113 }
1114 }
1115 }
1116
1117 free(dlist->Label);
1118 free(dlist);
1119 }
1120
1121
1122 /**
1123 * Called by _mesa_HashWalk() to check if a display list which is being
1124 * deleted belongs to a bitmap texture atlas.
1125 */
1126 static void
1127 check_atlas_for_deleted_list(GLuint atlas_id, void *data, void *userData)
1128 {
1129 struct gl_bitmap_atlas *atlas = (struct gl_bitmap_atlas *) data;
1130 GLuint list_id = *((GLuint *) userData); /* the list being deleted */
1131
1132 /* See if the list_id falls in the range contained in this texture atlas */
1133 if (atlas->complete &&
1134 list_id >= atlas_id &&
1135 list_id < atlas_id + atlas->numBitmaps) {
1136 /* Mark the atlas as incomplete so it doesn't get used. But don't
1137 * delete it yet since we don't want to try to recreate it in the next
1138 * glCallLists.
1139 */
1140 atlas->complete = false;
1141 atlas->incomplete = true;
1142 }
1143 }
1144
1145
1146 /**
1147 * Destroy a display list and remove from hash table.
1148 * \param list - display list number
1149 */
1150 static void
1151 destroy_list(struct gl_context *ctx, GLuint list)
1152 {
1153 struct gl_display_list *dlist;
1154
1155 if (list == 0)
1156 return;
1157
1158 dlist = _mesa_lookup_list(ctx, list);
1159 if (!dlist)
1160 return;
1161
1162 if (is_bitmap_list(dlist)) {
1163 /* If we're destroying a simple glBitmap display list, there's a
1164 * chance that we're destroying a bitmap image that's in a texture
1165 * atlas. Examine all atlases to see if that's the case. There's
1166 * usually few (if any) atlases so this isn't expensive.
1167 */
1168 _mesa_HashWalk(ctx->Shared->BitmapAtlas,
1169 check_atlas_for_deleted_list, &list);
1170 }
1171
1172 _mesa_delete_list(ctx, dlist);
1173 _mesa_HashRemove(ctx->Shared->DisplayList, list);
1174 }
1175
1176
1177 /*
1178 * Translate the nth element of list from <type> to GLint.
1179 */
1180 static GLint
1181 translate_id(GLsizei n, GLenum type, const GLvoid * list)
1182 {
1183 GLbyte *bptr;
1184 GLubyte *ubptr;
1185 GLshort *sptr;
1186 GLushort *usptr;
1187 GLint *iptr;
1188 GLuint *uiptr;
1189 GLfloat *fptr;
1190
1191 switch (type) {
1192 case GL_BYTE:
1193 bptr = (GLbyte *) list;
1194 return (GLint) bptr[n];
1195 case GL_UNSIGNED_BYTE:
1196 ubptr = (GLubyte *) list;
1197 return (GLint) ubptr[n];
1198 case GL_SHORT:
1199 sptr = (GLshort *) list;
1200 return (GLint) sptr[n];
1201 case GL_UNSIGNED_SHORT:
1202 usptr = (GLushort *) list;
1203 return (GLint) usptr[n];
1204 case GL_INT:
1205 iptr = (GLint *) list;
1206 return iptr[n];
1207 case GL_UNSIGNED_INT:
1208 uiptr = (GLuint *) list;
1209 return (GLint) uiptr[n];
1210 case GL_FLOAT:
1211 fptr = (GLfloat *) list;
1212 return (GLint) floorf(fptr[n]);
1213 case GL_2_BYTES:
1214 ubptr = ((GLubyte *) list) + 2 * n;
1215 return (GLint) ubptr[0] * 256
1216 + (GLint) ubptr[1];
1217 case GL_3_BYTES:
1218 ubptr = ((GLubyte *) list) + 3 * n;
1219 return (GLint) ubptr[0] * 65536
1220 + (GLint) ubptr[1] * 256
1221 + (GLint) ubptr[2];
1222 case GL_4_BYTES:
1223 ubptr = ((GLubyte *) list) + 4 * n;
1224 return (GLint) ubptr[0] * 16777216
1225 + (GLint) ubptr[1] * 65536
1226 + (GLint) ubptr[2] * 256
1227 + (GLint) ubptr[3];
1228 default:
1229 return 0;
1230 }
1231 }
1232
1233
1234 /**
1235 * Wrapper for _mesa_unpack_image/bitmap() that handles pixel buffer objects.
1236 * If width < 0 or height < 0 or format or type are invalid we'll just
1237 * return NULL. We will not generate an error since OpenGL command
1238 * arguments aren't error-checked until the command is actually executed
1239 * (not when they're compiled).
1240 * But if we run out of memory, GL_OUT_OF_MEMORY will be recorded.
1241 */
1242 static GLvoid *
1243 unpack_image(struct gl_context *ctx, GLuint dimensions,
1244 GLsizei width, GLsizei height, GLsizei depth,
1245 GLenum format, GLenum type, const GLvoid * pixels,
1246 const struct gl_pixelstore_attrib *unpack)
1247 {
1248 if (width <= 0 || height <= 0) {
1249 return NULL;
1250 }
1251
1252 if (_mesa_bytes_per_pixel(format, type) < 0) {
1253 /* bad format and/or type */
1254 return NULL;
1255 }
1256
1257 if (!_mesa_is_bufferobj(unpack->BufferObj)) {
1258 /* no PBO */
1259 GLvoid *image;
1260
1261 image = _mesa_unpack_image(dimensions, width, height, depth,
1262 format, type, pixels, unpack);
1263 if (pixels && !image) {
1264 _mesa_error(ctx, GL_OUT_OF_MEMORY, "display list construction");
1265 }
1266 return image;
1267 }
1268 else if (_mesa_validate_pbo_access(dimensions, unpack, width, height,
1269 depth, format, type, INT_MAX, pixels)) {
1270 const GLubyte *map, *src;
1271 GLvoid *image;
1272
1273 map = (GLubyte *)
1274 ctx->Driver.MapBufferRange(ctx, 0, unpack->BufferObj->Size,
1275 GL_MAP_READ_BIT, unpack->BufferObj,
1276 MAP_INTERNAL);
1277 if (!map) {
1278 /* unable to map src buffer! */
1279 _mesa_error(ctx, GL_INVALID_OPERATION, "unable to map PBO");
1280 return NULL;
1281 }
1282
1283 src = ADD_POINTERS(map, pixels);
1284 image = _mesa_unpack_image(dimensions, width, height, depth,
1285 format, type, src, unpack);
1286
1287 ctx->Driver.UnmapBuffer(ctx, unpack->BufferObj, MAP_INTERNAL);
1288
1289 if (!image) {
1290 _mesa_error(ctx, GL_OUT_OF_MEMORY, "display list construction");
1291 }
1292 return image;
1293 }
1294
1295 /* bad access! */
1296 _mesa_error(ctx, GL_INVALID_OPERATION, "invalid PBO access");
1297 return NULL;
1298 }
1299
1300
1301 /** Return copy of memory */
1302 static void *
1303 memdup(const void *src, GLsizei bytes)
1304 {
1305 void *b = bytes >= 0 ? malloc(bytes) : NULL;
1306 if (b)
1307 memcpy(b, src, bytes);
1308 return b;
1309 }
1310
1311
1312 /**
1313 * Allocate space for a display list instruction (opcode + payload space).
1314 * \param opcode the instruction opcode (OPCODE_* value)
1315 * \param bytes instruction payload size (not counting opcode)
1316 * \param align8 does the payload need to be 8-byte aligned?
1317 * This is only relevant in 64-bit environments.
1318 * \return pointer to allocated memory (the payload will be at pointer+1)
1319 */
1320 static Node *
1321 dlist_alloc(struct gl_context *ctx, OpCode opcode, GLuint bytes, bool align8)
1322 {
1323 const GLuint numNodes = 1 + (bytes + sizeof(Node) - 1) / sizeof(Node);
1324 const GLuint contNodes = 1 + POINTER_DWORDS; /* size of continue info */
1325 GLuint nopNode;
1326 Node *n;
1327
1328 if (opcode < OPCODE_EXT_0) {
1329 if (InstSize[opcode] == 0) {
1330 /* save instruction size now */
1331 InstSize[opcode] = numNodes;
1332 }
1333 else {
1334 /* make sure instruction size agrees */
1335 assert(numNodes == InstSize[opcode]);
1336 }
1337 }
1338
1339 if (sizeof(void *) > sizeof(Node) && align8
1340 && ctx->ListState.CurrentPos % 2 == 0) {
1341 /* The opcode would get placed at node[0] and the payload would start
1342 * at node[1]. But the payload needs to be at an even offset (8-byte
1343 * multiple).
1344 */
1345 nopNode = 1;
1346 }
1347 else {
1348 nopNode = 0;
1349 }
1350
1351 if (ctx->ListState.CurrentPos + nopNode + numNodes + contNodes
1352 > BLOCK_SIZE) {
1353 /* This block is full. Allocate a new block and chain to it */
1354 Node *newblock;
1355 n = ctx->ListState.CurrentBlock + ctx->ListState.CurrentPos;
1356 n[0].opcode = OPCODE_CONTINUE;
1357 newblock = malloc(sizeof(Node) * BLOCK_SIZE);
1358 if (!newblock) {
1359 _mesa_error(ctx, GL_OUT_OF_MEMORY, "Building display list");
1360 return NULL;
1361 }
1362
1363 /* a fresh block should be 8-byte aligned on 64-bit systems */
1364 assert(((GLintptr) newblock) % sizeof(void *) == 0);
1365
1366 save_pointer(&n[1], newblock);
1367 ctx->ListState.CurrentBlock = newblock;
1368 ctx->ListState.CurrentPos = 0;
1369
1370 /* Display list nodes are always 4 bytes. If we need 8-byte alignment
1371 * we have to insert a NOP so that the payload of the real opcode lands
1372 * on an even location:
1373 * node[0] = OPCODE_NOP
1374 * node[1] = OPCODE_x;
1375 * node[2] = start of payload
1376 */
1377 nopNode = sizeof(void *) > sizeof(Node) && align8;
1378 }
1379
1380 n = ctx->ListState.CurrentBlock + ctx->ListState.CurrentPos;
1381 if (nopNode) {
1382 assert(ctx->ListState.CurrentPos % 2 == 0); /* even value */
1383 n[0].opcode = OPCODE_NOP;
1384 n++;
1385 /* The "real" opcode will now be at an odd location and the payload
1386 * will be at an even location.
1387 */
1388 }
1389 ctx->ListState.CurrentPos += nopNode + numNodes;
1390
1391 n[0].opcode = opcode;
1392
1393 return n;
1394 }
1395
1396
1397
1398 /**
1399 * Allocate space for a display list instruction. Used by callers outside
1400 * this file for things like VBO vertex data.
1401 *
1402 * \param opcode the instruction opcode (OPCODE_* value)
1403 * \param bytes instruction size in bytes, not counting opcode.
1404 * \return pointer to the usable data area (not including the internal
1405 * opcode).
1406 */
1407 void *
1408 _mesa_dlist_alloc(struct gl_context *ctx, GLuint opcode, GLuint bytes)
1409 {
1410 Node *n = dlist_alloc(ctx, (OpCode) opcode, bytes, false);
1411 if (n)
1412 return n + 1; /* return pointer to payload area, after opcode */
1413 else
1414 return NULL;
1415 }
1416
1417
1418 /**
1419 * Same as _mesa_dlist_alloc(), but return a pointer which is 8-byte
1420 * aligned in 64-bit environments, 4-byte aligned otherwise.
1421 */
1422 void *
1423 _mesa_dlist_alloc_aligned(struct gl_context *ctx, GLuint opcode, GLuint bytes)
1424 {
1425 Node *n = dlist_alloc(ctx, (OpCode) opcode, bytes, true);
1426 if (n)
1427 return n + 1; /* return pointer to payload area, after opcode */
1428 else
1429 return NULL;
1430 }
1431
1432
1433 /**
1434 * This function allows modules and drivers to get their own opcodes
1435 * for extending display list functionality.
1436 * \param ctx the rendering context
1437 * \param size number of bytes for storing the new display list command
1438 * \param execute function to execute the new display list command
1439 * \param destroy function to destroy the new display list command
1440 * \param print function to print the new display list command
1441 * \return the new opcode number or -1 if error
1442 */
1443 GLint
1444 _mesa_dlist_alloc_opcode(struct gl_context *ctx,
1445 GLuint size,
1446 void (*execute) (struct gl_context *, void *),
1447 void (*destroy) (struct gl_context *, void *),
1448 void (*print) (struct gl_context *, void *, FILE *))
1449 {
1450 if (ctx->ListExt->NumOpcodes < MAX_DLIST_EXT_OPCODES) {
1451 const GLuint i = ctx->ListExt->NumOpcodes++;
1452 ctx->ListExt->Opcode[i].Size =
1453 1 + (size + sizeof(Node) - 1) / sizeof(Node);
1454 ctx->ListExt->Opcode[i].Execute = execute;
1455 ctx->ListExt->Opcode[i].Destroy = destroy;
1456 ctx->ListExt->Opcode[i].Print = print;
1457 return i + OPCODE_EXT_0;
1458 }
1459 return -1;
1460 }
1461
1462
1463 /**
1464 * Allocate space for a display list instruction. The space is basically
1465 * an array of Nodes where node[0] holds the opcode, node[1] is the first
1466 * function parameter, node[2] is the second parameter, etc.
1467 *
1468 * \param opcode one of OPCODE_x
1469 * \param nparams number of function parameters
1470 * \return pointer to start of instruction space
1471 */
1472 static inline Node *
1473 alloc_instruction(struct gl_context *ctx, OpCode opcode, GLuint nparams)
1474 {
1475 return dlist_alloc(ctx, opcode, nparams * sizeof(Node), false);
1476 }
1477
1478
1479 /**
1480 * Called by EndList to try to reduce memory used for the list.
1481 */
1482 static void
1483 trim_list(struct gl_context *ctx)
1484 {
1485 /* If the list we're ending only has one allocated block of nodes/tokens
1486 * and its size isn't a full block size, realloc the block to use less
1487 * memory. This is important for apps that create many small display
1488 * lists and apps that use glXUseXFont (many lists each containing one
1489 * glBitmap call).
1490 * Note: we currently only trim display lists that allocated one block
1491 * of tokens. That hits the short list case which is what we're mainly
1492 * concerned with. Trimming longer lists would involve traversing the
1493 * linked list of blocks.
1494 */
1495 struct gl_dlist_state *list = &ctx->ListState;
1496
1497 if ((list->CurrentList->Head == list->CurrentBlock) &&
1498 (list->CurrentPos < BLOCK_SIZE)) {
1499 /* There's only one block and it's not full, so realloc */
1500 GLuint newSize = list->CurrentPos * sizeof(Node);
1501 list->CurrentList->Head =
1502 list->CurrentBlock = realloc(list->CurrentBlock, newSize);
1503 if (!list->CurrentBlock) {
1504 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glEndList");
1505 }
1506 }
1507 }
1508
1509
1510
1511 /*
1512 * Display List compilation functions
1513 */
1514 static void GLAPIENTRY
1515 save_Accum(GLenum op, GLfloat value)
1516 {
1517 GET_CURRENT_CONTEXT(ctx);
1518 Node *n;
1519 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1520 n = alloc_instruction(ctx, OPCODE_ACCUM, 2);
1521 if (n) {
1522 n[1].e = op;
1523 n[2].f = value;
1524 }
1525 if (ctx->ExecuteFlag) {
1526 CALL_Accum(ctx->Exec, (op, value));
1527 }
1528 }
1529
1530
1531 static void GLAPIENTRY
1532 save_AlphaFunc(GLenum func, GLclampf ref)
1533 {
1534 GET_CURRENT_CONTEXT(ctx);
1535 Node *n;
1536 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1537 n = alloc_instruction(ctx, OPCODE_ALPHA_FUNC, 2);
1538 if (n) {
1539 n[1].e = func;
1540 n[2].f = (GLfloat) ref;
1541 }
1542 if (ctx->ExecuteFlag) {
1543 CALL_AlphaFunc(ctx->Exec, (func, ref));
1544 }
1545 }
1546
1547
1548 static void GLAPIENTRY
1549 save_BindTexture(GLenum target, GLuint texture)
1550 {
1551 GET_CURRENT_CONTEXT(ctx);
1552 Node *n;
1553 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1554 n = alloc_instruction(ctx, OPCODE_BIND_TEXTURE, 2);
1555 if (n) {
1556 n[1].e = target;
1557 n[2].ui = texture;
1558 }
1559 if (ctx->ExecuteFlag) {
1560 CALL_BindTexture(ctx->Exec, (target, texture));
1561 }
1562 }
1563
1564
1565 static void GLAPIENTRY
1566 save_Bitmap(GLsizei width, GLsizei height,
1567 GLfloat xorig, GLfloat yorig,
1568 GLfloat xmove, GLfloat ymove, const GLubyte * pixels)
1569 {
1570 GET_CURRENT_CONTEXT(ctx);
1571 Node *n;
1572 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1573 n = alloc_instruction(ctx, OPCODE_BITMAP, 6 + POINTER_DWORDS);
1574 if (n) {
1575 n[1].i = (GLint) width;
1576 n[2].i = (GLint) height;
1577 n[3].f = xorig;
1578 n[4].f = yorig;
1579 n[5].f = xmove;
1580 n[6].f = ymove;
1581 save_pointer(&n[7],
1582 unpack_image(ctx, 2, width, height, 1, GL_COLOR_INDEX,
1583 GL_BITMAP, pixels, &ctx->Unpack));
1584 }
1585 if (ctx->ExecuteFlag) {
1586 CALL_Bitmap(ctx->Exec, (width, height,
1587 xorig, yorig, xmove, ymove, pixels));
1588 }
1589 }
1590
1591
1592 static void GLAPIENTRY
1593 save_BlendEquation(GLenum mode)
1594 {
1595 GET_CURRENT_CONTEXT(ctx);
1596 Node *n;
1597 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1598 n = alloc_instruction(ctx, OPCODE_BLEND_EQUATION, 1);
1599 if (n) {
1600 n[1].e = mode;
1601 }
1602 if (ctx->ExecuteFlag) {
1603 CALL_BlendEquation(ctx->Exec, (mode));
1604 }
1605 }
1606
1607
1608 static void GLAPIENTRY
1609 save_BlendEquationSeparateEXT(GLenum modeRGB, GLenum modeA)
1610 {
1611 GET_CURRENT_CONTEXT(ctx);
1612 Node *n;
1613 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1614 n = alloc_instruction(ctx, OPCODE_BLEND_EQUATION_SEPARATE, 2);
1615 if (n) {
1616 n[1].e = modeRGB;
1617 n[2].e = modeA;
1618 }
1619 if (ctx->ExecuteFlag) {
1620 CALL_BlendEquationSeparate(ctx->Exec, (modeRGB, modeA));
1621 }
1622 }
1623
1624
1625 static void GLAPIENTRY
1626 save_BlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB,
1627 GLenum sfactorA, GLenum dfactorA)
1628 {
1629 GET_CURRENT_CONTEXT(ctx);
1630 Node *n;
1631 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1632 n = alloc_instruction(ctx, OPCODE_BLEND_FUNC_SEPARATE, 4);
1633 if (n) {
1634 n[1].e = sfactorRGB;
1635 n[2].e = dfactorRGB;
1636 n[3].e = sfactorA;
1637 n[4].e = dfactorA;
1638 }
1639 if (ctx->ExecuteFlag) {
1640 CALL_BlendFuncSeparate(ctx->Exec,
1641 (sfactorRGB, dfactorRGB, sfactorA, dfactorA));
1642 }
1643 }
1644
1645
1646 static void GLAPIENTRY
1647 save_BlendFunc(GLenum srcfactor, GLenum dstfactor)
1648 {
1649 save_BlendFuncSeparateEXT(srcfactor, dstfactor, srcfactor, dstfactor);
1650 }
1651
1652
1653 static void GLAPIENTRY
1654 save_BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
1655 {
1656 GET_CURRENT_CONTEXT(ctx);
1657 Node *n;
1658 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1659 n = alloc_instruction(ctx, OPCODE_BLEND_COLOR, 4);
1660 if (n) {
1661 n[1].f = red;
1662 n[2].f = green;
1663 n[3].f = blue;
1664 n[4].f = alpha;
1665 }
1666 if (ctx->ExecuteFlag) {
1667 CALL_BlendColor(ctx->Exec, (red, green, blue, alpha));
1668 }
1669 }
1670
1671 /* GL_ARB_draw_buffers_blend */
1672 static void GLAPIENTRY
1673 save_BlendFuncSeparatei(GLuint buf, GLenum sfactorRGB, GLenum dfactorRGB,
1674 GLenum sfactorA, GLenum dfactorA)
1675 {
1676 GET_CURRENT_CONTEXT(ctx);
1677 Node *n;
1678 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1679 n = alloc_instruction(ctx, OPCODE_BLEND_FUNC_SEPARATE_I, 5);
1680 if (n) {
1681 n[1].ui = buf;
1682 n[2].e = sfactorRGB;
1683 n[3].e = dfactorRGB;
1684 n[4].e = sfactorA;
1685 n[5].e = dfactorA;
1686 }
1687 if (ctx->ExecuteFlag) {
1688 CALL_BlendFuncSeparateiARB(ctx->Exec, (buf, sfactorRGB, dfactorRGB,
1689 sfactorA, dfactorA));
1690 }
1691 }
1692
1693 /* GL_ARB_draw_buffers_blend */
1694 static void GLAPIENTRY
1695 save_BlendFunci(GLuint buf, GLenum sfactor, GLenum dfactor)
1696 {
1697 GET_CURRENT_CONTEXT(ctx);
1698 Node *n;
1699 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1700 n = alloc_instruction(ctx, OPCODE_BLEND_FUNC_I, 3);
1701 if (n) {
1702 n[1].ui = buf;
1703 n[2].e = sfactor;
1704 n[3].e = dfactor;
1705 }
1706 if (ctx->ExecuteFlag) {
1707 CALL_BlendFunciARB(ctx->Exec, (buf, sfactor, dfactor));
1708 }
1709 }
1710
1711 /* GL_ARB_draw_buffers_blend */
1712 static void GLAPIENTRY
1713 save_BlendEquationi(GLuint buf, GLenum mode)
1714 {
1715 GET_CURRENT_CONTEXT(ctx);
1716 Node *n;
1717 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1718 n = alloc_instruction(ctx, OPCODE_BLEND_EQUATION_I, 2);
1719 if (n) {
1720 n[1].ui = buf;
1721 n[2].e = mode;
1722 }
1723 if (ctx->ExecuteFlag) {
1724 CALL_BlendEquationiARB(ctx->Exec, (buf, mode));
1725 }
1726 }
1727
1728 /* GL_ARB_draw_buffers_blend */
1729 static void GLAPIENTRY
1730 save_BlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeA)
1731 {
1732 GET_CURRENT_CONTEXT(ctx);
1733 Node *n;
1734 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1735 n = alloc_instruction(ctx, OPCODE_BLEND_EQUATION_SEPARATE_I, 3);
1736 if (n) {
1737 n[1].ui = buf;
1738 n[2].e = modeRGB;
1739 n[3].e = modeA;
1740 }
1741 if (ctx->ExecuteFlag) {
1742 CALL_BlendEquationSeparateiARB(ctx->Exec, (buf, modeRGB, modeA));
1743 }
1744 }
1745
1746
1747 /* GL_ARB_draw_instanced. */
1748 static void GLAPIENTRY
1749 save_DrawArraysInstancedARB(UNUSED GLenum mode,
1750 UNUSED GLint first,
1751 UNUSED GLsizei count,
1752 UNUSED GLsizei primcount)
1753 {
1754 GET_CURRENT_CONTEXT(ctx);
1755 _mesa_error(ctx, GL_INVALID_OPERATION,
1756 "glDrawArraysInstanced() during display list compile");
1757 }
1758
1759 static void GLAPIENTRY
1760 save_DrawElementsInstancedARB(UNUSED GLenum mode,
1761 UNUSED GLsizei count,
1762 UNUSED GLenum type,
1763 UNUSED const GLvoid *indices,
1764 UNUSED GLsizei primcount)
1765 {
1766 GET_CURRENT_CONTEXT(ctx);
1767 _mesa_error(ctx, GL_INVALID_OPERATION,
1768 "glDrawElementsInstanced() during display list compile");
1769 }
1770
1771 static void GLAPIENTRY
1772 save_DrawElementsInstancedBaseVertexARB(UNUSED GLenum mode,
1773 UNUSED GLsizei count,
1774 UNUSED GLenum type,
1775 UNUSED const GLvoid *indices,
1776 UNUSED GLsizei primcount,
1777 UNUSED GLint basevertex)
1778 {
1779 GET_CURRENT_CONTEXT(ctx);
1780 _mesa_error(ctx, GL_INVALID_OPERATION,
1781 "glDrawElementsInstancedBaseVertex() during display list compile");
1782 }
1783
1784 /* GL_ARB_base_instance. */
1785 static void GLAPIENTRY
1786 save_DrawArraysInstancedBaseInstance(UNUSED GLenum mode,
1787 UNUSED GLint first,
1788 UNUSED GLsizei count,
1789 UNUSED GLsizei primcount,
1790 UNUSED GLuint baseinstance)
1791 {
1792 GET_CURRENT_CONTEXT(ctx);
1793 _mesa_error(ctx, GL_INVALID_OPERATION,
1794 "glDrawArraysInstancedBaseInstance() during display list compile");
1795 }
1796
1797 static void APIENTRY
1798 save_DrawElementsInstancedBaseInstance(UNUSED GLenum mode,
1799 UNUSED GLsizei count,
1800 UNUSED GLenum type,
1801 UNUSED const void *indices,
1802 UNUSED GLsizei primcount,
1803 UNUSED GLuint baseinstance)
1804 {
1805 GET_CURRENT_CONTEXT(ctx);
1806 _mesa_error(ctx, GL_INVALID_OPERATION,
1807 "glDrawElementsInstancedBaseInstance() during display list compile");
1808 }
1809
1810 static void APIENTRY
1811 save_DrawElementsInstancedBaseVertexBaseInstance(UNUSED GLenum mode,
1812 UNUSED GLsizei count,
1813 UNUSED GLenum type,
1814 UNUSED const void *indices,
1815 UNUSED GLsizei primcount,
1816 UNUSED GLint basevertex,
1817 UNUSED GLuint baseinstance)
1818 {
1819 GET_CURRENT_CONTEXT(ctx);
1820 _mesa_error(ctx, GL_INVALID_OPERATION,
1821 "glDrawElementsInstancedBaseVertexBaseInstance() during display list compile");
1822 }
1823
1824
1825 /**
1826 * While building a display list we cache some OpenGL state.
1827 * Under some circumstances we need to invalidate that state (immediately
1828 * when we start compiling a list, or after glCallList(s)).
1829 */
1830 static void
1831 invalidate_saved_current_state(struct gl_context *ctx)
1832 {
1833 GLint i;
1834
1835 for (i = 0; i < VERT_ATTRIB_MAX; i++)
1836 ctx->ListState.ActiveAttribSize[i] = 0;
1837
1838 for (i = 0; i < MAT_ATTRIB_MAX; i++)
1839 ctx->ListState.ActiveMaterialSize[i] = 0;
1840
1841 memset(&ctx->ListState.Current, 0, sizeof ctx->ListState.Current);
1842
1843 ctx->Driver.CurrentSavePrimitive = PRIM_UNKNOWN;
1844 }
1845
1846
1847 static void GLAPIENTRY
1848 save_CallList(GLuint list)
1849 {
1850 GET_CURRENT_CONTEXT(ctx);
1851 Node *n;
1852 SAVE_FLUSH_VERTICES(ctx);
1853
1854 n = alloc_instruction(ctx, OPCODE_CALL_LIST, 1);
1855 if (n) {
1856 n[1].ui = list;
1857 }
1858
1859 /* After this, we don't know what state we're in. Invalidate all
1860 * cached information previously gathered:
1861 */
1862 invalidate_saved_current_state( ctx );
1863
1864 if (ctx->ExecuteFlag) {
1865 _mesa_CallList(list);
1866 }
1867 }
1868
1869
1870 static void GLAPIENTRY
1871 save_CallLists(GLsizei num, GLenum type, const GLvoid * lists)
1872 {
1873 GET_CURRENT_CONTEXT(ctx);
1874 unsigned type_size;
1875 Node *n;
1876 void *lists_copy;
1877
1878 SAVE_FLUSH_VERTICES(ctx);
1879
1880 switch (type) {
1881 case GL_BYTE:
1882 case GL_UNSIGNED_BYTE:
1883 type_size = 1;
1884 break;
1885 case GL_SHORT:
1886 case GL_UNSIGNED_SHORT:
1887 case GL_2_BYTES:
1888 type_size = 2;
1889 break;
1890 case GL_3_BYTES:
1891 type_size = 3;
1892 break;
1893 case GL_INT:
1894 case GL_UNSIGNED_INT:
1895 case GL_FLOAT:
1896 case GL_4_BYTES:
1897 type_size = 4;
1898 break;
1899 default:
1900 type_size = 0;
1901 }
1902
1903 if (num > 0 && type_size > 0) {
1904 /* create a copy of the array of list IDs to save in the display list */
1905 lists_copy = memdup(lists, num * type_size);
1906 } else {
1907 lists_copy = NULL;
1908 }
1909
1910 n = alloc_instruction(ctx, OPCODE_CALL_LISTS, 2 + POINTER_DWORDS);
1911 if (n) {
1912 n[1].i = num;
1913 n[2].e = type;
1914 save_pointer(&n[3], lists_copy);
1915 };
1916
1917 /* After this, we don't know what state we're in. Invalidate all
1918 * cached information previously gathered:
1919 */
1920 invalidate_saved_current_state( ctx );
1921
1922 if (ctx->ExecuteFlag) {
1923 CALL_CallLists(ctx->Exec, (num, type, lists));
1924 }
1925 }
1926
1927
1928 static void GLAPIENTRY
1929 save_Clear(GLbitfield mask)
1930 {
1931 GET_CURRENT_CONTEXT(ctx);
1932 Node *n;
1933 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1934 n = alloc_instruction(ctx, OPCODE_CLEAR, 1);
1935 if (n) {
1936 n[1].bf = mask;
1937 }
1938 if (ctx->ExecuteFlag) {
1939 CALL_Clear(ctx->Exec, (mask));
1940 }
1941 }
1942
1943
1944 static void GLAPIENTRY
1945 save_ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
1946 {
1947 GET_CURRENT_CONTEXT(ctx);
1948 Node *n;
1949 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1950 n = alloc_instruction(ctx, OPCODE_CLEAR_BUFFER_IV, 6);
1951 if (n) {
1952 n[1].e = buffer;
1953 n[2].i = drawbuffer;
1954 n[3].i = value[0];
1955 if (buffer == GL_COLOR) {
1956 n[4].i = value[1];
1957 n[5].i = value[2];
1958 n[6].i = value[3];
1959 }
1960 else {
1961 n[4].i = 0;
1962 n[5].i = 0;
1963 n[6].i = 0;
1964 }
1965 }
1966 if (ctx->ExecuteFlag) {
1967 CALL_ClearBufferiv(ctx->Exec, (buffer, drawbuffer, value));
1968 }
1969 }
1970
1971
1972 static void GLAPIENTRY
1973 save_ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
1974 {
1975 GET_CURRENT_CONTEXT(ctx);
1976 Node *n;
1977 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
1978 n = alloc_instruction(ctx, OPCODE_CLEAR_BUFFER_UIV, 6);
1979 if (n) {
1980 n[1].e = buffer;
1981 n[2].i = drawbuffer;
1982 n[3].ui = value[0];
1983 if (buffer == GL_COLOR) {
1984 n[4].ui = value[1];
1985 n[5].ui = value[2];
1986 n[6].ui = value[3];
1987 }
1988 else {
1989 n[4].ui = 0;
1990 n[5].ui = 0;
1991 n[6].ui = 0;
1992 }
1993 }
1994 if (ctx->ExecuteFlag) {
1995 CALL_ClearBufferuiv(ctx->Exec, (buffer, drawbuffer, value));
1996 }
1997 }
1998
1999
2000 static void GLAPIENTRY
2001 save_ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
2002 {
2003 GET_CURRENT_CONTEXT(ctx);
2004 Node *n;
2005 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2006 n = alloc_instruction(ctx, OPCODE_CLEAR_BUFFER_FV, 6);
2007 if (n) {
2008 n[1].e = buffer;
2009 n[2].i = drawbuffer;
2010 n[3].f = value[0];
2011 if (buffer == GL_COLOR) {
2012 n[4].f = value[1];
2013 n[5].f = value[2];
2014 n[6].f = value[3];
2015 }
2016 else {
2017 n[4].f = 0.0F;
2018 n[5].f = 0.0F;
2019 n[6].f = 0.0F;
2020 }
2021 }
2022 if (ctx->ExecuteFlag) {
2023 CALL_ClearBufferfv(ctx->Exec, (buffer, drawbuffer, value));
2024 }
2025 }
2026
2027
2028 static void GLAPIENTRY
2029 save_ClearBufferfi(GLenum buffer, GLint drawbuffer,
2030 GLfloat depth, GLint stencil)
2031 {
2032 GET_CURRENT_CONTEXT(ctx);
2033 Node *n;
2034 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2035 n = alloc_instruction(ctx, OPCODE_CLEAR_BUFFER_FI, 4);
2036 if (n) {
2037 n[1].e = buffer;
2038 n[2].i = drawbuffer;
2039 n[3].f = depth;
2040 n[4].i = stencil;
2041 }
2042 if (ctx->ExecuteFlag) {
2043 CALL_ClearBufferfi(ctx->Exec, (buffer, drawbuffer, depth, stencil));
2044 }
2045 }
2046
2047
2048 static void GLAPIENTRY
2049 save_ClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
2050 {
2051 GET_CURRENT_CONTEXT(ctx);
2052 Node *n;
2053 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2054 n = alloc_instruction(ctx, OPCODE_CLEAR_ACCUM, 4);
2055 if (n) {
2056 n[1].f = red;
2057 n[2].f = green;
2058 n[3].f = blue;
2059 n[4].f = alpha;
2060 }
2061 if (ctx->ExecuteFlag) {
2062 CALL_ClearAccum(ctx->Exec, (red, green, blue, alpha));
2063 }
2064 }
2065
2066
2067 static void GLAPIENTRY
2068 save_ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
2069 {
2070 GET_CURRENT_CONTEXT(ctx);
2071 Node *n;
2072 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2073 n = alloc_instruction(ctx, OPCODE_CLEAR_COLOR, 4);
2074 if (n) {
2075 n[1].f = red;
2076 n[2].f = green;
2077 n[3].f = blue;
2078 n[4].f = alpha;
2079 }
2080 if (ctx->ExecuteFlag) {
2081 CALL_ClearColor(ctx->Exec, (red, green, blue, alpha));
2082 }
2083 }
2084
2085
2086 static void GLAPIENTRY
2087 save_ClearDepth(GLclampd depth)
2088 {
2089 GET_CURRENT_CONTEXT(ctx);
2090 Node *n;
2091 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2092 n = alloc_instruction(ctx, OPCODE_CLEAR_DEPTH, 1);
2093 if (n) {
2094 n[1].f = (GLfloat) depth;
2095 }
2096 if (ctx->ExecuteFlag) {
2097 CALL_ClearDepth(ctx->Exec, (depth));
2098 }
2099 }
2100
2101
2102 static void GLAPIENTRY
2103 save_ClearIndex(GLfloat c)
2104 {
2105 GET_CURRENT_CONTEXT(ctx);
2106 Node *n;
2107 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2108 n = alloc_instruction(ctx, OPCODE_CLEAR_INDEX, 1);
2109 if (n) {
2110 n[1].f = c;
2111 }
2112 if (ctx->ExecuteFlag) {
2113 CALL_ClearIndex(ctx->Exec, (c));
2114 }
2115 }
2116
2117
2118 static void GLAPIENTRY
2119 save_ClearStencil(GLint s)
2120 {
2121 GET_CURRENT_CONTEXT(ctx);
2122 Node *n;
2123 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2124 n = alloc_instruction(ctx, OPCODE_CLEAR_STENCIL, 1);
2125 if (n) {
2126 n[1].i = s;
2127 }
2128 if (ctx->ExecuteFlag) {
2129 CALL_ClearStencil(ctx->Exec, (s));
2130 }
2131 }
2132
2133
2134 static void GLAPIENTRY
2135 save_ClipPlane(GLenum plane, const GLdouble * equ)
2136 {
2137 GET_CURRENT_CONTEXT(ctx);
2138 Node *n;
2139 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2140 n = alloc_instruction(ctx, OPCODE_CLIP_PLANE, 5);
2141 if (n) {
2142 n[1].e = plane;
2143 n[2].f = (GLfloat) equ[0];
2144 n[3].f = (GLfloat) equ[1];
2145 n[4].f = (GLfloat) equ[2];
2146 n[5].f = (GLfloat) equ[3];
2147 }
2148 if (ctx->ExecuteFlag) {
2149 CALL_ClipPlane(ctx->Exec, (plane, equ));
2150 }
2151 }
2152
2153
2154
2155 static void GLAPIENTRY
2156 save_ColorMask(GLboolean red, GLboolean green,
2157 GLboolean blue, GLboolean alpha)
2158 {
2159 GET_CURRENT_CONTEXT(ctx);
2160 Node *n;
2161 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2162 n = alloc_instruction(ctx, OPCODE_COLOR_MASK, 4);
2163 if (n) {
2164 n[1].b = red;
2165 n[2].b = green;
2166 n[3].b = blue;
2167 n[4].b = alpha;
2168 }
2169 if (ctx->ExecuteFlag) {
2170 CALL_ColorMask(ctx->Exec, (red, green, blue, alpha));
2171 }
2172 }
2173
2174
2175 static void GLAPIENTRY
2176 save_ColorMaskIndexed(GLuint buf, GLboolean red, GLboolean green,
2177 GLboolean blue, GLboolean alpha)
2178 {
2179 GET_CURRENT_CONTEXT(ctx);
2180 Node *n;
2181 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2182 n = alloc_instruction(ctx, OPCODE_COLOR_MASK_INDEXED, 5);
2183 if (n) {
2184 n[1].ui = buf;
2185 n[2].b = red;
2186 n[3].b = green;
2187 n[4].b = blue;
2188 n[5].b = alpha;
2189 }
2190 if (ctx->ExecuteFlag) {
2191 /*CALL_ColorMaski(ctx->Exec, (buf, red, green, blue, alpha));*/
2192 }
2193 }
2194
2195
2196 static void GLAPIENTRY
2197 save_ColorMaterial(GLenum face, GLenum mode)
2198 {
2199 GET_CURRENT_CONTEXT(ctx);
2200 Node *n;
2201 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2202
2203 n = alloc_instruction(ctx, OPCODE_COLOR_MATERIAL, 2);
2204 if (n) {
2205 n[1].e = face;
2206 n[2].e = mode;
2207 }
2208 if (ctx->ExecuteFlag) {
2209 CALL_ColorMaterial(ctx->Exec, (face, mode));
2210 }
2211 }
2212
2213
2214 static void GLAPIENTRY
2215 save_CopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
2216 {
2217 GET_CURRENT_CONTEXT(ctx);
2218 Node *n;
2219 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2220 n = alloc_instruction(ctx, OPCODE_COPY_PIXELS, 5);
2221 if (n) {
2222 n[1].i = x;
2223 n[2].i = y;
2224 n[3].i = (GLint) width;
2225 n[4].i = (GLint) height;
2226 n[5].e = type;
2227 }
2228 if (ctx->ExecuteFlag) {
2229 CALL_CopyPixels(ctx->Exec, (x, y, width, height, type));
2230 }
2231 }
2232
2233
2234
2235 static void GLAPIENTRY
2236 save_CopyTexImage1D(GLenum target, GLint level, GLenum internalformat,
2237 GLint x, GLint y, GLsizei width, GLint border)
2238 {
2239 GET_CURRENT_CONTEXT(ctx);
2240 Node *n;
2241 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2242 n = alloc_instruction(ctx, OPCODE_COPY_TEX_IMAGE1D, 7);
2243 if (n) {
2244 n[1].e = target;
2245 n[2].i = level;
2246 n[3].e = internalformat;
2247 n[4].i = x;
2248 n[5].i = y;
2249 n[6].i = width;
2250 n[7].i = border;
2251 }
2252 if (ctx->ExecuteFlag) {
2253 CALL_CopyTexImage1D(ctx->Exec, (target, level, internalformat,
2254 x, y, width, border));
2255 }
2256 }
2257
2258
2259 static void GLAPIENTRY
2260 save_CopyTexImage2D(GLenum target, GLint level,
2261 GLenum internalformat,
2262 GLint x, GLint y, GLsizei width,
2263 GLsizei height, GLint border)
2264 {
2265 GET_CURRENT_CONTEXT(ctx);
2266 Node *n;
2267 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2268 n = alloc_instruction(ctx, OPCODE_COPY_TEX_IMAGE2D, 8);
2269 if (n) {
2270 n[1].e = target;
2271 n[2].i = level;
2272 n[3].e = internalformat;
2273 n[4].i = x;
2274 n[5].i = y;
2275 n[6].i = width;
2276 n[7].i = height;
2277 n[8].i = border;
2278 }
2279 if (ctx->ExecuteFlag) {
2280 CALL_CopyTexImage2D(ctx->Exec, (target, level, internalformat,
2281 x, y, width, height, border));
2282 }
2283 }
2284
2285
2286
2287 static void GLAPIENTRY
2288 save_CopyTexSubImage1D(GLenum target, GLint level,
2289 GLint xoffset, GLint x, GLint y, GLsizei width)
2290 {
2291 GET_CURRENT_CONTEXT(ctx);
2292 Node *n;
2293 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2294 n = alloc_instruction(ctx, OPCODE_COPY_TEX_SUB_IMAGE1D, 6);
2295 if (n) {
2296 n[1].e = target;
2297 n[2].i = level;
2298 n[3].i = xoffset;
2299 n[4].i = x;
2300 n[5].i = y;
2301 n[6].i = width;
2302 }
2303 if (ctx->ExecuteFlag) {
2304 CALL_CopyTexSubImage1D(ctx->Exec,
2305 (target, level, xoffset, x, y, width));
2306 }
2307 }
2308
2309
2310 static void GLAPIENTRY
2311 save_CopyTexSubImage2D(GLenum target, GLint level,
2312 GLint xoffset, GLint yoffset,
2313 GLint x, GLint y, GLsizei width, GLint height)
2314 {
2315 GET_CURRENT_CONTEXT(ctx);
2316 Node *n;
2317 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2318 n = alloc_instruction(ctx, OPCODE_COPY_TEX_SUB_IMAGE2D, 8);
2319 if (n) {
2320 n[1].e = target;
2321 n[2].i = level;
2322 n[3].i = xoffset;
2323 n[4].i = yoffset;
2324 n[5].i = x;
2325 n[6].i = y;
2326 n[7].i = width;
2327 n[8].i = height;
2328 }
2329 if (ctx->ExecuteFlag) {
2330 CALL_CopyTexSubImage2D(ctx->Exec, (target, level, xoffset, yoffset,
2331 x, y, width, height));
2332 }
2333 }
2334
2335
2336 static void GLAPIENTRY
2337 save_CopyTexSubImage3D(GLenum target, GLint level,
2338 GLint xoffset, GLint yoffset, GLint zoffset,
2339 GLint x, GLint y, GLsizei width, GLint height)
2340 {
2341 GET_CURRENT_CONTEXT(ctx);
2342 Node *n;
2343 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2344 n = alloc_instruction(ctx, OPCODE_COPY_TEX_SUB_IMAGE3D, 9);
2345 if (n) {
2346 n[1].e = target;
2347 n[2].i = level;
2348 n[3].i = xoffset;
2349 n[4].i = yoffset;
2350 n[5].i = zoffset;
2351 n[6].i = x;
2352 n[7].i = y;
2353 n[8].i = width;
2354 n[9].i = height;
2355 }
2356 if (ctx->ExecuteFlag) {
2357 CALL_CopyTexSubImage3D(ctx->Exec, (target, level,
2358 xoffset, yoffset, zoffset,
2359 x, y, width, height));
2360 }
2361 }
2362
2363
2364 static void GLAPIENTRY
2365 save_CullFace(GLenum mode)
2366 {
2367 GET_CURRENT_CONTEXT(ctx);
2368 Node *n;
2369 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2370 n = alloc_instruction(ctx, OPCODE_CULL_FACE, 1);
2371 if (n) {
2372 n[1].e = mode;
2373 }
2374 if (ctx->ExecuteFlag) {
2375 CALL_CullFace(ctx->Exec, (mode));
2376 }
2377 }
2378
2379
2380 static void GLAPIENTRY
2381 save_DepthFunc(GLenum func)
2382 {
2383 GET_CURRENT_CONTEXT(ctx);
2384 Node *n;
2385 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2386 n = alloc_instruction(ctx, OPCODE_DEPTH_FUNC, 1);
2387 if (n) {
2388 n[1].e = func;
2389 }
2390 if (ctx->ExecuteFlag) {
2391 CALL_DepthFunc(ctx->Exec, (func));
2392 }
2393 }
2394
2395
2396 static void GLAPIENTRY
2397 save_DepthMask(GLboolean mask)
2398 {
2399 GET_CURRENT_CONTEXT(ctx);
2400 Node *n;
2401 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2402 n = alloc_instruction(ctx, OPCODE_DEPTH_MASK, 1);
2403 if (n) {
2404 n[1].b = mask;
2405 }
2406 if (ctx->ExecuteFlag) {
2407 CALL_DepthMask(ctx->Exec, (mask));
2408 }
2409 }
2410
2411
2412 static void GLAPIENTRY
2413 save_DepthRange(GLclampd nearval, GLclampd farval)
2414 {
2415 GET_CURRENT_CONTEXT(ctx);
2416 Node *n;
2417 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2418 n = alloc_instruction(ctx, OPCODE_DEPTH_RANGE, 2);
2419 if (n) {
2420 n[1].f = (GLfloat) nearval;
2421 n[2].f = (GLfloat) farval;
2422 }
2423 if (ctx->ExecuteFlag) {
2424 CALL_DepthRange(ctx->Exec, (nearval, farval));
2425 }
2426 }
2427
2428
2429 static void GLAPIENTRY
2430 save_Disable(GLenum cap)
2431 {
2432 GET_CURRENT_CONTEXT(ctx);
2433 Node *n;
2434 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2435 n = alloc_instruction(ctx, OPCODE_DISABLE, 1);
2436 if (n) {
2437 n[1].e = cap;
2438 }
2439 if (ctx->ExecuteFlag) {
2440 CALL_Disable(ctx->Exec, (cap));
2441 }
2442 }
2443
2444
2445 static void GLAPIENTRY
2446 save_DisableIndexed(GLuint index, GLenum cap)
2447 {
2448 GET_CURRENT_CONTEXT(ctx);
2449 Node *n;
2450 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2451 n = alloc_instruction(ctx, OPCODE_DISABLE_INDEXED, 2);
2452 if (n) {
2453 n[1].ui = index;
2454 n[2].e = cap;
2455 }
2456 if (ctx->ExecuteFlag) {
2457 CALL_Disablei(ctx->Exec, (index, cap));
2458 }
2459 }
2460
2461
2462 static void GLAPIENTRY
2463 save_DrawBuffer(GLenum mode)
2464 {
2465 GET_CURRENT_CONTEXT(ctx);
2466 Node *n;
2467 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2468 n = alloc_instruction(ctx, OPCODE_DRAW_BUFFER, 1);
2469 if (n) {
2470 n[1].e = mode;
2471 }
2472 if (ctx->ExecuteFlag) {
2473 CALL_DrawBuffer(ctx->Exec, (mode));
2474 }
2475 }
2476
2477
2478 static void GLAPIENTRY
2479 save_DrawPixels(GLsizei width, GLsizei height,
2480 GLenum format, GLenum type, const GLvoid * pixels)
2481 {
2482 GET_CURRENT_CONTEXT(ctx);
2483 Node *n;
2484
2485 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2486
2487 n = alloc_instruction(ctx, OPCODE_DRAW_PIXELS, 4 + POINTER_DWORDS);
2488 if (n) {
2489 n[1].i = width;
2490 n[2].i = height;
2491 n[3].e = format;
2492 n[4].e = type;
2493 save_pointer(&n[5],
2494 unpack_image(ctx, 2, width, height, 1, format, type,
2495 pixels, &ctx->Unpack));
2496 }
2497 if (ctx->ExecuteFlag) {
2498 CALL_DrawPixels(ctx->Exec, (width, height, format, type, pixels));
2499 }
2500 }
2501
2502
2503
2504 static void GLAPIENTRY
2505 save_Enable(GLenum cap)
2506 {
2507 GET_CURRENT_CONTEXT(ctx);
2508 Node *n;
2509 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2510 n = alloc_instruction(ctx, OPCODE_ENABLE, 1);
2511 if (n) {
2512 n[1].e = cap;
2513 }
2514 if (ctx->ExecuteFlag) {
2515 CALL_Enable(ctx->Exec, (cap));
2516 }
2517 }
2518
2519
2520
2521 static void GLAPIENTRY
2522 save_EnableIndexed(GLuint index, GLenum cap)
2523 {
2524 GET_CURRENT_CONTEXT(ctx);
2525 Node *n;
2526 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2527 n = alloc_instruction(ctx, OPCODE_ENABLE_INDEXED, 2);
2528 if (n) {
2529 n[1].ui = index;
2530 n[2].e = cap;
2531 }
2532 if (ctx->ExecuteFlag) {
2533 CALL_Enablei(ctx->Exec, (index, cap));
2534 }
2535 }
2536
2537
2538
2539 static void GLAPIENTRY
2540 save_EvalMesh1(GLenum mode, GLint i1, GLint i2)
2541 {
2542 GET_CURRENT_CONTEXT(ctx);
2543 Node *n;
2544 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2545 n = alloc_instruction(ctx, OPCODE_EVALMESH1, 3);
2546 if (n) {
2547 n[1].e = mode;
2548 n[2].i = i1;
2549 n[3].i = i2;
2550 }
2551 if (ctx->ExecuteFlag) {
2552 CALL_EvalMesh1(ctx->Exec, (mode, i1, i2));
2553 }
2554 }
2555
2556
2557 static void GLAPIENTRY
2558 save_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
2559 {
2560 GET_CURRENT_CONTEXT(ctx);
2561 Node *n;
2562 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2563 n = alloc_instruction(ctx, OPCODE_EVALMESH2, 5);
2564 if (n) {
2565 n[1].e = mode;
2566 n[2].i = i1;
2567 n[3].i = i2;
2568 n[4].i = j1;
2569 n[5].i = j2;
2570 }
2571 if (ctx->ExecuteFlag) {
2572 CALL_EvalMesh2(ctx->Exec, (mode, i1, i2, j1, j2));
2573 }
2574 }
2575
2576
2577
2578
2579 static void GLAPIENTRY
2580 save_Fogfv(GLenum pname, const GLfloat *params)
2581 {
2582 GET_CURRENT_CONTEXT(ctx);
2583 Node *n;
2584 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2585 n = alloc_instruction(ctx, OPCODE_FOG, 5);
2586 if (n) {
2587 n[1].e = pname;
2588 n[2].f = params[0];
2589 n[3].f = params[1];
2590 n[4].f = params[2];
2591 n[5].f = params[3];
2592 }
2593 if (ctx->ExecuteFlag) {
2594 CALL_Fogfv(ctx->Exec, (pname, params));
2595 }
2596 }
2597
2598
2599 static void GLAPIENTRY
2600 save_Fogf(GLenum pname, GLfloat param)
2601 {
2602 GLfloat parray[4];
2603 parray[0] = param;
2604 parray[1] = parray[2] = parray[3] = 0.0F;
2605 save_Fogfv(pname, parray);
2606 }
2607
2608
2609 static void GLAPIENTRY
2610 save_Fogiv(GLenum pname, const GLint *params)
2611 {
2612 GLfloat p[4];
2613 switch (pname) {
2614 case GL_FOG_MODE:
2615 case GL_FOG_DENSITY:
2616 case GL_FOG_START:
2617 case GL_FOG_END:
2618 case GL_FOG_INDEX:
2619 p[0] = (GLfloat) *params;
2620 p[1] = 0.0f;
2621 p[2] = 0.0f;
2622 p[3] = 0.0f;
2623 break;
2624 case GL_FOG_COLOR:
2625 p[0] = INT_TO_FLOAT(params[0]);
2626 p[1] = INT_TO_FLOAT(params[1]);
2627 p[2] = INT_TO_FLOAT(params[2]);
2628 p[3] = INT_TO_FLOAT(params[3]);
2629 break;
2630 default:
2631 /* Error will be caught later in gl_Fogfv */
2632 ASSIGN_4V(p, 0.0F, 0.0F, 0.0F, 0.0F);
2633 }
2634 save_Fogfv(pname, p);
2635 }
2636
2637
2638 static void GLAPIENTRY
2639 save_Fogi(GLenum pname, GLint param)
2640 {
2641 GLint parray[4];
2642 parray[0] = param;
2643 parray[1] = parray[2] = parray[3] = 0;
2644 save_Fogiv(pname, parray);
2645 }
2646
2647
2648 static void GLAPIENTRY
2649 save_FrontFace(GLenum mode)
2650 {
2651 GET_CURRENT_CONTEXT(ctx);
2652 Node *n;
2653 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2654 n = alloc_instruction(ctx, OPCODE_FRONT_FACE, 1);
2655 if (n) {
2656 n[1].e = mode;
2657 }
2658 if (ctx->ExecuteFlag) {
2659 CALL_FrontFace(ctx->Exec, (mode));
2660 }
2661 }
2662
2663
2664 static void GLAPIENTRY
2665 save_Frustum(GLdouble left, GLdouble right,
2666 GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval)
2667 {
2668 GET_CURRENT_CONTEXT(ctx);
2669 Node *n;
2670 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2671 n = alloc_instruction(ctx, OPCODE_FRUSTUM, 6);
2672 if (n) {
2673 n[1].f = (GLfloat) left;
2674 n[2].f = (GLfloat) right;
2675 n[3].f = (GLfloat) bottom;
2676 n[4].f = (GLfloat) top;
2677 n[5].f = (GLfloat) nearval;
2678 n[6].f = (GLfloat) farval;
2679 }
2680 if (ctx->ExecuteFlag) {
2681 CALL_Frustum(ctx->Exec, (left, right, bottom, top, nearval, farval));
2682 }
2683 }
2684
2685
2686 static void GLAPIENTRY
2687 save_Hint(GLenum target, GLenum mode)
2688 {
2689 GET_CURRENT_CONTEXT(ctx);
2690 Node *n;
2691 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2692 n = alloc_instruction(ctx, OPCODE_HINT, 2);
2693 if (n) {
2694 n[1].e = target;
2695 n[2].e = mode;
2696 }
2697 if (ctx->ExecuteFlag) {
2698 CALL_Hint(ctx->Exec, (target, mode));
2699 }
2700 }
2701
2702
2703 static void GLAPIENTRY
2704 save_IndexMask(GLuint mask)
2705 {
2706 GET_CURRENT_CONTEXT(ctx);
2707 Node *n;
2708 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2709 n = alloc_instruction(ctx, OPCODE_INDEX_MASK, 1);
2710 if (n) {
2711 n[1].ui = mask;
2712 }
2713 if (ctx->ExecuteFlag) {
2714 CALL_IndexMask(ctx->Exec, (mask));
2715 }
2716 }
2717
2718
2719 static void GLAPIENTRY
2720 save_InitNames(void)
2721 {
2722 GET_CURRENT_CONTEXT(ctx);
2723 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2724 (void) alloc_instruction(ctx, OPCODE_INIT_NAMES, 0);
2725 if (ctx->ExecuteFlag) {
2726 CALL_InitNames(ctx->Exec, ());
2727 }
2728 }
2729
2730
2731 static void GLAPIENTRY
2732 save_Lightfv(GLenum light, GLenum pname, const GLfloat *params)
2733 {
2734 GET_CURRENT_CONTEXT(ctx);
2735 Node *n;
2736 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2737 n = alloc_instruction(ctx, OPCODE_LIGHT, 6);
2738 if (n) {
2739 GLint i, nParams;
2740 n[1].e = light;
2741 n[2].e = pname;
2742 switch (pname) {
2743 case GL_AMBIENT:
2744 nParams = 4;
2745 break;
2746 case GL_DIFFUSE:
2747 nParams = 4;
2748 break;
2749 case GL_SPECULAR:
2750 nParams = 4;
2751 break;
2752 case GL_POSITION:
2753 nParams = 4;
2754 break;
2755 case GL_SPOT_DIRECTION:
2756 nParams = 3;
2757 break;
2758 case GL_SPOT_EXPONENT:
2759 nParams = 1;
2760 break;
2761 case GL_SPOT_CUTOFF:
2762 nParams = 1;
2763 break;
2764 case GL_CONSTANT_ATTENUATION:
2765 nParams = 1;
2766 break;
2767 case GL_LINEAR_ATTENUATION:
2768 nParams = 1;
2769 break;
2770 case GL_QUADRATIC_ATTENUATION:
2771 nParams = 1;
2772 break;
2773 default:
2774 nParams = 0;
2775 }
2776 for (i = 0; i < nParams; i++) {
2777 n[3 + i].f = params[i];
2778 }
2779 }
2780 if (ctx->ExecuteFlag) {
2781 CALL_Lightfv(ctx->Exec, (light, pname, params));
2782 }
2783 }
2784
2785
2786 static void GLAPIENTRY
2787 save_Lightf(GLenum light, GLenum pname, GLfloat param)
2788 {
2789 GLfloat parray[4];
2790 parray[0] = param;
2791 parray[1] = parray[2] = parray[3] = 0.0F;
2792 save_Lightfv(light, pname, parray);
2793 }
2794
2795
2796 static void GLAPIENTRY
2797 save_Lightiv(GLenum light, GLenum pname, const GLint *params)
2798 {
2799 GLfloat fparam[4];
2800 switch (pname) {
2801 case GL_AMBIENT:
2802 case GL_DIFFUSE:
2803 case GL_SPECULAR:
2804 fparam[0] = INT_TO_FLOAT(params[0]);
2805 fparam[1] = INT_TO_FLOAT(params[1]);
2806 fparam[2] = INT_TO_FLOAT(params[2]);
2807 fparam[3] = INT_TO_FLOAT(params[3]);
2808 break;
2809 case GL_POSITION:
2810 fparam[0] = (GLfloat) params[0];
2811 fparam[1] = (GLfloat) params[1];
2812 fparam[2] = (GLfloat) params[2];
2813 fparam[3] = (GLfloat) params[3];
2814 break;
2815 case GL_SPOT_DIRECTION:
2816 fparam[0] = (GLfloat) params[0];
2817 fparam[1] = (GLfloat) params[1];
2818 fparam[2] = (GLfloat) params[2];
2819 break;
2820 case GL_SPOT_EXPONENT:
2821 case GL_SPOT_CUTOFF:
2822 case GL_CONSTANT_ATTENUATION:
2823 case GL_LINEAR_ATTENUATION:
2824 case GL_QUADRATIC_ATTENUATION:
2825 fparam[0] = (GLfloat) params[0];
2826 break;
2827 default:
2828 /* error will be caught later in gl_Lightfv */
2829 ;
2830 }
2831 save_Lightfv(light, pname, fparam);
2832 }
2833
2834
2835 static void GLAPIENTRY
2836 save_Lighti(GLenum light, GLenum pname, GLint param)
2837 {
2838 GLint parray[4];
2839 parray[0] = param;
2840 parray[1] = parray[2] = parray[3] = 0;
2841 save_Lightiv(light, pname, parray);
2842 }
2843
2844
2845 static void GLAPIENTRY
2846 save_LightModelfv(GLenum pname, const GLfloat *params)
2847 {
2848 GET_CURRENT_CONTEXT(ctx);
2849 Node *n;
2850 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2851 n = alloc_instruction(ctx, OPCODE_LIGHT_MODEL, 5);
2852 if (n) {
2853 n[1].e = pname;
2854 n[2].f = params[0];
2855 n[3].f = params[1];
2856 n[4].f = params[2];
2857 n[5].f = params[3];
2858 }
2859 if (ctx->ExecuteFlag) {
2860 CALL_LightModelfv(ctx->Exec, (pname, params));
2861 }
2862 }
2863
2864
2865 static void GLAPIENTRY
2866 save_LightModelf(GLenum pname, GLfloat param)
2867 {
2868 GLfloat parray[4];
2869 parray[0] = param;
2870 parray[1] = parray[2] = parray[3] = 0.0F;
2871 save_LightModelfv(pname, parray);
2872 }
2873
2874
2875 static void GLAPIENTRY
2876 save_LightModeliv(GLenum pname, const GLint *params)
2877 {
2878 GLfloat fparam[4];
2879 switch (pname) {
2880 case GL_LIGHT_MODEL_AMBIENT:
2881 fparam[0] = INT_TO_FLOAT(params[0]);
2882 fparam[1] = INT_TO_FLOAT(params[1]);
2883 fparam[2] = INT_TO_FLOAT(params[2]);
2884 fparam[3] = INT_TO_FLOAT(params[3]);
2885 break;
2886 case GL_LIGHT_MODEL_LOCAL_VIEWER:
2887 case GL_LIGHT_MODEL_TWO_SIDE:
2888 case GL_LIGHT_MODEL_COLOR_CONTROL:
2889 fparam[0] = (GLfloat) params[0];
2890 fparam[1] = 0.0F;
2891 fparam[2] = 0.0F;
2892 fparam[3] = 0.0F;
2893 break;
2894 default:
2895 /* Error will be caught later in gl_LightModelfv */
2896 ASSIGN_4V(fparam, 0.0F, 0.0F, 0.0F, 0.0F);
2897 }
2898 save_LightModelfv(pname, fparam);
2899 }
2900
2901
2902 static void GLAPIENTRY
2903 save_LightModeli(GLenum pname, GLint param)
2904 {
2905 GLint parray[4];
2906 parray[0] = param;
2907 parray[1] = parray[2] = parray[3] = 0;
2908 save_LightModeliv(pname, parray);
2909 }
2910
2911
2912 static void GLAPIENTRY
2913 save_LineStipple(GLint factor, GLushort pattern)
2914 {
2915 GET_CURRENT_CONTEXT(ctx);
2916 Node *n;
2917 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2918 n = alloc_instruction(ctx, OPCODE_LINE_STIPPLE, 2);
2919 if (n) {
2920 n[1].i = factor;
2921 n[2].us = pattern;
2922 }
2923 if (ctx->ExecuteFlag) {
2924 CALL_LineStipple(ctx->Exec, (factor, pattern));
2925 }
2926 }
2927
2928
2929 static void GLAPIENTRY
2930 save_LineWidth(GLfloat width)
2931 {
2932 GET_CURRENT_CONTEXT(ctx);
2933 Node *n;
2934 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2935 n = alloc_instruction(ctx, OPCODE_LINE_WIDTH, 1);
2936 if (n) {
2937 n[1].f = width;
2938 }
2939 if (ctx->ExecuteFlag) {
2940 CALL_LineWidth(ctx->Exec, (width));
2941 }
2942 }
2943
2944
2945 static void GLAPIENTRY
2946 save_ListBase(GLuint base)
2947 {
2948 GET_CURRENT_CONTEXT(ctx);
2949 Node *n;
2950 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2951 n = alloc_instruction(ctx, OPCODE_LIST_BASE, 1);
2952 if (n) {
2953 n[1].ui = base;
2954 }
2955 if (ctx->ExecuteFlag) {
2956 CALL_ListBase(ctx->Exec, (base));
2957 }
2958 }
2959
2960
2961 static void GLAPIENTRY
2962 save_LoadIdentity(void)
2963 {
2964 GET_CURRENT_CONTEXT(ctx);
2965 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2966 (void) alloc_instruction(ctx, OPCODE_LOAD_IDENTITY, 0);
2967 if (ctx->ExecuteFlag) {
2968 CALL_LoadIdentity(ctx->Exec, ());
2969 }
2970 }
2971
2972
2973 static void GLAPIENTRY
2974 save_LoadMatrixf(const GLfloat * m)
2975 {
2976 GET_CURRENT_CONTEXT(ctx);
2977 Node *n;
2978 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
2979 n = alloc_instruction(ctx, OPCODE_LOAD_MATRIX, 16);
2980 if (n) {
2981 GLuint i;
2982 for (i = 0; i < 16; i++) {
2983 n[1 + i].f = m[i];
2984 }
2985 }
2986 if (ctx->ExecuteFlag) {
2987 CALL_LoadMatrixf(ctx->Exec, (m));
2988 }
2989 }
2990
2991
2992 static void GLAPIENTRY
2993 save_LoadMatrixd(const GLdouble * m)
2994 {
2995 GLfloat f[16];
2996 GLint i;
2997 for (i = 0; i < 16; i++) {
2998 f[i] = (GLfloat) m[i];
2999 }
3000 save_LoadMatrixf(f);
3001 }
3002
3003
3004 static void GLAPIENTRY
3005 save_LoadName(GLuint name)
3006 {
3007 GET_CURRENT_CONTEXT(ctx);
3008 Node *n;
3009 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3010 n = alloc_instruction(ctx, OPCODE_LOAD_NAME, 1);
3011 if (n) {
3012 n[1].ui = name;
3013 }
3014 if (ctx->ExecuteFlag) {
3015 CALL_LoadName(ctx->Exec, (name));
3016 }
3017 }
3018
3019
3020 static void GLAPIENTRY
3021 save_LogicOp(GLenum opcode)
3022 {
3023 GET_CURRENT_CONTEXT(ctx);
3024 Node *n;
3025 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3026 n = alloc_instruction(ctx, OPCODE_LOGIC_OP, 1);
3027 if (n) {
3028 n[1].e = opcode;
3029 }
3030 if (ctx->ExecuteFlag) {
3031 CALL_LogicOp(ctx->Exec, (opcode));
3032 }
3033 }
3034
3035
3036 static void GLAPIENTRY
3037 save_Map1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride,
3038 GLint order, const GLdouble * points)
3039 {
3040 GET_CURRENT_CONTEXT(ctx);
3041 Node *n;
3042 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3043 n = alloc_instruction(ctx, OPCODE_MAP1, 5 + POINTER_DWORDS);
3044 if (n) {
3045 GLfloat *pnts = _mesa_copy_map_points1d(target, stride, order, points);
3046 n[1].e = target;
3047 n[2].f = (GLfloat) u1;
3048 n[3].f = (GLfloat) u2;
3049 n[4].i = _mesa_evaluator_components(target); /* stride */
3050 n[5].i = order;
3051 save_pointer(&n[6], pnts);
3052 }
3053 if (ctx->ExecuteFlag) {
3054 CALL_Map1d(ctx->Exec, (target, u1, u2, stride, order, points));
3055 }
3056 }
3057
3058 static void GLAPIENTRY
3059 save_Map1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride,
3060 GLint order, const GLfloat * points)
3061 {
3062 GET_CURRENT_CONTEXT(ctx);
3063 Node *n;
3064 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3065 n = alloc_instruction(ctx, OPCODE_MAP1, 5 + POINTER_DWORDS);
3066 if (n) {
3067 GLfloat *pnts = _mesa_copy_map_points1f(target, stride, order, points);
3068 n[1].e = target;
3069 n[2].f = u1;
3070 n[3].f = u2;
3071 n[4].i = _mesa_evaluator_components(target); /* stride */
3072 n[5].i = order;
3073 save_pointer(&n[6], pnts);
3074 }
3075 if (ctx->ExecuteFlag) {
3076 CALL_Map1f(ctx->Exec, (target, u1, u2, stride, order, points));
3077 }
3078 }
3079
3080
3081 static void GLAPIENTRY
3082 save_Map2d(GLenum target,
3083 GLdouble u1, GLdouble u2, GLint ustride, GLint uorder,
3084 GLdouble v1, GLdouble v2, GLint vstride, GLint vorder,
3085 const GLdouble * points)
3086 {
3087 GET_CURRENT_CONTEXT(ctx);
3088 Node *n;
3089 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3090 n = alloc_instruction(ctx, OPCODE_MAP2, 9 + POINTER_DWORDS);
3091 if (n) {
3092 GLfloat *pnts = _mesa_copy_map_points2d(target, ustride, uorder,
3093 vstride, vorder, points);
3094 n[1].e = target;
3095 n[2].f = (GLfloat) u1;
3096 n[3].f = (GLfloat) u2;
3097 n[4].f = (GLfloat) v1;
3098 n[5].f = (GLfloat) v2;
3099 /* XXX verify these strides are correct */
3100 n[6].i = _mesa_evaluator_components(target) * vorder; /*ustride */
3101 n[7].i = _mesa_evaluator_components(target); /*vstride */
3102 n[8].i = uorder;
3103 n[9].i = vorder;
3104 save_pointer(&n[10], pnts);
3105 }
3106 if (ctx->ExecuteFlag) {
3107 CALL_Map2d(ctx->Exec, (target,
3108 u1, u2, ustride, uorder,
3109 v1, v2, vstride, vorder, points));
3110 }
3111 }
3112
3113
3114 static void GLAPIENTRY
3115 save_Map2f(GLenum target,
3116 GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
3117 GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
3118 const GLfloat * points)
3119 {
3120 GET_CURRENT_CONTEXT(ctx);
3121 Node *n;
3122 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3123 n = alloc_instruction(ctx, OPCODE_MAP2, 9 + POINTER_DWORDS);
3124 if (n) {
3125 GLfloat *pnts = _mesa_copy_map_points2f(target, ustride, uorder,
3126 vstride, vorder, points);
3127 n[1].e = target;
3128 n[2].f = u1;
3129 n[3].f = u2;
3130 n[4].f = v1;
3131 n[5].f = v2;
3132 /* XXX verify these strides are correct */
3133 n[6].i = _mesa_evaluator_components(target) * vorder; /*ustride */
3134 n[7].i = _mesa_evaluator_components(target); /*vstride */
3135 n[8].i = uorder;
3136 n[9].i = vorder;
3137 save_pointer(&n[10], pnts);
3138 }
3139 if (ctx->ExecuteFlag) {
3140 CALL_Map2f(ctx->Exec, (target, u1, u2, ustride, uorder,
3141 v1, v2, vstride, vorder, points));
3142 }
3143 }
3144
3145
3146 static void GLAPIENTRY
3147 save_MapGrid1f(GLint un, GLfloat u1, GLfloat u2)
3148 {
3149 GET_CURRENT_CONTEXT(ctx);
3150 Node *n;
3151 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3152 n = alloc_instruction(ctx, OPCODE_MAPGRID1, 3);
3153 if (n) {
3154 n[1].i = un;
3155 n[2].f = u1;
3156 n[3].f = u2;
3157 }
3158 if (ctx->ExecuteFlag) {
3159 CALL_MapGrid1f(ctx->Exec, (un, u1, u2));
3160 }
3161 }
3162
3163
3164 static void GLAPIENTRY
3165 save_MapGrid1d(GLint un, GLdouble u1, GLdouble u2)
3166 {
3167 save_MapGrid1f(un, (GLfloat) u1, (GLfloat) u2);
3168 }
3169
3170
3171 static void GLAPIENTRY
3172 save_MapGrid2f(GLint un, GLfloat u1, GLfloat u2,
3173 GLint vn, GLfloat v1, GLfloat v2)
3174 {
3175 GET_CURRENT_CONTEXT(ctx);
3176 Node *n;
3177 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3178 n = alloc_instruction(ctx, OPCODE_MAPGRID2, 6);
3179 if (n) {
3180 n[1].i = un;
3181 n[2].f = u1;
3182 n[3].f = u2;
3183 n[4].i = vn;
3184 n[5].f = v1;
3185 n[6].f = v2;
3186 }
3187 if (ctx->ExecuteFlag) {
3188 CALL_MapGrid2f(ctx->Exec, (un, u1, u2, vn, v1, v2));
3189 }
3190 }
3191
3192
3193
3194 static void GLAPIENTRY
3195 save_MapGrid2d(GLint un, GLdouble u1, GLdouble u2,
3196 GLint vn, GLdouble v1, GLdouble v2)
3197 {
3198 save_MapGrid2f(un, (GLfloat) u1, (GLfloat) u2,
3199 vn, (GLfloat) v1, (GLfloat) v2);
3200 }
3201
3202
3203 static void GLAPIENTRY
3204 save_MatrixMode(GLenum mode)
3205 {
3206 GET_CURRENT_CONTEXT(ctx);
3207 Node *n;
3208 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3209 n = alloc_instruction(ctx, OPCODE_MATRIX_MODE, 1);
3210 if (n) {
3211 n[1].e = mode;
3212 }
3213 if (ctx->ExecuteFlag) {
3214 CALL_MatrixMode(ctx->Exec, (mode));
3215 }
3216 }
3217
3218
3219 static void GLAPIENTRY
3220 save_MultMatrixf(const GLfloat * m)
3221 {
3222 GET_CURRENT_CONTEXT(ctx);
3223 Node *n;
3224 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3225 n = alloc_instruction(ctx, OPCODE_MULT_MATRIX, 16);
3226 if (n) {
3227 GLuint i;
3228 for (i = 0; i < 16; i++) {
3229 n[1 + i].f = m[i];
3230 }
3231 }
3232 if (ctx->ExecuteFlag) {
3233 CALL_MultMatrixf(ctx->Exec, (m));
3234 }
3235 }
3236
3237
3238 static void GLAPIENTRY
3239 save_MultMatrixd(const GLdouble * m)
3240 {
3241 GLfloat f[16];
3242 GLint i;
3243 for (i = 0; i < 16; i++) {
3244 f[i] = (GLfloat) m[i];
3245 }
3246 save_MultMatrixf(f);
3247 }
3248
3249
3250 static void GLAPIENTRY
3251 save_NewList(GLuint name, GLenum mode)
3252 {
3253 GET_CURRENT_CONTEXT(ctx);
3254 /* It's an error to call this function while building a display list */
3255 _mesa_error(ctx, GL_INVALID_OPERATION, "glNewList");
3256 (void) name;
3257 (void) mode;
3258 }
3259
3260
3261
3262 static void GLAPIENTRY
3263 save_Ortho(GLdouble left, GLdouble right,
3264 GLdouble bottom, GLdouble top, GLdouble nearval, GLdouble farval)
3265 {
3266 GET_CURRENT_CONTEXT(ctx);
3267 Node *n;
3268 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3269 n = alloc_instruction(ctx, OPCODE_ORTHO, 6);
3270 if (n) {
3271 n[1].f = (GLfloat) left;
3272 n[2].f = (GLfloat) right;
3273 n[3].f = (GLfloat) bottom;
3274 n[4].f = (GLfloat) top;
3275 n[5].f = (GLfloat) nearval;
3276 n[6].f = (GLfloat) farval;
3277 }
3278 if (ctx->ExecuteFlag) {
3279 CALL_Ortho(ctx->Exec, (left, right, bottom, top, nearval, farval));
3280 }
3281 }
3282
3283
3284 static void GLAPIENTRY
3285 save_PixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
3286 {
3287 GET_CURRENT_CONTEXT(ctx);
3288 Node *n;
3289 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3290 n = alloc_instruction(ctx, OPCODE_PIXEL_MAP, 2 + POINTER_DWORDS);
3291 if (n) {
3292 n[1].e = map;
3293 n[2].i = mapsize;
3294 save_pointer(&n[3], memdup(values, mapsize * sizeof(GLfloat)));
3295 }
3296 if (ctx->ExecuteFlag) {
3297 CALL_PixelMapfv(ctx->Exec, (map, mapsize, values));
3298 }
3299 }
3300
3301
3302 static void GLAPIENTRY
3303 save_PixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
3304 {
3305 GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
3306 GLint i;
3307 if (map == GL_PIXEL_MAP_I_TO_I || map == GL_PIXEL_MAP_S_TO_S) {
3308 for (i = 0; i < mapsize; i++) {
3309 fvalues[i] = (GLfloat) values[i];
3310 }
3311 }
3312 else {
3313 for (i = 0; i < mapsize; i++) {
3314 fvalues[i] = UINT_TO_FLOAT(values[i]);
3315 }
3316 }
3317 save_PixelMapfv(map, mapsize, fvalues);
3318 }
3319
3320
3321 static void GLAPIENTRY
3322 save_PixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
3323 {
3324 GLfloat fvalues[MAX_PIXEL_MAP_TABLE];
3325 GLint i;
3326 if (map == GL_PIXEL_MAP_I_TO_I || map == GL_PIXEL_MAP_S_TO_S) {
3327 for (i = 0; i < mapsize; i++) {
3328 fvalues[i] = (GLfloat) values[i];
3329 }
3330 }
3331 else {
3332 for (i = 0; i < mapsize; i++) {
3333 fvalues[i] = USHORT_TO_FLOAT(values[i]);
3334 }
3335 }
3336 save_PixelMapfv(map, mapsize, fvalues);
3337 }
3338
3339
3340 static void GLAPIENTRY
3341 save_PixelTransferf(GLenum pname, GLfloat param)
3342 {
3343 GET_CURRENT_CONTEXT(ctx);
3344 Node *n;
3345 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3346 n = alloc_instruction(ctx, OPCODE_PIXEL_TRANSFER, 2);
3347 if (n) {
3348 n[1].e = pname;
3349 n[2].f = param;
3350 }
3351 if (ctx->ExecuteFlag) {
3352 CALL_PixelTransferf(ctx->Exec, (pname, param));
3353 }
3354 }
3355
3356
3357 static void GLAPIENTRY
3358 save_PixelTransferi(GLenum pname, GLint param)
3359 {
3360 save_PixelTransferf(pname, (GLfloat) param);
3361 }
3362
3363
3364 static void GLAPIENTRY
3365 save_PixelZoom(GLfloat xfactor, GLfloat yfactor)
3366 {
3367 GET_CURRENT_CONTEXT(ctx);
3368 Node *n;
3369 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3370 n = alloc_instruction(ctx, OPCODE_PIXEL_ZOOM, 2);
3371 if (n) {
3372 n[1].f = xfactor;
3373 n[2].f = yfactor;
3374 }
3375 if (ctx->ExecuteFlag) {
3376 CALL_PixelZoom(ctx->Exec, (xfactor, yfactor));
3377 }
3378 }
3379
3380
3381 static void GLAPIENTRY
3382 save_PointParameterfvEXT(GLenum pname, const GLfloat *params)
3383 {
3384 GET_CURRENT_CONTEXT(ctx);
3385 Node *n;
3386 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3387 n = alloc_instruction(ctx, OPCODE_POINT_PARAMETERS, 4);
3388 if (n) {
3389 n[1].e = pname;
3390 n[2].f = params[0];
3391 n[3].f = params[1];
3392 n[4].f = params[2];
3393 }
3394 if (ctx->ExecuteFlag) {
3395 CALL_PointParameterfv(ctx->Exec, (pname, params));
3396 }
3397 }
3398
3399
3400 static void GLAPIENTRY
3401 save_PointParameterfEXT(GLenum pname, GLfloat param)
3402 {
3403 GLfloat parray[3];
3404 parray[0] = param;
3405 parray[1] = parray[2] = 0.0F;
3406 save_PointParameterfvEXT(pname, parray);
3407 }
3408
3409 static void GLAPIENTRY
3410 save_PointParameteriNV(GLenum pname, GLint param)
3411 {
3412 GLfloat parray[3];
3413 parray[0] = (GLfloat) param;
3414 parray[1] = parray[2] = 0.0F;
3415 save_PointParameterfvEXT(pname, parray);
3416 }
3417
3418 static void GLAPIENTRY
3419 save_PointParameterivNV(GLenum pname, const GLint * param)
3420 {
3421 GLfloat parray[3];
3422 parray[0] = (GLfloat) param[0];
3423 parray[1] = parray[2] = 0.0F;
3424 save_PointParameterfvEXT(pname, parray);
3425 }
3426
3427
3428 static void GLAPIENTRY
3429 save_PointSize(GLfloat size)
3430 {
3431 GET_CURRENT_CONTEXT(ctx);
3432 Node *n;
3433 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3434 n = alloc_instruction(ctx, OPCODE_POINT_SIZE, 1);
3435 if (n) {
3436 n[1].f = size;
3437 }
3438 if (ctx->ExecuteFlag) {
3439 CALL_PointSize(ctx->Exec, (size));
3440 }
3441 }
3442
3443
3444 static void GLAPIENTRY
3445 save_PolygonMode(GLenum face, GLenum mode)
3446 {
3447 GET_CURRENT_CONTEXT(ctx);
3448 Node *n;
3449 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3450 n = alloc_instruction(ctx, OPCODE_POLYGON_MODE, 2);
3451 if (n) {
3452 n[1].e = face;
3453 n[2].e = mode;
3454 }
3455 if (ctx->ExecuteFlag) {
3456 CALL_PolygonMode(ctx->Exec, (face, mode));
3457 }
3458 }
3459
3460
3461 static void GLAPIENTRY
3462 save_PolygonStipple(const GLubyte * pattern)
3463 {
3464 GET_CURRENT_CONTEXT(ctx);
3465 Node *n;
3466
3467 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3468
3469 n = alloc_instruction(ctx, OPCODE_POLYGON_STIPPLE, POINTER_DWORDS);
3470 if (n) {
3471 save_pointer(&n[1],
3472 unpack_image(ctx, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP,
3473 pattern, &ctx->Unpack));
3474 }
3475 if (ctx->ExecuteFlag) {
3476 CALL_PolygonStipple(ctx->Exec, ((GLubyte *) pattern));
3477 }
3478 }
3479
3480
3481 static void GLAPIENTRY
3482 save_PolygonOffset(GLfloat factor, GLfloat units)
3483 {
3484 GET_CURRENT_CONTEXT(ctx);
3485 Node *n;
3486 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3487 n = alloc_instruction(ctx, OPCODE_POLYGON_OFFSET, 2);
3488 if (n) {
3489 n[1].f = factor;
3490 n[2].f = units;
3491 }
3492 if (ctx->ExecuteFlag) {
3493 CALL_PolygonOffset(ctx->Exec, (factor, units));
3494 }
3495 }
3496
3497
3498 static void GLAPIENTRY
3499 save_PolygonOffsetEXT(GLfloat factor, GLfloat bias)
3500 {
3501 GET_CURRENT_CONTEXT(ctx);
3502 /* XXX mult by DepthMaxF here??? */
3503 save_PolygonOffset(factor, ctx->DrawBuffer->_DepthMaxF * bias);
3504 }
3505
3506 static void GLAPIENTRY
3507 save_PolygonOffsetClampEXT(GLfloat factor, GLfloat units, GLfloat clamp)
3508 {
3509 GET_CURRENT_CONTEXT(ctx);
3510 Node *n;
3511 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3512 n = alloc_instruction(ctx, OPCODE_POLYGON_OFFSET_CLAMP, 3);
3513 if (n) {
3514 n[1].f = factor;
3515 n[2].f = units;
3516 n[3].f = clamp;
3517 }
3518 if (ctx->ExecuteFlag) {
3519 CALL_PolygonOffsetClampEXT(ctx->Exec, (factor, units, clamp));
3520 }
3521 }
3522
3523 static void GLAPIENTRY
3524 save_PopAttrib(void)
3525 {
3526 GET_CURRENT_CONTEXT(ctx);
3527 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3528 (void) alloc_instruction(ctx, OPCODE_POP_ATTRIB, 0);
3529 if (ctx->ExecuteFlag) {
3530 CALL_PopAttrib(ctx->Exec, ());
3531 }
3532 }
3533
3534
3535 static void GLAPIENTRY
3536 save_PopMatrix(void)
3537 {
3538 GET_CURRENT_CONTEXT(ctx);
3539 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3540 (void) alloc_instruction(ctx, OPCODE_POP_MATRIX, 0);
3541 if (ctx->ExecuteFlag) {
3542 CALL_PopMatrix(ctx->Exec, ());
3543 }
3544 }
3545
3546
3547 static void GLAPIENTRY
3548 save_PopName(void)
3549 {
3550 GET_CURRENT_CONTEXT(ctx);
3551 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3552 (void) alloc_instruction(ctx, OPCODE_POP_NAME, 0);
3553 if (ctx->ExecuteFlag) {
3554 CALL_PopName(ctx->Exec, ());
3555 }
3556 }
3557
3558
3559 static void GLAPIENTRY
3560 save_PrioritizeTextures(GLsizei num, const GLuint * textures,
3561 const GLclampf * priorities)
3562 {
3563 GET_CURRENT_CONTEXT(ctx);
3564 GLint i;
3565 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3566
3567 for (i = 0; i < num; i++) {
3568 Node *n;
3569 n = alloc_instruction(ctx, OPCODE_PRIORITIZE_TEXTURE, 2);
3570 if (n) {
3571 n[1].ui = textures[i];
3572 n[2].f = priorities[i];
3573 }
3574 }
3575 if (ctx->ExecuteFlag) {
3576 CALL_PrioritizeTextures(ctx->Exec, (num, textures, priorities));
3577 }
3578 }
3579
3580
3581 static void GLAPIENTRY
3582 save_PushAttrib(GLbitfield mask)
3583 {
3584 GET_CURRENT_CONTEXT(ctx);
3585 Node *n;
3586 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3587 n = alloc_instruction(ctx, OPCODE_PUSH_ATTRIB, 1);
3588 if (n) {
3589 n[1].bf = mask;
3590 }
3591 if (ctx->ExecuteFlag) {
3592 CALL_PushAttrib(ctx->Exec, (mask));
3593 }
3594 }
3595
3596
3597 static void GLAPIENTRY
3598 save_PushMatrix(void)
3599 {
3600 GET_CURRENT_CONTEXT(ctx);
3601 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3602 (void) alloc_instruction(ctx, OPCODE_PUSH_MATRIX, 0);
3603 if (ctx->ExecuteFlag) {
3604 CALL_PushMatrix(ctx->Exec, ());
3605 }
3606 }
3607
3608
3609 static void GLAPIENTRY
3610 save_PushName(GLuint name)
3611 {
3612 GET_CURRENT_CONTEXT(ctx);
3613 Node *n;
3614 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3615 n = alloc_instruction(ctx, OPCODE_PUSH_NAME, 1);
3616 if (n) {
3617 n[1].ui = name;
3618 }
3619 if (ctx->ExecuteFlag) {
3620 CALL_PushName(ctx->Exec, (name));
3621 }
3622 }
3623
3624
3625 static void GLAPIENTRY
3626 save_RasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
3627 {
3628 GET_CURRENT_CONTEXT(ctx);
3629 Node *n;
3630 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3631 n = alloc_instruction(ctx, OPCODE_RASTER_POS, 4);
3632 if (n) {
3633 n[1].f = x;
3634 n[2].f = y;
3635 n[3].f = z;
3636 n[4].f = w;
3637 }
3638 if (ctx->ExecuteFlag) {
3639 CALL_RasterPos4f(ctx->Exec, (x, y, z, w));
3640 }
3641 }
3642
3643 static void GLAPIENTRY
3644 save_RasterPos2d(GLdouble x, GLdouble y)
3645 {
3646 save_RasterPos4f((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
3647 }
3648
3649 static void GLAPIENTRY
3650 save_RasterPos2f(GLfloat x, GLfloat y)
3651 {
3652 save_RasterPos4f(x, y, 0.0F, 1.0F);
3653 }
3654
3655 static void GLAPIENTRY
3656 save_RasterPos2i(GLint x, GLint y)
3657 {
3658 save_RasterPos4f((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
3659 }
3660
3661 static void GLAPIENTRY
3662 save_RasterPos2s(GLshort x, GLshort y)
3663 {
3664 save_RasterPos4f(x, y, 0.0F, 1.0F);
3665 }
3666
3667 static void GLAPIENTRY
3668 save_RasterPos3d(GLdouble x, GLdouble y, GLdouble z)
3669 {
3670 save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
3671 }
3672
3673 static void GLAPIENTRY
3674 save_RasterPos3f(GLfloat x, GLfloat y, GLfloat z)
3675 {
3676 save_RasterPos4f(x, y, z, 1.0F);
3677 }
3678
3679 static void GLAPIENTRY
3680 save_RasterPos3i(GLint x, GLint y, GLint z)
3681 {
3682 save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
3683 }
3684
3685 static void GLAPIENTRY
3686 save_RasterPos3s(GLshort x, GLshort y, GLshort z)
3687 {
3688 save_RasterPos4f(x, y, z, 1.0F);
3689 }
3690
3691 static void GLAPIENTRY
3692 save_RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
3693 {
3694 save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
3695 }
3696
3697 static void GLAPIENTRY
3698 save_RasterPos4i(GLint x, GLint y, GLint z, GLint w)
3699 {
3700 save_RasterPos4f((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
3701 }
3702
3703 static void GLAPIENTRY
3704 save_RasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
3705 {
3706 save_RasterPos4f(x, y, z, w);
3707 }
3708
3709 static void GLAPIENTRY
3710 save_RasterPos2dv(const GLdouble * v)
3711 {
3712 save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
3713 }
3714
3715 static void GLAPIENTRY
3716 save_RasterPos2fv(const GLfloat * v)
3717 {
3718 save_RasterPos4f(v[0], v[1], 0.0F, 1.0F);
3719 }
3720
3721 static void GLAPIENTRY
3722 save_RasterPos2iv(const GLint * v)
3723 {
3724 save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
3725 }
3726
3727 static void GLAPIENTRY
3728 save_RasterPos2sv(const GLshort * v)
3729 {
3730 save_RasterPos4f(v[0], v[1], 0.0F, 1.0F);
3731 }
3732
3733 static void GLAPIENTRY
3734 save_RasterPos3dv(const GLdouble * v)
3735 {
3736 save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
3737 }
3738
3739 static void GLAPIENTRY
3740 save_RasterPos3fv(const GLfloat * v)
3741 {
3742 save_RasterPos4f(v[0], v[1], v[2], 1.0F);
3743 }
3744
3745 static void GLAPIENTRY
3746 save_RasterPos3iv(const GLint * v)
3747 {
3748 save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
3749 }
3750
3751 static void GLAPIENTRY
3752 save_RasterPos3sv(const GLshort * v)
3753 {
3754 save_RasterPos4f(v[0], v[1], v[2], 1.0F);
3755 }
3756
3757 static void GLAPIENTRY
3758 save_RasterPos4dv(const GLdouble * v)
3759 {
3760 save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1],
3761 (GLfloat) v[2], (GLfloat) v[3]);
3762 }
3763
3764 static void GLAPIENTRY
3765 save_RasterPos4fv(const GLfloat * v)
3766 {
3767 save_RasterPos4f(v[0], v[1], v[2], v[3]);
3768 }
3769
3770 static void GLAPIENTRY
3771 save_RasterPos4iv(const GLint * v)
3772 {
3773 save_RasterPos4f((GLfloat) v[0], (GLfloat) v[1],
3774 (GLfloat) v[2], (GLfloat) v[3]);
3775 }
3776
3777 static void GLAPIENTRY
3778 save_RasterPos4sv(const GLshort * v)
3779 {
3780 save_RasterPos4f(v[0], v[1], v[2], v[3]);
3781 }
3782
3783
3784 static void GLAPIENTRY
3785 save_PassThrough(GLfloat token)
3786 {
3787 GET_CURRENT_CONTEXT(ctx);
3788 Node *n;
3789 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3790 n = alloc_instruction(ctx, OPCODE_PASSTHROUGH, 1);
3791 if (n) {
3792 n[1].f = token;
3793 }
3794 if (ctx->ExecuteFlag) {
3795 CALL_PassThrough(ctx->Exec, (token));
3796 }
3797 }
3798
3799
3800 static void GLAPIENTRY
3801 save_ReadBuffer(GLenum mode)
3802 {
3803 GET_CURRENT_CONTEXT(ctx);
3804 Node *n;
3805 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3806 n = alloc_instruction(ctx, OPCODE_READ_BUFFER, 1);
3807 if (n) {
3808 n[1].e = mode;
3809 }
3810 if (ctx->ExecuteFlag) {
3811 CALL_ReadBuffer(ctx->Exec, (mode));
3812 }
3813 }
3814
3815
3816 static void GLAPIENTRY
3817 save_Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
3818 {
3819 GET_CURRENT_CONTEXT(ctx);
3820 Node *n;
3821 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3822 n = alloc_instruction(ctx, OPCODE_ROTATE, 4);
3823 if (n) {
3824 n[1].f = angle;
3825 n[2].f = x;
3826 n[3].f = y;
3827 n[4].f = z;
3828 }
3829 if (ctx->ExecuteFlag) {
3830 CALL_Rotatef(ctx->Exec, (angle, x, y, z));
3831 }
3832 }
3833
3834
3835 static void GLAPIENTRY
3836 save_Rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
3837 {
3838 save_Rotatef((GLfloat) angle, (GLfloat) x, (GLfloat) y, (GLfloat) z);
3839 }
3840
3841
3842 static void GLAPIENTRY
3843 save_Scalef(GLfloat x, GLfloat y, GLfloat z)
3844 {
3845 GET_CURRENT_CONTEXT(ctx);
3846 Node *n;
3847 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3848 n = alloc_instruction(ctx, OPCODE_SCALE, 3);
3849 if (n) {
3850 n[1].f = x;
3851 n[2].f = y;
3852 n[3].f = z;
3853 }
3854 if (ctx->ExecuteFlag) {
3855 CALL_Scalef(ctx->Exec, (x, y, z));
3856 }
3857 }
3858
3859
3860 static void GLAPIENTRY
3861 save_Scaled(GLdouble x, GLdouble y, GLdouble z)
3862 {
3863 save_Scalef((GLfloat) x, (GLfloat) y, (GLfloat) z);
3864 }
3865
3866
3867 static void GLAPIENTRY
3868 save_Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
3869 {
3870 GET_CURRENT_CONTEXT(ctx);
3871 Node *n;
3872 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3873 n = alloc_instruction(ctx, OPCODE_SCISSOR, 4);
3874 if (n) {
3875 n[1].i = x;
3876 n[2].i = y;
3877 n[3].i = width;
3878 n[4].i = height;
3879 }
3880 if (ctx->ExecuteFlag) {
3881 CALL_Scissor(ctx->Exec, (x, y, width, height));
3882 }
3883 }
3884
3885
3886 static void GLAPIENTRY
3887 save_ShadeModel(GLenum mode)
3888 {
3889 GET_CURRENT_CONTEXT(ctx);
3890 Node *n;
3891 ASSERT_OUTSIDE_SAVE_BEGIN_END(ctx);
3892
3893 if (ctx->ExecuteFlag) {
3894 CALL_ShadeModel(ctx->Exec, (mode));
3895 }
3896
3897 /* Don't compile this call if it's a no-op.
3898 * By avoiding this state change we have a better chance of
3899 * coalescing subsequent drawing commands into one batch.
3900 */
3901 if (ctx->ListState.Current.ShadeModel == mode)
3902 return;
3903
3904 SAVE_FLUSH_VERTICES(ctx);
3905
3906 ctx->ListState.Current.ShadeModel = mode;
3907
3908 n = alloc_instruction(ctx, OPCODE_SHADE_MODEL, 1);
3909 if (n) {
3910 n[1].e = mode;
3911 }
3912 }
3913
3914
3915 static void GLAPIENTRY
3916 save_StencilFunc(GLenum func, GLint ref, GLuint mask)
3917 {
3918 GET_CURRENT_CONTEXT(ctx);
3919 Node *n;
3920 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3921 n = alloc_instruction(ctx, OPCODE_STENCIL_FUNC, 3);
3922 if (n) {
3923 n[1].e = func;
3924 n[2].i = ref;
3925 n[3].ui = mask;
3926 }
3927 if (ctx->ExecuteFlag) {
3928 CALL_StencilFunc(ctx->Exec, (func, ref, mask));
3929 }
3930 }
3931
3932
3933 static void GLAPIENTRY
3934 save_StencilMask(GLuint mask)
3935 {
3936 GET_CURRENT_CONTEXT(ctx);
3937 Node *n;
3938 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3939 n = alloc_instruction(ctx, OPCODE_STENCIL_MASK, 1);
3940 if (n) {
3941 n[1].ui = mask;
3942 }
3943 if (ctx->ExecuteFlag) {
3944 CALL_StencilMask(ctx->Exec, (mask));
3945 }
3946 }
3947
3948
3949 static void GLAPIENTRY
3950 save_StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
3951 {
3952 GET_CURRENT_CONTEXT(ctx);
3953 Node *n;
3954 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3955 n = alloc_instruction(ctx, OPCODE_STENCIL_OP, 3);
3956 if (n) {
3957 n[1].e = fail;
3958 n[2].e = zfail;
3959 n[3].e = zpass;
3960 }
3961 if (ctx->ExecuteFlag) {
3962 CALL_StencilOp(ctx->Exec, (fail, zfail, zpass));
3963 }
3964 }
3965
3966
3967 static void GLAPIENTRY
3968 save_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
3969 {
3970 GET_CURRENT_CONTEXT(ctx);
3971 Node *n;
3972 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3973 n = alloc_instruction(ctx, OPCODE_STENCIL_FUNC_SEPARATE, 4);
3974 if (n) {
3975 n[1].e = face;
3976 n[2].e = func;
3977 n[3].i = ref;
3978 n[4].ui = mask;
3979 }
3980 if (ctx->ExecuteFlag) {
3981 CALL_StencilFuncSeparate(ctx->Exec, (face, func, ref, mask));
3982 }
3983 }
3984
3985
3986 static void GLAPIENTRY
3987 save_StencilFuncSeparateATI(GLenum frontfunc, GLenum backfunc, GLint ref,
3988 GLuint mask)
3989 {
3990 GET_CURRENT_CONTEXT(ctx);
3991 Node *n;
3992 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
3993 /* GL_FRONT */
3994 n = alloc_instruction(ctx, OPCODE_STENCIL_FUNC_SEPARATE, 4);
3995 if (n) {
3996 n[1].e = GL_FRONT;
3997 n[2].e = frontfunc;
3998 n[3].i = ref;
3999 n[4].ui = mask;
4000 }
4001 /* GL_BACK */
4002 n = alloc_instruction(ctx, OPCODE_STENCIL_FUNC_SEPARATE, 4);
4003 if (n) {
4004 n[1].e = GL_BACK;
4005 n[2].e = backfunc;
4006 n[3].i = ref;
4007 n[4].ui = mask;
4008 }
4009 if (ctx->ExecuteFlag) {
4010 CALL_StencilFuncSeparate(ctx->Exec, (GL_FRONT, frontfunc, ref, mask));
4011 CALL_StencilFuncSeparate(ctx->Exec, (GL_BACK, backfunc, ref, mask));
4012 }
4013 }
4014
4015
4016 static void GLAPIENTRY
4017 save_StencilMaskSeparate(GLenum face, GLuint mask)
4018 {
4019 GET_CURRENT_CONTEXT(ctx);
4020 Node *n;
4021 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4022 n = alloc_instruction(ctx, OPCODE_STENCIL_MASK_SEPARATE, 2);
4023 if (n) {
4024 n[1].e = face;
4025 n[2].ui = mask;
4026 }
4027 if (ctx->ExecuteFlag) {
4028 CALL_StencilMaskSeparate(ctx->Exec, (face, mask));
4029 }
4030 }
4031
4032
4033 static void GLAPIENTRY
4034 save_StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
4035 {
4036 GET_CURRENT_CONTEXT(ctx);
4037 Node *n;
4038 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4039 n = alloc_instruction(ctx, OPCODE_STENCIL_OP_SEPARATE, 4);
4040 if (n) {
4041 n[1].e = face;
4042 n[2].e = fail;
4043 n[3].e = zfail;
4044 n[4].e = zpass;
4045 }
4046 if (ctx->ExecuteFlag) {
4047 CALL_StencilOpSeparate(ctx->Exec, (face, fail, zfail, zpass));
4048 }
4049 }
4050
4051
4052 static void GLAPIENTRY
4053 save_TexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
4054 {
4055 GET_CURRENT_CONTEXT(ctx);
4056 Node *n;
4057 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4058 n = alloc_instruction(ctx, OPCODE_TEXENV, 6);
4059 if (n) {
4060 n[1].e = target;
4061 n[2].e = pname;
4062 if (pname == GL_TEXTURE_ENV_COLOR) {
4063 n[3].f = params[0];
4064 n[4].f = params[1];
4065 n[5].f = params[2];
4066 n[6].f = params[3];
4067 }
4068 else {
4069 n[3].f = params[0];
4070 n[4].f = n[5].f = n[6].f = 0.0F;
4071 }
4072 }
4073 if (ctx->ExecuteFlag) {
4074 CALL_TexEnvfv(ctx->Exec, (target, pname, params));
4075 }
4076 }
4077
4078
4079 static void GLAPIENTRY
4080 save_TexEnvf(GLenum target, GLenum pname, GLfloat param)
4081 {
4082 GLfloat parray[4];
4083 parray[0] = (GLfloat) param;
4084 parray[1] = parray[2] = parray[3] = 0.0F;
4085 save_TexEnvfv(target, pname, parray);
4086 }
4087
4088
4089 static void GLAPIENTRY
4090 save_TexEnvi(GLenum target, GLenum pname, GLint param)
4091 {
4092 GLfloat p[4];
4093 p[0] = (GLfloat) param;
4094 p[1] = p[2] = p[3] = 0.0F;
4095 save_TexEnvfv(target, pname, p);
4096 }
4097
4098
4099 static void GLAPIENTRY
4100 save_TexEnviv(GLenum target, GLenum pname, const GLint * param)
4101 {
4102 GLfloat p[4];
4103 if (pname == GL_TEXTURE_ENV_COLOR) {
4104 p[0] = INT_TO_FLOAT(param[0]);
4105 p[1] = INT_TO_FLOAT(param[1]);
4106 p[2] = INT_TO_FLOAT(param[2]);
4107 p[3] = INT_TO_FLOAT(param[3]);
4108 }
4109 else {
4110 p[0] = (GLfloat) param[0];
4111 p[1] = p[2] = p[3] = 0.0F;
4112 }
4113 save_TexEnvfv(target, pname, p);
4114 }
4115
4116
4117 static void GLAPIENTRY
4118 save_TexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
4119 {
4120 GET_CURRENT_CONTEXT(ctx);
4121 Node *n;
4122 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4123 n = alloc_instruction(ctx, OPCODE_TEXGEN, 6);
4124 if (n) {
4125 n[1].e = coord;
4126 n[2].e = pname;
4127 n[3].f = params[0];
4128 n[4].f = params[1];
4129 n[5].f = params[2];
4130 n[6].f = params[3];
4131 }
4132 if (ctx->ExecuteFlag) {
4133 CALL_TexGenfv(ctx->Exec, (coord, pname, params));
4134 }
4135 }
4136
4137
4138 static void GLAPIENTRY
4139 save_TexGeniv(GLenum coord, GLenum pname, const GLint *params)
4140 {
4141 GLfloat p[4];
4142 p[0] = (GLfloat) params[0];
4143 p[1] = (GLfloat) params[1];
4144 p[2] = (GLfloat) params[2];
4145 p[3] = (GLfloat) params[3];
4146 save_TexGenfv(coord, pname, p);
4147 }
4148
4149
4150 static void GLAPIENTRY
4151 save_TexGend(GLenum coord, GLenum pname, GLdouble param)
4152 {
4153 GLfloat parray[4];
4154 parray[0] = (GLfloat) param;
4155 parray[1] = parray[2] = parray[3] = 0.0F;
4156 save_TexGenfv(coord, pname, parray);
4157 }
4158
4159
4160 static void GLAPIENTRY
4161 save_TexGendv(GLenum coord, GLenum pname, const GLdouble *params)
4162 {
4163 GLfloat p[4];
4164 p[0] = (GLfloat) params[0];
4165 p[1] = (GLfloat) params[1];
4166 p[2] = (GLfloat) params[2];
4167 p[3] = (GLfloat) params[3];
4168 save_TexGenfv(coord, pname, p);
4169 }
4170
4171
4172 static void GLAPIENTRY
4173 save_TexGenf(GLenum coord, GLenum pname, GLfloat param)
4174 {
4175 GLfloat parray[4];
4176 parray[0] = param;
4177 parray[1] = parray[2] = parray[3] = 0.0F;
4178 save_TexGenfv(coord, pname, parray);
4179 }
4180
4181
4182 static void GLAPIENTRY
4183 save_TexGeni(GLenum coord, GLenum pname, GLint param)
4184 {
4185 GLint parray[4];
4186 parray[0] = param;
4187 parray[1] = parray[2] = parray[3] = 0;
4188 save_TexGeniv(coord, pname, parray);
4189 }
4190
4191
4192 static void GLAPIENTRY
4193 save_TexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
4194 {
4195 GET_CURRENT_CONTEXT(ctx);
4196 Node *n;
4197 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4198 n = alloc_instruction(ctx, OPCODE_TEXPARAMETER, 6);
4199 if (n) {
4200 n[1].e = target;
4201 n[2].e = pname;
4202 n[3].f = params[0];
4203 n[4].f = params[1];
4204 n[5].f = params[2];
4205 n[6].f = params[3];
4206 }
4207 if (ctx->ExecuteFlag) {
4208 CALL_TexParameterfv(ctx->Exec, (target, pname, params));
4209 }
4210 }
4211
4212
4213 static void GLAPIENTRY
4214 save_TexParameterf(GLenum target, GLenum pname, GLfloat param)
4215 {
4216 GLfloat parray[4];
4217 parray[0] = param;
4218 parray[1] = parray[2] = parray[3] = 0.0F;
4219 save_TexParameterfv(target, pname, parray);
4220 }
4221
4222
4223 static void GLAPIENTRY
4224 save_TexParameteri(GLenum target, GLenum pname, GLint param)
4225 {
4226 GLfloat fparam[4];
4227 fparam[0] = (GLfloat) param;
4228 fparam[1] = fparam[2] = fparam[3] = 0.0F;
4229 save_TexParameterfv(target, pname, fparam);
4230 }
4231
4232
4233 static void GLAPIENTRY
4234 save_TexParameteriv(GLenum target, GLenum pname, const GLint *params)
4235 {
4236 GLfloat fparam[4];
4237 fparam[0] = (GLfloat) params[0];
4238 fparam[1] = fparam[2] = fparam[3] = 0.0F;
4239 save_TexParameterfv(target, pname, fparam);
4240 }
4241
4242
4243 static void GLAPIENTRY
4244 save_TexImage1D(GLenum target,
4245 GLint level, GLint components,
4246 GLsizei width, GLint border,
4247 GLenum format, GLenum type, const GLvoid * pixels)
4248 {
4249 GET_CURRENT_CONTEXT(ctx);
4250 if (target == GL_PROXY_TEXTURE_1D) {
4251 /* don't compile, execute immediately */
4252 CALL_TexImage1D(ctx->Exec, (target, level, components, width,
4253 border, format, type, pixels));
4254 }
4255 else {
4256 Node *n;
4257 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4258 n = alloc_instruction(ctx, OPCODE_TEX_IMAGE1D, 7 + POINTER_DWORDS);
4259 if (n) {
4260 n[1].e = target;
4261 n[2].i = level;
4262 n[3].i = components;
4263 n[4].i = (GLint) width;
4264 n[5].i = border;
4265 n[6].e = format;
4266 n[7].e = type;
4267 save_pointer(&n[8],
4268 unpack_image(ctx, 1, width, 1, 1, format, type,
4269 pixels, &ctx->Unpack));
4270 }
4271 if (ctx->ExecuteFlag) {
4272 CALL_TexImage1D(ctx->Exec, (target, level, components, width,
4273 border, format, type, pixels));
4274 }
4275 }
4276 }
4277
4278
4279 static void GLAPIENTRY
4280 save_TexImage2D(GLenum target,
4281 GLint level, GLint components,
4282 GLsizei width, GLsizei height, GLint border,
4283 GLenum format, GLenum type, const GLvoid * pixels)
4284 {
4285 GET_CURRENT_CONTEXT(ctx);
4286 if (target == GL_PROXY_TEXTURE_2D) {
4287 /* don't compile, execute immediately */
4288 CALL_TexImage2D(ctx->Exec, (target, level, components, width,
4289 height, border, format, type, pixels));
4290 }
4291 else {
4292 Node *n;
4293 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4294 n = alloc_instruction(ctx, OPCODE_TEX_IMAGE2D, 8 + POINTER_DWORDS);
4295 if (n) {
4296 n[1].e = target;
4297 n[2].i = level;
4298 n[3].i = components;
4299 n[4].i = (GLint) width;
4300 n[5].i = (GLint) height;
4301 n[6].i = border;
4302 n[7].e = format;
4303 n[8].e = type;
4304 save_pointer(&n[9],
4305 unpack_image(ctx, 2, width, height, 1, format, type,
4306 pixels, &ctx->Unpack));
4307 }
4308 if (ctx->ExecuteFlag) {
4309 CALL_TexImage2D(ctx->Exec, (target, level, components, width,
4310 height, border, format, type, pixels));
4311 }
4312 }
4313 }
4314
4315
4316 static void GLAPIENTRY
4317 save_TexImage3D(GLenum target,
4318 GLint level, GLint internalFormat,
4319 GLsizei width, GLsizei height, GLsizei depth,
4320 GLint border,
4321 GLenum format, GLenum type, const GLvoid * pixels)
4322 {
4323 GET_CURRENT_CONTEXT(ctx);
4324 if (target == GL_PROXY_TEXTURE_3D) {
4325 /* don't compile, execute immediately */
4326 CALL_TexImage3D(ctx->Exec, (target, level, internalFormat, width,
4327 height, depth, border, format, type,
4328 pixels));
4329 }
4330 else {
4331 Node *n;
4332 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4333 n = alloc_instruction(ctx, OPCODE_TEX_IMAGE3D, 9 + POINTER_DWORDS);
4334 if (n) {
4335 n[1].e = target;
4336 n[2].i = level;
4337 n[3].i = (GLint) internalFormat;
4338 n[4].i = (GLint) width;
4339 n[5].i = (GLint) height;
4340 n[6].i = (GLint) depth;
4341 n[7].i = border;
4342 n[8].e = format;
4343 n[9].e = type;
4344 save_pointer(&n[10],
4345 unpack_image(ctx, 3, width, height, depth, format, type,
4346 pixels, &ctx->Unpack));
4347 }
4348 if (ctx->ExecuteFlag) {
4349 CALL_TexImage3D(ctx->Exec, (target, level, internalFormat, width,
4350 height, depth, border, format, type,
4351 pixels));
4352 }
4353 }
4354 }
4355
4356
4357 static void GLAPIENTRY
4358 save_TexSubImage1D(GLenum target, GLint level, GLint xoffset,
4359 GLsizei width, GLenum format, GLenum type,
4360 const GLvoid * pixels)
4361 {
4362 GET_CURRENT_CONTEXT(ctx);
4363 Node *n;
4364
4365 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4366
4367 n = alloc_instruction(ctx, OPCODE_TEX_SUB_IMAGE1D, 6 + POINTER_DWORDS);
4368 if (n) {
4369 n[1].e = target;
4370 n[2].i = level;
4371 n[3].i = xoffset;
4372 n[4].i = (GLint) width;
4373 n[5].e = format;
4374 n[6].e = type;
4375 save_pointer(&n[7],
4376 unpack_image(ctx, 1, width, 1, 1, format, type,
4377 pixels, &ctx->Unpack));
4378 }
4379 if (ctx->ExecuteFlag) {
4380 CALL_TexSubImage1D(ctx->Exec, (target, level, xoffset, width,
4381 format, type, pixels));
4382 }
4383 }
4384
4385
4386 static void GLAPIENTRY
4387 save_TexSubImage2D(GLenum target, GLint level,
4388 GLint xoffset, GLint yoffset,
4389 GLsizei width, GLsizei height,
4390 GLenum format, GLenum type, const GLvoid * pixels)
4391 {
4392 GET_CURRENT_CONTEXT(ctx);
4393 Node *n;
4394
4395 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4396
4397 n = alloc_instruction(ctx, OPCODE_TEX_SUB_IMAGE2D, 8 + POINTER_DWORDS);
4398 if (n) {
4399 n[1].e = target;
4400 n[2].i = level;
4401 n[3].i = xoffset;
4402 n[4].i = yoffset;
4403 n[5].i = (GLint) width;
4404 n[6].i = (GLint) height;
4405 n[7].e = format;
4406 n[8].e = type;
4407 save_pointer(&n[9],
4408 unpack_image(ctx, 2, width, height, 1, format, type,
4409 pixels, &ctx->Unpack));
4410 }
4411 if (ctx->ExecuteFlag) {
4412 CALL_TexSubImage2D(ctx->Exec, (target, level, xoffset, yoffset,
4413 width, height, format, type, pixels));
4414 }
4415 }
4416
4417
4418 static void GLAPIENTRY
4419 save_TexSubImage3D(GLenum target, GLint level,
4420 GLint xoffset, GLint yoffset, GLint zoffset,
4421 GLsizei width, GLsizei height, GLsizei depth,
4422 GLenum format, GLenum type, const GLvoid * pixels)
4423 {
4424 GET_CURRENT_CONTEXT(ctx);
4425 Node *n;
4426
4427 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4428
4429 n = alloc_instruction(ctx, OPCODE_TEX_SUB_IMAGE3D, 10 + POINTER_DWORDS);
4430 if (n) {
4431 n[1].e = target;
4432 n[2].i = level;
4433 n[3].i = xoffset;
4434 n[4].i = yoffset;
4435 n[5].i = zoffset;
4436 n[6].i = (GLint) width;
4437 n[7].i = (GLint) height;
4438 n[8].i = (GLint) depth;
4439 n[9].e = format;
4440 n[10].e = type;
4441 save_pointer(&n[11],
4442 unpack_image(ctx, 3, width, height, depth, format, type,
4443 pixels, &ctx->Unpack));
4444 }
4445 if (ctx->ExecuteFlag) {
4446 CALL_TexSubImage3D(ctx->Exec, (target, level,
4447 xoffset, yoffset, zoffset,
4448 width, height, depth, format, type,
4449 pixels));
4450 }
4451 }
4452
4453
4454 static void GLAPIENTRY
4455 save_Translatef(GLfloat x, GLfloat y, GLfloat z)
4456 {
4457 GET_CURRENT_CONTEXT(ctx);
4458 Node *n;
4459 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4460 n = alloc_instruction(ctx, OPCODE_TRANSLATE, 3);
4461 if (n) {
4462 n[1].f = x;
4463 n[2].f = y;
4464 n[3].f = z;
4465 }
4466 if (ctx->ExecuteFlag) {
4467 CALL_Translatef(ctx->Exec, (x, y, z));
4468 }
4469 }
4470
4471
4472 static void GLAPIENTRY
4473 save_Translated(GLdouble x, GLdouble y, GLdouble z)
4474 {
4475 save_Translatef((GLfloat) x, (GLfloat) y, (GLfloat) z);
4476 }
4477
4478
4479
4480 static void GLAPIENTRY
4481 save_Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
4482 {
4483 GET_CURRENT_CONTEXT(ctx);
4484 Node *n;
4485 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4486 n = alloc_instruction(ctx, OPCODE_VIEWPORT, 4);
4487 if (n) {
4488 n[1].i = x;
4489 n[2].i = y;
4490 n[3].i = (GLint) width;
4491 n[4].i = (GLint) height;
4492 }
4493 if (ctx->ExecuteFlag) {
4494 CALL_Viewport(ctx->Exec, (x, y, width, height));
4495 }
4496 }
4497
4498
4499 static void GLAPIENTRY
4500 save_WindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
4501 {
4502 GET_CURRENT_CONTEXT(ctx);
4503 Node *n;
4504 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4505 n = alloc_instruction(ctx, OPCODE_WINDOW_POS, 4);
4506 if (n) {
4507 n[1].f = x;
4508 n[2].f = y;
4509 n[3].f = z;
4510 n[4].f = w;
4511 }
4512 if (ctx->ExecuteFlag) {
4513 CALL_WindowPos4fMESA(ctx->Exec, (x, y, z, w));
4514 }
4515 }
4516
4517 static void GLAPIENTRY
4518 save_WindowPos2dMESA(GLdouble x, GLdouble y)
4519 {
4520 save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
4521 }
4522
4523 static void GLAPIENTRY
4524 save_WindowPos2fMESA(GLfloat x, GLfloat y)
4525 {
4526 save_WindowPos4fMESA(x, y, 0.0F, 1.0F);
4527 }
4528
4529 static void GLAPIENTRY
4530 save_WindowPos2iMESA(GLint x, GLint y)
4531 {
4532 save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, 0.0F, 1.0F);
4533 }
4534
4535 static void GLAPIENTRY
4536 save_WindowPos2sMESA(GLshort x, GLshort y)
4537 {
4538 save_WindowPos4fMESA(x, y, 0.0F, 1.0F);
4539 }
4540
4541 static void GLAPIENTRY
4542 save_WindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z)
4543 {
4544 save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
4545 }
4546
4547 static void GLAPIENTRY
4548 save_WindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
4549 {
4550 save_WindowPos4fMESA(x, y, z, 1.0F);
4551 }
4552
4553 static void GLAPIENTRY
4554 save_WindowPos3iMESA(GLint x, GLint y, GLint z)
4555 {
4556 save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, 1.0F);
4557 }
4558
4559 static void GLAPIENTRY
4560 save_WindowPos3sMESA(GLshort x, GLshort y, GLshort z)
4561 {
4562 save_WindowPos4fMESA(x, y, z, 1.0F);
4563 }
4564
4565 static void GLAPIENTRY
4566 save_WindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
4567 {
4568 save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
4569 }
4570
4571 static void GLAPIENTRY
4572 save_WindowPos4iMESA(GLint x, GLint y, GLint z, GLint w)
4573 {
4574 save_WindowPos4fMESA((GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
4575 }
4576
4577 static void GLAPIENTRY
4578 save_WindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w)
4579 {
4580 save_WindowPos4fMESA(x, y, z, w);
4581 }
4582
4583 static void GLAPIENTRY
4584 save_WindowPos2dvMESA(const GLdouble * v)
4585 {
4586 save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
4587 }
4588
4589 static void GLAPIENTRY
4590 save_WindowPos2fvMESA(const GLfloat * v)
4591 {
4592 save_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);
4593 }
4594
4595 static void GLAPIENTRY
4596 save_WindowPos2ivMESA(const GLint * v)
4597 {
4598 save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], 0.0F, 1.0F);
4599 }
4600
4601 static void GLAPIENTRY
4602 save_WindowPos2svMESA(const GLshort * v)
4603 {
4604 save_WindowPos4fMESA(v[0], v[1], 0.0F, 1.0F);
4605 }
4606
4607 static void GLAPIENTRY
4608 save_WindowPos3dvMESA(const GLdouble * v)
4609 {
4610 save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
4611 }
4612
4613 static void GLAPIENTRY
4614 save_WindowPos3fvMESA(const GLfloat * v)
4615 {
4616 save_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);
4617 }
4618
4619 static void GLAPIENTRY
4620 save_WindowPos3ivMESA(const GLint * v)
4621 {
4622 save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], 1.0F);
4623 }
4624
4625 static void GLAPIENTRY
4626 save_WindowPos3svMESA(const GLshort * v)
4627 {
4628 save_WindowPos4fMESA(v[0], v[1], v[2], 1.0F);
4629 }
4630
4631 static void GLAPIENTRY
4632 save_WindowPos4dvMESA(const GLdouble * v)
4633 {
4634 save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1],
4635 (GLfloat) v[2], (GLfloat) v[3]);
4636 }
4637
4638 static void GLAPIENTRY
4639 save_WindowPos4fvMESA(const GLfloat * v)
4640 {
4641 save_WindowPos4fMESA(v[0], v[1], v[2], v[3]);
4642 }
4643
4644 static void GLAPIENTRY
4645 save_WindowPos4ivMESA(const GLint * v)
4646 {
4647 save_WindowPos4fMESA((GLfloat) v[0], (GLfloat) v[1],
4648 (GLfloat) v[2], (GLfloat) v[3]);
4649 }
4650
4651 static void GLAPIENTRY
4652 save_WindowPos4svMESA(const GLshort * v)
4653 {
4654 save_WindowPos4fMESA(v[0], v[1], v[2], v[3]);
4655 }
4656
4657
4658
4659 /* GL_ARB_multitexture */
4660 static void GLAPIENTRY
4661 save_ActiveTextureARB(GLenum target)
4662 {
4663 GET_CURRENT_CONTEXT(ctx);
4664 Node *n;
4665 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4666 n = alloc_instruction(ctx, OPCODE_ACTIVE_TEXTURE, 1);
4667 if (n) {
4668 n[1].e = target;
4669 }
4670 if (ctx->ExecuteFlag) {
4671 CALL_ActiveTexture(ctx->Exec, (target));
4672 }
4673 }
4674
4675
4676 /* GL_ARB_transpose_matrix */
4677
4678 static void GLAPIENTRY
4679 save_LoadTransposeMatrixdARB(const GLdouble m[16])
4680 {
4681 GLfloat tm[16];
4682 _math_transposefd(tm, m);
4683 save_LoadMatrixf(tm);
4684 }
4685
4686
4687 static void GLAPIENTRY
4688 save_LoadTransposeMatrixfARB(const GLfloat m[16])
4689 {
4690 GLfloat tm[16];
4691 _math_transposef(tm, m);
4692 save_LoadMatrixf(tm);
4693 }
4694
4695
4696 static void GLAPIENTRY
4697 save_MultTransposeMatrixdARB(const GLdouble m[16])
4698 {
4699 GLfloat tm[16];
4700 _math_transposefd(tm, m);
4701 save_MultMatrixf(tm);
4702 }
4703
4704
4705 static void GLAPIENTRY
4706 save_MultTransposeMatrixfARB(const GLfloat m[16])
4707 {
4708 GLfloat tm[16];
4709 _math_transposef(tm, m);
4710 save_MultMatrixf(tm);
4711 }
4712
4713 static GLvoid *copy_data(const GLvoid *data, GLsizei size, const char *func)
4714 {
4715 GET_CURRENT_CONTEXT(ctx);
4716 GLvoid *image;
4717
4718 if (!data)
4719 return NULL;
4720
4721 image = malloc(size);
4722 if (!image) {
4723 _mesa_error(ctx, GL_OUT_OF_MEMORY, "%s", func);
4724 return NULL;
4725 }
4726 memcpy(image, data, size);
4727
4728 return image;
4729 }
4730
4731
4732 /* GL_ARB_texture_compression */
4733 static void GLAPIENTRY
4734 save_CompressedTexImage1DARB(GLenum target, GLint level,
4735 GLenum internalFormat, GLsizei width,
4736 GLint border, GLsizei imageSize,
4737 const GLvoid * data)
4738 {
4739 GET_CURRENT_CONTEXT(ctx);
4740 if (target == GL_PROXY_TEXTURE_1D) {
4741 /* don't compile, execute immediately */
4742 CALL_CompressedTexImage1D(ctx->Exec, (target, level, internalFormat,
4743 width, border, imageSize,
4744 data));
4745 }
4746 else {
4747 Node *n;
4748 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4749
4750 n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_IMAGE_1D,
4751 6 + POINTER_DWORDS);
4752 if (n) {
4753 n[1].e = target;
4754 n[2].i = level;
4755 n[3].e = internalFormat;
4756 n[4].i = (GLint) width;
4757 n[5].i = border;
4758 n[6].i = imageSize;
4759 save_pointer(&n[7],
4760 copy_data(data, imageSize, "glCompressedTexImage1DARB"));
4761 }
4762 if (ctx->ExecuteFlag) {
4763 CALL_CompressedTexImage1D(ctx->Exec,
4764 (target, level, internalFormat, width,
4765 border, imageSize, data));
4766 }
4767 }
4768 }
4769
4770
4771 static void GLAPIENTRY
4772 save_CompressedTexImage2DARB(GLenum target, GLint level,
4773 GLenum internalFormat, GLsizei width,
4774 GLsizei height, GLint border, GLsizei imageSize,
4775 const GLvoid * data)
4776 {
4777 GET_CURRENT_CONTEXT(ctx);
4778 if (target == GL_PROXY_TEXTURE_2D) {
4779 /* don't compile, execute immediately */
4780 CALL_CompressedTexImage2D(ctx->Exec, (target, level, internalFormat,
4781 width, height, border,
4782 imageSize, data));
4783 }
4784 else {
4785 Node *n;
4786 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4787
4788 n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_IMAGE_2D,
4789 7 + POINTER_DWORDS);
4790 if (n) {
4791 n[1].e = target;
4792 n[2].i = level;
4793 n[3].e = internalFormat;
4794 n[4].i = (GLint) width;
4795 n[5].i = (GLint) height;
4796 n[6].i = border;
4797 n[7].i = imageSize;
4798 save_pointer(&n[8],
4799 copy_data(data, imageSize, "glCompressedTexImage2DARB"));
4800 }
4801 if (ctx->ExecuteFlag) {
4802 CALL_CompressedTexImage2D(ctx->Exec,
4803 (target, level, internalFormat, width,
4804 height, border, imageSize, data));
4805 }
4806 }
4807 }
4808
4809
4810 static void GLAPIENTRY
4811 save_CompressedTexImage3DARB(GLenum target, GLint level,
4812 GLenum internalFormat, GLsizei width,
4813 GLsizei height, GLsizei depth, GLint border,
4814 GLsizei imageSize, const GLvoid * data)
4815 {
4816 GET_CURRENT_CONTEXT(ctx);
4817 if (target == GL_PROXY_TEXTURE_3D) {
4818 /* don't compile, execute immediately */
4819 CALL_CompressedTexImage3D(ctx->Exec, (target, level, internalFormat,
4820 width, height, depth, border,
4821 imageSize, data));
4822 }
4823 else {
4824 Node *n;
4825 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4826
4827 n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_IMAGE_3D,
4828 8 + POINTER_DWORDS);
4829 if (n) {
4830 n[1].e = target;
4831 n[2].i = level;
4832 n[3].e = internalFormat;
4833 n[4].i = (GLint) width;
4834 n[5].i = (GLint) height;
4835 n[6].i = (GLint) depth;
4836 n[7].i = border;
4837 n[8].i = imageSize;
4838 save_pointer(&n[9],
4839 copy_data(data, imageSize, "glCompressedTexImage3DARB"));
4840 }
4841 if (ctx->ExecuteFlag) {
4842 CALL_CompressedTexImage3D(ctx->Exec,
4843 (target, level, internalFormat, width,
4844 height, depth, border, imageSize,
4845 data));
4846 }
4847 }
4848 }
4849
4850
4851 static void GLAPIENTRY
4852 save_CompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset,
4853 GLsizei width, GLenum format,
4854 GLsizei imageSize, const GLvoid * data)
4855 {
4856 Node *n;
4857 GET_CURRENT_CONTEXT(ctx);
4858 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4859
4860 n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D,
4861 6 + POINTER_DWORDS);
4862 if (n) {
4863 n[1].e = target;
4864 n[2].i = level;
4865 n[3].i = xoffset;
4866 n[4].i = (GLint) width;
4867 n[5].e = format;
4868 n[6].i = imageSize;
4869 save_pointer(&n[7],
4870 copy_data(data, imageSize, "glCompressedTexSubImage1DARB"));
4871 }
4872 if (ctx->ExecuteFlag) {
4873 CALL_CompressedTexSubImage1D(ctx->Exec, (target, level, xoffset,
4874 width, format, imageSize,
4875 data));
4876 }
4877 }
4878
4879
4880 static void GLAPIENTRY
4881 save_CompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset,
4882 GLint yoffset, GLsizei width, GLsizei height,
4883 GLenum format, GLsizei imageSize,
4884 const GLvoid * data)
4885 {
4886 Node *n;
4887 GET_CURRENT_CONTEXT(ctx);
4888 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4889
4890 n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D,
4891 8 + POINTER_DWORDS);
4892 if (n) {
4893 n[1].e = target;
4894 n[2].i = level;
4895 n[3].i = xoffset;
4896 n[4].i = yoffset;
4897 n[5].i = (GLint) width;
4898 n[6].i = (GLint) height;
4899 n[7].e = format;
4900 n[8].i = imageSize;
4901 save_pointer(&n[9],
4902 copy_data(data, imageSize, "glCompressedTexSubImage2DARB"));
4903 }
4904 if (ctx->ExecuteFlag) {
4905 CALL_CompressedTexSubImage2D(ctx->Exec,
4906 (target, level, xoffset, yoffset, width,
4907 height, format, imageSize, data));
4908 }
4909 }
4910
4911
4912 static void GLAPIENTRY
4913 save_CompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset,
4914 GLint yoffset, GLint zoffset, GLsizei width,
4915 GLsizei height, GLsizei depth, GLenum format,
4916 GLsizei imageSize, const GLvoid * data)
4917 {
4918 Node *n;
4919 GET_CURRENT_CONTEXT(ctx);
4920 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4921
4922 n = alloc_instruction(ctx, OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D,
4923 10 + POINTER_DWORDS);
4924 if (n) {
4925 n[1].e = target;
4926 n[2].i = level;
4927 n[3].i = xoffset;
4928 n[4].i = yoffset;
4929 n[5].i = zoffset;
4930 n[6].i = (GLint) width;
4931 n[7].i = (GLint) height;
4932 n[8].i = (GLint) depth;
4933 n[9].e = format;
4934 n[10].i = imageSize;
4935 save_pointer(&n[11],
4936 copy_data(data, imageSize, "glCompressedTexSubImage3DARB"));
4937 }
4938 if (ctx->ExecuteFlag) {
4939 CALL_CompressedTexSubImage3D(ctx->Exec,
4940 (target, level, xoffset, yoffset,
4941 zoffset, width, height, depth, format,
4942 imageSize, data));
4943 }
4944 }
4945
4946
4947 /* GL_ARB_multisample */
4948 static void GLAPIENTRY
4949 save_SampleCoverageARB(GLclampf value, GLboolean invert)
4950 {
4951 GET_CURRENT_CONTEXT(ctx);
4952 Node *n;
4953 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4954 n = alloc_instruction(ctx, OPCODE_SAMPLE_COVERAGE, 2);
4955 if (n) {
4956 n[1].f = value;
4957 n[2].b = invert;
4958 }
4959 if (ctx->ExecuteFlag) {
4960 CALL_SampleCoverage(ctx->Exec, (value, invert));
4961 }
4962 }
4963
4964
4965 /*
4966 * GL_ARB_vertex_program
4967 */
4968 static void GLAPIENTRY
4969 save_BindProgramARB(GLenum target, GLuint id)
4970 {
4971 GET_CURRENT_CONTEXT(ctx);
4972 Node *n;
4973 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4974 n = alloc_instruction(ctx, OPCODE_BIND_PROGRAM_ARB, 2);
4975 if (n) {
4976 n[1].e = target;
4977 n[2].ui = id;
4978 }
4979 if (ctx->ExecuteFlag) {
4980 CALL_BindProgramARB(ctx->Exec, (target, id));
4981 }
4982 }
4983
4984 static void GLAPIENTRY
4985 save_ProgramEnvParameter4fARB(GLenum target, GLuint index,
4986 GLfloat x, GLfloat y, GLfloat z, GLfloat w)
4987 {
4988 GET_CURRENT_CONTEXT(ctx);
4989 Node *n;
4990 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
4991 n = alloc_instruction(ctx, OPCODE_PROGRAM_ENV_PARAMETER_ARB, 6);
4992 if (n) {
4993 n[1].e = target;
4994 n[2].ui = index;
4995 n[3].f = x;
4996 n[4].f = y;
4997 n[5].f = z;
4998 n[6].f = w;
4999 }
5000 if (ctx->ExecuteFlag) {
5001 CALL_ProgramEnvParameter4fARB(ctx->Exec, (target, index, x, y, z, w));
5002 }
5003 }
5004
5005
5006 static void GLAPIENTRY
5007 save_ProgramEnvParameter4fvARB(GLenum target, GLuint index,
5008 const GLfloat *params)
5009 {
5010 save_ProgramEnvParameter4fARB(target, index, params[0], params[1],
5011 params[2], params[3]);
5012 }
5013
5014
5015 static void GLAPIENTRY
5016 save_ProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count,
5017 const GLfloat * params)
5018 {
5019 GET_CURRENT_CONTEXT(ctx);
5020 Node *n;
5021 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5022
5023 if (count > 0) {
5024 GLint i;
5025 const GLfloat * p = params;
5026
5027 for (i = 0 ; i < count ; i++) {
5028 n = alloc_instruction(ctx, OPCODE_PROGRAM_ENV_PARAMETER_ARB, 6);
5029 if (n) {
5030 n[1].e = target;
5031 n[2].ui = index;
5032 n[3].f = p[0];
5033 n[4].f = p[1];
5034 n[5].f = p[2];
5035 n[6].f = p[3];
5036 p += 4;
5037 }
5038 }
5039 }
5040
5041 if (ctx->ExecuteFlag) {
5042 CALL_ProgramEnvParameters4fvEXT(ctx->Exec, (target, index, count, params));
5043 }
5044 }
5045
5046
5047 static void GLAPIENTRY
5048 save_ProgramEnvParameter4dARB(GLenum target, GLuint index,
5049 GLdouble x, GLdouble y, GLdouble z, GLdouble w)
5050 {
5051 save_ProgramEnvParameter4fARB(target, index,
5052 (GLfloat) x,
5053 (GLfloat) y, (GLfloat) z, (GLfloat) w);
5054 }
5055
5056
5057 static void GLAPIENTRY
5058 save_ProgramEnvParameter4dvARB(GLenum target, GLuint index,
5059 const GLdouble *params)
5060 {
5061 save_ProgramEnvParameter4fARB(target, index,
5062 (GLfloat) params[0],
5063 (GLfloat) params[1],
5064 (GLfloat) params[2], (GLfloat) params[3]);
5065 }
5066
5067
5068 static void GLAPIENTRY
5069 save_ProgramLocalParameter4fARB(GLenum target, GLuint index,
5070 GLfloat x, GLfloat y, GLfloat z, GLfloat w)
5071 {
5072 GET_CURRENT_CONTEXT(ctx);
5073 Node *n;
5074 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5075 n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
5076 if (n) {
5077 n[1].e = target;
5078 n[2].ui = index;
5079 n[3].f = x;
5080 n[4].f = y;
5081 n[5].f = z;
5082 n[6].f = w;
5083 }
5084 if (ctx->ExecuteFlag) {
5085 CALL_ProgramLocalParameter4fARB(ctx->Exec, (target, index, x, y, z, w));
5086 }
5087 }
5088
5089
5090 static void GLAPIENTRY
5091 save_ProgramLocalParameter4fvARB(GLenum target, GLuint index,
5092 const GLfloat *params)
5093 {
5094 GET_CURRENT_CONTEXT(ctx);
5095 Node *n;
5096 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5097 n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
5098 if (n) {
5099 n[1].e = target;
5100 n[2].ui = index;
5101 n[3].f = params[0];
5102 n[4].f = params[1];
5103 n[5].f = params[2];
5104 n[6].f = params[3];
5105 }
5106 if (ctx->ExecuteFlag) {
5107 CALL_ProgramLocalParameter4fvARB(ctx->Exec, (target, index, params));
5108 }
5109 }
5110
5111
5112 static void GLAPIENTRY
5113 save_ProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count,
5114 const GLfloat *params)
5115 {
5116 GET_CURRENT_CONTEXT(ctx);
5117 Node *n;
5118 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5119
5120 if (count > 0) {
5121 GLint i;
5122 const GLfloat * p = params;
5123
5124 for (i = 0 ; i < count ; i++) {
5125 n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
5126 if (n) {
5127 n[1].e = target;
5128 n[2].ui = index;
5129 n[3].f = p[0];
5130 n[4].f = p[1];
5131 n[5].f = p[2];
5132 n[6].f = p[3];
5133 p += 4;
5134 }
5135 }
5136 }
5137
5138 if (ctx->ExecuteFlag) {
5139 CALL_ProgramLocalParameters4fvEXT(ctx->Exec, (target, index, count, params));
5140 }
5141 }
5142
5143
5144 static void GLAPIENTRY
5145 save_ProgramLocalParameter4dARB(GLenum target, GLuint index,
5146 GLdouble x, GLdouble y,
5147 GLdouble z, GLdouble w)
5148 {
5149 GET_CURRENT_CONTEXT(ctx);
5150 Node *n;
5151 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5152 n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
5153 if (n) {
5154 n[1].e = target;
5155 n[2].ui = index;
5156 n[3].f = (GLfloat) x;
5157 n[4].f = (GLfloat) y;
5158 n[5].f = (GLfloat) z;
5159 n[6].f = (GLfloat) w;
5160 }
5161 if (ctx->ExecuteFlag) {
5162 CALL_ProgramLocalParameter4dARB(ctx->Exec, (target, index, x, y, z, w));
5163 }
5164 }
5165
5166
5167 static void GLAPIENTRY
5168 save_ProgramLocalParameter4dvARB(GLenum target, GLuint index,
5169 const GLdouble *params)
5170 {
5171 GET_CURRENT_CONTEXT(ctx);
5172 Node *n;
5173 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5174 n = alloc_instruction(ctx, OPCODE_PROGRAM_LOCAL_PARAMETER_ARB, 6);
5175 if (n) {
5176 n[1].e = target;
5177 n[2].ui = index;
5178 n[3].f = (GLfloat) params[0];
5179 n[4].f = (GLfloat) params[1];
5180 n[5].f = (GLfloat) params[2];
5181 n[6].f = (GLfloat) params[3];
5182 }
5183 if (ctx->ExecuteFlag) {
5184 CALL_ProgramLocalParameter4dvARB(ctx->Exec, (target, index, params));
5185 }
5186 }
5187
5188
5189 /* GL_EXT_stencil_two_side */
5190 static void GLAPIENTRY
5191 save_ActiveStencilFaceEXT(GLenum face)
5192 {
5193 GET_CURRENT_CONTEXT(ctx);
5194 Node *n;
5195 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5196 n = alloc_instruction(ctx, OPCODE_ACTIVE_STENCIL_FACE_EXT, 1);
5197 if (n) {
5198 n[1].e = face;
5199 }
5200 if (ctx->ExecuteFlag) {
5201 CALL_ActiveStencilFaceEXT(ctx->Exec, (face));
5202 }
5203 }
5204
5205
5206 /* GL_EXT_depth_bounds_test */
5207 static void GLAPIENTRY
5208 save_DepthBoundsEXT(GLclampd zmin, GLclampd zmax)
5209 {
5210 GET_CURRENT_CONTEXT(ctx);
5211 Node *n;
5212 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5213 n = alloc_instruction(ctx, OPCODE_DEPTH_BOUNDS_EXT, 2);
5214 if (n) {
5215 n[1].f = (GLfloat) zmin;
5216 n[2].f = (GLfloat) zmax;
5217 }
5218 if (ctx->ExecuteFlag) {
5219 CALL_DepthBoundsEXT(ctx->Exec, (zmin, zmax));
5220 }
5221 }
5222
5223
5224
5225 static void GLAPIENTRY
5226 save_ProgramStringARB(GLenum target, GLenum format, GLsizei len,
5227 const GLvoid * string)
5228 {
5229 GET_CURRENT_CONTEXT(ctx);
5230 Node *n;
5231
5232 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5233
5234 n = alloc_instruction(ctx, OPCODE_PROGRAM_STRING_ARB, 3 + POINTER_DWORDS);
5235 if (n) {
5236 GLubyte *programCopy = malloc(len);
5237 if (!programCopy) {
5238 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glProgramStringARB");
5239 return;
5240 }
5241 memcpy(programCopy, string, len);
5242 n[1].e = target;
5243 n[2].e = format;
5244 n[3].i = len;
5245 save_pointer(&n[4], programCopy);
5246 }
5247 if (ctx->ExecuteFlag) {
5248 CALL_ProgramStringARB(ctx->Exec, (target, format, len, string));
5249 }
5250 }
5251
5252
5253 static void GLAPIENTRY
5254 save_BeginQueryARB(GLenum target, GLuint id)
5255 {
5256 GET_CURRENT_CONTEXT(ctx);
5257 Node *n;
5258 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5259 n = alloc_instruction(ctx, OPCODE_BEGIN_QUERY_ARB, 2);
5260 if (n) {
5261 n[1].e = target;
5262 n[2].ui = id;
5263 }
5264 if (ctx->ExecuteFlag) {
5265 CALL_BeginQuery(ctx->Exec, (target, id));
5266 }
5267 }
5268
5269 static void GLAPIENTRY
5270 save_EndQueryARB(GLenum target)
5271 {
5272 GET_CURRENT_CONTEXT(ctx);
5273 Node *n;
5274 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5275 n = alloc_instruction(ctx, OPCODE_END_QUERY_ARB, 1);
5276 if (n) {
5277 n[1].e = target;
5278 }
5279 if (ctx->ExecuteFlag) {
5280 CALL_EndQuery(ctx->Exec, (target));
5281 }
5282 }
5283
5284 static void GLAPIENTRY
5285 save_QueryCounter(GLuint id, GLenum target)
5286 {
5287 GET_CURRENT_CONTEXT(ctx);
5288 Node *n;
5289 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5290 n = alloc_instruction(ctx, OPCODE_QUERY_COUNTER, 2);
5291 if (n) {
5292 n[1].ui = id;
5293 n[2].e = target;
5294 }
5295 if (ctx->ExecuteFlag) {
5296 CALL_QueryCounter(ctx->Exec, (id, target));
5297 }
5298 }
5299
5300 static void GLAPIENTRY
5301 save_BeginQueryIndexed(GLenum target, GLuint index, GLuint id)
5302 {
5303 GET_CURRENT_CONTEXT(ctx);
5304 Node *n;
5305 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5306 n = alloc_instruction(ctx, OPCODE_BEGIN_QUERY_INDEXED, 3);
5307 if (n) {
5308 n[1].e = target;
5309 n[2].ui = index;
5310 n[3].ui = id;
5311 }
5312 if (ctx->ExecuteFlag) {
5313 CALL_BeginQueryIndexed(ctx->Exec, (target, index, id));
5314 }
5315 }
5316
5317 static void GLAPIENTRY
5318 save_EndQueryIndexed(GLenum target, GLuint index)
5319 {
5320 GET_CURRENT_CONTEXT(ctx);
5321 Node *n;
5322 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5323 n = alloc_instruction(ctx, OPCODE_END_QUERY_INDEXED, 2);
5324 if (n) {
5325 n[1].e = target;
5326 n[2].ui = index;
5327 }
5328 if (ctx->ExecuteFlag) {
5329 CALL_EndQueryIndexed(ctx->Exec, (target, index));
5330 }
5331 }
5332
5333
5334 static void GLAPIENTRY
5335 save_DrawBuffersARB(GLsizei count, const GLenum * buffers)
5336 {
5337 GET_CURRENT_CONTEXT(ctx);
5338 Node *n;
5339 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5340 n = alloc_instruction(ctx, OPCODE_DRAW_BUFFERS_ARB, 1 + MAX_DRAW_BUFFERS);
5341 if (n) {
5342 GLint i;
5343 n[1].i = count;
5344 if (count > MAX_DRAW_BUFFERS)
5345 count = MAX_DRAW_BUFFERS;
5346 for (i = 0; i < count; i++) {
5347 n[2 + i].e = buffers[i];
5348 }
5349 }
5350 if (ctx->ExecuteFlag) {
5351 CALL_DrawBuffers(ctx->Exec, (count, buffers));
5352 }
5353 }
5354
5355 static void GLAPIENTRY
5356 save_BindFragmentShaderATI(GLuint id)
5357 {
5358 GET_CURRENT_CONTEXT(ctx);
5359 Node *n;
5360
5361 n = alloc_instruction(ctx, OPCODE_BIND_FRAGMENT_SHADER_ATI, 1);
5362 if (n) {
5363 n[1].ui = id;
5364 }
5365 if (ctx->ExecuteFlag) {
5366 CALL_BindFragmentShaderATI(ctx->Exec, (id));
5367 }
5368 }
5369
5370 static void GLAPIENTRY
5371 save_SetFragmentShaderConstantATI(GLuint dst, const GLfloat *value)
5372 {
5373 GET_CURRENT_CONTEXT(ctx);
5374 Node *n;
5375
5376 n = alloc_instruction(ctx, OPCODE_SET_FRAGMENT_SHADER_CONSTANTS_ATI, 5);
5377 if (n) {
5378 n[1].ui = dst;
5379 n[2].f = value[0];
5380 n[3].f = value[1];
5381 n[4].f = value[2];
5382 n[5].f = value[3];
5383 }
5384 if (ctx->ExecuteFlag) {
5385 CALL_SetFragmentShaderConstantATI(ctx->Exec, (dst, value));
5386 }
5387 }
5388
5389 static void GLAPIENTRY
5390 save_Attr1fNV(GLenum attr, GLfloat x)
5391 {
5392 GET_CURRENT_CONTEXT(ctx);
5393 Node *n;
5394 SAVE_FLUSH_VERTICES(ctx);
5395 n = alloc_instruction(ctx, OPCODE_ATTR_1F_NV, 2);
5396 if (n) {
5397 n[1].e = attr;
5398 n[2].f = x;
5399 }
5400
5401 assert(attr < MAX_VERTEX_GENERIC_ATTRIBS);
5402 ctx->ListState.ActiveAttribSize[attr] = 1;
5403 ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1);
5404
5405 if (ctx->ExecuteFlag) {
5406 CALL_VertexAttrib1fNV(ctx->Exec, (attr, x));
5407 }
5408 }
5409
5410 static void GLAPIENTRY
5411 save_Attr2fNV(GLenum attr, GLfloat x, GLfloat y)
5412 {
5413 GET_CURRENT_CONTEXT(ctx);
5414 Node *n;
5415 SAVE_FLUSH_VERTICES(ctx);
5416 n = alloc_instruction(ctx, OPCODE_ATTR_2F_NV, 3);
5417 if (n) {
5418 n[1].e = attr;
5419 n[2].f = x;
5420 n[3].f = y;
5421 }
5422
5423 assert(attr < MAX_VERTEX_GENERIC_ATTRIBS);
5424 ctx->ListState.ActiveAttribSize[attr] = 2;
5425 ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, 0, 1);
5426
5427 if (ctx->ExecuteFlag) {
5428 CALL_VertexAttrib2fNV(ctx->Exec, (attr, x, y));
5429 }
5430 }
5431
5432 static void GLAPIENTRY
5433 save_Attr3fNV(GLenum attr, GLfloat x, GLfloat y, GLfloat z)
5434 {
5435 GET_CURRENT_CONTEXT(ctx);
5436 Node *n;
5437 SAVE_FLUSH_VERTICES(ctx);
5438 n = alloc_instruction(ctx, OPCODE_ATTR_3F_NV, 4);
5439 if (n) {
5440 n[1].e = attr;
5441 n[2].f = x;
5442 n[3].f = y;
5443 n[4].f = z;
5444 }
5445
5446 assert(attr < MAX_VERTEX_GENERIC_ATTRIBS);
5447 ctx->ListState.ActiveAttribSize[attr] = 3;
5448 ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, 1);
5449
5450 if (ctx->ExecuteFlag) {
5451 CALL_VertexAttrib3fNV(ctx->Exec, (attr, x, y, z));
5452 }
5453 }
5454
5455 static void GLAPIENTRY
5456 save_Attr4fNV(GLenum attr, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
5457 {
5458 GET_CURRENT_CONTEXT(ctx);
5459 Node *n;
5460 SAVE_FLUSH_VERTICES(ctx);
5461 n = alloc_instruction(ctx, OPCODE_ATTR_4F_NV, 5);
5462 if (n) {
5463 n[1].e = attr;
5464 n[2].f = x;
5465 n[3].f = y;
5466 n[4].f = z;
5467 n[5].f = w;
5468 }
5469
5470 assert(attr < MAX_VERTEX_GENERIC_ATTRIBS);
5471 ctx->ListState.ActiveAttribSize[attr] = 4;
5472 ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, w);
5473
5474 if (ctx->ExecuteFlag) {
5475 CALL_VertexAttrib4fNV(ctx->Exec, (attr, x, y, z, w));
5476 }
5477 }
5478
5479
5480 static void GLAPIENTRY
5481 save_Attr1fARB(GLenum attr, GLfloat x)
5482 {
5483 GET_CURRENT_CONTEXT(ctx);
5484 Node *n;
5485 SAVE_FLUSH_VERTICES(ctx);
5486 n = alloc_instruction(ctx, OPCODE_ATTR_1F_ARB, 2);
5487 if (n) {
5488 n[1].e = attr;
5489 n[2].f = x;
5490 }
5491
5492 assert(attr < MAX_VERTEX_GENERIC_ATTRIBS);
5493 ctx->ListState.ActiveAttribSize[attr] = 1;
5494 ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, 0, 0, 1);
5495
5496 if (ctx->ExecuteFlag) {
5497 CALL_VertexAttrib1fARB(ctx->Exec, (attr, x));
5498 }
5499 }
5500
5501 static void GLAPIENTRY
5502 save_Attr2fARB(GLenum attr, GLfloat x, GLfloat y)
5503 {
5504 GET_CURRENT_CONTEXT(ctx);
5505 Node *n;
5506 SAVE_FLUSH_VERTICES(ctx);
5507 n = alloc_instruction(ctx, OPCODE_ATTR_2F_ARB, 3);
5508 if (n) {
5509 n[1].e = attr;
5510 n[2].f = x;
5511 n[3].f = y;
5512 }
5513
5514 assert(attr < MAX_VERTEX_GENERIC_ATTRIBS);
5515 ctx->ListState.ActiveAttribSize[attr] = 2;
5516 ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, 0, 1);
5517
5518 if (ctx->ExecuteFlag) {
5519 CALL_VertexAttrib2fARB(ctx->Exec, (attr, x, y));
5520 }
5521 }
5522
5523 static void GLAPIENTRY
5524 save_Attr3fARB(GLenum attr, GLfloat x, GLfloat y, GLfloat z)
5525 {
5526 GET_CURRENT_CONTEXT(ctx);
5527 Node *n;
5528 SAVE_FLUSH_VERTICES(ctx);
5529 n = alloc_instruction(ctx, OPCODE_ATTR_3F_ARB, 4);
5530 if (n) {
5531 n[1].e = attr;
5532 n[2].f = x;
5533 n[3].f = y;
5534 n[4].f = z;
5535 }
5536
5537 assert(attr < MAX_VERTEX_GENERIC_ATTRIBS);
5538 ctx->ListState.ActiveAttribSize[attr] = 3;
5539 ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, 1);
5540
5541 if (ctx->ExecuteFlag) {
5542 CALL_VertexAttrib3fARB(ctx->Exec, (attr, x, y, z));
5543 }
5544 }
5545
5546 static void GLAPIENTRY
5547 save_Attr4fARB(GLenum attr, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
5548 {
5549 GET_CURRENT_CONTEXT(ctx);
5550 Node *n;
5551 SAVE_FLUSH_VERTICES(ctx);
5552 n = alloc_instruction(ctx, OPCODE_ATTR_4F_ARB, 5);
5553 if (n) {
5554 n[1].e = attr;
5555 n[2].f = x;
5556 n[3].f = y;
5557 n[4].f = z;
5558 n[5].f = w;
5559 }
5560
5561 assert(attr < MAX_VERTEX_GENERIC_ATTRIBS);
5562 ctx->ListState.ActiveAttribSize[attr] = 4;
5563 ASSIGN_4V(ctx->ListState.CurrentAttrib[attr], x, y, z, w);
5564
5565 if (ctx->ExecuteFlag) {
5566 CALL_VertexAttrib4fARB(ctx->Exec, (attr, x, y, z, w));
5567 }
5568 }
5569
5570
5571 static void GLAPIENTRY
5572 save_EvalCoord1f(GLfloat x)
5573 {
5574 GET_CURRENT_CONTEXT(ctx);
5575 Node *n;
5576 SAVE_FLUSH_VERTICES(ctx);
5577 n = alloc_instruction(ctx, OPCODE_EVAL_C1, 1);
5578 if (n) {
5579 n[1].f = x;
5580 }
5581 if (ctx->ExecuteFlag) {
5582 CALL_EvalCoord1f(ctx->Exec, (x));
5583 }
5584 }
5585
5586 static void GLAPIENTRY
5587 save_EvalCoord1fv(const GLfloat * v)
5588 {
5589 save_EvalCoord1f(v[0]);
5590 }
5591
5592 static void GLAPIENTRY
5593 save_EvalCoord2f(GLfloat x, GLfloat y)
5594 {
5595 GET_CURRENT_CONTEXT(ctx);
5596 Node *n;
5597 SAVE_FLUSH_VERTICES(ctx);
5598 n = alloc_instruction(ctx, OPCODE_EVAL_C2, 2);
5599 if (n) {
5600 n[1].f = x;
5601 n[2].f = y;
5602 }
5603 if (ctx->ExecuteFlag) {
5604 CALL_EvalCoord2f(ctx->Exec, (x, y));
5605 }
5606 }
5607
5608 static void GLAPIENTRY
5609 save_EvalCoord2fv(const GLfloat * v)
5610 {
5611 save_EvalCoord2f(v[0], v[1]);
5612 }
5613
5614
5615 static void GLAPIENTRY
5616 save_EvalPoint1(GLint x)
5617 {
5618 GET_CURRENT_CONTEXT(ctx);
5619 Node *n;
5620 SAVE_FLUSH_VERTICES(ctx);
5621 n = alloc_instruction(ctx, OPCODE_EVAL_P1, 1);
5622 if (n) {
5623 n[1].i = x;
5624 }
5625 if (ctx->ExecuteFlag) {
5626 CALL_EvalPoint1(ctx->Exec, (x));
5627 }
5628 }
5629
5630 static void GLAPIENTRY
5631 save_EvalPoint2(GLint x, GLint y)
5632 {
5633 GET_CURRENT_CONTEXT(ctx);
5634 Node *n;
5635 SAVE_FLUSH_VERTICES(ctx);
5636 n = alloc_instruction(ctx, OPCODE_EVAL_P2, 2);
5637 if (n) {
5638 n[1].i = x;
5639 n[2].i = y;
5640 }
5641 if (ctx->ExecuteFlag) {
5642 CALL_EvalPoint2(ctx->Exec, (x, y));
5643 }
5644 }
5645
5646 static void GLAPIENTRY
5647 save_Indexf(GLfloat x)
5648 {
5649 save_Attr1fNV(VERT_ATTRIB_COLOR_INDEX, x);
5650 }
5651
5652 static void GLAPIENTRY
5653 save_Indexfv(const GLfloat * v)
5654 {
5655 save_Attr1fNV(VERT_ATTRIB_COLOR_INDEX, v[0]);
5656 }
5657
5658 static void GLAPIENTRY
5659 save_EdgeFlag(GLboolean x)
5660 {
5661 save_Attr1fNV(VERT_ATTRIB_EDGEFLAG, x ? 1.0f : 0.0f);
5662 }
5663
5664
5665 /**
5666 * Compare 'count' elements of vectors 'a' and 'b'.
5667 * \return GL_TRUE if equal, GL_FALSE if different.
5668 */
5669 static inline GLboolean
5670 compare_vec(const GLfloat *a, const GLfloat *b, GLuint count)
5671 {
5672 return memcmp( a, b, count * sizeof(GLfloat) ) == 0;
5673 }
5674
5675
5676 /**
5677 * This glMaterial function is used for glMaterial calls that are outside
5678 * a glBegin/End pair. For glMaterial inside glBegin/End, see the VBO code.
5679 */
5680 static void GLAPIENTRY
5681 save_Materialfv(GLenum face, GLenum pname, const GLfloat * param)
5682 {
5683 GET_CURRENT_CONTEXT(ctx);
5684 Node *n;
5685 int args, i;
5686 GLuint bitmask;
5687
5688 switch (face) {
5689 case GL_BACK:
5690 case GL_FRONT:
5691 case GL_FRONT_AND_BACK:
5692 break;
5693 default:
5694 _mesa_compile_error(ctx, GL_INVALID_ENUM, "glMaterial(face)");
5695 return;
5696 }
5697
5698 switch (pname) {
5699 case GL_EMISSION:
5700 case GL_AMBIENT:
5701 case GL_DIFFUSE:
5702 case GL_SPECULAR:
5703 case GL_AMBIENT_AND_DIFFUSE:
5704 args = 4;
5705 break;
5706 case GL_SHININESS:
5707 args = 1;
5708 break;
5709 case GL_COLOR_INDEXES:
5710 args = 3;
5711 break;
5712 default:
5713 _mesa_compile_error(ctx, GL_INVALID_ENUM, "glMaterial(pname)");
5714 return;
5715 }
5716
5717 if (ctx->ExecuteFlag) {
5718 CALL_Materialfv(ctx->Exec, (face, pname, param));
5719 }
5720
5721 bitmask = _mesa_material_bitmask(ctx, face, pname, ~0, NULL);
5722
5723 /* Try to eliminate redundant statechanges. Because it is legal to
5724 * call glMaterial even inside begin/end calls, don't need to worry
5725 * about ctx->Driver.CurrentSavePrimitive here.
5726 */
5727 for (i = 0; i < MAT_ATTRIB_MAX; i++) {
5728 if (bitmask & (1 << i)) {
5729 if (ctx->ListState.ActiveMaterialSize[i] == args &&
5730 compare_vec(ctx->ListState.CurrentMaterial[i], param, args)) {
5731 /* no change in material value */
5732 bitmask &= ~(1 << i);
5733 }
5734 else {
5735 ctx->ListState.ActiveMaterialSize[i] = args;
5736 COPY_SZ_4V(ctx->ListState.CurrentMaterial[i], args, param);
5737 }
5738 }
5739 }
5740
5741 /* If this call has no effect, return early */
5742 if (bitmask == 0)
5743 return;
5744
5745 SAVE_FLUSH_VERTICES(ctx);
5746
5747 n = alloc_instruction(ctx, OPCODE_MATERIAL, 6);
5748 if (n) {
5749 n[1].e = face;
5750 n[2].e = pname;
5751 for (i = 0; i < args; i++)
5752 n[3 + i].f = param[i];
5753 }
5754 }
5755
5756 static void GLAPIENTRY
5757 save_Begin(GLenum mode)
5758 {
5759 GET_CURRENT_CONTEXT(ctx);
5760
5761 if (!_mesa_is_valid_prim_mode(ctx, mode)) {
5762 /* compile this error into the display list */
5763 _mesa_compile_error(ctx, GL_INVALID_ENUM, "glBegin(mode)");
5764 }
5765 else if (_mesa_inside_dlist_begin_end(ctx)) {
5766 /* compile this error into the display list */
5767 _mesa_compile_error(ctx, GL_INVALID_OPERATION, "recursive glBegin");
5768 }
5769 else {
5770 ctx->Driver.CurrentSavePrimitive = mode;
5771
5772 vbo_save_NotifyBegin(ctx, mode);
5773 }
5774 }
5775
5776 static void GLAPIENTRY
5777 save_End(void)
5778 {
5779 GET_CURRENT_CONTEXT(ctx);
5780 SAVE_FLUSH_VERTICES(ctx);
5781 (void) alloc_instruction(ctx, OPCODE_END, 0);
5782 ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;
5783 if (ctx->ExecuteFlag) {
5784 CALL_End(ctx->Exec, ());
5785 }
5786 }
5787
5788 static void GLAPIENTRY
5789 save_Rectf(GLfloat a, GLfloat b, GLfloat c, GLfloat d)
5790 {
5791 GET_CURRENT_CONTEXT(ctx);
5792 Node *n;
5793 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
5794 n = alloc_instruction(ctx, OPCODE_RECTF, 4);
5795 if (n) {
5796 n[1].f = a;
5797 n[2].f = b;
5798 n[3].f = c;
5799 n[4].f = d;
5800 }
5801 if (ctx->ExecuteFlag) {
5802 CALL_Rectf(ctx->Exec, (a, b, c, d));
5803 }
5804 }
5805
5806
5807 static void GLAPIENTRY
5808 save_Vertex2f(GLfloat x, GLfloat y)
5809 {
5810 save_Attr2fNV(VERT_ATTRIB_POS, x, y);
5811 }
5812
5813 static void GLAPIENTRY
5814 save_Vertex2fv(const GLfloat * v)
5815 {
5816 save_Attr2fNV(VERT_ATTRIB_POS, v[0], v[1]);
5817 }
5818
5819 static void GLAPIENTRY
5820 save_Vertex3f(GLfloat x, GLfloat y, GLfloat z)
5821 {
5822 save_Attr3fNV(VERT_ATTRIB_POS, x, y, z);
5823 }
5824
5825 static void GLAPIENTRY
5826 save_Vertex3fv(const GLfloat * v)
5827 {
5828 save_Attr3fNV(VERT_ATTRIB_POS, v[0], v[1], v[2]);
5829 }
5830
5831 static void GLAPIENTRY
5832 save_Vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
5833 {
5834 save_Attr4fNV(VERT_ATTRIB_POS, x, y, z, w);
5835 }
5836
5837 static void GLAPIENTRY
5838 save_Vertex4fv(const GLfloat * v)
5839 {
5840 save_Attr4fNV(VERT_ATTRIB_POS, v[0], v[1], v[2], v[3]);
5841 }
5842
5843 static void GLAPIENTRY
5844 save_TexCoord1f(GLfloat x)
5845 {
5846 save_Attr1fNV(VERT_ATTRIB_TEX0, x);
5847 }
5848
5849 static void GLAPIENTRY
5850 save_TexCoord1fv(const GLfloat * v)
5851 {
5852 save_Attr1fNV(VERT_ATTRIB_TEX0, v[0]);
5853 }
5854
5855 static void GLAPIENTRY
5856 save_TexCoord2f(GLfloat x, GLfloat y)
5857 {
5858 save_Attr2fNV(VERT_ATTRIB_TEX0, x, y);
5859 }
5860
5861 static void GLAPIENTRY
5862 save_TexCoord2fv(const GLfloat * v)
5863 {
5864 save_Attr2fNV(VERT_ATTRIB_TEX0, v[0], v[1]);
5865 }
5866
5867 static void GLAPIENTRY
5868 save_TexCoord3f(GLfloat x, GLfloat y, GLfloat z)
5869 {
5870 save_Attr3fNV(VERT_ATTRIB_TEX0, x, y, z);
5871 }
5872
5873 static void GLAPIENTRY
5874 save_TexCoord3fv(const GLfloat * v)
5875 {
5876 save_Attr3fNV(VERT_ATTRIB_TEX0, v[0], v[1], v[2]);
5877 }
5878
5879 static void GLAPIENTRY
5880 save_TexCoord4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
5881 {
5882 save_Attr4fNV(VERT_ATTRIB_TEX0, x, y, z, w);
5883 }
5884
5885 static void GLAPIENTRY
5886 save_TexCoord4fv(const GLfloat * v)
5887 {
5888 save_Attr4fNV(VERT_ATTRIB_TEX0, v[0], v[1], v[2], v[3]);
5889 }
5890
5891 static void GLAPIENTRY
5892 save_Normal3f(GLfloat x, GLfloat y, GLfloat z)
5893 {
5894 save_Attr3fNV(VERT_ATTRIB_NORMAL, x, y, z);
5895 }
5896
5897 static void GLAPIENTRY
5898 save_Normal3fv(const GLfloat * v)
5899 {
5900 save_Attr3fNV(VERT_ATTRIB_NORMAL, v[0], v[1], v[2]);
5901 }
5902
5903 static void GLAPIENTRY
5904 save_FogCoordfEXT(GLfloat x)
5905 {
5906 save_Attr1fNV(VERT_ATTRIB_FOG, x);
5907 }
5908
5909 static void GLAPIENTRY
5910 save_FogCoordfvEXT(const GLfloat * v)
5911 {
5912 save_Attr1fNV(VERT_ATTRIB_FOG, v[0]);
5913 }
5914
5915 static void GLAPIENTRY
5916 save_Color3f(GLfloat x, GLfloat y, GLfloat z)
5917 {
5918 save_Attr3fNV(VERT_ATTRIB_COLOR0, x, y, z);
5919 }
5920
5921 static void GLAPIENTRY
5922 save_Color3fv(const GLfloat * v)
5923 {
5924 save_Attr3fNV(VERT_ATTRIB_COLOR0, v[0], v[1], v[2]);
5925 }
5926
5927 static void GLAPIENTRY
5928 save_Color4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
5929 {
5930 save_Attr4fNV(VERT_ATTRIB_COLOR0, x, y, z, w);
5931 }
5932
5933 static void GLAPIENTRY
5934 save_Color4fv(const GLfloat * v)
5935 {
5936 save_Attr4fNV(VERT_ATTRIB_COLOR0, v[0], v[1], v[2], v[3]);
5937 }
5938
5939 static void GLAPIENTRY
5940 save_SecondaryColor3fEXT(GLfloat x, GLfloat y, GLfloat z)
5941 {
5942 save_Attr3fNV(VERT_ATTRIB_COLOR1, x, y, z);
5943 }
5944
5945 static void GLAPIENTRY
5946 save_SecondaryColor3fvEXT(const GLfloat * v)
5947 {
5948 save_Attr3fNV(VERT_ATTRIB_COLOR1, v[0], v[1], v[2]);
5949 }
5950
5951
5952 /* Just call the respective ATTR for texcoord
5953 */
5954 static void GLAPIENTRY
5955 save_MultiTexCoord1f(GLenum target, GLfloat x)
5956 {
5957 GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
5958 save_Attr1fNV(attr, x);
5959 }
5960
5961 static void GLAPIENTRY
5962 save_MultiTexCoord1fv(GLenum target, const GLfloat * v)
5963 {
5964 GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
5965 save_Attr1fNV(attr, v[0]);
5966 }
5967
5968 static void GLAPIENTRY
5969 save_MultiTexCoord2f(GLenum target, GLfloat x, GLfloat y)
5970 {
5971 GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
5972 save_Attr2fNV(attr, x, y);
5973 }
5974
5975 static void GLAPIENTRY
5976 save_MultiTexCoord2fv(GLenum target, const GLfloat * v)
5977 {
5978 GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
5979 save_Attr2fNV(attr, v[0], v[1]);
5980 }
5981
5982 static void GLAPIENTRY
5983 save_MultiTexCoord3f(GLenum target, GLfloat x, GLfloat y, GLfloat z)
5984 {
5985 GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
5986 save_Attr3fNV(attr, x, y, z);
5987 }
5988
5989 static void GLAPIENTRY
5990 save_MultiTexCoord3fv(GLenum target, const GLfloat * v)
5991 {
5992 GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
5993 save_Attr3fNV(attr, v[0], v[1], v[2]);
5994 }
5995
5996 static void GLAPIENTRY
5997 save_MultiTexCoord4f(GLenum target, GLfloat x, GLfloat y,
5998 GLfloat z, GLfloat w)
5999 {
6000 GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
6001 save_Attr4fNV(attr, x, y, z, w);
6002 }
6003
6004 static void GLAPIENTRY
6005 save_MultiTexCoord4fv(GLenum target, const GLfloat * v)
6006 {
6007 GLuint attr = (target & 0x7) + VERT_ATTRIB_TEX0;
6008 save_Attr4fNV(attr, v[0], v[1], v[2], v[3]);
6009 }
6010
6011
6012 /**
6013 * Record a GL_INVALID_VALUE error when an invalid vertex attribute
6014 * index is found.
6015 */
6016 static void
6017 index_error(void)
6018 {
6019 GET_CURRENT_CONTEXT(ctx);
6020 _mesa_error(ctx, GL_INVALID_VALUE, "VertexAttribf(index)");
6021 }
6022
6023
6024
6025 static void GLAPIENTRY
6026 save_VertexAttrib1fARB(GLuint index, GLfloat x)
6027 {
6028 if (index < MAX_VERTEX_GENERIC_ATTRIBS)
6029 save_Attr1fARB(index, x);
6030 else
6031 index_error();
6032 }
6033
6034 static void GLAPIENTRY
6035 save_VertexAttrib1fvARB(GLuint index, const GLfloat * v)
6036 {
6037 if (index < MAX_VERTEX_GENERIC_ATTRIBS)
6038 save_Attr1fARB(index, v[0]);
6039 else
6040 index_error();
6041 }
6042
6043 static void GLAPIENTRY
6044 save_VertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
6045 {
6046 if (index < MAX_VERTEX_GENERIC_ATTRIBS)
6047 save_Attr2fARB(index, x, y);
6048 else
6049 index_error();
6050 }
6051
6052 static void GLAPIENTRY
6053 save_VertexAttrib2fvARB(GLuint index, const GLfloat * v)
6054 {
6055 if (index < MAX_VERTEX_GENERIC_ATTRIBS)
6056 save_Attr2fARB(index, v[0], v[1]);
6057 else
6058 index_error();
6059 }
6060
6061 static void GLAPIENTRY
6062 save_VertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
6063 {
6064 if (index < MAX_VERTEX_GENERIC_ATTRIBS)
6065 save_Attr3fARB(index, x, y, z);
6066 else
6067 index_error();
6068 }
6069
6070 static void GLAPIENTRY
6071 save_VertexAttrib3fvARB(GLuint index, const GLfloat * v)
6072 {
6073 if (index < MAX_VERTEX_GENERIC_ATTRIBS)
6074 save_Attr3fARB(index, v[0], v[1], v[2]);
6075 else
6076 index_error();
6077 }
6078
6079 static void GLAPIENTRY
6080 save_VertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z,
6081 GLfloat w)
6082 {
6083 if (index < MAX_VERTEX_GENERIC_ATTRIBS)
6084 save_Attr4fARB(index, x, y, z, w);
6085 else
6086 index_error();
6087 }
6088
6089 static void GLAPIENTRY
6090 save_VertexAttrib4fvARB(GLuint index, const GLfloat * v)
6091 {
6092 if (index < MAX_VERTEX_GENERIC_ATTRIBS)
6093 save_Attr4fARB(index, v[0], v[1], v[2], v[3]);
6094 else
6095 index_error();
6096 }
6097
6098 static void GLAPIENTRY
6099 save_PrimitiveRestartNV(void)
6100 {
6101 /* Note: this is used when outside a glBegin/End pair in a display list */
6102 GET_CURRENT_CONTEXT(ctx);
6103 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6104 (void) alloc_instruction(ctx, OPCODE_PRIMITIVE_RESTART_NV, 0);
6105 if (ctx->ExecuteFlag) {
6106 CALL_PrimitiveRestartNV(ctx->Exec, ());
6107 }
6108 }
6109
6110
6111 static void GLAPIENTRY
6112 save_BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
6113 GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
6114 GLbitfield mask, GLenum filter)
6115 {
6116 GET_CURRENT_CONTEXT(ctx);
6117 Node *n;
6118 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6119 n = alloc_instruction(ctx, OPCODE_BLIT_FRAMEBUFFER, 10);
6120 if (n) {
6121 n[1].i = srcX0;
6122 n[2].i = srcY0;
6123 n[3].i = srcX1;
6124 n[4].i = srcY1;
6125 n[5].i = dstX0;
6126 n[6].i = dstY0;
6127 n[7].i = dstX1;
6128 n[8].i = dstY1;
6129 n[9].i = mask;
6130 n[10].e = filter;
6131 }
6132 if (ctx->ExecuteFlag) {
6133 CALL_BlitFramebuffer(ctx->Exec, (srcX0, srcY0, srcX1, srcY1,
6134 dstX0, dstY0, dstX1, dstY1,
6135 mask, filter));
6136 }
6137 }
6138
6139
6140 /** GL_EXT_provoking_vertex */
6141 static void GLAPIENTRY
6142 save_ProvokingVertexEXT(GLenum mode)
6143 {
6144 GET_CURRENT_CONTEXT(ctx);
6145 Node *n;
6146 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6147 n = alloc_instruction(ctx, OPCODE_PROVOKING_VERTEX, 1);
6148 if (n) {
6149 n[1].e = mode;
6150 }
6151 if (ctx->ExecuteFlag) {
6152 /*CALL_ProvokingVertex(ctx->Exec, (mode));*/
6153 _mesa_ProvokingVertex(mode);
6154 }
6155 }
6156
6157
6158 /** GL_EXT_transform_feedback */
6159 static void GLAPIENTRY
6160 save_BeginTransformFeedback(GLenum mode)
6161 {
6162 GET_CURRENT_CONTEXT(ctx);
6163 Node *n;
6164 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6165 n = alloc_instruction(ctx, OPCODE_BEGIN_TRANSFORM_FEEDBACK, 1);
6166 if (n) {
6167 n[1].e = mode;
6168 }
6169 if (ctx->ExecuteFlag) {
6170 CALL_BeginTransformFeedback(ctx->Exec, (mode));
6171 }
6172 }
6173
6174
6175 /** GL_EXT_transform_feedback */
6176 static void GLAPIENTRY
6177 save_EndTransformFeedback(void)
6178 {
6179 GET_CURRENT_CONTEXT(ctx);
6180 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6181 (void) alloc_instruction(ctx, OPCODE_END_TRANSFORM_FEEDBACK, 0);
6182 if (ctx->ExecuteFlag) {
6183 CALL_EndTransformFeedback(ctx->Exec, ());
6184 }
6185 }
6186
6187 static void GLAPIENTRY
6188 save_BindTransformFeedback(GLenum target, GLuint name)
6189 {
6190 GET_CURRENT_CONTEXT(ctx);
6191 Node *n;
6192 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6193 n = alloc_instruction(ctx, OPCODE_BIND_TRANSFORM_FEEDBACK, 2);
6194 if (n) {
6195 n[1].e = target;
6196 n[2].ui = name;
6197 }
6198 if (ctx->ExecuteFlag) {
6199 CALL_BindTransformFeedback(ctx->Exec, (target, name));
6200 }
6201 }
6202
6203 static void GLAPIENTRY
6204 save_PauseTransformFeedback(void)
6205 {
6206 GET_CURRENT_CONTEXT(ctx);
6207 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6208 (void) alloc_instruction(ctx, OPCODE_PAUSE_TRANSFORM_FEEDBACK, 0);
6209 if (ctx->ExecuteFlag) {
6210 CALL_PauseTransformFeedback(ctx->Exec, ());
6211 }
6212 }
6213
6214 static void GLAPIENTRY
6215 save_ResumeTransformFeedback(void)
6216 {
6217 GET_CURRENT_CONTEXT(ctx);
6218 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6219 (void) alloc_instruction(ctx, OPCODE_RESUME_TRANSFORM_FEEDBACK, 0);
6220 if (ctx->ExecuteFlag) {
6221 CALL_ResumeTransformFeedback(ctx->Exec, ());
6222 }
6223 }
6224
6225 static void GLAPIENTRY
6226 save_DrawTransformFeedback(GLenum mode, GLuint name)
6227 {
6228 GET_CURRENT_CONTEXT(ctx);
6229 Node *n;
6230 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6231 n = alloc_instruction(ctx, OPCODE_DRAW_TRANSFORM_FEEDBACK, 2);
6232 if (n) {
6233 n[1].e = mode;
6234 n[2].ui = name;
6235 }
6236 if (ctx->ExecuteFlag) {
6237 CALL_DrawTransformFeedback(ctx->Exec, (mode, name));
6238 }
6239 }
6240
6241 static void GLAPIENTRY
6242 save_DrawTransformFeedbackStream(GLenum mode, GLuint name, GLuint stream)
6243 {
6244 GET_CURRENT_CONTEXT(ctx);
6245 Node *n;
6246 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6247 n = alloc_instruction(ctx, OPCODE_DRAW_TRANSFORM_FEEDBACK_STREAM, 3);
6248 if (n) {
6249 n[1].e = mode;
6250 n[2].ui = name;
6251 n[3].ui = stream;
6252 }
6253 if (ctx->ExecuteFlag) {
6254 CALL_DrawTransformFeedbackStream(ctx->Exec, (mode, name, stream));
6255 }
6256 }
6257
6258 static void GLAPIENTRY
6259 save_DrawTransformFeedbackInstanced(GLenum mode, GLuint name,
6260 GLsizei primcount)
6261 {
6262 GET_CURRENT_CONTEXT(ctx);
6263 Node *n;
6264 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6265 n = alloc_instruction(ctx, OPCODE_DRAW_TRANSFORM_FEEDBACK_INSTANCED, 3);
6266 if (n) {
6267 n[1].e = mode;
6268 n[2].ui = name;
6269 n[3].si = primcount;
6270 }
6271 if (ctx->ExecuteFlag) {
6272 CALL_DrawTransformFeedbackInstanced(ctx->Exec, (mode, name, primcount));
6273 }
6274 }
6275
6276 static void GLAPIENTRY
6277 save_DrawTransformFeedbackStreamInstanced(GLenum mode, GLuint name,
6278 GLuint stream, GLsizei primcount)
6279 {
6280 GET_CURRENT_CONTEXT(ctx);
6281 Node *n;
6282 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6283 n = alloc_instruction(ctx, OPCODE_DRAW_TRANSFORM_FEEDBACK_STREAM_INSTANCED, 4);
6284 if (n) {
6285 n[1].e = mode;
6286 n[2].ui = name;
6287 n[3].ui = stream;
6288 n[4].si = primcount;
6289 }
6290 if (ctx->ExecuteFlag) {
6291 CALL_DrawTransformFeedbackStreamInstanced(ctx->Exec, (mode, name, stream,
6292 primcount));
6293 }
6294 }
6295
6296 static void GLAPIENTRY
6297 save_UseProgram(GLuint program)
6298 {
6299 GET_CURRENT_CONTEXT(ctx);
6300 Node *n;
6301 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6302 n = alloc_instruction(ctx, OPCODE_USE_PROGRAM, 1);
6303 if (n) {
6304 n[1].ui = program;
6305 }
6306 if (ctx->ExecuteFlag) {
6307 CALL_UseProgram(ctx->Exec, (program));
6308 }
6309 }
6310
6311
6312 static void GLAPIENTRY
6313 save_Uniform1fARB(GLint location, GLfloat x)
6314 {
6315 GET_CURRENT_CONTEXT(ctx);
6316 Node *n;
6317 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6318 n = alloc_instruction(ctx, OPCODE_UNIFORM_1F, 2);
6319 if (n) {
6320 n[1].i = location;
6321 n[2].f = x;
6322 }
6323 if (ctx->ExecuteFlag) {
6324 CALL_Uniform1f(ctx->Exec, (location, x));
6325 }
6326 }
6327
6328
6329 static void GLAPIENTRY
6330 save_Uniform2fARB(GLint location, GLfloat x, GLfloat y)
6331 {
6332 GET_CURRENT_CONTEXT(ctx);
6333 Node *n;
6334 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6335 n = alloc_instruction(ctx, OPCODE_UNIFORM_2F, 3);
6336 if (n) {
6337 n[1].i = location;
6338 n[2].f = x;
6339 n[3].f = y;
6340 }
6341 if (ctx->ExecuteFlag) {
6342 CALL_Uniform2f(ctx->Exec, (location, x, y));
6343 }
6344 }
6345
6346
6347 static void GLAPIENTRY
6348 save_Uniform3fARB(GLint location, GLfloat x, GLfloat y, GLfloat z)
6349 {
6350 GET_CURRENT_CONTEXT(ctx);
6351 Node *n;
6352 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6353 n = alloc_instruction(ctx, OPCODE_UNIFORM_3F, 4);
6354 if (n) {
6355 n[1].i = location;
6356 n[2].f = x;
6357 n[3].f = y;
6358 n[4].f = z;
6359 }
6360 if (ctx->ExecuteFlag) {
6361 CALL_Uniform3f(ctx->Exec, (location, x, y, z));
6362 }
6363 }
6364
6365
6366 static void GLAPIENTRY
6367 save_Uniform4fARB(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
6368 {
6369 GET_CURRENT_CONTEXT(ctx);
6370 Node *n;
6371 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6372 n = alloc_instruction(ctx, OPCODE_UNIFORM_4F, 5);
6373 if (n) {
6374 n[1].i = location;
6375 n[2].f = x;
6376 n[3].f = y;
6377 n[4].f = z;
6378 n[5].f = w;
6379 }
6380 if (ctx->ExecuteFlag) {
6381 CALL_Uniform4f(ctx->Exec, (location, x, y, z, w));
6382 }
6383 }
6384
6385
6386 static void GLAPIENTRY
6387 save_Uniform1fvARB(GLint location, GLsizei count, const GLfloat *v)
6388 {
6389 GET_CURRENT_CONTEXT(ctx);
6390 Node *n;
6391 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6392 n = alloc_instruction(ctx, OPCODE_UNIFORM_1FV, 2 + POINTER_DWORDS);
6393 if (n) {
6394 n[1].i = location;
6395 n[2].i = count;
6396 save_pointer(&n[3], memdup(v, count * 1 * sizeof(GLfloat)));
6397 }
6398 if (ctx->ExecuteFlag) {
6399 CALL_Uniform1fv(ctx->Exec, (location, count, v));
6400 }
6401 }
6402
6403 static void GLAPIENTRY
6404 save_Uniform2fvARB(GLint location, GLsizei count, const GLfloat *v)
6405 {
6406 GET_CURRENT_CONTEXT(ctx);
6407 Node *n;
6408 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6409 n = alloc_instruction(ctx, OPCODE_UNIFORM_2FV, 2 + POINTER_DWORDS);
6410 if (n) {
6411 n[1].i = location;
6412 n[2].i = count;
6413 save_pointer(&n[3], memdup(v, count * 2 * sizeof(GLfloat)));
6414 }
6415 if (ctx->ExecuteFlag) {
6416 CALL_Uniform2fv(ctx->Exec, (location, count, v));
6417 }
6418 }
6419
6420 static void GLAPIENTRY
6421 save_Uniform3fvARB(GLint location, GLsizei count, const GLfloat *v)
6422 {
6423 GET_CURRENT_CONTEXT(ctx);
6424 Node *n;
6425 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6426 n = alloc_instruction(ctx, OPCODE_UNIFORM_3FV, 2 + POINTER_DWORDS);
6427 if (n) {
6428 n[1].i = location;
6429 n[2].i = count;
6430 save_pointer(&n[3], memdup(v, count * 3 * sizeof(GLfloat)));
6431 }
6432 if (ctx->ExecuteFlag) {
6433 CALL_Uniform3fv(ctx->Exec, (location, count, v));
6434 }
6435 }
6436
6437 static void GLAPIENTRY
6438 save_Uniform4fvARB(GLint location, GLsizei count, const GLfloat *v)
6439 {
6440 GET_CURRENT_CONTEXT(ctx);
6441 Node *n;
6442 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6443 n = alloc_instruction(ctx, OPCODE_UNIFORM_4FV, 2 + POINTER_DWORDS);
6444 if (n) {
6445 n[1].i = location;
6446 n[2].i = count;
6447 save_pointer(&n[3], memdup(v, count * 4 * sizeof(GLfloat)));
6448 }
6449 if (ctx->ExecuteFlag) {
6450 CALL_Uniform4fv(ctx->Exec, (location, count, v));
6451 }
6452 }
6453
6454
6455 static void GLAPIENTRY
6456 save_Uniform1iARB(GLint location, GLint x)
6457 {
6458 GET_CURRENT_CONTEXT(ctx);
6459 Node *n;
6460 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6461 n = alloc_instruction(ctx, OPCODE_UNIFORM_1I, 2);
6462 if (n) {
6463 n[1].i = location;
6464 n[2].i = x;
6465 }
6466 if (ctx->ExecuteFlag) {
6467 CALL_Uniform1i(ctx->Exec, (location, x));
6468 }
6469 }
6470
6471 static void GLAPIENTRY
6472 save_Uniform2iARB(GLint location, GLint x, GLint y)
6473 {
6474 GET_CURRENT_CONTEXT(ctx);
6475 Node *n;
6476 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6477 n = alloc_instruction(ctx, OPCODE_UNIFORM_2I, 3);
6478 if (n) {
6479 n[1].i = location;
6480 n[2].i = x;
6481 n[3].i = y;
6482 }
6483 if (ctx->ExecuteFlag) {
6484 CALL_Uniform2i(ctx->Exec, (location, x, y));
6485 }
6486 }
6487
6488 static void GLAPIENTRY
6489 save_Uniform3iARB(GLint location, GLint x, GLint y, GLint z)
6490 {
6491 GET_CURRENT_CONTEXT(ctx);
6492 Node *n;
6493 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6494 n = alloc_instruction(ctx, OPCODE_UNIFORM_3I, 4);
6495 if (n) {
6496 n[1].i = location;
6497 n[2].i = x;
6498 n[3].i = y;
6499 n[4].i = z;
6500 }
6501 if (ctx->ExecuteFlag) {
6502 CALL_Uniform3i(ctx->Exec, (location, x, y, z));
6503 }
6504 }
6505
6506 static void GLAPIENTRY
6507 save_Uniform4iARB(GLint location, GLint x, GLint y, GLint z, GLint w)
6508 {
6509 GET_CURRENT_CONTEXT(ctx);
6510 Node *n;
6511 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6512 n = alloc_instruction(ctx, OPCODE_UNIFORM_4I, 5);
6513 if (n) {
6514 n[1].i = location;
6515 n[2].i = x;
6516 n[3].i = y;
6517 n[4].i = z;
6518 n[5].i = w;
6519 }
6520 if (ctx->ExecuteFlag) {
6521 CALL_Uniform4i(ctx->Exec, (location, x, y, z, w));
6522 }
6523 }
6524
6525
6526
6527 static void GLAPIENTRY
6528 save_Uniform1ivARB(GLint location, GLsizei count, const GLint *v)
6529 {
6530 GET_CURRENT_CONTEXT(ctx);
6531 Node *n;
6532 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6533 n = alloc_instruction(ctx, OPCODE_UNIFORM_1IV, 2 + POINTER_DWORDS);
6534 if (n) {
6535 n[1].i = location;
6536 n[2].i = count;
6537 save_pointer(&n[3], memdup(v, count * 1 * sizeof(GLint)));
6538 }
6539 if (ctx->ExecuteFlag) {
6540 CALL_Uniform1iv(ctx->Exec, (location, count, v));
6541 }
6542 }
6543
6544 static void GLAPIENTRY
6545 save_Uniform2ivARB(GLint location, GLsizei count, const GLint *v)
6546 {
6547 GET_CURRENT_CONTEXT(ctx);
6548 Node *n;
6549 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6550 n = alloc_instruction(ctx, OPCODE_UNIFORM_2IV, 2 + POINTER_DWORDS);
6551 if (n) {
6552 n[1].i = location;
6553 n[2].i = count;
6554 save_pointer(&n[3], memdup(v, count * 2 * sizeof(GLint)));
6555 }
6556 if (ctx->ExecuteFlag) {
6557 CALL_Uniform2iv(ctx->Exec, (location, count, v));
6558 }
6559 }
6560
6561 static void GLAPIENTRY
6562 save_Uniform3ivARB(GLint location, GLsizei count, const GLint *v)
6563 {
6564 GET_CURRENT_CONTEXT(ctx);
6565 Node *n;
6566 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6567 n = alloc_instruction(ctx, OPCODE_UNIFORM_3IV, 2 + POINTER_DWORDS);
6568 if (n) {
6569 n[1].i = location;
6570 n[2].i = count;
6571 save_pointer(&n[3], memdup(v, count * 3 * sizeof(GLint)));
6572 }
6573 if (ctx->ExecuteFlag) {
6574 CALL_Uniform3iv(ctx->Exec, (location, count, v));
6575 }
6576 }
6577
6578 static void GLAPIENTRY
6579 save_Uniform4ivARB(GLint location, GLsizei count, const GLint *v)
6580 {
6581 GET_CURRENT_CONTEXT(ctx);
6582 Node *n;
6583 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6584 n = alloc_instruction(ctx, OPCODE_UNIFORM_4IV, 2 + POINTER_DWORDS);
6585 if (n) {
6586 n[1].i = location;
6587 n[2].i = count;
6588 save_pointer(&n[3], memdup(v, count * 4 * sizeof(GLfloat)));
6589 }
6590 if (ctx->ExecuteFlag) {
6591 CALL_Uniform4iv(ctx->Exec, (location, count, v));
6592 }
6593 }
6594
6595
6596
6597 static void GLAPIENTRY
6598 save_Uniform1ui(GLint location, GLuint x)
6599 {
6600 GET_CURRENT_CONTEXT(ctx);
6601 Node *n;
6602 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6603 n = alloc_instruction(ctx, OPCODE_UNIFORM_1UI, 2);
6604 if (n) {
6605 n[1].i = location;
6606 n[2].i = x;
6607 }
6608 if (ctx->ExecuteFlag) {
6609 /*CALL_Uniform1ui(ctx->Exec, (location, x));*/
6610 }
6611 }
6612
6613 static void GLAPIENTRY
6614 save_Uniform2ui(GLint location, GLuint x, GLuint y)
6615 {
6616 GET_CURRENT_CONTEXT(ctx);
6617 Node *n;
6618 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6619 n = alloc_instruction(ctx, OPCODE_UNIFORM_2UI, 3);
6620 if (n) {
6621 n[1].i = location;
6622 n[2].i = x;
6623 n[3].i = y;
6624 }
6625 if (ctx->ExecuteFlag) {
6626 /*CALL_Uniform2ui(ctx->Exec, (location, x, y));*/
6627 }
6628 }
6629
6630 static void GLAPIENTRY
6631 save_Uniform3ui(GLint location, GLuint x, GLuint y, GLuint z)
6632 {
6633 GET_CURRENT_CONTEXT(ctx);
6634 Node *n;
6635 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6636 n = alloc_instruction(ctx, OPCODE_UNIFORM_3UI, 4);
6637 if (n) {
6638 n[1].i = location;
6639 n[2].i = x;
6640 n[3].i = y;
6641 n[4].i = z;
6642 }
6643 if (ctx->ExecuteFlag) {
6644 /*CALL_Uniform3ui(ctx->Exec, (location, x, y, z));*/
6645 }
6646 }
6647
6648 static void GLAPIENTRY
6649 save_Uniform4ui(GLint location, GLuint x, GLuint y, GLuint z, GLuint w)
6650 {
6651 GET_CURRENT_CONTEXT(ctx);
6652 Node *n;
6653 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6654 n = alloc_instruction(ctx, OPCODE_UNIFORM_4UI, 5);
6655 if (n) {
6656 n[1].i = location;
6657 n[2].i = x;
6658 n[3].i = y;
6659 n[4].i = z;
6660 n[5].i = w;
6661 }
6662 if (ctx->ExecuteFlag) {
6663 /*CALL_Uniform4ui(ctx->Exec, (location, x, y, z, w));*/
6664 }
6665 }
6666
6667
6668
6669 static void GLAPIENTRY
6670 save_Uniform1uiv(GLint location, GLsizei count, const GLuint *v)
6671 {
6672 GET_CURRENT_CONTEXT(ctx);
6673 Node *n;
6674 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6675 n = alloc_instruction(ctx, OPCODE_UNIFORM_1UIV, 2 + POINTER_DWORDS);
6676 if (n) {
6677 n[1].i = location;
6678 n[2].i = count;
6679 save_pointer(&n[3], memdup(v, count * 1 * sizeof(*v)));
6680 }
6681 if (ctx->ExecuteFlag) {
6682 /*CALL_Uniform1uiv(ctx->Exec, (location, count, v));*/
6683 }
6684 }
6685
6686 static void GLAPIENTRY
6687 save_Uniform2uiv(GLint location, GLsizei count, const GLuint *v)
6688 {
6689 GET_CURRENT_CONTEXT(ctx);
6690 Node *n;
6691 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6692 n = alloc_instruction(ctx, OPCODE_UNIFORM_2UIV, 2 + POINTER_DWORDS);
6693 if (n) {
6694 n[1].i = location;
6695 n[2].i = count;
6696 save_pointer(&n[3], memdup(v, count * 2 * sizeof(*v)));
6697 }
6698 if (ctx->ExecuteFlag) {
6699 /*CALL_Uniform2uiv(ctx->Exec, (location, count, v));*/
6700 }
6701 }
6702
6703 static void GLAPIENTRY
6704 save_Uniform3uiv(GLint location, GLsizei count, const GLuint *v)
6705 {
6706 GET_CURRENT_CONTEXT(ctx);
6707 Node *n;
6708 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6709 n = alloc_instruction(ctx, OPCODE_UNIFORM_3UIV, 2 + POINTER_DWORDS);
6710 if (n) {
6711 n[1].i = location;
6712 n[2].i = count;
6713 save_pointer(&n[3], memdup(v, count * 3 * sizeof(*v)));
6714 }
6715 if (ctx->ExecuteFlag) {
6716 /*CALL_Uniform3uiv(ctx->Exec, (location, count, v));*/
6717 }
6718 }
6719
6720 static void GLAPIENTRY
6721 save_Uniform4uiv(GLint location, GLsizei count, const GLuint *v)
6722 {
6723 GET_CURRENT_CONTEXT(ctx);
6724 Node *n;
6725 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6726 n = alloc_instruction(ctx, OPCODE_UNIFORM_4UIV, 2 + POINTER_DWORDS);
6727 if (n) {
6728 n[1].i = location;
6729 n[2].i = count;
6730 save_pointer(&n[3], memdup(v, count * 4 * sizeof(*v)));
6731 }
6732 if (ctx->ExecuteFlag) {
6733 /*CALL_Uniform4uiv(ctx->Exec, (location, count, v));*/
6734 }
6735 }
6736
6737
6738
6739 static void GLAPIENTRY
6740 save_UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose,
6741 const GLfloat *m)
6742 {
6743 GET_CURRENT_CONTEXT(ctx);
6744 Node *n;
6745 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6746 n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX22, 3 + POINTER_DWORDS);
6747 if (n) {
6748 n[1].i = location;
6749 n[2].i = count;
6750 n[3].b = transpose;
6751 save_pointer(&n[4], memdup(m, count * 2 * 2 * sizeof(GLfloat)));
6752 }
6753 if (ctx->ExecuteFlag) {
6754 CALL_UniformMatrix2fv(ctx->Exec, (location, count, transpose, m));
6755 }
6756 }
6757
6758 static void GLAPIENTRY
6759 save_UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose,
6760 const GLfloat *m)
6761 {
6762 GET_CURRENT_CONTEXT(ctx);
6763 Node *n;
6764 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6765 n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX33, 3 + POINTER_DWORDS);
6766 if (n) {
6767 n[1].i = location;
6768 n[2].i = count;
6769 n[3].b = transpose;
6770 save_pointer(&n[4], memdup(m, count * 3 * 3 * sizeof(GLfloat)));
6771 }
6772 if (ctx->ExecuteFlag) {
6773 CALL_UniformMatrix3fv(ctx->Exec, (location, count, transpose, m));
6774 }
6775 }
6776
6777 static void GLAPIENTRY
6778 save_UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose,
6779 const GLfloat *m)
6780 {
6781 GET_CURRENT_CONTEXT(ctx);
6782 Node *n;
6783 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6784 n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX44, 3 + POINTER_DWORDS);
6785 if (n) {
6786 n[1].i = location;
6787 n[2].i = count;
6788 n[3].b = transpose;
6789 save_pointer(&n[4], memdup(m, count * 4 * 4 * sizeof(GLfloat)));
6790 }
6791 if (ctx->ExecuteFlag) {
6792 CALL_UniformMatrix4fv(ctx->Exec, (location, count, transpose, m));
6793 }
6794 }
6795
6796
6797 static void GLAPIENTRY
6798 save_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose,
6799 const GLfloat *m)
6800 {
6801 GET_CURRENT_CONTEXT(ctx);
6802 Node *n;
6803 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6804 n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX23, 3 + POINTER_DWORDS);
6805 if (n) {
6806 n[1].i = location;
6807 n[2].i = count;
6808 n[3].b = transpose;
6809 save_pointer(&n[4], memdup(m, count * 2 * 3 * sizeof(GLfloat)));
6810 }
6811 if (ctx->ExecuteFlag) {
6812 CALL_UniformMatrix2x3fv(ctx->Exec, (location, count, transpose, m));
6813 }
6814 }
6815
6816 static void GLAPIENTRY
6817 save_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose,
6818 const GLfloat *m)
6819 {
6820 GET_CURRENT_CONTEXT(ctx);
6821 Node *n;
6822 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6823 n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX32, 3 + POINTER_DWORDS);
6824 if (n) {
6825 n[1].i = location;
6826 n[2].i = count;
6827 n[3].b = transpose;
6828 save_pointer(&n[4], memdup(m, count * 3 * 2 * sizeof(GLfloat)));
6829 }
6830 if (ctx->ExecuteFlag) {
6831 CALL_UniformMatrix3x2fv(ctx->Exec, (location, count, transpose, m));
6832 }
6833 }
6834
6835
6836 static void GLAPIENTRY
6837 save_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose,
6838 const GLfloat *m)
6839 {
6840 GET_CURRENT_CONTEXT(ctx);
6841 Node *n;
6842 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6843 n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX24, 3 + POINTER_DWORDS);
6844 if (n) {
6845 n[1].i = location;
6846 n[2].i = count;
6847 n[3].b = transpose;
6848 save_pointer(&n[4], memdup(m, count * 2 * 4 * sizeof(GLfloat)));
6849 }
6850 if (ctx->ExecuteFlag) {
6851 CALL_UniformMatrix2x4fv(ctx->Exec, (location, count, transpose, m));
6852 }
6853 }
6854
6855 static void GLAPIENTRY
6856 save_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose,
6857 const GLfloat *m)
6858 {
6859 GET_CURRENT_CONTEXT(ctx);
6860 Node *n;
6861 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6862 n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX42, 3 + POINTER_DWORDS);
6863 if (n) {
6864 n[1].i = location;
6865 n[2].i = count;
6866 n[3].b = transpose;
6867 save_pointer(&n[4], memdup(m, count * 4 * 2 * sizeof(GLfloat)));
6868 }
6869 if (ctx->ExecuteFlag) {
6870 CALL_UniformMatrix4x2fv(ctx->Exec, (location, count, transpose, m));
6871 }
6872 }
6873
6874
6875 static void GLAPIENTRY
6876 save_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose,
6877 const GLfloat *m)
6878 {
6879 GET_CURRENT_CONTEXT(ctx);
6880 Node *n;
6881 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6882 n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX34, 3 + POINTER_DWORDS);
6883 if (n) {
6884 n[1].i = location;
6885 n[2].i = count;
6886 n[3].b = transpose;
6887 save_pointer(&n[4], memdup(m, count * 3 * 4 * sizeof(GLfloat)));
6888 }
6889 if (ctx->ExecuteFlag) {
6890 CALL_UniformMatrix3x4fv(ctx->Exec, (location, count, transpose, m));
6891 }
6892 }
6893
6894 static void GLAPIENTRY
6895 save_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose,
6896 const GLfloat *m)
6897 {
6898 GET_CURRENT_CONTEXT(ctx);
6899 Node *n;
6900 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6901 n = alloc_instruction(ctx, OPCODE_UNIFORM_MATRIX43, 3 + POINTER_DWORDS);
6902 if (n) {
6903 n[1].i = location;
6904 n[2].i = count;
6905 n[3].b = transpose;
6906 save_pointer(&n[4], memdup(m, count * 4 * 3 * sizeof(GLfloat)));
6907 }
6908 if (ctx->ExecuteFlag) {
6909 CALL_UniformMatrix4x3fv(ctx->Exec, (location, count, transpose, m));
6910 }
6911 }
6912
6913 static void GLAPIENTRY
6914 save_UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
6915 {
6916 GET_CURRENT_CONTEXT(ctx);
6917 Node *n;
6918 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6919 n = alloc_instruction(ctx, OPCODE_USE_PROGRAM_STAGES, 3);
6920 if (n) {
6921 n[1].ui = pipeline;
6922 n[2].ui = stages;
6923 n[3].ui = program;
6924 }
6925 if (ctx->ExecuteFlag) {
6926 CALL_UseProgramStages(ctx->Exec, (pipeline, stages, program));
6927 }
6928 }
6929
6930 static void GLAPIENTRY
6931 save_ProgramUniform1f(GLuint program, GLint location, GLfloat x)
6932 {
6933 GET_CURRENT_CONTEXT(ctx);
6934 Node *n;
6935 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6936 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1F, 3);
6937 if (n) {
6938 n[1].ui = program;
6939 n[2].i = location;
6940 n[3].f = x;
6941 }
6942 if (ctx->ExecuteFlag) {
6943 CALL_ProgramUniform1f(ctx->Exec, (program, location, x));
6944 }
6945 }
6946
6947 static void GLAPIENTRY
6948 save_ProgramUniform2f(GLuint program, GLint location, GLfloat x, GLfloat y)
6949 {
6950 GET_CURRENT_CONTEXT(ctx);
6951 Node *n;
6952 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6953 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2F, 4);
6954 if (n) {
6955 n[1].ui = program;
6956 n[2].i = location;
6957 n[3].f = x;
6958 n[4].f = y;
6959 }
6960 if (ctx->ExecuteFlag) {
6961 CALL_ProgramUniform2f(ctx->Exec, (program, location, x, y));
6962 }
6963 }
6964
6965 static void GLAPIENTRY
6966 save_ProgramUniform3f(GLuint program, GLint location,
6967 GLfloat x, GLfloat y, GLfloat z)
6968 {
6969 GET_CURRENT_CONTEXT(ctx);
6970 Node *n;
6971 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6972 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3F, 5);
6973 if (n) {
6974 n[1].ui = program;
6975 n[2].i = location;
6976 n[3].f = x;
6977 n[4].f = y;
6978 n[5].f = z;
6979 }
6980 if (ctx->ExecuteFlag) {
6981 CALL_ProgramUniform3f(ctx->Exec, (program, location, x, y, z));
6982 }
6983 }
6984
6985 static void GLAPIENTRY
6986 save_ProgramUniform4f(GLuint program, GLint location,
6987 GLfloat x, GLfloat y, GLfloat z, GLfloat w)
6988 {
6989 GET_CURRENT_CONTEXT(ctx);
6990 Node *n;
6991 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
6992 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4F, 6);
6993 if (n) {
6994 n[1].ui = program;
6995 n[2].i = location;
6996 n[3].f = x;
6997 n[4].f = y;
6998 n[5].f = z;
6999 n[6].f = w;
7000 }
7001 if (ctx->ExecuteFlag) {
7002 CALL_ProgramUniform4f(ctx->Exec, (program, location, x, y, z, w));
7003 }
7004 }
7005
7006 static void GLAPIENTRY
7007 save_ProgramUniform1fv(GLuint program, GLint location, GLsizei count,
7008 const GLfloat *v)
7009 {
7010 GET_CURRENT_CONTEXT(ctx);
7011 Node *n;
7012 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7013 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1FV, 3 + POINTER_DWORDS);
7014 if (n) {
7015 n[1].ui = program;
7016 n[2].i = location;
7017 n[3].i = count;
7018 save_pointer(&n[4], memdup(v, count * 1 * sizeof(GLfloat)));
7019 }
7020 if (ctx->ExecuteFlag) {
7021 CALL_ProgramUniform1fv(ctx->Exec, (program, location, count, v));
7022 }
7023 }
7024
7025 static void GLAPIENTRY
7026 save_ProgramUniform2fv(GLuint program, GLint location, GLsizei count,
7027 const GLfloat *v)
7028 {
7029 GET_CURRENT_CONTEXT(ctx);
7030 Node *n;
7031 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7032 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2FV, 3 + POINTER_DWORDS);
7033 if (n) {
7034 n[1].ui = program;
7035 n[2].i = location;
7036 n[3].i = count;
7037 save_pointer(&n[4], memdup(v, count * 2 * sizeof(GLfloat)));
7038 }
7039 if (ctx->ExecuteFlag) {
7040 CALL_ProgramUniform2fv(ctx->Exec, (program, location, count, v));
7041 }
7042 }
7043
7044 static void GLAPIENTRY
7045 save_ProgramUniform3fv(GLuint program, GLint location, GLsizei count,
7046 const GLfloat *v)
7047 {
7048 GET_CURRENT_CONTEXT(ctx);
7049 Node *n;
7050 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7051 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3FV, 3 + POINTER_DWORDS);
7052 if (n) {
7053 n[1].ui = program;
7054 n[2].i = location;
7055 n[3].i = count;
7056 save_pointer(&n[4], memdup(v, count * 3 * sizeof(GLfloat)));
7057 }
7058 if (ctx->ExecuteFlag) {
7059 CALL_ProgramUniform3fv(ctx->Exec, (program, location, count, v));
7060 }
7061 }
7062
7063 static void GLAPIENTRY
7064 save_ProgramUniform4fv(GLuint program, GLint location, GLsizei count,
7065 const GLfloat *v)
7066 {
7067 GET_CURRENT_CONTEXT(ctx);
7068 Node *n;
7069 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7070 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4FV, 3 + POINTER_DWORDS);
7071 if (n) {
7072 n[1].ui = program;
7073 n[2].i = location;
7074 n[3].i = count;
7075 save_pointer(&n[4], memdup(v, count * 4 * sizeof(GLfloat)));
7076 }
7077 if (ctx->ExecuteFlag) {
7078 CALL_ProgramUniform4fv(ctx->Exec, (program, location, count, v));
7079 }
7080 }
7081
7082 static void GLAPIENTRY
7083 save_ProgramUniform1i(GLuint program, GLint location, GLint x)
7084 {
7085 GET_CURRENT_CONTEXT(ctx);
7086 Node *n;
7087 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7088 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1I, 3);
7089 if (n) {
7090 n[1].ui = program;
7091 n[2].i = location;
7092 n[3].i = x;
7093 }
7094 if (ctx->ExecuteFlag) {
7095 CALL_ProgramUniform1i(ctx->Exec, (program, location, x));
7096 }
7097 }
7098
7099 static void GLAPIENTRY
7100 save_ProgramUniform2i(GLuint program, GLint location, GLint x, GLint y)
7101 {
7102 GET_CURRENT_CONTEXT(ctx);
7103 Node *n;
7104 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7105 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2I, 4);
7106 if (n) {
7107 n[1].ui = program;
7108 n[2].i = location;
7109 n[3].i = x;
7110 n[4].i = y;
7111 }
7112 if (ctx->ExecuteFlag) {
7113 CALL_ProgramUniform2i(ctx->Exec, (program, location, x, y));
7114 }
7115 }
7116
7117 static void GLAPIENTRY
7118 save_ProgramUniform3i(GLuint program, GLint location,
7119 GLint x, GLint y, GLint z)
7120 {
7121 GET_CURRENT_CONTEXT(ctx);
7122 Node *n;
7123 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7124 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3I, 5);
7125 if (n) {
7126 n[1].ui = program;
7127 n[2].i = location;
7128 n[3].i = x;
7129 n[4].i = y;
7130 n[5].i = z;
7131 }
7132 if (ctx->ExecuteFlag) {
7133 CALL_ProgramUniform3i(ctx->Exec, (program, location, x, y, z));
7134 }
7135 }
7136
7137 static void GLAPIENTRY
7138 save_ProgramUniform4i(GLuint program, GLint location,
7139 GLint x, GLint y, GLint z, GLint w)
7140 {
7141 GET_CURRENT_CONTEXT(ctx);
7142 Node *n;
7143 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7144 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4I, 6);
7145 if (n) {
7146 n[1].ui = program;
7147 n[2].i = location;
7148 n[3].i = x;
7149 n[4].i = y;
7150 n[5].i = z;
7151 n[6].i = w;
7152 }
7153 if (ctx->ExecuteFlag) {
7154 CALL_ProgramUniform4i(ctx->Exec, (program, location, x, y, z, w));
7155 }
7156 }
7157
7158 static void GLAPIENTRY
7159 save_ProgramUniform1iv(GLuint program, GLint location, GLsizei count,
7160 const GLint *v)
7161 {
7162 GET_CURRENT_CONTEXT(ctx);
7163 Node *n;
7164 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7165 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1IV, 3 + POINTER_DWORDS);
7166 if (n) {
7167 n[1].ui = program;
7168 n[2].i = location;
7169 n[3].i = count;
7170 save_pointer(&n[4], memdup(v, count * 1 * sizeof(GLint)));
7171 }
7172 if (ctx->ExecuteFlag) {
7173 CALL_ProgramUniform1iv(ctx->Exec, (program, location, count, v));
7174 }
7175 }
7176
7177 static void GLAPIENTRY
7178 save_ProgramUniform2iv(GLuint program, GLint location, GLsizei count,
7179 const GLint *v)
7180 {
7181 GET_CURRENT_CONTEXT(ctx);
7182 Node *n;
7183 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7184 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2IV, 3 + POINTER_DWORDS);
7185 if (n) {
7186 n[1].ui = program;
7187 n[2].i = location;
7188 n[3].i = count;
7189 save_pointer(&n[4], memdup(v, count * 2 * sizeof(GLint)));
7190 }
7191 if (ctx->ExecuteFlag) {
7192 CALL_ProgramUniform2iv(ctx->Exec, (program, location, count, v));
7193 }
7194 }
7195
7196 static void GLAPIENTRY
7197 save_ProgramUniform3iv(GLuint program, GLint location, GLsizei count,
7198 const GLint *v)
7199 {
7200 GET_CURRENT_CONTEXT(ctx);
7201 Node *n;
7202 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7203 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3IV, 3 + POINTER_DWORDS);
7204 if (n) {
7205 n[1].ui = program;
7206 n[2].i = location;
7207 n[3].i = count;
7208 save_pointer(&n[4], memdup(v, count * 3 * sizeof(GLint)));
7209 }
7210 if (ctx->ExecuteFlag) {
7211 CALL_ProgramUniform3iv(ctx->Exec, (program, location, count, v));
7212 }
7213 }
7214
7215 static void GLAPIENTRY
7216 save_ProgramUniform4iv(GLuint program, GLint location, GLsizei count,
7217 const GLint *v)
7218 {
7219 GET_CURRENT_CONTEXT(ctx);
7220 Node *n;
7221 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7222 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4IV, 3 + POINTER_DWORDS);
7223 if (n) {
7224 n[1].ui = program;
7225 n[2].i = location;
7226 n[3].i = count;
7227 save_pointer(&n[4], memdup(v, count * 4 * sizeof(GLint)));
7228 }
7229 if (ctx->ExecuteFlag) {
7230 CALL_ProgramUniform4iv(ctx->Exec, (program, location, count, v));
7231 }
7232 }
7233
7234 static void GLAPIENTRY
7235 save_ProgramUniform1ui(GLuint program, GLint location, GLuint x)
7236 {
7237 GET_CURRENT_CONTEXT(ctx);
7238 Node *n;
7239 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7240 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1UI, 3);
7241 if (n) {
7242 n[1].ui = program;
7243 n[2].i = location;
7244 n[3].ui = x;
7245 }
7246 if (ctx->ExecuteFlag) {
7247 CALL_ProgramUniform1ui(ctx->Exec, (program, location, x));
7248 }
7249 }
7250
7251 static void GLAPIENTRY
7252 save_ProgramUniform2ui(GLuint program, GLint location, GLuint x, GLuint y)
7253 {
7254 GET_CURRENT_CONTEXT(ctx);
7255 Node *n;
7256 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7257 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2UI, 4);
7258 if (n) {
7259 n[1].ui = program;
7260 n[2].i = location;
7261 n[3].ui = x;
7262 n[4].ui = y;
7263 }
7264 if (ctx->ExecuteFlag) {
7265 CALL_ProgramUniform2ui(ctx->Exec, (program, location, x, y));
7266 }
7267 }
7268
7269 static void GLAPIENTRY
7270 save_ProgramUniform3ui(GLuint program, GLint location,
7271 GLuint x, GLuint y, GLuint z)
7272 {
7273 GET_CURRENT_CONTEXT(ctx);
7274 Node *n;
7275 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7276 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3UI, 5);
7277 if (n) {
7278 n[1].ui = program;
7279 n[2].i = location;
7280 n[3].ui = x;
7281 n[4].ui = y;
7282 n[5].ui = z;
7283 }
7284 if (ctx->ExecuteFlag) {
7285 CALL_ProgramUniform3ui(ctx->Exec, (program, location, x, y, z));
7286 }
7287 }
7288
7289 static void GLAPIENTRY
7290 save_ProgramUniform4ui(GLuint program, GLint location,
7291 GLuint x, GLuint y, GLuint z, GLuint w)
7292 {
7293 GET_CURRENT_CONTEXT(ctx);
7294 Node *n;
7295 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7296 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4UI, 6);
7297 if (n) {
7298 n[1].ui = program;
7299 n[2].i = location;
7300 n[3].ui = x;
7301 n[4].ui = y;
7302 n[5].ui = z;
7303 n[6].ui = w;
7304 }
7305 if (ctx->ExecuteFlag) {
7306 CALL_ProgramUniform4ui(ctx->Exec, (program, location, x, y, z, w));
7307 }
7308 }
7309
7310 static void GLAPIENTRY
7311 save_ProgramUniform1uiv(GLuint program, GLint location, GLsizei count,
7312 const GLuint *v)
7313 {
7314 GET_CURRENT_CONTEXT(ctx);
7315 Node *n;
7316 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7317 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_1UIV, 3 + POINTER_DWORDS);
7318 if (n) {
7319 n[1].ui = program;
7320 n[2].i = location;
7321 n[3].i = count;
7322 save_pointer(&n[4], memdup(v, count * 1 * sizeof(GLuint)));
7323 }
7324 if (ctx->ExecuteFlag) {
7325 CALL_ProgramUniform1uiv(ctx->Exec, (program, location, count, v));
7326 }
7327 }
7328
7329 static void GLAPIENTRY
7330 save_ProgramUniform2uiv(GLuint program, GLint location, GLsizei count,
7331 const GLuint *v)
7332 {
7333 GET_CURRENT_CONTEXT(ctx);
7334 Node *n;
7335 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7336 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_2UIV, 3 + POINTER_DWORDS);
7337 if (n) {
7338 n[1].ui = program;
7339 n[2].i = location;
7340 n[3].i = count;
7341 save_pointer(&n[4], memdup(v, count * 2 * sizeof(GLuint)));
7342 }
7343 if (ctx->ExecuteFlag) {
7344 CALL_ProgramUniform2uiv(ctx->Exec, (program, location, count, v));
7345 }
7346 }
7347
7348 static void GLAPIENTRY
7349 save_ProgramUniform3uiv(GLuint program, GLint location, GLsizei count,
7350 const GLuint *v)
7351 {
7352 GET_CURRENT_CONTEXT(ctx);
7353 Node *n;
7354 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7355 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_3UIV, 3 + POINTER_DWORDS);
7356 if (n) {
7357 n[1].ui = program;
7358 n[2].i = location;
7359 n[3].i = count;
7360 save_pointer(&n[4], memdup(v, count * 3 * sizeof(GLuint)));
7361 }
7362 if (ctx->ExecuteFlag) {
7363 CALL_ProgramUniform3uiv(ctx->Exec, (program, location, count, v));
7364 }
7365 }
7366
7367 static void GLAPIENTRY
7368 save_ProgramUniform4uiv(GLuint program, GLint location, GLsizei count,
7369 const GLuint *v)
7370 {
7371 GET_CURRENT_CONTEXT(ctx);
7372 Node *n;
7373 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7374 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_4UIV, 3 + POINTER_DWORDS);
7375 if (n) {
7376 n[1].ui = program;
7377 n[2].i = location;
7378 n[3].i = count;
7379 save_pointer(&n[4], memdup(v, count * 4 * sizeof(GLuint)));
7380 }
7381 if (ctx->ExecuteFlag) {
7382 CALL_ProgramUniform4uiv(ctx->Exec, (program, location, count, v));
7383 }
7384 }
7385
7386 static void GLAPIENTRY
7387 save_ProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count,
7388 GLboolean transpose, const GLfloat *v)
7389 {
7390 GET_CURRENT_CONTEXT(ctx);
7391 Node *n;
7392 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7393 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX22F,
7394 4 + POINTER_DWORDS);
7395 if (n) {
7396 n[1].ui = program;
7397 n[2].i = location;
7398 n[3].i = count;
7399 n[4].b = transpose;
7400 save_pointer(&n[5], memdup(v, count * 2 * 2 * sizeof(GLfloat)));
7401 }
7402 if (ctx->ExecuteFlag) {
7403 CALL_ProgramUniformMatrix2fv(ctx->Exec,
7404 (program, location, count, transpose, v));
7405 }
7406 }
7407
7408 static void GLAPIENTRY
7409 save_ProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count,
7410 GLboolean transpose, const GLfloat *v)
7411 {
7412 GET_CURRENT_CONTEXT(ctx);
7413 Node *n;
7414 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7415 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX23F,
7416 4 + POINTER_DWORDS);
7417 if (n) {
7418 n[1].ui = program;
7419 n[2].i = location;
7420 n[3].i = count;
7421 n[4].b = transpose;
7422 save_pointer(&n[5], memdup(v, count * 2 * 3 * sizeof(GLfloat)));
7423 }
7424 if (ctx->ExecuteFlag) {
7425 CALL_ProgramUniformMatrix2x3fv(ctx->Exec,
7426 (program, location, count, transpose, v));
7427 }
7428 }
7429
7430 static void GLAPIENTRY
7431 save_ProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count,
7432 GLboolean transpose, const GLfloat *v)
7433 {
7434 GET_CURRENT_CONTEXT(ctx);
7435 Node *n;
7436 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7437 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX24F,
7438 4 + POINTER_DWORDS);
7439 if (n) {
7440 n[1].ui = program;
7441 n[2].i = location;
7442 n[3].i = count;
7443 n[4].b = transpose;
7444 save_pointer(&n[5], memdup(v, count * 2 * 4 * sizeof(GLfloat)));
7445 }
7446 if (ctx->ExecuteFlag) {
7447 CALL_ProgramUniformMatrix2x4fv(ctx->Exec,
7448 (program, location, count, transpose, v));
7449 }
7450 }
7451
7452 static void GLAPIENTRY
7453 save_ProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count,
7454 GLboolean transpose, const GLfloat *v)
7455 {
7456 GET_CURRENT_CONTEXT(ctx);
7457 Node *n;
7458 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7459 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX32F,
7460 4 + POINTER_DWORDS);
7461 if (n) {
7462 n[1].ui = program;
7463 n[2].i = location;
7464 n[3].i = count;
7465 n[4].b = transpose;
7466 save_pointer(&n[5], memdup(v, count * 3 * 2 * sizeof(GLfloat)));
7467 }
7468 if (ctx->ExecuteFlag) {
7469 CALL_ProgramUniformMatrix3x2fv(ctx->Exec,
7470 (program, location, count, transpose, v));
7471 }
7472 }
7473
7474 static void GLAPIENTRY
7475 save_ProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count,
7476 GLboolean transpose, const GLfloat *v)
7477 {
7478 GET_CURRENT_CONTEXT(ctx);
7479 Node *n;
7480 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7481 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX33F,
7482 4 + POINTER_DWORDS);
7483 if (n) {
7484 n[1].ui = program;
7485 n[2].i = location;
7486 n[3].i = count;
7487 n[4].b = transpose;
7488 save_pointer(&n[5], memdup(v, count * 3 * 3 * sizeof(GLfloat)));
7489 }
7490 if (ctx->ExecuteFlag) {
7491 CALL_ProgramUniformMatrix3fv(ctx->Exec,
7492 (program, location, count, transpose, v));
7493 }
7494 }
7495
7496 static void GLAPIENTRY
7497 save_ProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count,
7498 GLboolean transpose, const GLfloat *v)
7499 {
7500 GET_CURRENT_CONTEXT(ctx);
7501 Node *n;
7502 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7503 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX34F,
7504 4 + POINTER_DWORDS);
7505 if (n) {
7506 n[1].ui = program;
7507 n[2].i = location;
7508 n[3].i = count;
7509 n[4].b = transpose;
7510 save_pointer(&n[5], memdup(v, count * 3 * 4 * sizeof(GLfloat)));
7511 }
7512 if (ctx->ExecuteFlag) {
7513 CALL_ProgramUniformMatrix3x4fv(ctx->Exec,
7514 (program, location, count, transpose, v));
7515 }
7516 }
7517
7518 static void GLAPIENTRY
7519 save_ProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count,
7520 GLboolean transpose, const GLfloat *v)
7521 {
7522 GET_CURRENT_CONTEXT(ctx);
7523 Node *n;
7524 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7525 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX42F,
7526 4 + POINTER_DWORDS);
7527 if (n) {
7528 n[1].ui = program;
7529 n[2].i = location;
7530 n[3].i = count;
7531 n[4].b = transpose;
7532 save_pointer(&n[5], memdup(v, count * 4 * 2 * sizeof(GLfloat)));
7533 }
7534 if (ctx->ExecuteFlag) {
7535 CALL_ProgramUniformMatrix4x2fv(ctx->Exec,
7536 (program, location, count, transpose, v));
7537 }
7538 }
7539
7540 static void GLAPIENTRY
7541 save_ProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count,
7542 GLboolean transpose, const GLfloat *v)
7543 {
7544 GET_CURRENT_CONTEXT(ctx);
7545 Node *n;
7546 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7547 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX43F,
7548 4 + POINTER_DWORDS);
7549 if (n) {
7550 n[1].ui = program;
7551 n[2].i = location;
7552 n[3].i = count;
7553 n[4].b = transpose;
7554 save_pointer(&n[5], memdup(v, count * 4 * 3 * sizeof(GLfloat)));
7555 }
7556 if (ctx->ExecuteFlag) {
7557 CALL_ProgramUniformMatrix4x3fv(ctx->Exec,
7558 (program, location, count, transpose, v));
7559 }
7560 }
7561
7562 static void GLAPIENTRY
7563 save_ProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count,
7564 GLboolean transpose, const GLfloat *v)
7565 {
7566 GET_CURRENT_CONTEXT(ctx);
7567 Node *n;
7568 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7569 n = alloc_instruction(ctx, OPCODE_PROGRAM_UNIFORM_MATRIX44F,
7570 4 + POINTER_DWORDS);
7571 if (n) {
7572 n[1].ui = program;
7573 n[2].i = location;
7574 n[3].i = count;
7575 n[4].b = transpose;
7576 save_pointer(&n[5], memdup(v, count * 4 * 4 * sizeof(GLfloat)));
7577 }
7578 if (ctx->ExecuteFlag) {
7579 CALL_ProgramUniformMatrix4fv(ctx->Exec,
7580 (program, location, count, transpose, v));
7581 }
7582 }
7583
7584 static void GLAPIENTRY
7585 save_ClipControl(GLenum origin, GLenum depth)
7586 {
7587 GET_CURRENT_CONTEXT(ctx);
7588 Node *n;
7589 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7590 n = alloc_instruction(ctx, OPCODE_CLIP_CONTROL, 2);
7591 if (n) {
7592 n[1].e = origin;
7593 n[2].e = depth;
7594 }
7595 if (ctx->ExecuteFlag) {
7596 CALL_ClipControl(ctx->Exec, (origin, depth));
7597 }
7598 }
7599
7600 static void GLAPIENTRY
7601 save_ClampColorARB(GLenum target, GLenum clamp)
7602 {
7603 GET_CURRENT_CONTEXT(ctx);
7604 Node *n;
7605 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7606 n = alloc_instruction(ctx, OPCODE_CLAMP_COLOR, 2);
7607 if (n) {
7608 n[1].e = target;
7609 n[2].e = clamp;
7610 }
7611 if (ctx->ExecuteFlag) {
7612 CALL_ClampColor(ctx->Exec, (target, clamp));
7613 }
7614 }
7615
7616 /** GL_EXT_texture_integer */
7617 static void GLAPIENTRY
7618 save_ClearColorIi(GLint red, GLint green, GLint blue, GLint alpha)
7619 {
7620 GET_CURRENT_CONTEXT(ctx);
7621 Node *n;
7622 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7623 n = alloc_instruction(ctx, OPCODE_CLEARCOLOR_I, 4);
7624 if (n) {
7625 n[1].i = red;
7626 n[2].i = green;
7627 n[3].i = blue;
7628 n[4].i = alpha;
7629 }
7630 if (ctx->ExecuteFlag) {
7631 CALL_ClearColorIiEXT(ctx->Exec, (red, green, blue, alpha));
7632 }
7633 }
7634
7635 /** GL_EXT_texture_integer */
7636 static void GLAPIENTRY
7637 save_ClearColorIui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
7638 {
7639 GET_CURRENT_CONTEXT(ctx);
7640 Node *n;
7641 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7642 n = alloc_instruction(ctx, OPCODE_CLEARCOLOR_UI, 4);
7643 if (n) {
7644 n[1].ui = red;
7645 n[2].ui = green;
7646 n[3].ui = blue;
7647 n[4].ui = alpha;
7648 }
7649 if (ctx->ExecuteFlag) {
7650 CALL_ClearColorIuiEXT(ctx->Exec, (red, green, blue, alpha));
7651 }
7652 }
7653
7654 /** GL_EXT_texture_integer */
7655 static void GLAPIENTRY
7656 save_TexParameterIiv(GLenum target, GLenum pname, const GLint *params)
7657 {
7658 GET_CURRENT_CONTEXT(ctx);
7659 Node *n;
7660 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7661 n = alloc_instruction(ctx, OPCODE_TEXPARAMETER_I, 6);
7662 if (n) {
7663 n[1].e = target;
7664 n[2].e = pname;
7665 n[3].i = params[0];
7666 n[4].i = params[1];
7667 n[5].i = params[2];
7668 n[6].i = params[3];
7669 }
7670 if (ctx->ExecuteFlag) {
7671 CALL_TexParameterIiv(ctx->Exec, (target, pname, params));
7672 }
7673 }
7674
7675 /** GL_EXT_texture_integer */
7676 static void GLAPIENTRY
7677 save_TexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
7678 {
7679 GET_CURRENT_CONTEXT(ctx);
7680 Node *n;
7681 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7682 n = alloc_instruction(ctx, OPCODE_TEXPARAMETER_UI, 6);
7683 if (n) {
7684 n[1].e = target;
7685 n[2].e = pname;
7686 n[3].ui = params[0];
7687 n[4].ui = params[1];
7688 n[5].ui = params[2];
7689 n[6].ui = params[3];
7690 }
7691 if (ctx->ExecuteFlag) {
7692 CALL_TexParameterIuiv(ctx->Exec, (target, pname, params));
7693 }
7694 }
7695
7696 /* GL_ARB_instanced_arrays */
7697 static void GLAPIENTRY
7698 save_VertexAttribDivisor(GLuint index, GLuint divisor)
7699 {
7700 GET_CURRENT_CONTEXT(ctx);
7701 Node *n;
7702 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7703 n = alloc_instruction(ctx, OPCODE_VERTEX_ATTRIB_DIVISOR, 2);
7704 if (n) {
7705 n[1].ui = index;
7706 n[2].ui = divisor;
7707 }
7708 if (ctx->ExecuteFlag) {
7709 CALL_VertexAttribDivisor(ctx->Exec, (index, divisor));
7710 }
7711 }
7712
7713
7714 /* GL_NV_texture_barrier */
7715 static void GLAPIENTRY
7716 save_TextureBarrierNV(void)
7717 {
7718 GET_CURRENT_CONTEXT(ctx);
7719 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7720 alloc_instruction(ctx, OPCODE_TEXTURE_BARRIER_NV, 0);
7721 if (ctx->ExecuteFlag) {
7722 CALL_TextureBarrierNV(ctx->Exec, ());
7723 }
7724 }
7725
7726
7727 /* GL_ARB_sampler_objects */
7728 static void GLAPIENTRY
7729 save_BindSampler(GLuint unit, GLuint sampler)
7730 {
7731 Node *n;
7732 GET_CURRENT_CONTEXT(ctx);
7733 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7734 n = alloc_instruction(ctx, OPCODE_BIND_SAMPLER, 2);
7735 if (n) {
7736 n[1].ui = unit;
7737 n[2].ui = sampler;
7738 }
7739 if (ctx->ExecuteFlag) {
7740 CALL_BindSampler(ctx->Exec, (unit, sampler));
7741 }
7742 }
7743
7744 static void GLAPIENTRY
7745 save_SamplerParameteriv(GLuint sampler, GLenum pname, const GLint *params)
7746 {
7747 Node *n;
7748 GET_CURRENT_CONTEXT(ctx);
7749 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7750 n = alloc_instruction(ctx, OPCODE_SAMPLER_PARAMETERIV, 6);
7751 if (n) {
7752 n[1].ui = sampler;
7753 n[2].e = pname;
7754 n[3].i = params[0];
7755 if (pname == GL_TEXTURE_BORDER_COLOR) {
7756 n[4].i = params[1];
7757 n[5].i = params[2];
7758 n[6].i = params[3];
7759 }
7760 else {
7761 n[4].i = n[5].i = n[6].i = 0;
7762 }
7763 }
7764 if (ctx->ExecuteFlag) {
7765 CALL_SamplerParameteriv(ctx->Exec, (sampler, pname, params));
7766 }
7767 }
7768
7769 static void GLAPIENTRY
7770 save_SamplerParameteri(GLuint sampler, GLenum pname, GLint param)
7771 {
7772 GLint parray[4];
7773 parray[0] = param;
7774 parray[1] = parray[2] = parray[3] = 0;
7775 save_SamplerParameteriv(sampler, pname, parray);
7776 }
7777
7778 static void GLAPIENTRY
7779 save_SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *params)
7780 {
7781 Node *n;
7782 GET_CURRENT_CONTEXT(ctx);
7783 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7784 n = alloc_instruction(ctx, OPCODE_SAMPLER_PARAMETERFV, 6);
7785 if (n) {
7786 n[1].ui = sampler;
7787 n[2].e = pname;
7788 n[3].f = params[0];
7789 if (pname == GL_TEXTURE_BORDER_COLOR) {
7790 n[4].f = params[1];
7791 n[5].f = params[2];
7792 n[6].f = params[3];
7793 }
7794 else {
7795 n[4].f = n[5].f = n[6].f = 0.0F;
7796 }
7797 }
7798 if (ctx->ExecuteFlag) {
7799 CALL_SamplerParameterfv(ctx->Exec, (sampler, pname, params));
7800 }
7801 }
7802
7803 static void GLAPIENTRY
7804 save_SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
7805 {
7806 GLfloat parray[4];
7807 parray[0] = param;
7808 parray[1] = parray[2] = parray[3] = 0.0F;
7809 save_SamplerParameterfv(sampler, pname, parray);
7810 }
7811
7812 static void GLAPIENTRY
7813 save_SamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *params)
7814 {
7815 Node *n;
7816 GET_CURRENT_CONTEXT(ctx);
7817 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7818 n = alloc_instruction(ctx, OPCODE_SAMPLER_PARAMETERIIV, 6);
7819 if (n) {
7820 n[1].ui = sampler;
7821 n[2].e = pname;
7822 n[3].i = params[0];
7823 if (pname == GL_TEXTURE_BORDER_COLOR) {
7824 n[4].i = params[1];
7825 n[5].i = params[2];
7826 n[6].i = params[3];
7827 }
7828 else {
7829 n[4].i = n[5].i = n[6].i = 0;
7830 }
7831 }
7832 if (ctx->ExecuteFlag) {
7833 CALL_SamplerParameterIiv(ctx->Exec, (sampler, pname, params));
7834 }
7835 }
7836
7837 static void GLAPIENTRY
7838 save_SamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *params)
7839 {
7840 Node *n;
7841 GET_CURRENT_CONTEXT(ctx);
7842 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7843 n = alloc_instruction(ctx, OPCODE_SAMPLER_PARAMETERUIV, 6);
7844 if (n) {
7845 n[1].ui = sampler;
7846 n[2].e = pname;
7847 n[3].ui = params[0];
7848 if (pname == GL_TEXTURE_BORDER_COLOR) {
7849 n[4].ui = params[1];
7850 n[5].ui = params[2];
7851 n[6].ui = params[3];
7852 }
7853 else {
7854 n[4].ui = n[5].ui = n[6].ui = 0;
7855 }
7856 }
7857 if (ctx->ExecuteFlag) {
7858 CALL_SamplerParameterIuiv(ctx->Exec, (sampler, pname, params));
7859 }
7860 }
7861
7862 static void GLAPIENTRY
7863 save_WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
7864 {
7865 Node *n;
7866 GET_CURRENT_CONTEXT(ctx);
7867 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7868 n = alloc_instruction(ctx, OPCODE_WAIT_SYNC, 4);
7869 if (n) {
7870 union uint64_pair p;
7871 p.uint64 = timeout;
7872 n[1].bf = flags;
7873 n[2].ui = p.uint32[0];
7874 n[3].ui = p.uint32[1];
7875 save_pointer(&n[4], sync);
7876 }
7877 if (ctx->ExecuteFlag) {
7878 CALL_WaitSync(ctx->Exec, (sync, flags, timeout));
7879 }
7880 }
7881
7882
7883 /** GL_NV_conditional_render */
7884 static void GLAPIENTRY
7885 save_BeginConditionalRender(GLuint queryId, GLenum mode)
7886 {
7887 GET_CURRENT_CONTEXT(ctx);
7888 Node *n;
7889 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7890 n = alloc_instruction(ctx, OPCODE_BEGIN_CONDITIONAL_RENDER, 2);
7891 if (n) {
7892 n[1].i = queryId;
7893 n[2].e = mode;
7894 }
7895 if (ctx->ExecuteFlag) {
7896 CALL_BeginConditionalRender(ctx->Exec, (queryId, mode));
7897 }
7898 }
7899
7900 static void GLAPIENTRY
7901 save_EndConditionalRender(void)
7902 {
7903 GET_CURRENT_CONTEXT(ctx);
7904 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7905 alloc_instruction(ctx, OPCODE_END_CONDITIONAL_RENDER, 0);
7906 if (ctx->ExecuteFlag) {
7907 CALL_EndConditionalRender(ctx->Exec, ());
7908 }
7909 }
7910
7911 static void GLAPIENTRY
7912 save_UniformBlockBinding(GLuint prog, GLuint index, GLuint binding)
7913 {
7914 GET_CURRENT_CONTEXT(ctx);
7915 Node *n;
7916 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7917 n = alloc_instruction(ctx, OPCODE_UNIFORM_BLOCK_BINDING, 3);
7918 if (n) {
7919 n[1].ui = prog;
7920 n[2].ui = index;
7921 n[3].ui = binding;
7922 }
7923 if (ctx->ExecuteFlag) {
7924 CALL_UniformBlockBinding(ctx->Exec, (prog, index, binding));
7925 }
7926 }
7927
7928 /** GL_EXT_window_rectangles */
7929 static void GLAPIENTRY
7930 save_WindowRectanglesEXT(GLenum mode, GLsizei count, const GLint *box)
7931 {
7932 GET_CURRENT_CONTEXT(ctx);
7933 Node *n;
7934 ASSERT_OUTSIDE_SAVE_BEGIN_END_AND_FLUSH(ctx);
7935 n = alloc_instruction(ctx, OPCODE_WINDOW_RECTANGLES, 2 + POINTER_DWORDS);
7936 if (n) {
7937 GLint *box_copy = NULL;
7938
7939 if (count > 0)
7940 box_copy = memdup(box, sizeof(GLint) * 4 * count);
7941 n[1].e = mode;
7942 n[2].si = count;
7943 save_pointer(&n[3], box_copy);
7944 }
7945 if (ctx->ExecuteFlag) {
7946 CALL_WindowRectanglesEXT(ctx->Exec, (mode, count, box));
7947 }
7948 }
7949
7950 /**
7951 * Save an error-generating command into display list.
7952 *
7953 * KW: Will appear in the list before the vertex buffer containing the
7954 * command that provoked the error. I don't see this as a problem.
7955 */
7956 static void
7957 save_error(struct gl_context *ctx, GLenum error, const char *s)
7958 {
7959 Node *n;
7960 n = alloc_instruction(ctx, OPCODE_ERROR, 1 + POINTER_DWORDS);
7961 if (n) {
7962 n[1].e = error;
7963 save_pointer(&n[2], (void *) s);
7964 /* note: the data/string here doesn't have to be freed in
7965 * _mesa_delete_list() since the string is never dynamically
7966 * allocated.
7967 */
7968 }
7969 }
7970
7971
7972 /**
7973 * Compile an error into current display list.
7974 */
7975 void
7976 _mesa_compile_error(struct gl_context *ctx, GLenum error, const char *s)
7977 {
7978 if (ctx->CompileFlag)
7979 save_error(ctx, error, s);
7980 if (ctx->ExecuteFlag)
7981 _mesa_error(ctx, error, "%s", s);
7982 }
7983
7984
7985 /**
7986 * Test if ID names a display list.
7987 */
7988 static GLboolean
7989 islist(struct gl_context *ctx, GLuint list)
7990 {
7991 if (list > 0 && _mesa_lookup_list(ctx, list)) {
7992 return GL_TRUE;
7993 }
7994 else {
7995 return GL_FALSE;
7996 }
7997 }
7998
7999
8000
8001 /**********************************************************************/
8002 /* Display list execution */
8003 /**********************************************************************/
8004
8005
8006 /*
8007 * Execute a display list. Note that the ListBase offset must have already
8008 * been added before calling this function. I.e. the list argument is
8009 * the absolute list number, not relative to ListBase.
8010 * \param list - display list number
8011 */
8012 static void
8013 execute_list(struct gl_context *ctx, GLuint list)
8014 {
8015 struct gl_display_list *dlist;
8016 Node *n;
8017 GLboolean done;
8018
8019 if (list == 0 || !islist(ctx, list))
8020 return;
8021
8022 if (ctx->ListState.CallDepth == MAX_LIST_NESTING) {
8023 /* raise an error? */
8024 return;
8025 }
8026
8027 dlist = _mesa_lookup_list(ctx, list);
8028 if (!dlist)
8029 return;
8030
8031 ctx->ListState.CallDepth++;
8032
8033 vbo_save_BeginCallList(ctx, dlist);
8034
8035 n = dlist->Head;
8036
8037 done = GL_FALSE;
8038 while (!done) {
8039 const OpCode opcode = n[0].opcode;
8040
8041 if (is_ext_opcode(opcode)) {
8042 n += ext_opcode_execute(ctx, n);
8043 }
8044 else {
8045 switch (opcode) {
8046 case OPCODE_ERROR:
8047 _mesa_error(ctx, n[1].e, "%s", (const char *) get_pointer(&n[2]));
8048 break;
8049 case OPCODE_ACCUM:
8050 CALL_Accum(ctx->Exec, (n[1].e, n[2].f));
8051 break;
8052 case OPCODE_ALPHA_FUNC:
8053 CALL_AlphaFunc(ctx->Exec, (n[1].e, n[2].f));
8054 break;
8055 case OPCODE_BIND_TEXTURE:
8056 CALL_BindTexture(ctx->Exec, (n[1].e, n[2].ui));
8057 break;
8058 case OPCODE_BITMAP:
8059 {
8060 const struct gl_pixelstore_attrib save = ctx->Unpack;
8061 ctx->Unpack = ctx->DefaultPacking;
8062 CALL_Bitmap(ctx->Exec, ((GLsizei) n[1].i, (GLsizei) n[2].i,
8063 n[3].f, n[4].f, n[5].f, n[6].f,
8064 get_pointer(&n[7])));
8065 ctx->Unpack = save; /* restore */
8066 }
8067 break;
8068 case OPCODE_BLEND_COLOR:
8069 CALL_BlendColor(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
8070 break;
8071 case OPCODE_BLEND_EQUATION:
8072 CALL_BlendEquation(ctx->Exec, (n[1].e));
8073 break;
8074 case OPCODE_BLEND_EQUATION_SEPARATE:
8075 CALL_BlendEquationSeparate(ctx->Exec, (n[1].e, n[2].e));
8076 break;
8077 case OPCODE_BLEND_FUNC_SEPARATE:
8078 CALL_BlendFuncSeparate(ctx->Exec,
8079 (n[1].e, n[2].e, n[3].e, n[4].e));
8080 break;
8081
8082 case OPCODE_BLEND_FUNC_I:
8083 /* GL_ARB_draw_buffers_blend */
8084 CALL_BlendFunciARB(ctx->Exec, (n[1].ui, n[2].e, n[3].e));
8085 break;
8086 case OPCODE_BLEND_FUNC_SEPARATE_I:
8087 /* GL_ARB_draw_buffers_blend */
8088 CALL_BlendFuncSeparateiARB(ctx->Exec, (n[1].ui, n[2].e, n[3].e,
8089 n[4].e, n[5].e));
8090 break;
8091 case OPCODE_BLEND_EQUATION_I:
8092 /* GL_ARB_draw_buffers_blend */
8093 CALL_BlendEquationiARB(ctx->Exec, (n[1].ui, n[2].e));
8094 break;
8095 case OPCODE_BLEND_EQUATION_SEPARATE_I:
8096 /* GL_ARB_draw_buffers_blend */
8097 CALL_BlendEquationSeparateiARB(ctx->Exec,
8098 (n[1].ui, n[2].e, n[3].e));
8099 break;
8100
8101 case OPCODE_CALL_LIST:
8102 /* Generated by glCallList(), don't add ListBase */
8103 if (ctx->ListState.CallDepth < MAX_LIST_NESTING) {
8104 execute_list(ctx, n[1].ui);
8105 }
8106 break;
8107 case OPCODE_CALL_LISTS:
8108 if (ctx->ListState.CallDepth < MAX_LIST_NESTING) {
8109 CALL_CallLists(ctx->Exec, (n[1].i, n[2].e, get_pointer(&n[3])));
8110 }
8111 break;
8112 case OPCODE_CLEAR:
8113 CALL_Clear(ctx->Exec, (n[1].bf));
8114 break;
8115 case OPCODE_CLEAR_BUFFER_IV:
8116 {
8117 GLint value[4];
8118 value[0] = n[3].i;
8119 value[1] = n[4].i;
8120 value[2] = n[5].i;
8121 value[3] = n[6].i;
8122 CALL_ClearBufferiv(ctx->Exec, (n[1].e, n[2].i, value));
8123 }
8124 break;
8125 case OPCODE_CLEAR_BUFFER_UIV:
8126 {
8127 GLuint value[4];
8128 value[0] = n[3].ui;
8129 value[1] = n[4].ui;
8130 value[2] = n[5].ui;
8131 value[3] = n[6].ui;
8132 CALL_ClearBufferuiv(ctx->Exec, (n[1].e, n[2].i, value));
8133 }
8134 break;
8135 case OPCODE_CLEAR_BUFFER_FV:
8136 {
8137 GLfloat value[4];
8138 value[0] = n[3].f;
8139 value[1] = n[4].f;
8140 value[2] = n[5].f;
8141 value[3] = n[6].f;
8142 CALL_ClearBufferfv(ctx->Exec, (n[1].e, n[2].i, value));
8143 }
8144 break;
8145 case OPCODE_CLEAR_BUFFER_FI:
8146 CALL_ClearBufferfi(ctx->Exec, (n[1].e, n[2].i, n[3].f, n[4].i));
8147 break;
8148 case OPCODE_CLEAR_COLOR:
8149 CALL_ClearColor(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
8150 break;
8151 case OPCODE_CLEAR_ACCUM:
8152 CALL_ClearAccum(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
8153 break;
8154 case OPCODE_CLEAR_DEPTH:
8155 CALL_ClearDepth(ctx->Exec, ((GLclampd) n[1].f));
8156 break;
8157 case OPCODE_CLEAR_INDEX:
8158 CALL_ClearIndex(ctx->Exec, ((GLfloat) n[1].ui));
8159 break;
8160 case OPCODE_CLEAR_STENCIL:
8161 CALL_ClearStencil(ctx->Exec, (n[1].i));
8162 break;
8163 case OPCODE_CLIP_PLANE:
8164 {
8165 GLdouble eq[4];
8166 eq[0] = n[2].f;
8167 eq[1] = n[3].f;
8168 eq[2] = n[4].f;
8169 eq[3] = n[5].f;
8170 CALL_ClipPlane(ctx->Exec, (n[1].e, eq));
8171 }
8172 break;
8173 case OPCODE_COLOR_MASK:
8174 CALL_ColorMask(ctx->Exec, (n[1].b, n[2].b, n[3].b, n[4].b));
8175 break;
8176 case OPCODE_COLOR_MASK_INDEXED:
8177 CALL_ColorMaski(ctx->Exec, (n[1].ui, n[2].b, n[3].b,
8178 n[4].b, n[5].b));
8179 break;
8180 case OPCODE_COLOR_MATERIAL:
8181 CALL_ColorMaterial(ctx->Exec, (n[1].e, n[2].e));
8182 break;
8183 case OPCODE_COPY_PIXELS:
8184 CALL_CopyPixels(ctx->Exec, (n[1].i, n[2].i,
8185 (GLsizei) n[3].i, (GLsizei) n[4].i,
8186 n[5].e));
8187 break;
8188 case OPCODE_COPY_TEX_IMAGE1D:
8189 CALL_CopyTexImage1D(ctx->Exec, (n[1].e, n[2].i, n[3].e, n[4].i,
8190 n[5].i, n[6].i, n[7].i));
8191 break;
8192 case OPCODE_COPY_TEX_IMAGE2D:
8193 CALL_CopyTexImage2D(ctx->Exec, (n[1].e, n[2].i, n[3].e, n[4].i,
8194 n[5].i, n[6].i, n[7].i, n[8].i));
8195 break;
8196 case OPCODE_COPY_TEX_SUB_IMAGE1D:
8197 CALL_CopyTexSubImage1D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
8198 n[4].i, n[5].i, n[6].i));
8199 break;
8200 case OPCODE_COPY_TEX_SUB_IMAGE2D:
8201 CALL_CopyTexSubImage2D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
8202 n[4].i, n[5].i, n[6].i, n[7].i,
8203 n[8].i));
8204 break;
8205 case OPCODE_COPY_TEX_SUB_IMAGE3D:
8206 CALL_CopyTexSubImage3D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
8207 n[4].i, n[5].i, n[6].i, n[7].i,
8208 n[8].i, n[9].i));
8209 break;
8210 case OPCODE_CULL_FACE:
8211 CALL_CullFace(ctx->Exec, (n[1].e));
8212 break;
8213 case OPCODE_DEPTH_FUNC:
8214 CALL_DepthFunc(ctx->Exec, (n[1].e));
8215 break;
8216 case OPCODE_DEPTH_MASK:
8217 CALL_DepthMask(ctx->Exec, (n[1].b));
8218 break;
8219 case OPCODE_DEPTH_RANGE:
8220 CALL_DepthRange(ctx->Exec,
8221 ((GLclampd) n[1].f, (GLclampd) n[2].f));
8222 break;
8223 case OPCODE_DISABLE:
8224 CALL_Disable(ctx->Exec, (n[1].e));
8225 break;
8226 case OPCODE_DISABLE_INDEXED:
8227 CALL_Disablei(ctx->Exec, (n[1].ui, n[2].e));
8228 break;
8229 case OPCODE_DRAW_BUFFER:
8230 CALL_DrawBuffer(ctx->Exec, (n[1].e));
8231 break;
8232 case OPCODE_DRAW_PIXELS:
8233 {
8234 const struct gl_pixelstore_attrib save = ctx->Unpack;
8235 ctx->Unpack = ctx->DefaultPacking;
8236 CALL_DrawPixels(ctx->Exec, (n[1].i, n[2].i, n[3].e, n[4].e,
8237 get_pointer(&n[5])));
8238 ctx->Unpack = save; /* restore */
8239 }
8240 break;
8241 case OPCODE_ENABLE:
8242 CALL_Enable(ctx->Exec, (n[1].e));
8243 break;
8244 case OPCODE_ENABLE_INDEXED:
8245 CALL_Enablei(ctx->Exec, (n[1].ui, n[2].e));
8246 break;
8247 case OPCODE_EVALMESH1:
8248 CALL_EvalMesh1(ctx->Exec, (n[1].e, n[2].i, n[3].i));
8249 break;
8250 case OPCODE_EVALMESH2:
8251 CALL_EvalMesh2(ctx->Exec,
8252 (n[1].e, n[2].i, n[3].i, n[4].i, n[5].i));
8253 break;
8254 case OPCODE_FOG:
8255 {
8256 GLfloat p[4];
8257 p[0] = n[2].f;
8258 p[1] = n[3].f;
8259 p[2] = n[4].f;
8260 p[3] = n[5].f;
8261 CALL_Fogfv(ctx->Exec, (n[1].e, p));
8262 }
8263 break;
8264 case OPCODE_FRONT_FACE:
8265 CALL_FrontFace(ctx->Exec, (n[1].e));
8266 break;
8267 case OPCODE_FRUSTUM:
8268 CALL_Frustum(ctx->Exec,
8269 (n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f));
8270 break;
8271 case OPCODE_HINT:
8272 CALL_Hint(ctx->Exec, (n[1].e, n[2].e));
8273 break;
8274 case OPCODE_INDEX_MASK:
8275 CALL_IndexMask(ctx->Exec, (n[1].ui));
8276 break;
8277 case OPCODE_INIT_NAMES:
8278 CALL_InitNames(ctx->Exec, ());
8279 break;
8280 case OPCODE_LIGHT:
8281 {
8282 GLfloat p[4];
8283 p[0] = n[3].f;
8284 p[1] = n[4].f;
8285 p[2] = n[5].f;
8286 p[3] = n[6].f;
8287 CALL_Lightfv(ctx->Exec, (n[1].e, n[2].e, p));
8288 }
8289 break;
8290 case OPCODE_LIGHT_MODEL:
8291 {
8292 GLfloat p[4];
8293 p[0] = n[2].f;
8294 p[1] = n[3].f;
8295 p[2] = n[4].f;
8296 p[3] = n[5].f;
8297 CALL_LightModelfv(ctx->Exec, (n[1].e, p));
8298 }
8299 break;
8300 case OPCODE_LINE_STIPPLE:
8301 CALL_LineStipple(ctx->Exec, (n[1].i, n[2].us));
8302 break;
8303 case OPCODE_LINE_WIDTH:
8304 CALL_LineWidth(ctx->Exec, (n[1].f));
8305 break;
8306 case OPCODE_LIST_BASE:
8307 CALL_ListBase(ctx->Exec, (n[1].ui));
8308 break;
8309 case OPCODE_LOAD_IDENTITY:
8310 CALL_LoadIdentity(ctx->Exec, ());
8311 break;
8312 case OPCODE_LOAD_MATRIX:
8313 STATIC_ASSERT(sizeof(Node) == sizeof(GLfloat));
8314 CALL_LoadMatrixf(ctx->Exec, (&n[1].f));
8315 break;
8316 case OPCODE_LOAD_NAME:
8317 CALL_LoadName(ctx->Exec, (n[1].ui));
8318 break;
8319 case OPCODE_LOGIC_OP:
8320 CALL_LogicOp(ctx->Exec, (n[1].e));
8321 break;
8322 case OPCODE_MAP1:
8323 {
8324 GLenum target = n[1].e;
8325 GLint ustride = _mesa_evaluator_components(target);
8326 GLint uorder = n[5].i;
8327 GLfloat u1 = n[2].f;
8328 GLfloat u2 = n[3].f;
8329 CALL_Map1f(ctx->Exec, (target, u1, u2, ustride, uorder,
8330 (GLfloat *) get_pointer(&n[6])));
8331 }
8332 break;
8333 case OPCODE_MAP2:
8334 {
8335 GLenum target = n[1].e;
8336 GLfloat u1 = n[2].f;
8337 GLfloat u2 = n[3].f;
8338 GLfloat v1 = n[4].f;
8339 GLfloat v2 = n[5].f;
8340 GLint ustride = n[6].i;
8341 GLint vstride = n[7].i;
8342 GLint uorder = n[8].i;
8343 GLint vorder = n[9].i;
8344 CALL_Map2f(ctx->Exec, (target, u1, u2, ustride, uorder,
8345 v1, v2, vstride, vorder,
8346 (GLfloat *) get_pointer(&n[10])));
8347 }
8348 break;
8349 case OPCODE_MAPGRID1:
8350 CALL_MapGrid1f(ctx->Exec, (n[1].i, n[2].f, n[3].f));
8351 break;
8352 case OPCODE_MAPGRID2:
8353 CALL_MapGrid2f(ctx->Exec,
8354 (n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f));
8355 break;
8356 case OPCODE_MATRIX_MODE:
8357 CALL_MatrixMode(ctx->Exec, (n[1].e));
8358 break;
8359 case OPCODE_MULT_MATRIX:
8360 CALL_MultMatrixf(ctx->Exec, (&n[1].f));
8361 break;
8362 case OPCODE_ORTHO:
8363 CALL_Ortho(ctx->Exec,
8364 (n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f));
8365 break;
8366 case OPCODE_PASSTHROUGH:
8367 CALL_PassThrough(ctx->Exec, (n[1].f));
8368 break;
8369 case OPCODE_PIXEL_MAP:
8370 CALL_PixelMapfv(ctx->Exec,
8371 (n[1].e, n[2].i, get_pointer(&n[3])));
8372 break;
8373 case OPCODE_PIXEL_TRANSFER:
8374 CALL_PixelTransferf(ctx->Exec, (n[1].e, n[2].f));
8375 break;
8376 case OPCODE_PIXEL_ZOOM:
8377 CALL_PixelZoom(ctx->Exec, (n[1].f, n[2].f));
8378 break;
8379 case OPCODE_POINT_SIZE:
8380 CALL_PointSize(ctx->Exec, (n[1].f));
8381 break;
8382 case OPCODE_POINT_PARAMETERS:
8383 {
8384 GLfloat params[3];
8385 params[0] = n[2].f;
8386 params[1] = n[3].f;
8387 params[2] = n[4].f;
8388 CALL_PointParameterfv(ctx->Exec, (n[1].e, params));
8389 }
8390 break;
8391 case OPCODE_POLYGON_MODE:
8392 CALL_PolygonMode(ctx->Exec, (n[1].e, n[2].e));
8393 break;
8394 case OPCODE_POLYGON_STIPPLE:
8395 {
8396 const struct gl_pixelstore_attrib save = ctx->Unpack;
8397 ctx->Unpack = ctx->DefaultPacking;
8398 CALL_PolygonStipple(ctx->Exec, (get_pointer(&n[1])));
8399 ctx->Unpack = save; /* restore */
8400 }
8401 break;
8402 case OPCODE_POLYGON_OFFSET:
8403 CALL_PolygonOffset(ctx->Exec, (n[1].f, n[2].f));
8404 break;
8405 case OPCODE_POLYGON_OFFSET_CLAMP:
8406 CALL_PolygonOffsetClampEXT(ctx->Exec, (n[1].f, n[2].f, n[3].f));
8407 break;
8408 case OPCODE_POP_ATTRIB:
8409 CALL_PopAttrib(ctx->Exec, ());
8410 break;
8411 case OPCODE_POP_MATRIX:
8412 CALL_PopMatrix(ctx->Exec, ());
8413 break;
8414 case OPCODE_POP_NAME:
8415 CALL_PopName(ctx->Exec, ());
8416 break;
8417 case OPCODE_PRIORITIZE_TEXTURE:
8418 CALL_PrioritizeTextures(ctx->Exec, (1, &n[1].ui, &n[2].f));
8419 break;
8420 case OPCODE_PUSH_ATTRIB:
8421 CALL_PushAttrib(ctx->Exec, (n[1].bf));
8422 break;
8423 case OPCODE_PUSH_MATRIX:
8424 CALL_PushMatrix(ctx->Exec, ());
8425 break;
8426 case OPCODE_PUSH_NAME:
8427 CALL_PushName(ctx->Exec, (n[1].ui));
8428 break;
8429 case OPCODE_RASTER_POS:
8430 CALL_RasterPos4f(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
8431 break;
8432 case OPCODE_READ_BUFFER:
8433 CALL_ReadBuffer(ctx->Exec, (n[1].e));
8434 break;
8435 case OPCODE_ROTATE:
8436 CALL_Rotatef(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
8437 break;
8438 case OPCODE_SCALE:
8439 CALL_Scalef(ctx->Exec, (n[1].f, n[2].f, n[3].f));
8440 break;
8441 case OPCODE_SCISSOR:
8442 CALL_Scissor(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));
8443 break;
8444 case OPCODE_SHADE_MODEL:
8445 CALL_ShadeModel(ctx->Exec, (n[1].e));
8446 break;
8447 case OPCODE_PROVOKING_VERTEX:
8448 CALL_ProvokingVertex(ctx->Exec, (n[1].e));
8449 break;
8450 case OPCODE_STENCIL_FUNC:
8451 CALL_StencilFunc(ctx->Exec, (n[1].e, n[2].i, n[3].ui));
8452 break;
8453 case OPCODE_STENCIL_MASK:
8454 CALL_StencilMask(ctx->Exec, (n[1].ui));
8455 break;
8456 case OPCODE_STENCIL_OP:
8457 CALL_StencilOp(ctx->Exec, (n[1].e, n[2].e, n[3].e));
8458 break;
8459 case OPCODE_STENCIL_FUNC_SEPARATE:
8460 CALL_StencilFuncSeparate(ctx->Exec,
8461 (n[1].e, n[2].e, n[3].i, n[4].ui));
8462 break;
8463 case OPCODE_STENCIL_MASK_SEPARATE:
8464 CALL_StencilMaskSeparate(ctx->Exec, (n[1].e, n[2].ui));
8465 break;
8466 case OPCODE_STENCIL_OP_SEPARATE:
8467 CALL_StencilOpSeparate(ctx->Exec,
8468 (n[1].e, n[2].e, n[3].e, n[4].e));
8469 break;
8470 case OPCODE_TEXENV:
8471 {
8472 GLfloat params[4];
8473 params[0] = n[3].f;
8474 params[1] = n[4].f;
8475 params[2] = n[5].f;
8476 params[3] = n[6].f;
8477 CALL_TexEnvfv(ctx->Exec, (n[1].e, n[2].e, params));
8478 }
8479 break;
8480 case OPCODE_TEXGEN:
8481 {
8482 GLfloat params[4];
8483 params[0] = n[3].f;
8484 params[1] = n[4].f;
8485 params[2] = n[5].f;
8486 params[3] = n[6].f;
8487 CALL_TexGenfv(ctx->Exec, (n[1].e, n[2].e, params));
8488 }
8489 break;
8490 case OPCODE_TEXPARAMETER:
8491 {
8492 GLfloat params[4];
8493 params[0] = n[3].f;
8494 params[1] = n[4].f;
8495 params[2] = n[5].f;
8496 params[3] = n[6].f;
8497 CALL_TexParameterfv(ctx->Exec, (n[1].e, n[2].e, params));
8498 }
8499 break;
8500 case OPCODE_TEX_IMAGE1D:
8501 {
8502 const struct gl_pixelstore_attrib save = ctx->Unpack;
8503 ctx->Unpack = ctx->DefaultPacking;
8504 CALL_TexImage1D(ctx->Exec, (n[1].e, /* target */
8505 n[2].i, /* level */
8506 n[3].i, /* components */
8507 n[4].i, /* width */
8508 n[5].e, /* border */
8509 n[6].e, /* format */
8510 n[7].e, /* type */
8511 get_pointer(&n[8])));
8512 ctx->Unpack = save; /* restore */
8513 }
8514 break;
8515 case OPCODE_TEX_IMAGE2D:
8516 {
8517 const struct gl_pixelstore_attrib save = ctx->Unpack;
8518 ctx->Unpack = ctx->DefaultPacking;
8519 CALL_TexImage2D(ctx->Exec, (n[1].e, /* target */
8520 n[2].i, /* level */
8521 n[3].i, /* components */
8522 n[4].i, /* width */
8523 n[5].i, /* height */
8524 n[6].e, /* border */
8525 n[7].e, /* format */
8526 n[8].e, /* type */
8527 get_pointer(&n[9])));
8528 ctx->Unpack = save; /* restore */
8529 }
8530 break;
8531 case OPCODE_TEX_IMAGE3D:
8532 {
8533 const struct gl_pixelstore_attrib save = ctx->Unpack;
8534 ctx->Unpack = ctx->DefaultPacking;
8535 CALL_TexImage3D(ctx->Exec, (n[1].e, /* target */
8536 n[2].i, /* level */
8537 n[3].i, /* components */
8538 n[4].i, /* width */
8539 n[5].i, /* height */
8540 n[6].i, /* depth */
8541 n[7].e, /* border */
8542 n[8].e, /* format */
8543 n[9].e, /* type */
8544 get_pointer(&n[10])));
8545 ctx->Unpack = save; /* restore */
8546 }
8547 break;
8548 case OPCODE_TEX_SUB_IMAGE1D:
8549 {
8550 const struct gl_pixelstore_attrib save = ctx->Unpack;
8551 ctx->Unpack = ctx->DefaultPacking;
8552 CALL_TexSubImage1D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
8553 n[4].i, n[5].e,
8554 n[6].e, get_pointer(&n[7])));
8555 ctx->Unpack = save; /* restore */
8556 }
8557 break;
8558 case OPCODE_TEX_SUB_IMAGE2D:
8559 {
8560 const struct gl_pixelstore_attrib save = ctx->Unpack;
8561 ctx->Unpack = ctx->DefaultPacking;
8562 CALL_TexSubImage2D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
8563 n[4].i, n[5].e,
8564 n[6].i, n[7].e, n[8].e,
8565 get_pointer(&n[9])));
8566 ctx->Unpack = save; /* restore */
8567 }
8568 break;
8569 case OPCODE_TEX_SUB_IMAGE3D:
8570 {
8571 const struct gl_pixelstore_attrib save = ctx->Unpack;
8572 ctx->Unpack = ctx->DefaultPacking;
8573 CALL_TexSubImage3D(ctx->Exec, (n[1].e, n[2].i, n[3].i,
8574 n[4].i, n[5].i, n[6].i, n[7].i,
8575 n[8].i, n[9].e, n[10].e,
8576 get_pointer(&n[11])));
8577 ctx->Unpack = save; /* restore */
8578 }
8579 break;
8580 case OPCODE_TRANSLATE:
8581 CALL_Translatef(ctx->Exec, (n[1].f, n[2].f, n[3].f));
8582 break;
8583 case OPCODE_VIEWPORT:
8584 CALL_Viewport(ctx->Exec, (n[1].i, n[2].i,
8585 (GLsizei) n[3].i, (GLsizei) n[4].i));
8586 break;
8587 case OPCODE_WINDOW_POS:
8588 CALL_WindowPos4fMESA(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
8589 break;
8590 case OPCODE_ACTIVE_TEXTURE: /* GL_ARB_multitexture */
8591 CALL_ActiveTexture(ctx->Exec, (n[1].e));
8592 break;
8593 case OPCODE_COMPRESSED_TEX_IMAGE_1D: /* GL_ARB_texture_compression */
8594 CALL_CompressedTexImage1D(ctx->Exec, (n[1].e, n[2].i, n[3].e,
8595 n[4].i, n[5].i, n[6].i,
8596 get_pointer(&n[7])));
8597 break;
8598 case OPCODE_COMPRESSED_TEX_IMAGE_2D: /* GL_ARB_texture_compression */
8599 CALL_CompressedTexImage2D(ctx->Exec, (n[1].e, n[2].i, n[3].e,
8600 n[4].i, n[5].i, n[6].i,
8601 n[7].i, get_pointer(&n[8])));
8602 break;
8603 case OPCODE_COMPRESSED_TEX_IMAGE_3D: /* GL_ARB_texture_compression */
8604 CALL_CompressedTexImage3D(ctx->Exec, (n[1].e, n[2].i, n[3].e,
8605 n[4].i, n[5].i, n[6].i,
8606 n[7].i, n[8].i,
8607 get_pointer(&n[9])));
8608 break;
8609 case OPCODE_COMPRESSED_TEX_SUB_IMAGE_1D: /* GL_ARB_texture_compress */
8610 CALL_CompressedTexSubImage1D(ctx->Exec,
8611 (n[1].e, n[2].i, n[3].i, n[4].i,
8612 n[5].e, n[6].i,
8613 get_pointer(&n[7])));
8614 break;
8615 case OPCODE_COMPRESSED_TEX_SUB_IMAGE_2D: /* GL_ARB_texture_compress */
8616 CALL_CompressedTexSubImage2D(ctx->Exec,
8617 (n[1].e, n[2].i, n[3].i, n[4].i,
8618 n[5].i, n[6].i, n[7].e, n[8].i,
8619 get_pointer(&n[9])));
8620 break;
8621 case OPCODE_COMPRESSED_TEX_SUB_IMAGE_3D: /* GL_ARB_texture_compress */
8622 CALL_CompressedTexSubImage3D(ctx->Exec,
8623 (n[1].e, n[2].i, n[3].i, n[4].i,
8624 n[5].i, n[6].i, n[7].i, n[8].i,
8625 n[9].e, n[10].i,
8626 get_pointer(&n[11])));
8627 break;
8628 case OPCODE_SAMPLE_COVERAGE: /* GL_ARB_multisample */
8629 CALL_SampleCoverage(ctx->Exec, (n[1].f, n[2].b));
8630 break;
8631 case OPCODE_WINDOW_POS_ARB: /* GL_ARB_window_pos */
8632 CALL_WindowPos3f(ctx->Exec, (n[1].f, n[2].f, n[3].f));
8633 break;
8634 case OPCODE_BIND_PROGRAM_ARB: /* GL_ARB_vertex_program */
8635 CALL_BindProgramARB(ctx->Exec, (n[1].e, n[2].ui));
8636 break;
8637 case OPCODE_PROGRAM_LOCAL_PARAMETER_ARB:
8638 CALL_ProgramLocalParameter4fARB(ctx->Exec,
8639 (n[1].e, n[2].ui, n[3].f, n[4].f,
8640 n[5].f, n[6].f));
8641 break;
8642 case OPCODE_ACTIVE_STENCIL_FACE_EXT:
8643 CALL_ActiveStencilFaceEXT(ctx->Exec, (n[1].e));
8644 break;
8645 case OPCODE_DEPTH_BOUNDS_EXT:
8646 CALL_DepthBoundsEXT(ctx->Exec, (n[1].f, n[2].f));
8647 break;
8648 case OPCODE_PROGRAM_STRING_ARB:
8649 CALL_ProgramStringARB(ctx->Exec,
8650 (n[1].e, n[2].e, n[3].i,
8651 get_pointer(&n[4])));
8652 break;
8653 case OPCODE_PROGRAM_ENV_PARAMETER_ARB:
8654 CALL_ProgramEnvParameter4fARB(ctx->Exec, (n[1].e, n[2].ui, n[3].f,
8655 n[4].f, n[5].f,
8656 n[6].f));
8657 break;
8658 case OPCODE_BEGIN_QUERY_ARB:
8659 CALL_BeginQuery(ctx->Exec, (n[1].e, n[2].ui));
8660 break;
8661 case OPCODE_END_QUERY_ARB:
8662 CALL_EndQuery(ctx->Exec, (n[1].e));
8663 break;
8664 case OPCODE_QUERY_COUNTER:
8665 CALL_QueryCounter(ctx->Exec, (n[1].ui, n[2].e));
8666 break;
8667 case OPCODE_BEGIN_QUERY_INDEXED:
8668 CALL_BeginQueryIndexed(ctx->Exec, (n[1].e, n[2].ui, n[3].ui));
8669 break;
8670 case OPCODE_END_QUERY_INDEXED:
8671 CALL_EndQueryIndexed(ctx->Exec, (n[1].e, n[2].ui));
8672 break;
8673 case OPCODE_DRAW_BUFFERS_ARB:
8674 {
8675 GLenum buffers[MAX_DRAW_BUFFERS];
8676 GLint i, count = MIN2(n[1].i, MAX_DRAW_BUFFERS);
8677 for (i = 0; i < count; i++)
8678 buffers[i] = n[2 + i].e;
8679 CALL_DrawBuffers(ctx->Exec, (n[1].i, buffers));
8680 }
8681 break;
8682 case OPCODE_BLIT_FRAMEBUFFER:
8683 CALL_BlitFramebuffer(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i,
8684 n[5].i, n[6].i, n[7].i, n[8].i,
8685 n[9].i, n[10].e));
8686 break;
8687 case OPCODE_PRIMITIVE_RESTART_NV:
8688 CALL_PrimitiveRestartNV(ctx->Exec, ());
8689 break;
8690
8691 case OPCODE_USE_PROGRAM:
8692 CALL_UseProgram(ctx->Exec, (n[1].ui));
8693 break;
8694 case OPCODE_UNIFORM_1F:
8695 CALL_Uniform1f(ctx->Exec, (n[1].i, n[2].f));
8696 break;
8697 case OPCODE_UNIFORM_2F:
8698 CALL_Uniform2f(ctx->Exec, (n[1].i, n[2].f, n[3].f));
8699 break;
8700 case OPCODE_UNIFORM_3F:
8701 CALL_Uniform3f(ctx->Exec, (n[1].i, n[2].f, n[3].f, n[4].f));
8702 break;
8703 case OPCODE_UNIFORM_4F:
8704 CALL_Uniform4f(ctx->Exec,
8705 (n[1].i, n[2].f, n[3].f, n[4].f, n[5].f));
8706 break;
8707 case OPCODE_UNIFORM_1FV:
8708 CALL_Uniform1fv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
8709 break;
8710 case OPCODE_UNIFORM_2FV:
8711 CALL_Uniform2fv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
8712 break;
8713 case OPCODE_UNIFORM_3FV:
8714 CALL_Uniform3fv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
8715 break;
8716 case OPCODE_UNIFORM_4FV:
8717 CALL_Uniform4fv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
8718 break;
8719 case OPCODE_UNIFORM_1I:
8720 CALL_Uniform1i(ctx->Exec, (n[1].i, n[2].i));
8721 break;
8722 case OPCODE_UNIFORM_2I:
8723 CALL_Uniform2i(ctx->Exec, (n[1].i, n[2].i, n[3].i));
8724 break;
8725 case OPCODE_UNIFORM_3I:
8726 CALL_Uniform3i(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));
8727 break;
8728 case OPCODE_UNIFORM_4I:
8729 CALL_Uniform4i(ctx->Exec,
8730 (n[1].i, n[2].i, n[3].i, n[4].i, n[5].i));
8731 break;
8732 case OPCODE_UNIFORM_1IV:
8733 CALL_Uniform1iv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
8734 break;
8735 case OPCODE_UNIFORM_2IV:
8736 CALL_Uniform2iv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
8737 break;
8738 case OPCODE_UNIFORM_3IV:
8739 CALL_Uniform3iv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
8740 break;
8741 case OPCODE_UNIFORM_4IV:
8742 CALL_Uniform4iv(ctx->Exec, (n[1].i, n[2].i, get_pointer(&n[3])));
8743 break;
8744 case OPCODE_UNIFORM_1UI:
8745 /*CALL_Uniform1uiARB(ctx->Exec, (n[1].i, n[2].i));*/
8746 break;
8747 case OPCODE_UNIFORM_2UI:
8748 /*CALL_Uniform2uiARB(ctx->Exec, (n[1].i, n[2].i, n[3].i));*/
8749 break;
8750 case OPCODE_UNIFORM_3UI:
8751 /*CALL_Uniform3uiARB(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));*/
8752 break;
8753 case OPCODE_UNIFORM_4UI:
8754 /*CALL_Uniform4uiARB(ctx->Exec,
8755 (n[1].i, n[2].i, n[3].i, n[4].i, n[5].i));
8756 */
8757 break;
8758 case OPCODE_UNIFORM_1UIV:
8759 /*CALL_Uniform1uivARB(ctx->Exec, (n[1].i, n[2].i,
8760 get_pointer(&n[3])));*/
8761 break;
8762 case OPCODE_UNIFORM_2UIV:
8763 /*CALL_Uniform2uivARB(ctx->Exec, (n[1].i, n[2].i,
8764 get_pointer(&n[3])));*/
8765 break;
8766 case OPCODE_UNIFORM_3UIV:
8767 /*CALL_Uniform3uivARB(ctx->Exec, (n[1].i, n[2].i,
8768 get_pointer(&n[3])));*/
8769 break;
8770 case OPCODE_UNIFORM_4UIV:
8771 /*CALL_Uniform4uivARB(ctx->Exec, (n[1].i, n[2].i,
8772 get_pointer(&n[3])));*/
8773 break;
8774 case OPCODE_UNIFORM_MATRIX22:
8775 CALL_UniformMatrix2fv(ctx->Exec,
8776 (n[1].i, n[2].i, n[3].b, get_pointer(&n[4])));
8777 break;
8778 case OPCODE_UNIFORM_MATRIX33:
8779 CALL_UniformMatrix3fv(ctx->Exec,
8780 (n[1].i, n[2].i, n[3].b, get_pointer(&n[4])));
8781 break;
8782 case OPCODE_UNIFORM_MATRIX44:
8783 CALL_UniformMatrix4fv(ctx->Exec,
8784 (n[1].i, n[2].i, n[3].b, get_pointer(&n[4])));
8785 break;
8786 case OPCODE_UNIFORM_MATRIX23:
8787 CALL_UniformMatrix2x3fv(ctx->Exec,
8788 (n[1].i, n[2].i, n[3].b, get_pointer(&n[4])));
8789 break;
8790 case OPCODE_UNIFORM_MATRIX32:
8791 CALL_UniformMatrix3x2fv(ctx->Exec,
8792 (n[1].i, n[2].i, n[3].b, get_pointer(&n[4])));
8793 break;
8794 case OPCODE_UNIFORM_MATRIX24:
8795 CALL_UniformMatrix2x4fv(ctx->Exec,
8796 (n[1].i, n[2].i, n[3].b, get_pointer(&n[4])));
8797 break;
8798 case OPCODE_UNIFORM_MATRIX42:
8799 CALL_UniformMatrix4x2fv(ctx->Exec,
8800 (n[1].i, n[2].i, n[3].b, get_pointer(&n[4])));
8801 break;
8802 case OPCODE_UNIFORM_MATRIX34:
8803 CALL_UniformMatrix3x4fv(ctx->Exec,
8804 (n[1].i, n[2].i, n[3].b, get_pointer(&n[4])));
8805 break;
8806 case OPCODE_UNIFORM_MATRIX43:
8807 CALL_UniformMatrix4x3fv(ctx->Exec,
8808 (n[1].i, n[2].i, n[3].b, get_pointer(&n[4])));
8809 break;
8810
8811 case OPCODE_USE_PROGRAM_STAGES:
8812 CALL_UseProgramStages(ctx->Exec, (n[1].ui, n[2].ui, n[3].ui));
8813 break;
8814 case OPCODE_PROGRAM_UNIFORM_1F:
8815 CALL_ProgramUniform1f(ctx->Exec, (n[1].ui, n[2].i, n[3].f));
8816 break;
8817 case OPCODE_PROGRAM_UNIFORM_2F:
8818 CALL_ProgramUniform2f(ctx->Exec, (n[1].ui, n[2].i, n[3].f, n[4].f));
8819 break;
8820 case OPCODE_PROGRAM_UNIFORM_3F:
8821 CALL_ProgramUniform3f(ctx->Exec, (n[1].ui, n[2].i,
8822 n[3].f, n[4].f, n[5].f));
8823 break;
8824 case OPCODE_PROGRAM_UNIFORM_4F:
8825 CALL_ProgramUniform4f(ctx->Exec, (n[1].ui, n[2].i,
8826 n[3].f, n[4].f, n[5].f, n[6].f));
8827 break;
8828 case OPCODE_PROGRAM_UNIFORM_1FV:
8829 CALL_ProgramUniform1fv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
8830 get_pointer(&n[4])));
8831 break;
8832 case OPCODE_PROGRAM_UNIFORM_2FV:
8833 CALL_ProgramUniform2fv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
8834 get_pointer(&n[4])));
8835 break;
8836 case OPCODE_PROGRAM_UNIFORM_3FV:
8837 CALL_ProgramUniform3fv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
8838 get_pointer(&n[4])));
8839 break;
8840 case OPCODE_PROGRAM_UNIFORM_4FV:
8841 CALL_ProgramUniform4fv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
8842 get_pointer(&n[4])));
8843 break;
8844 case OPCODE_PROGRAM_UNIFORM_1I:
8845 CALL_ProgramUniform1i(ctx->Exec, (n[1].ui, n[2].i, n[3].i));
8846 break;
8847 case OPCODE_PROGRAM_UNIFORM_2I:
8848 CALL_ProgramUniform2i(ctx->Exec, (n[1].ui, n[2].i, n[3].i, n[4].i));
8849 break;
8850 case OPCODE_PROGRAM_UNIFORM_3I:
8851 CALL_ProgramUniform3i(ctx->Exec, (n[1].ui, n[2].i,
8852 n[3].i, n[4].i, n[5].i));
8853 break;
8854 case OPCODE_PROGRAM_UNIFORM_4I:
8855 CALL_ProgramUniform4i(ctx->Exec, (n[1].ui, n[2].i,
8856 n[3].i, n[4].i, n[5].i, n[6].i));
8857 break;
8858 case OPCODE_PROGRAM_UNIFORM_1IV:
8859 CALL_ProgramUniform1iv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
8860 get_pointer(&n[4])));
8861 break;
8862 case OPCODE_PROGRAM_UNIFORM_2IV:
8863 CALL_ProgramUniform2iv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
8864 get_pointer(&n[4])));
8865 break;
8866 case OPCODE_PROGRAM_UNIFORM_3IV:
8867 CALL_ProgramUniform3iv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
8868 get_pointer(&n[4])));
8869 break;
8870 case OPCODE_PROGRAM_UNIFORM_4IV:
8871 CALL_ProgramUniform4iv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
8872 get_pointer(&n[4])));
8873 break;
8874 case OPCODE_PROGRAM_UNIFORM_1UI:
8875 CALL_ProgramUniform1ui(ctx->Exec, (n[1].ui, n[2].i, n[3].ui));
8876 break;
8877 case OPCODE_PROGRAM_UNIFORM_2UI:
8878 CALL_ProgramUniform2ui(ctx->Exec, (n[1].ui, n[2].i,
8879 n[3].ui, n[4].ui));
8880 break;
8881 case OPCODE_PROGRAM_UNIFORM_3UI:
8882 CALL_ProgramUniform3ui(ctx->Exec, (n[1].ui, n[2].i,
8883 n[3].ui, n[4].ui, n[5].ui));
8884 break;
8885 case OPCODE_PROGRAM_UNIFORM_4UI:
8886 CALL_ProgramUniform4ui(ctx->Exec, (n[1].ui, n[2].i,
8887 n[3].ui,
8888 n[4].ui, n[5].ui, n[6].ui));
8889 break;
8890 case OPCODE_PROGRAM_UNIFORM_1UIV:
8891 CALL_ProgramUniform1uiv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
8892 get_pointer(&n[4])));
8893 break;
8894 case OPCODE_PROGRAM_UNIFORM_2UIV:
8895 CALL_ProgramUniform2uiv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
8896 get_pointer(&n[4])));
8897 break;
8898 case OPCODE_PROGRAM_UNIFORM_3UIV:
8899 CALL_ProgramUniform3uiv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
8900 get_pointer(&n[4])));
8901 break;
8902 case OPCODE_PROGRAM_UNIFORM_4UIV:
8903 CALL_ProgramUniform4uiv(ctx->Exec, (n[1].ui, n[2].i, n[3].i,
8904 get_pointer(&n[4])));
8905 break;
8906 case OPCODE_PROGRAM_UNIFORM_MATRIX22F:
8907 CALL_ProgramUniformMatrix2fv(ctx->Exec,
8908 (n[1].ui, n[2].i, n[3].i, n[4].b,
8909 get_pointer(&n[5])));
8910 break;
8911 case OPCODE_PROGRAM_UNIFORM_MATRIX23F:
8912 CALL_ProgramUniformMatrix2x3fv(ctx->Exec,
8913 (n[1].ui, n[2].i, n[3].i, n[4].b,
8914 get_pointer(&n[5])));
8915 break;
8916 case OPCODE_PROGRAM_UNIFORM_MATRIX24F:
8917 CALL_ProgramUniformMatrix2x4fv(ctx->Exec,
8918 (n[1].ui, n[2].i, n[3].i, n[4].b,
8919 get_pointer(&n[5])));
8920 break;
8921 case OPCODE_PROGRAM_UNIFORM_MATRIX32F:
8922 CALL_ProgramUniformMatrix3x2fv(ctx->Exec,
8923 (n[1].ui, n[2].i, n[3].i, n[4].b,
8924 get_pointer(&n[5])));
8925 break;
8926 case OPCODE_PROGRAM_UNIFORM_MATRIX33F:
8927 CALL_ProgramUniformMatrix3fv(ctx->Exec,
8928 (n[1].ui, n[2].i, n[3].i, n[4].b,
8929 get_pointer(&n[5])));
8930 break;
8931 case OPCODE_PROGRAM_UNIFORM_MATRIX34F:
8932 CALL_ProgramUniformMatrix3x4fv(ctx->Exec,
8933 (n[1].ui, n[2].i, n[3].i, n[4].b,
8934 get_pointer(&n[5])));
8935 break;
8936 case OPCODE_PROGRAM_UNIFORM_MATRIX42F:
8937 CALL_ProgramUniformMatrix4x2fv(ctx->Exec,
8938 (n[1].ui, n[2].i, n[3].i, n[4].b,
8939 get_pointer(&n[5])));
8940 break;
8941 case OPCODE_PROGRAM_UNIFORM_MATRIX43F:
8942 CALL_ProgramUniformMatrix4x3fv(ctx->Exec,
8943 (n[1].ui, n[2].i, n[3].i, n[4].b,
8944 get_pointer(&n[5])));
8945 break;
8946 case OPCODE_PROGRAM_UNIFORM_MATRIX44F:
8947 CALL_ProgramUniformMatrix4fv(ctx->Exec,
8948 (n[1].ui, n[2].i, n[3].i, n[4].b,
8949 get_pointer(&n[5])));
8950 break;
8951
8952 case OPCODE_CLIP_CONTROL:
8953 CALL_ClipControl(ctx->Exec, (n[1].e, n[2].e));
8954 break;
8955
8956 case OPCODE_CLAMP_COLOR:
8957 CALL_ClampColor(ctx->Exec, (n[1].e, n[2].e));
8958 break;
8959
8960 case OPCODE_BIND_FRAGMENT_SHADER_ATI:
8961 CALL_BindFragmentShaderATI(ctx->Exec, (n[1].i));
8962 break;
8963 case OPCODE_SET_FRAGMENT_SHADER_CONSTANTS_ATI:
8964 CALL_SetFragmentShaderConstantATI(ctx->Exec, (n[1].ui, &n[2].f));
8965 break;
8966 case OPCODE_ATTR_1F_NV:
8967 CALL_VertexAttrib1fNV(ctx->Exec, (n[1].e, n[2].f));
8968 break;
8969 case OPCODE_ATTR_2F_NV:
8970 CALL_VertexAttrib2fvNV(ctx->Exec, (n[1].e, &n[2].f));
8971 break;
8972 case OPCODE_ATTR_3F_NV:
8973 CALL_VertexAttrib3fvNV(ctx->Exec, (n[1].e, &n[2].f));
8974 break;
8975 case OPCODE_ATTR_4F_NV:
8976 CALL_VertexAttrib4fvNV(ctx->Exec, (n[1].e, &n[2].f));
8977 break;
8978 case OPCODE_ATTR_1F_ARB:
8979 CALL_VertexAttrib1fARB(ctx->Exec, (n[1].e, n[2].f));
8980 break;
8981 case OPCODE_ATTR_2F_ARB:
8982 CALL_VertexAttrib2fvARB(ctx->Exec, (n[1].e, &n[2].f));
8983 break;
8984 case OPCODE_ATTR_3F_ARB:
8985 CALL_VertexAttrib3fvARB(ctx->Exec, (n[1].e, &n[2].f));
8986 break;
8987 case OPCODE_ATTR_4F_ARB:
8988 CALL_VertexAttrib4fvARB(ctx->Exec, (n[1].e, &n[2].f));
8989 break;
8990 case OPCODE_MATERIAL:
8991 CALL_Materialfv(ctx->Exec, (n[1].e, n[2].e, &n[3].f));
8992 break;
8993 case OPCODE_BEGIN:
8994 CALL_Begin(ctx->Exec, (n[1].e));
8995 break;
8996 case OPCODE_END:
8997 CALL_End(ctx->Exec, ());
8998 break;
8999 case OPCODE_RECTF:
9000 CALL_Rectf(ctx->Exec, (n[1].f, n[2].f, n[3].f, n[4].f));
9001 break;
9002 case OPCODE_EVAL_C1:
9003 CALL_EvalCoord1f(ctx->Exec, (n[1].f));
9004 break;
9005 case OPCODE_EVAL_C2:
9006 CALL_EvalCoord2f(ctx->Exec, (n[1].f, n[2].f));
9007 break;
9008 case OPCODE_EVAL_P1:
9009 CALL_EvalPoint1(ctx->Exec, (n[1].i));
9010 break;
9011 case OPCODE_EVAL_P2:
9012 CALL_EvalPoint2(ctx->Exec, (n[1].i, n[2].i));
9013 break;
9014
9015 /* GL_EXT_texture_integer */
9016 case OPCODE_CLEARCOLOR_I:
9017 CALL_ClearColorIiEXT(ctx->Exec, (n[1].i, n[2].i, n[3].i, n[4].i));
9018 break;
9019 case OPCODE_CLEARCOLOR_UI:
9020 CALL_ClearColorIuiEXT(ctx->Exec,
9021 (n[1].ui, n[2].ui, n[3].ui, n[4].ui));
9022 break;
9023 case OPCODE_TEXPARAMETER_I:
9024 {
9025 GLint params[4];
9026 params[0] = n[3].i;
9027 params[1] = n[4].i;
9028 params[2] = n[5].i;
9029 params[3] = n[6].i;
9030 CALL_TexParameterIiv(ctx->Exec, (n[1].e, n[2].e, params));
9031 }
9032 break;
9033 case OPCODE_TEXPARAMETER_UI:
9034 {
9035 GLuint params[4];
9036 params[0] = n[3].ui;
9037 params[1] = n[4].ui;
9038 params[2] = n[5].ui;
9039 params[3] = n[6].ui;
9040 CALL_TexParameterIuiv(ctx->Exec, (n[1].e, n[2].e, params));
9041 }
9042 break;
9043
9044 case OPCODE_VERTEX_ATTRIB_DIVISOR:
9045 /* GL_ARB_instanced_arrays */
9046 CALL_VertexAttribDivisor(ctx->Exec, (n[1].ui, n[2].ui));
9047 break;
9048
9049 case OPCODE_TEXTURE_BARRIER_NV:
9050 CALL_TextureBarrierNV(ctx->Exec, ());
9051 break;
9052
9053 /* GL_EXT/ARB_transform_feedback */
9054 case OPCODE_BEGIN_TRANSFORM_FEEDBACK:
9055 CALL_BeginTransformFeedback(ctx->Exec, (n[1].e));
9056 break;
9057 case OPCODE_END_TRANSFORM_FEEDBACK:
9058 CALL_EndTransformFeedback(ctx->Exec, ());
9059 break;
9060 case OPCODE_BIND_TRANSFORM_FEEDBACK:
9061 CALL_BindTransformFeedback(ctx->Exec, (n[1].e, n[2].ui));
9062 break;
9063 case OPCODE_PAUSE_TRANSFORM_FEEDBACK:
9064 CALL_PauseTransformFeedback(ctx->Exec, ());
9065 break;
9066 case OPCODE_RESUME_TRANSFORM_FEEDBACK:
9067 CALL_ResumeTransformFeedback(ctx->Exec, ());
9068 break;
9069 case OPCODE_DRAW_TRANSFORM_FEEDBACK:
9070 CALL_DrawTransformFeedback(ctx->Exec, (n[1].e, n[2].ui));
9071 break;
9072 case OPCODE_DRAW_TRANSFORM_FEEDBACK_STREAM:
9073 CALL_DrawTransformFeedbackStream(ctx->Exec,
9074 (n[1].e, n[2].ui, n[3].ui));
9075 break;
9076 case OPCODE_DRAW_TRANSFORM_FEEDBACK_INSTANCED:
9077 CALL_DrawTransformFeedbackInstanced(ctx->Exec,
9078 (n[1].e, n[2].ui, n[3].si));
9079 break;
9080 case OPCODE_DRAW_TRANSFORM_FEEDBACK_STREAM_INSTANCED:
9081 CALL_DrawTransformFeedbackStreamInstanced(ctx->Exec,
9082 (n[1].e, n[2].ui, n[3].ui, n[4].si));
9083 break;
9084
9085
9086 case OPCODE_BIND_SAMPLER:
9087 CALL_BindSampler(ctx->Exec, (n[1].ui, n[2].ui));
9088 break;
9089 case OPCODE_SAMPLER_PARAMETERIV:
9090 {
9091 GLint params[4];
9092 params[0] = n[3].i;
9093 params[1] = n[4].i;
9094 params[2] = n[5].i;
9095 params[3] = n[6].i;
9096 CALL_SamplerParameteriv(ctx->Exec, (n[1].ui, n[2].e, params));
9097 }
9098 break;
9099 case OPCODE_SAMPLER_PARAMETERFV:
9100 {
9101 GLfloat params[4];
9102 params[0] = n[3].f;
9103 params[1] = n[4].f;
9104 params[2] = n[5].f;
9105 params[3] = n[6].f;
9106 CALL_SamplerParameterfv(ctx->Exec, (n[1].ui, n[2].e, params));
9107 }
9108 break;
9109 case OPCODE_SAMPLER_PARAMETERIIV:
9110 {
9111 GLint params[4];
9112 params[0] = n[3].i;
9113 params[1] = n[4].i;
9114 params[2] = n[5].i;
9115 params[3] = n[6].i;
9116 CALL_SamplerParameterIiv(ctx->Exec, (n[1].ui, n[2].e, params));
9117 }
9118 break;
9119 case OPCODE_SAMPLER_PARAMETERUIV:
9120 {
9121 GLuint params[4];
9122 params[0] = n[3].ui;
9123 params[1] = n[4].ui;
9124 params[2] = n[5].ui;
9125 params[3] = n[6].ui;
9126 CALL_SamplerParameterIuiv(ctx->Exec, (n[1].ui, n[2].e, params));
9127 }
9128 break;
9129
9130 /* GL_ARB_sync */
9131 case OPCODE_WAIT_SYNC:
9132 {
9133 union uint64_pair p;
9134 p.uint32[0] = n[2].ui;
9135 p.uint32[1] = n[3].ui;
9136 CALL_WaitSync(ctx->Exec,
9137 (get_pointer(&n[4]), n[1].bf, p.uint64));
9138 }
9139 break;
9140
9141 /* GL_NV_conditional_render */
9142 case OPCODE_BEGIN_CONDITIONAL_RENDER:
9143 CALL_BeginConditionalRender(ctx->Exec, (n[1].i, n[2].e));
9144 break;
9145 case OPCODE_END_CONDITIONAL_RENDER:
9146 CALL_EndConditionalRender(ctx->Exec, ());
9147 break;
9148
9149 case OPCODE_UNIFORM_BLOCK_BINDING:
9150 CALL_UniformBlockBinding(ctx->Exec, (n[1].ui, n[2].ui, n[3].ui));
9151 break;
9152
9153 /* GL_EXT_window_rectangles */
9154 case OPCODE_WINDOW_RECTANGLES:
9155 CALL_WindowRectanglesEXT(
9156 ctx->Exec, (n[1].e, n[2].si, get_pointer(&n[3])));
9157 break;
9158
9159 case OPCODE_CONTINUE:
9160 n = (Node *) get_pointer(&n[1]);
9161 break;
9162 case OPCODE_NOP:
9163 /* no-op */
9164 break;
9165 case OPCODE_END_OF_LIST:
9166 done = GL_TRUE;
9167 break;
9168 default:
9169 {
9170 char msg[1000];
9171 _mesa_snprintf(msg, sizeof(msg), "Error in execute_list: opcode=%d",
9172 (int) opcode);
9173 _mesa_problem(ctx, "%s", msg);
9174 }
9175 done = GL_TRUE;
9176 }
9177
9178 /* increment n to point to next compiled command */
9179 if (opcode != OPCODE_CONTINUE) {
9180 n += InstSize[opcode];
9181 }
9182 }
9183 }
9184
9185 vbo_save_EndCallList(ctx);
9186
9187 ctx->ListState.CallDepth--;
9188 }
9189
9190
9191
9192 /**********************************************************************/
9193 /* GL functions */
9194 /**********************************************************************/
9195
9196 /**
9197 * Test if a display list number is valid.
9198 */
9199 GLboolean GLAPIENTRY
9200 _mesa_IsList(GLuint list)
9201 {
9202 GET_CURRENT_CONTEXT(ctx);
9203 FLUSH_VERTICES(ctx, 0); /* must be called before assert */
9204 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
9205 return islist(ctx, list);
9206 }
9207
9208
9209 /**
9210 * Delete a sequence of consecutive display lists.
9211 */
9212 void GLAPIENTRY
9213 _mesa_DeleteLists(GLuint list, GLsizei range)
9214 {
9215 GET_CURRENT_CONTEXT(ctx);
9216 GLuint i;
9217 FLUSH_VERTICES(ctx, 0); /* must be called before assert */
9218 ASSERT_OUTSIDE_BEGIN_END(ctx);
9219
9220 if (range < 0) {
9221 _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteLists");
9222 return;
9223 }
9224
9225 if (range > 1) {
9226 /* We may be deleting a set of bitmap lists. See if there's a
9227 * bitmap atlas to free.
9228 */
9229 struct gl_bitmap_atlas *atlas = lookup_bitmap_atlas(ctx, list);
9230 if (atlas) {
9231 _mesa_delete_bitmap_atlas(ctx, atlas);
9232 _mesa_HashRemove(ctx->Shared->BitmapAtlas, list);
9233 }
9234 }
9235
9236 for (i = list; i < list + range; i++) {
9237 destroy_list(ctx, i);
9238 }
9239 }
9240
9241
9242 /**
9243 * Return a display list number, n, such that lists n through n+range-1
9244 * are free.
9245 */
9246 GLuint GLAPIENTRY
9247 _mesa_GenLists(GLsizei range)
9248 {
9249 GET_CURRENT_CONTEXT(ctx);
9250 GLuint base;
9251 FLUSH_VERTICES(ctx, 0); /* must be called before assert */
9252 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, 0);
9253
9254 if (range < 0) {
9255 _mesa_error(ctx, GL_INVALID_VALUE, "glGenLists");
9256 return 0;
9257 }
9258 if (range == 0) {
9259 return 0;
9260 }
9261
9262 /*
9263 * Make this an atomic operation
9264 */
9265 _mesa_HashLockMutex(ctx->Shared->DisplayList);
9266
9267 base = _mesa_HashFindFreeKeyBlock(ctx->Shared->DisplayList, range);
9268 if (base) {
9269 /* reserve the list IDs by with empty/dummy lists */
9270 GLint i;
9271 for (i = 0; i < range; i++) {
9272 _mesa_HashInsertLocked(ctx->Shared->DisplayList, base + i,
9273 make_list(base + i, 1));
9274 }
9275 }
9276
9277 if (USE_BITMAP_ATLAS &&
9278 range > 16 &&
9279 ctx->Driver.DrawAtlasBitmaps) {
9280 /* "range > 16" is a rough heuristic to guess when glGenLists might be
9281 * used to allocate display lists for glXUseXFont or wglUseFontBitmaps.
9282 * Create the empty atlas now.
9283 */
9284 struct gl_bitmap_atlas *atlas = lookup_bitmap_atlas(ctx, base);
9285 if (!atlas) {
9286 atlas = alloc_bitmap_atlas(ctx, base);
9287 }
9288 if (atlas) {
9289 /* Atlas _should_ be new/empty now, but clobbering is OK */
9290 assert(atlas->numBitmaps == 0);
9291 atlas->numBitmaps = range;
9292 }
9293 }
9294
9295 _mesa_HashUnlockMutex(ctx->Shared->DisplayList);
9296
9297 return base;
9298 }
9299
9300
9301 /**
9302 * Begin a new display list.
9303 */
9304 void GLAPIENTRY
9305 _mesa_NewList(GLuint name, GLenum mode)
9306 {
9307 GET_CURRENT_CONTEXT(ctx);
9308
9309 FLUSH_CURRENT(ctx, 0); /* must be called before assert */
9310 ASSERT_OUTSIDE_BEGIN_END(ctx);
9311
9312 if (MESA_VERBOSE & VERBOSE_API)
9313 _mesa_debug(ctx, "glNewList %u %s\n", name,
9314 _mesa_enum_to_string(mode));
9315
9316 if (name == 0) {
9317 _mesa_error(ctx, GL_INVALID_VALUE, "glNewList");
9318 return;
9319 }
9320
9321 if (mode != GL_COMPILE && mode != GL_COMPILE_AND_EXECUTE) {
9322 _mesa_error(ctx, GL_INVALID_ENUM, "glNewList");
9323 return;
9324 }
9325
9326 if (ctx->ListState.CurrentList) {
9327 /* already compiling a display list */
9328 _mesa_error(ctx, GL_INVALID_OPERATION, "glNewList");
9329 return;
9330 }
9331
9332 ctx->CompileFlag = GL_TRUE;
9333 ctx->ExecuteFlag = (mode == GL_COMPILE_AND_EXECUTE);
9334
9335 /* Reset accumulated list state */
9336 invalidate_saved_current_state( ctx );
9337
9338 /* Allocate new display list */
9339 ctx->ListState.CurrentList = make_list(name, BLOCK_SIZE);
9340 ctx->ListState.CurrentBlock = ctx->ListState.CurrentList->Head;
9341 ctx->ListState.CurrentPos = 0;
9342
9343 vbo_save_NewList(ctx, name, mode);
9344
9345 ctx->CurrentServerDispatch = ctx->Save;
9346 _glapi_set_dispatch(ctx->CurrentServerDispatch);
9347 if (ctx->MarshalExec == NULL) {
9348 ctx->CurrentClientDispatch = ctx->CurrentServerDispatch;
9349 }
9350 }
9351
9352
9353 /**
9354 * End definition of current display list.
9355 */
9356 void GLAPIENTRY
9357 _mesa_EndList(void)
9358 {
9359 GET_CURRENT_CONTEXT(ctx);
9360 SAVE_FLUSH_VERTICES(ctx);
9361 FLUSH_VERTICES(ctx, 0);
9362
9363 if (MESA_VERBOSE & VERBOSE_API)
9364 _mesa_debug(ctx, "glEndList\n");
9365
9366 if (ctx->ExecuteFlag && _mesa_inside_dlist_begin_end(ctx)) {
9367 _mesa_error(ctx, GL_INVALID_OPERATION,
9368 "glEndList() called inside glBegin/End");
9369 }
9370
9371 /* Check that a list is under construction */
9372 if (!ctx->ListState.CurrentList) {
9373 _mesa_error(ctx, GL_INVALID_OPERATION, "glEndList");
9374 return;
9375 }
9376
9377 /* Call before emitting END_OF_LIST, in case the driver wants to
9378 * emit opcodes itself.
9379 */
9380 vbo_save_EndList(ctx);
9381
9382 (void) alloc_instruction(ctx, OPCODE_END_OF_LIST, 0);
9383
9384 trim_list(ctx);
9385
9386 /* Destroy old list, if any */
9387 destroy_list(ctx, ctx->ListState.CurrentList->Name);
9388
9389 /* Install the new list */
9390 _mesa_HashInsert(ctx->Shared->DisplayList,
9391 ctx->ListState.CurrentList->Name,
9392 ctx->ListState.CurrentList);
9393
9394
9395 if (MESA_VERBOSE & VERBOSE_DISPLAY_LIST)
9396 mesa_print_display_list(ctx->ListState.CurrentList->Name);
9397
9398 ctx->ListState.CurrentList = NULL;
9399 ctx->ListState.CurrentBlock = NULL;
9400 ctx->ListState.CurrentPos = 0;
9401 ctx->ExecuteFlag = GL_TRUE;
9402 ctx->CompileFlag = GL_FALSE;
9403
9404 ctx->CurrentServerDispatch = ctx->Exec;
9405 _glapi_set_dispatch(ctx->CurrentServerDispatch);
9406 if (ctx->MarshalExec == NULL) {
9407 ctx->CurrentClientDispatch = ctx->CurrentServerDispatch;
9408 }
9409 }
9410
9411
9412 void GLAPIENTRY
9413 _mesa_CallList(GLuint list)
9414 {
9415 GLboolean save_compile_flag;
9416 GET_CURRENT_CONTEXT(ctx);
9417 FLUSH_CURRENT(ctx, 0);
9418
9419 if (MESA_VERBOSE & VERBOSE_API)
9420 _mesa_debug(ctx, "glCallList %d\n", list);
9421
9422 if (list == 0) {
9423 _mesa_error(ctx, GL_INVALID_VALUE, "glCallList(list==0)");
9424 return;
9425 }
9426
9427 if (0)
9428 mesa_print_display_list( list );
9429
9430 /* VERY IMPORTANT: Save the CompileFlag status, turn it off,
9431 * execute the display list, and restore the CompileFlag.
9432 */
9433 save_compile_flag = ctx->CompileFlag;
9434 if (save_compile_flag) {
9435 ctx->CompileFlag = GL_FALSE;
9436 }
9437
9438 execute_list(ctx, list);
9439 ctx->CompileFlag = save_compile_flag;
9440
9441 /* also restore API function pointers to point to "save" versions */
9442 if (save_compile_flag) {
9443 ctx->CurrentServerDispatch = ctx->Save;
9444 _glapi_set_dispatch(ctx->CurrentServerDispatch);
9445 if (ctx->MarshalExec == NULL) {
9446 ctx->CurrentClientDispatch = ctx->CurrentServerDispatch;
9447 }
9448 }
9449 }
9450
9451
9452 /**
9453 * Try to execute a glCallLists() command where the display lists contain
9454 * glBitmap commands with a texture atlas.
9455 * \return true for success, false otherwise
9456 */
9457 static bool
9458 render_bitmap_atlas(struct gl_context *ctx, GLsizei n, GLenum type,
9459 const void *lists)
9460 {
9461 struct gl_bitmap_atlas *atlas;
9462 int i;
9463
9464 if (!USE_BITMAP_ATLAS ||
9465 !ctx->Current.RasterPosValid ||
9466 ctx->List.ListBase == 0 ||
9467 type != GL_UNSIGNED_BYTE ||
9468 !ctx->Driver.DrawAtlasBitmaps) {
9469 /* unsupported */
9470 return false;
9471 }
9472
9473 atlas = lookup_bitmap_atlas(ctx, ctx->List.ListBase);
9474
9475 if (!atlas) {
9476 /* Even if glGenLists wasn't called, we can still try to create
9477 * the atlas now.
9478 */
9479 atlas = alloc_bitmap_atlas(ctx, ctx->List.ListBase);
9480 }
9481
9482 if (atlas && !atlas->complete && !atlas->incomplete) {
9483 /* Try to build the bitmap atlas now.
9484 * If the atlas was created in glGenLists, we'll have recorded the
9485 * number of lists (bitmaps). Otherwise, take a guess at 256.
9486 */
9487 if (atlas->numBitmaps == 0)
9488 atlas->numBitmaps = 256;
9489 build_bitmap_atlas(ctx, atlas, ctx->List.ListBase);
9490 }
9491
9492 if (!atlas || !atlas->complete) {
9493 return false;
9494 }
9495
9496 /* check that all display list IDs are in the atlas */
9497 for (i = 0; i < n; i++) {
9498 const GLubyte *ids = (const GLubyte *) lists;
9499
9500 if (ids[i] >= atlas->numBitmaps) {
9501 return false;
9502 }
9503 }
9504
9505 ctx->Driver.DrawAtlasBitmaps(ctx, atlas, n, (const GLubyte *) lists);
9506
9507 return true;
9508 }
9509
9510
9511 /**
9512 * Execute glCallLists: call multiple display lists.
9513 */
9514 void GLAPIENTRY
9515 _mesa_CallLists(GLsizei n, GLenum type, const GLvoid * lists)
9516 {
9517 GET_CURRENT_CONTEXT(ctx);
9518 GLint i;
9519 GLboolean save_compile_flag;
9520
9521 if (MESA_VERBOSE & VERBOSE_API)
9522 _mesa_debug(ctx, "glCallLists %d\n", n);
9523
9524 switch (type) {
9525 case GL_BYTE:
9526 case GL_UNSIGNED_BYTE:
9527 case GL_SHORT:
9528 case GL_UNSIGNED_SHORT:
9529 case GL_INT:
9530 case GL_UNSIGNED_INT:
9531 case GL_FLOAT:
9532 case GL_2_BYTES:
9533 case GL_3_BYTES:
9534 case GL_4_BYTES:
9535 /* OK */
9536 break;
9537 default:
9538 _mesa_error(ctx, GL_INVALID_ENUM, "glCallLists(type)");
9539 return;
9540 }
9541
9542 if (n < 0) {
9543 _mesa_error(ctx, GL_INVALID_VALUE, "glCallLists(n < 0)");
9544 return;
9545 } else if (n == 0 || lists == NULL) {
9546 /* nothing to do */
9547 return;
9548 }
9549
9550 if (render_bitmap_atlas(ctx, n, type, lists)) {
9551 return;
9552 }
9553
9554 /* Save the CompileFlag status, turn it off, execute display list,
9555 * and restore the CompileFlag.
9556 */
9557 save_compile_flag = ctx->CompileFlag;
9558 ctx->CompileFlag = GL_FALSE;
9559
9560 for (i = 0; i < n; i++) {
9561 GLuint list = (GLuint) (ctx->List.ListBase + translate_id(i, type, lists));
9562 execute_list(ctx, list);
9563 }
9564
9565 ctx->CompileFlag = save_compile_flag;
9566
9567 /* also restore API function pointers to point to "save" versions */
9568 if (save_compile_flag) {
9569 ctx->CurrentServerDispatch = ctx->Save;
9570 _glapi_set_dispatch(ctx->CurrentServerDispatch);
9571 if (ctx->MarshalExec == NULL) {
9572 ctx->CurrentClientDispatch = ctx->CurrentServerDispatch;
9573 }
9574 }
9575 }
9576
9577
9578 /**
9579 * Set the offset added to list numbers in glCallLists.
9580 */
9581 void GLAPIENTRY
9582 _mesa_ListBase(GLuint base)
9583 {
9584 GET_CURRENT_CONTEXT(ctx);
9585 FLUSH_VERTICES(ctx, 0); /* must be called before assert */
9586 ASSERT_OUTSIDE_BEGIN_END(ctx);
9587 ctx->List.ListBase = base;
9588 }
9589
9590 /**
9591 * Setup the given dispatch table to point to Mesa's display list
9592 * building functions.
9593 *
9594 * This does not include any of the tnl functions - they are
9595 * initialized from _mesa_init_api_defaults and from the active vtxfmt
9596 * struct.
9597 */
9598 void
9599 _mesa_initialize_save_table(const struct gl_context *ctx)
9600 {
9601 struct _glapi_table *table = ctx->Save;
9602 int numEntries = MAX2(_gloffset_COUNT, _glapi_get_dispatch_table_size());
9603
9604 /* Initially populate the dispatch table with the contents of the
9605 * normal-execution dispatch table. This lets us skip populating functions
9606 * that should be called directly instead of compiled into display lists.
9607 */
9608 memcpy(table, ctx->Exec, numEntries * sizeof(_glapi_proc));
9609
9610 _mesa_loopback_init_api_table(ctx, table);
9611
9612 /* VBO functions */
9613 vbo_initialize_save_dispatch(ctx, table);
9614
9615 /* GL 1.0 */
9616 SET_Accum(table, save_Accum);
9617 SET_AlphaFunc(table, save_AlphaFunc);
9618 SET_Bitmap(table, save_Bitmap);
9619 SET_BlendFunc(table, save_BlendFunc);
9620 SET_CallList(table, save_CallList);
9621 SET_CallLists(table, save_CallLists);
9622 SET_Clear(table, save_Clear);
9623 SET_ClearAccum(table, save_ClearAccum);
9624 SET_ClearColor(table, save_ClearColor);
9625 SET_ClearDepth(table, save_ClearDepth);
9626 SET_ClearIndex(table, save_ClearIndex);
9627 SET_ClearStencil(table, save_ClearStencil);
9628 SET_ClipPlane(table, save_ClipPlane);
9629 SET_ColorMask(table, save_ColorMask);
9630 SET_ColorMaski(table, save_ColorMaskIndexed);
9631 SET_ColorMaterial(table, save_ColorMaterial);
9632 SET_CopyPixels(table, save_CopyPixels);
9633 SET_CullFace(table, save_CullFace);
9634 SET_DepthFunc(table, save_DepthFunc);
9635 SET_DepthMask(table, save_DepthMask);
9636 SET_DepthRange(table, save_DepthRange);
9637 SET_Disable(table, save_Disable);
9638 SET_Disablei(table, save_DisableIndexed);
9639 SET_DrawBuffer(table, save_DrawBuffer);
9640 SET_DrawPixels(table, save_DrawPixels);
9641 SET_Enable(table, save_Enable);
9642 SET_Enablei(table, save_EnableIndexed);
9643 SET_EvalMesh1(table, save_EvalMesh1);
9644 SET_EvalMesh2(table, save_EvalMesh2);
9645 SET_Fogf(table, save_Fogf);
9646 SET_Fogfv(table, save_Fogfv);
9647 SET_Fogi(table, save_Fogi);
9648 SET_Fogiv(table, save_Fogiv);
9649 SET_FrontFace(table, save_FrontFace);
9650 SET_Frustum(table, save_Frustum);
9651 SET_Hint(table, save_Hint);
9652 SET_IndexMask(table, save_IndexMask);
9653 SET_InitNames(table, save_InitNames);
9654 SET_LightModelf(table, save_LightModelf);
9655 SET_LightModelfv(table, save_LightModelfv);
9656 SET_LightModeli(table, save_LightModeli);
9657 SET_LightModeliv(table, save_LightModeliv);
9658 SET_Lightf(table, save_Lightf);
9659 SET_Lightfv(table, save_Lightfv);
9660 SET_Lighti(table, save_Lighti);
9661 SET_Lightiv(table, save_Lightiv);
9662 SET_LineStipple(table, save_LineStipple);
9663 SET_LineWidth(table, save_LineWidth);
9664 SET_ListBase(table, save_ListBase);
9665 SET_LoadIdentity(table, save_LoadIdentity);
9666 SET_LoadMatrixd(table, save_LoadMatrixd);
9667 SET_LoadMatrixf(table, save_LoadMatrixf);
9668 SET_LoadName(table, save_LoadName);
9669 SET_LogicOp(table, save_LogicOp);
9670 SET_Map1d(table, save_Map1d);
9671 SET_Map1f(table, save_Map1f);
9672 SET_Map2d(table, save_Map2d);
9673 SET_Map2f(table, save_Map2f);
9674 SET_MapGrid1d(table, save_MapGrid1d);
9675 SET_MapGrid1f(table, save_MapGrid1f);
9676 SET_MapGrid2d(table, save_MapGrid2d);
9677 SET_MapGrid2f(table, save_MapGrid2f);
9678 SET_MatrixMode(table, save_MatrixMode);
9679 SET_MultMatrixd(table, save_MultMatrixd);
9680 SET_MultMatrixf(table, save_MultMatrixf);
9681 SET_NewList(table, save_NewList);
9682 SET_Ortho(table, save_Ortho);
9683 SET_PassThrough(table, save_PassThrough);
9684 SET_PixelMapfv(table, save_PixelMapfv);
9685 SET_PixelMapuiv(table, save_PixelMapuiv);
9686 SET_PixelMapusv(table, save_PixelMapusv);
9687 SET_PixelTransferf(table, save_PixelTransferf);
9688 SET_PixelTransferi(table, save_PixelTransferi);
9689 SET_PixelZoom(table, save_PixelZoom);
9690 SET_PointSize(table, save_PointSize);
9691 SET_PolygonMode(table, save_PolygonMode);
9692 SET_PolygonOffset(table, save_PolygonOffset);
9693 SET_PolygonStipple(table, save_PolygonStipple);
9694 SET_PopAttrib(table, save_PopAttrib);
9695 SET_PopMatrix(table, save_PopMatrix);
9696 SET_PopName(table, save_PopName);
9697 SET_PushAttrib(table, save_PushAttrib);
9698 SET_PushMatrix(table, save_PushMatrix);
9699 SET_PushName(table, save_PushName);
9700 SET_RasterPos2d(table, save_RasterPos2d);
9701 SET_RasterPos2dv(table, save_RasterPos2dv);
9702 SET_RasterPos2f(table, save_RasterPos2f);
9703 SET_RasterPos2fv(table, save_RasterPos2fv);
9704 SET_RasterPos2i(table, save_RasterPos2i);
9705 SET_RasterPos2iv(table, save_RasterPos2iv);
9706 SET_RasterPos2s(table, save_RasterPos2s);
9707 SET_RasterPos2sv(table, save_RasterPos2sv);
9708 SET_RasterPos3d(table, save_RasterPos3d);
9709 SET_RasterPos3dv(table, save_RasterPos3dv);
9710 SET_RasterPos3f(table, save_RasterPos3f);
9711 SET_RasterPos3fv(table, save_RasterPos3fv);
9712 SET_RasterPos3i(table, save_RasterPos3i);
9713 SET_RasterPos3iv(table, save_RasterPos3iv);
9714 SET_RasterPos3s(table, save_RasterPos3s);
9715 SET_RasterPos3sv(table, save_RasterPos3sv);
9716 SET_RasterPos4d(table, save_RasterPos4d);
9717 SET_RasterPos4dv(table, save_RasterPos4dv);
9718 SET_RasterPos4f(table, save_RasterPos4f);
9719 SET_RasterPos4fv(table, save_RasterPos4fv);
9720 SET_RasterPos4i(table, save_RasterPos4i);
9721 SET_RasterPos4iv(table, save_RasterPos4iv);
9722 SET_RasterPos4s(table, save_RasterPos4s);
9723 SET_RasterPos4sv(table, save_RasterPos4sv);
9724 SET_ReadBuffer(table, save_ReadBuffer);
9725 SET_Rectf(table, save_Rectf);
9726 SET_Rotated(table, save_Rotated);
9727 SET_Rotatef(table, save_Rotatef);
9728 SET_Scaled(table, save_Scaled);
9729 SET_Scalef(table, save_Scalef);
9730 SET_Scissor(table, save_Scissor);
9731 SET_ShadeModel(table, save_ShadeModel);
9732 SET_StencilFunc(table, save_StencilFunc);
9733 SET_StencilMask(table, save_StencilMask);
9734 SET_StencilOp(table, save_StencilOp);
9735 SET_TexEnvf(table, save_TexEnvf);
9736 SET_TexEnvfv(table, save_TexEnvfv);
9737 SET_TexEnvi(table, save_TexEnvi);
9738 SET_TexEnviv(table, save_TexEnviv);
9739 SET_TexGend(table, save_TexGend);
9740 SET_TexGendv(table, save_TexGendv);
9741 SET_TexGenf(table, save_TexGenf);
9742 SET_TexGenfv(table, save_TexGenfv);
9743 SET_TexGeni(table, save_TexGeni);
9744 SET_TexGeniv(table, save_TexGeniv);
9745 SET_TexImage1D(table, save_TexImage1D);
9746 SET_TexImage2D(table, save_TexImage2D);
9747 SET_TexParameterf(table, save_TexParameterf);
9748 SET_TexParameterfv(table, save_TexParameterfv);
9749 SET_TexParameteri(table, save_TexParameteri);
9750 SET_TexParameteriv(table, save_TexParameteriv);
9751 SET_Translated(table, save_Translated);
9752 SET_Translatef(table, save_Translatef);
9753 SET_Viewport(table, save_Viewport);
9754
9755 /* GL 1.1 */
9756 SET_BindTexture(table, save_BindTexture);
9757 SET_CopyTexImage1D(table, save_CopyTexImage1D);
9758 SET_CopyTexImage2D(table, save_CopyTexImage2D);
9759 SET_CopyTexSubImage1D(table, save_CopyTexSubImage1D);
9760 SET_CopyTexSubImage2D(table, save_CopyTexSubImage2D);
9761 SET_PrioritizeTextures(table, save_PrioritizeTextures);
9762 SET_TexSubImage1D(table, save_TexSubImage1D);
9763 SET_TexSubImage2D(table, save_TexSubImage2D);
9764
9765 /* GL 1.2 */
9766 SET_CopyTexSubImage3D(table, save_CopyTexSubImage3D);
9767 SET_TexImage3D(table, save_TexImage3D);
9768 SET_TexSubImage3D(table, save_TexSubImage3D);
9769
9770 /* GL 2.0 */
9771 SET_StencilFuncSeparate(table, save_StencilFuncSeparate);
9772 SET_StencilMaskSeparate(table, save_StencilMaskSeparate);
9773 SET_StencilOpSeparate(table, save_StencilOpSeparate);
9774
9775 /* ATI_separate_stencil */
9776 SET_StencilFuncSeparateATI(table, save_StencilFuncSeparateATI);
9777
9778 /* GL_ARB_imaging */
9779 /* Not all are supported */
9780 SET_BlendColor(table, save_BlendColor);
9781 SET_BlendEquation(table, save_BlendEquation);
9782
9783 /* 2. GL_EXT_blend_color */
9784 #if 0
9785 SET_BlendColorEXT(table, save_BlendColorEXT);
9786 #endif
9787
9788 /* 3. GL_EXT_polygon_offset */
9789 SET_PolygonOffsetEXT(table, save_PolygonOffsetEXT);
9790
9791 /* 6. GL_EXT_texture3d */
9792 #if 0
9793 SET_CopyTexSubImage3DEXT(table, save_CopyTexSubImage3D);
9794 SET_TexImage3DEXT(table, save_TexImage3DEXT);
9795 SET_TexSubImage3DEXT(table, save_TexSubImage3D);
9796 #endif
9797
9798 /* 37. GL_EXT_blend_minmax */
9799 #if 0
9800 SET_BlendEquationEXT(table, save_BlendEquationEXT);
9801 #endif
9802
9803 /* 54. GL_EXT_point_parameters */
9804 SET_PointParameterf(table, save_PointParameterfEXT);
9805 SET_PointParameterfv(table, save_PointParameterfvEXT);
9806
9807 /* 173. GL_EXT_blend_func_separate */
9808 SET_BlendFuncSeparate(table, save_BlendFuncSeparateEXT);
9809
9810 /* 197. GL_MESA_window_pos */
9811 SET_WindowPos2d(table, save_WindowPos2dMESA);
9812 SET_WindowPos2dv(table, save_WindowPos2dvMESA);
9813 SET_WindowPos2f(table, save_WindowPos2fMESA);
9814 SET_WindowPos2fv(table, save_WindowPos2fvMESA);
9815 SET_WindowPos2i(table, save_WindowPos2iMESA);
9816 SET_WindowPos2iv(table, save_WindowPos2ivMESA);
9817 SET_WindowPos2s(table, save_WindowPos2sMESA);
9818 SET_WindowPos2sv(table, save_WindowPos2svMESA);
9819 SET_WindowPos3d(table, save_WindowPos3dMESA);
9820 SET_WindowPos3dv(table, save_WindowPos3dvMESA);
9821 SET_WindowPos3f(table, save_WindowPos3fMESA);
9822 SET_WindowPos3fv(table, save_WindowPos3fvMESA);
9823 SET_WindowPos3i(table, save_WindowPos3iMESA);
9824 SET_WindowPos3iv(table, save_WindowPos3ivMESA);
9825 SET_WindowPos3s(table, save_WindowPos3sMESA);
9826 SET_WindowPos3sv(table, save_WindowPos3svMESA);
9827 SET_WindowPos4dMESA(table, save_WindowPos4dMESA);
9828 SET_WindowPos4dvMESA(table, save_WindowPos4dvMESA);
9829 SET_WindowPos4fMESA(table, save_WindowPos4fMESA);
9830 SET_WindowPos4fvMESA(table, save_WindowPos4fvMESA);
9831 SET_WindowPos4iMESA(table, save_WindowPos4iMESA);
9832 SET_WindowPos4ivMESA(table, save_WindowPos4ivMESA);
9833 SET_WindowPos4sMESA(table, save_WindowPos4sMESA);
9834 SET_WindowPos4svMESA(table, save_WindowPos4svMESA);
9835
9836 /* 245. GL_ATI_fragment_shader */
9837 SET_BindFragmentShaderATI(table, save_BindFragmentShaderATI);
9838 SET_SetFragmentShaderConstantATI(table, save_SetFragmentShaderConstantATI);
9839
9840 /* 262. GL_NV_point_sprite */
9841 SET_PointParameteri(table, save_PointParameteriNV);
9842 SET_PointParameteriv(table, save_PointParameterivNV);
9843
9844 /* 268. GL_EXT_stencil_two_side */
9845 SET_ActiveStencilFaceEXT(table, save_ActiveStencilFaceEXT);
9846
9847 /* ???. GL_EXT_depth_bounds_test */
9848 SET_DepthBoundsEXT(table, save_DepthBoundsEXT);
9849
9850 /* ARB 1. GL_ARB_multitexture */
9851 SET_ActiveTexture(table, save_ActiveTextureARB);
9852
9853 /* ARB 3. GL_ARB_transpose_matrix */
9854 SET_LoadTransposeMatrixd(table, save_LoadTransposeMatrixdARB);
9855 SET_LoadTransposeMatrixf(table, save_LoadTransposeMatrixfARB);
9856 SET_MultTransposeMatrixd(table, save_MultTransposeMatrixdARB);
9857 SET_MultTransposeMatrixf(table, save_MultTransposeMatrixfARB);
9858
9859 /* ARB 5. GL_ARB_multisample */
9860 SET_SampleCoverage(table, save_SampleCoverageARB);
9861
9862 /* ARB 12. GL_ARB_texture_compression */
9863 SET_CompressedTexImage3D(table, save_CompressedTexImage3DARB);
9864 SET_CompressedTexImage2D(table, save_CompressedTexImage2DARB);
9865 SET_CompressedTexImage1D(table, save_CompressedTexImage1DARB);
9866 SET_CompressedTexSubImage3D(table, save_CompressedTexSubImage3DARB);
9867 SET_CompressedTexSubImage2D(table, save_CompressedTexSubImage2DARB);
9868 SET_CompressedTexSubImage1D(table, save_CompressedTexSubImage1DARB);
9869
9870 /* ARB 14. GL_ARB_point_parameters */
9871 /* aliased with EXT_point_parameters functions */
9872
9873 /* ARB 25. GL_ARB_window_pos */
9874 /* aliased with MESA_window_pos functions */
9875
9876 /* ARB 26. GL_ARB_vertex_program */
9877 /* ARB 27. GL_ARB_fragment_program */
9878 /* glVertexAttrib* functions alias the NV ones, handled elsewhere */
9879 SET_ProgramStringARB(table, save_ProgramStringARB);
9880 SET_BindProgramARB(table, save_BindProgramARB);
9881 SET_ProgramEnvParameter4dARB(table, save_ProgramEnvParameter4dARB);
9882 SET_ProgramEnvParameter4dvARB(table, save_ProgramEnvParameter4dvARB);
9883 SET_ProgramEnvParameter4fARB(table, save_ProgramEnvParameter4fARB);
9884 SET_ProgramEnvParameter4fvARB(table, save_ProgramEnvParameter4fvARB);
9885 SET_ProgramLocalParameter4dARB(table, save_ProgramLocalParameter4dARB);
9886 SET_ProgramLocalParameter4dvARB(table, save_ProgramLocalParameter4dvARB);
9887 SET_ProgramLocalParameter4fARB(table, save_ProgramLocalParameter4fARB);
9888 SET_ProgramLocalParameter4fvARB(table, save_ProgramLocalParameter4fvARB);
9889
9890 SET_BeginQuery(table, save_BeginQueryARB);
9891 SET_EndQuery(table, save_EndQueryARB);
9892 SET_QueryCounter(table, save_QueryCounter);
9893
9894 SET_DrawBuffers(table, save_DrawBuffersARB);
9895
9896 SET_BlitFramebuffer(table, save_BlitFramebufferEXT);
9897
9898 SET_UseProgram(table, save_UseProgram);
9899 SET_Uniform1f(table, save_Uniform1fARB);
9900 SET_Uniform2f(table, save_Uniform2fARB);
9901 SET_Uniform3f(table, save_Uniform3fARB);
9902 SET_Uniform4f(table, save_Uniform4fARB);
9903 SET_Uniform1fv(table, save_Uniform1fvARB);
9904 SET_Uniform2fv(table, save_Uniform2fvARB);
9905 SET_Uniform3fv(table, save_Uniform3fvARB);
9906 SET_Uniform4fv(table, save_Uniform4fvARB);
9907 SET_Uniform1i(table, save_Uniform1iARB);
9908 SET_Uniform2i(table, save_Uniform2iARB);
9909 SET_Uniform3i(table, save_Uniform3iARB);
9910 SET_Uniform4i(table, save_Uniform4iARB);
9911 SET_Uniform1iv(table, save_Uniform1ivARB);
9912 SET_Uniform2iv(table, save_Uniform2ivARB);
9913 SET_Uniform3iv(table, save_Uniform3ivARB);
9914 SET_Uniform4iv(table, save_Uniform4ivARB);
9915 SET_UniformMatrix2fv(table, save_UniformMatrix2fvARB);
9916 SET_UniformMatrix3fv(table, save_UniformMatrix3fvARB);
9917 SET_UniformMatrix4fv(table, save_UniformMatrix4fvARB);
9918 SET_UniformMatrix2x3fv(table, save_UniformMatrix2x3fv);
9919 SET_UniformMatrix3x2fv(table, save_UniformMatrix3x2fv);
9920 SET_UniformMatrix2x4fv(table, save_UniformMatrix2x4fv);
9921 SET_UniformMatrix4x2fv(table, save_UniformMatrix4x2fv);
9922 SET_UniformMatrix3x4fv(table, save_UniformMatrix3x4fv);
9923 SET_UniformMatrix4x3fv(table, save_UniformMatrix4x3fv);
9924
9925 /* 299. GL_EXT_blend_equation_separate */
9926 SET_BlendEquationSeparate(table, save_BlendEquationSeparateEXT);
9927
9928 /* GL_EXT_gpu_program_parameters */
9929 SET_ProgramEnvParameters4fvEXT(table, save_ProgramEnvParameters4fvEXT);
9930 SET_ProgramLocalParameters4fvEXT(table, save_ProgramLocalParameters4fvEXT);
9931
9932 /* 364. GL_EXT_provoking_vertex */
9933 SET_ProvokingVertex(table, save_ProvokingVertexEXT);
9934
9935 /* GL_EXT_texture_integer */
9936 SET_ClearColorIiEXT(table, save_ClearColorIi);
9937 SET_ClearColorIuiEXT(table, save_ClearColorIui);
9938 SET_TexParameterIiv(table, save_TexParameterIiv);
9939 SET_TexParameterIuiv(table, save_TexParameterIuiv);
9940
9941 /* GL_ARB_clip_control */
9942 SET_ClipControl(table, save_ClipControl);
9943
9944 /* GL_ARB_color_buffer_float */
9945 SET_ClampColor(table, save_ClampColorARB);
9946
9947 /* GL 3.0 */
9948 SET_ClearBufferiv(table, save_ClearBufferiv);
9949 SET_ClearBufferuiv(table, save_ClearBufferuiv);
9950 SET_ClearBufferfv(table, save_ClearBufferfv);
9951 SET_ClearBufferfi(table, save_ClearBufferfi);
9952 #if 0
9953 SET_Uniform1ui(table, save_Uniform1ui);
9954 SET_Uniform2ui(table, save_Uniform2ui);
9955 SET_Uniform3ui(table, save_Uniform3ui);
9956 SET_Uniform4ui(table, save_Uniform4ui);
9957 SET_Uniform1uiv(table, save_Uniform1uiv);
9958 SET_Uniform2uiv(table, save_Uniform2uiv);
9959 SET_Uniform3uiv(table, save_Uniform3uiv);
9960 SET_Uniform4uiv(table, save_Uniform4uiv);
9961 #else
9962 (void) save_Uniform1ui;
9963 (void) save_Uniform2ui;
9964 (void) save_Uniform3ui;
9965 (void) save_Uniform4ui;
9966 (void) save_Uniform1uiv;
9967 (void) save_Uniform2uiv;
9968 (void) save_Uniform3uiv;
9969 (void) save_Uniform4uiv;
9970 #endif
9971
9972 /* These are: */
9973 SET_BeginTransformFeedback(table, save_BeginTransformFeedback);
9974 SET_EndTransformFeedback(table, save_EndTransformFeedback);
9975 SET_BindTransformFeedback(table, save_BindTransformFeedback);
9976 SET_PauseTransformFeedback(table, save_PauseTransformFeedback);
9977 SET_ResumeTransformFeedback(table, save_ResumeTransformFeedback);
9978 SET_DrawTransformFeedback(table, save_DrawTransformFeedback);
9979 SET_DrawTransformFeedbackStream(table, save_DrawTransformFeedbackStream);
9980 SET_DrawTransformFeedbackInstanced(table,
9981 save_DrawTransformFeedbackInstanced);
9982 SET_DrawTransformFeedbackStreamInstanced(table,
9983 save_DrawTransformFeedbackStreamInstanced);
9984 SET_BeginQueryIndexed(table, save_BeginQueryIndexed);
9985 SET_EndQueryIndexed(table, save_EndQueryIndexed);
9986
9987 /* GL_ARB_instanced_arrays */
9988 SET_VertexAttribDivisor(table, save_VertexAttribDivisor);
9989
9990 /* GL_NV_texture_barrier */
9991 SET_TextureBarrierNV(table, save_TextureBarrierNV);
9992
9993 SET_BindSampler(table, save_BindSampler);
9994 SET_SamplerParameteri(table, save_SamplerParameteri);
9995 SET_SamplerParameterf(table, save_SamplerParameterf);
9996 SET_SamplerParameteriv(table, save_SamplerParameteriv);
9997 SET_SamplerParameterfv(table, save_SamplerParameterfv);
9998 SET_SamplerParameterIiv(table, save_SamplerParameterIiv);
9999 SET_SamplerParameterIuiv(table, save_SamplerParameterIuiv);
10000
10001 /* GL_ARB_draw_buffer_blend */
10002 SET_BlendFunciARB(table, save_BlendFunci);
10003 SET_BlendFuncSeparateiARB(table, save_BlendFuncSeparatei);
10004 SET_BlendEquationiARB(table, save_BlendEquationi);
10005 SET_BlendEquationSeparateiARB(table, save_BlendEquationSeparatei);
10006
10007 /* GL_NV_conditional_render */
10008 SET_BeginConditionalRender(table, save_BeginConditionalRender);
10009 SET_EndConditionalRender(table, save_EndConditionalRender);
10010
10011 /* GL_ARB_sync */
10012 SET_WaitSync(table, save_WaitSync);
10013
10014 /* GL_ARB_uniform_buffer_object */
10015 SET_UniformBlockBinding(table, save_UniformBlockBinding);
10016
10017 /* GL_ARB_draw_instanced */
10018 SET_DrawArraysInstancedARB(table, save_DrawArraysInstancedARB);
10019 SET_DrawElementsInstancedARB(table, save_DrawElementsInstancedARB);
10020
10021 /* GL_ARB_draw_elements_base_vertex */
10022 SET_DrawElementsInstancedBaseVertex(table, save_DrawElementsInstancedBaseVertexARB);
10023
10024 /* GL_ARB_base_instance */
10025 SET_DrawArraysInstancedBaseInstance(table, save_DrawArraysInstancedBaseInstance);
10026 SET_DrawElementsInstancedBaseInstance(table, save_DrawElementsInstancedBaseInstance);
10027 SET_DrawElementsInstancedBaseVertexBaseInstance(table, save_DrawElementsInstancedBaseVertexBaseInstance);
10028
10029 /* OpenGL 4.2 / GL_ARB_separate_shader_objects */
10030 SET_UseProgramStages(table, save_UseProgramStages);
10031 SET_ProgramUniform1f(table, save_ProgramUniform1f);
10032 SET_ProgramUniform2f(table, save_ProgramUniform2f);
10033 SET_ProgramUniform3f(table, save_ProgramUniform3f);
10034 SET_ProgramUniform4f(table, save_ProgramUniform4f);
10035 SET_ProgramUniform1fv(table, save_ProgramUniform1fv);
10036 SET_ProgramUniform2fv(table, save_ProgramUniform2fv);
10037 SET_ProgramUniform3fv(table, save_ProgramUniform3fv);
10038 SET_ProgramUniform4fv(table, save_ProgramUniform4fv);
10039 SET_ProgramUniform1i(table, save_ProgramUniform1i);
10040 SET_ProgramUniform2i(table, save_ProgramUniform2i);
10041 SET_ProgramUniform3i(table, save_ProgramUniform3i);
10042 SET_ProgramUniform4i(table, save_ProgramUniform4i);
10043 SET_ProgramUniform1iv(table, save_ProgramUniform1iv);
10044 SET_ProgramUniform2iv(table, save_ProgramUniform2iv);
10045 SET_ProgramUniform3iv(table, save_ProgramUniform3iv);
10046 SET_ProgramUniform4iv(table, save_ProgramUniform4iv);
10047 SET_ProgramUniform1ui(table, save_ProgramUniform1ui);
10048 SET_ProgramUniform2ui(table, save_ProgramUniform2ui);
10049 SET_ProgramUniform3ui(table, save_ProgramUniform3ui);
10050 SET_ProgramUniform4ui(table, save_ProgramUniform4ui);
10051 SET_ProgramUniform1uiv(table, save_ProgramUniform1uiv);
10052 SET_ProgramUniform2uiv(table, save_ProgramUniform2uiv);
10053 SET_ProgramUniform3uiv(table, save_ProgramUniform3uiv);
10054 SET_ProgramUniform4uiv(table, save_ProgramUniform4uiv);
10055 SET_ProgramUniformMatrix2fv(table, save_ProgramUniformMatrix2fv);
10056 SET_ProgramUniformMatrix3fv(table, save_ProgramUniformMatrix3fv);
10057 SET_ProgramUniformMatrix4fv(table, save_ProgramUniformMatrix4fv);
10058 SET_ProgramUniformMatrix2x3fv(table, save_ProgramUniformMatrix2x3fv);
10059 SET_ProgramUniformMatrix3x2fv(table, save_ProgramUniformMatrix3x2fv);
10060 SET_ProgramUniformMatrix2x4fv(table, save_ProgramUniformMatrix2x4fv);
10061 SET_ProgramUniformMatrix4x2fv(table, save_ProgramUniformMatrix4x2fv);
10062 SET_ProgramUniformMatrix3x4fv(table, save_ProgramUniformMatrix3x4fv);
10063 SET_ProgramUniformMatrix4x3fv(table, save_ProgramUniformMatrix4x3fv);
10064
10065 /* GL_{ARB,EXT}_polygon_offset_clamp */
10066 SET_PolygonOffsetClampEXT(table, save_PolygonOffsetClampEXT);
10067
10068 /* GL_EXT_window_rectangles */
10069 SET_WindowRectanglesEXT(table, save_WindowRectanglesEXT);
10070 }
10071
10072
10073
10074 static const char *
10075 enum_string(GLenum k)
10076 {
10077 return _mesa_enum_to_string(k);
10078 }
10079
10080
10081 /**
10082 * Print the commands in a display list. For debugging only.
10083 * TODO: many commands aren't handled yet.
10084 * \param fname filename to write display list to. If null, use stdout.
10085 */
10086 static void GLAPIENTRY
10087 print_list(struct gl_context *ctx, GLuint list, const char *fname)
10088 {
10089 struct gl_display_list *dlist;
10090 Node *n;
10091 GLboolean done;
10092 FILE *f = stdout;
10093
10094 if (fname) {
10095 f = fopen(fname, "w");
10096 if (!f)
10097 return;
10098 }
10099
10100 if (!islist(ctx, list)) {
10101 fprintf(f, "%u is not a display list ID\n", list);
10102 goto out;
10103 }
10104
10105 dlist = _mesa_lookup_list(ctx, list);
10106 if (!dlist) {
10107 goto out;
10108 }
10109
10110 n = dlist->Head;
10111
10112 fprintf(f, "START-LIST %u, address %p\n", list, (void *) n);
10113
10114 done = n ? GL_FALSE : GL_TRUE;
10115 while (!done) {
10116 const OpCode opcode = n[0].opcode;
10117
10118 if (is_ext_opcode(opcode)) {
10119 n += ext_opcode_print(ctx, n, f);
10120 }
10121 else {
10122 switch (opcode) {
10123 case OPCODE_ACCUM:
10124 fprintf(f, "Accum %s %g\n", enum_string(n[1].e), n[2].f);
10125 break;
10126 case OPCODE_ACTIVE_TEXTURE:
10127 fprintf(f, "ActiveTexture(%s)\n", enum_string(n[1].e));
10128 break;
10129 case OPCODE_BITMAP:
10130 fprintf(f, "Bitmap %d %d %g %g %g %g %p\n", n[1].i, n[2].i,
10131 n[3].f, n[4].f, n[5].f, n[6].f,
10132 get_pointer(&n[7]));
10133 break;
10134 case OPCODE_BLEND_COLOR:
10135 fprintf(f, "BlendColor %f, %f, %f, %f\n",
10136 n[1].f, n[2].f, n[3].f, n[4].f);
10137 break;
10138 case OPCODE_BLEND_EQUATION:
10139 fprintf(f, "BlendEquation %s\n",
10140 enum_string(n[1].e));
10141 break;
10142 case OPCODE_BLEND_EQUATION_SEPARATE:
10143 fprintf(f, "BlendEquationSeparate %s, %s\n",
10144 enum_string(n[1].e),
10145 enum_string(n[2].e));
10146 break;
10147 case OPCODE_BLEND_FUNC_SEPARATE:
10148 fprintf(f, "BlendFuncSeparate %s, %s, %s, %s\n",
10149 enum_string(n[1].e),
10150 enum_string(n[2].e),
10151 enum_string(n[3].e),
10152 enum_string(n[4].e));
10153 break;
10154 case OPCODE_BLEND_EQUATION_I:
10155 fprintf(f, "BlendEquationi %u, %s\n",
10156 n[1].ui, enum_string(n[2].e));
10157 break;
10158 case OPCODE_BLEND_EQUATION_SEPARATE_I:
10159 fprintf(f, "BlendEquationSeparatei %u, %s, %s\n",
10160 n[1].ui, enum_string(n[2].e), enum_string(n[3].e));
10161 break;
10162 case OPCODE_BLEND_FUNC_I:
10163 fprintf(f, "BlendFunci %u, %s, %s\n",
10164 n[1].ui, enum_string(n[2].e), enum_string(n[3].e));
10165 break;
10166 case OPCODE_BLEND_FUNC_SEPARATE_I:
10167 fprintf(f, "BlendFuncSeparatei %u, %s, %s, %s, %s\n",
10168 n[1].ui,
10169 enum_string(n[2].e),
10170 enum_string(n[3].e),
10171 enum_string(n[4].e),
10172 enum_string(n[5].e));
10173 break;
10174 case OPCODE_CALL_LIST:
10175 fprintf(f, "CallList %d\n", (int) n[1].ui);
10176 break;
10177 case OPCODE_CALL_LISTS:
10178 fprintf(f, "CallLists %d, %s\n", n[1].i, enum_string(n[1].e));
10179 break;
10180 case OPCODE_DISABLE:
10181 fprintf(f, "Disable %s\n", enum_string(n[1].e));
10182 break;
10183 case OPCODE_ENABLE:
10184 fprintf(f, "Enable %s\n", enum_string(n[1].e));
10185 break;
10186 case OPCODE_FRUSTUM:
10187 fprintf(f, "Frustum %g %g %g %g %g %g\n",
10188 n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f);
10189 break;
10190 case OPCODE_LINE_STIPPLE:
10191 fprintf(f, "LineStipple %d %x\n", n[1].i, (int) n[2].us);
10192 break;
10193 case OPCODE_LINE_WIDTH:
10194 fprintf(f, "LineWidth %f\n", n[1].f);
10195 break;
10196 case OPCODE_LOAD_IDENTITY:
10197 fprintf(f, "LoadIdentity\n");
10198 break;
10199 case OPCODE_LOAD_MATRIX:
10200 fprintf(f, "LoadMatrix\n");
10201 fprintf(f, " %8f %8f %8f %8f\n",
10202 n[1].f, n[5].f, n[9].f, n[13].f);
10203 fprintf(f, " %8f %8f %8f %8f\n",
10204 n[2].f, n[6].f, n[10].f, n[14].f);
10205 fprintf(f, " %8f %8f %8f %8f\n",
10206 n[3].f, n[7].f, n[11].f, n[15].f);
10207 fprintf(f, " %8f %8f %8f %8f\n",
10208 n[4].f, n[8].f, n[12].f, n[16].f);
10209 break;
10210 case OPCODE_MULT_MATRIX:
10211 fprintf(f, "MultMatrix (or Rotate)\n");
10212 fprintf(f, " %8f %8f %8f %8f\n",
10213 n[1].f, n[5].f, n[9].f, n[13].f);
10214 fprintf(f, " %8f %8f %8f %8f\n",
10215 n[2].f, n[6].f, n[10].f, n[14].f);
10216 fprintf(f, " %8f %8f %8f %8f\n",
10217 n[3].f, n[7].f, n[11].f, n[15].f);
10218 fprintf(f, " %8f %8f %8f %8f\n",
10219 n[4].f, n[8].f, n[12].f, n[16].f);
10220 break;
10221 case OPCODE_ORTHO:
10222 fprintf(f, "Ortho %g %g %g %g %g %g\n",
10223 n[1].f, n[2].f, n[3].f, n[4].f, n[5].f, n[6].f);
10224 break;
10225 case OPCODE_POINT_SIZE:
10226 fprintf(f, "PointSize %f\n", n[1].f);
10227 break;
10228 case OPCODE_POP_ATTRIB:
10229 fprintf(f, "PopAttrib\n");
10230 break;
10231 case OPCODE_POP_MATRIX:
10232 fprintf(f, "PopMatrix\n");
10233 break;
10234 case OPCODE_POP_NAME:
10235 fprintf(f, "PopName\n");
10236 break;
10237 case OPCODE_PUSH_ATTRIB:
10238 fprintf(f, "PushAttrib %x\n", n[1].bf);
10239 break;
10240 case OPCODE_PUSH_MATRIX:
10241 fprintf(f, "PushMatrix\n");
10242 break;
10243 case OPCODE_PUSH_NAME:
10244 fprintf(f, "PushName %d\n", (int) n[1].ui);
10245 break;
10246 case OPCODE_RASTER_POS:
10247 fprintf(f, "RasterPos %g %g %g %g\n",
10248 n[1].f, n[2].f, n[3].f, n[4].f);
10249 break;
10250 case OPCODE_ROTATE:
10251 fprintf(f, "Rotate %g %g %g %g\n",
10252 n[1].f, n[2].f, n[3].f, n[4].f);
10253 break;
10254 case OPCODE_SCALE:
10255 fprintf(f, "Scale %g %g %g\n", n[1].f, n[2].f, n[3].f);
10256 break;
10257 case OPCODE_TRANSLATE:
10258 fprintf(f, "Translate %g %g %g\n", n[1].f, n[2].f, n[3].f);
10259 break;
10260 case OPCODE_BIND_TEXTURE:
10261 fprintf(f, "BindTexture %s %d\n",
10262 _mesa_enum_to_string(n[1].ui), n[2].ui);
10263 break;
10264 case OPCODE_SHADE_MODEL:
10265 fprintf(f, "ShadeModel %s\n", _mesa_enum_to_string(n[1].ui));
10266 break;
10267 case OPCODE_MAP1:
10268 fprintf(f, "Map1 %s %.3f %.3f %d %d\n",
10269 _mesa_enum_to_string(n[1].ui),
10270 n[2].f, n[3].f, n[4].i, n[5].i);
10271 break;
10272 case OPCODE_MAP2:
10273 fprintf(f, "Map2 %s %.3f %.3f %.3f %.3f %d %d %d %d\n",
10274 _mesa_enum_to_string(n[1].ui),
10275 n[2].f, n[3].f, n[4].f, n[5].f,
10276 n[6].i, n[7].i, n[8].i, n[9].i);
10277 break;
10278 case OPCODE_MAPGRID1:
10279 fprintf(f, "MapGrid1 %d %.3f %.3f\n", n[1].i, n[2].f, n[3].f);
10280 break;
10281 case OPCODE_MAPGRID2:
10282 fprintf(f, "MapGrid2 %d %.3f %.3f, %d %.3f %.3f\n",
10283 n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f);
10284 break;
10285 case OPCODE_EVALMESH1:
10286 fprintf(f, "EvalMesh1 %d %d\n", n[1].i, n[2].i);
10287 break;
10288 case OPCODE_EVALMESH2:
10289 fprintf(f, "EvalMesh2 %d %d %d %d\n",
10290 n[1].i, n[2].i, n[3].i, n[4].i);
10291 break;
10292
10293 case OPCODE_ATTR_1F_NV:
10294 fprintf(f, "ATTR_1F_NV attr %d: %f\n", n[1].i, n[2].f);
10295 break;
10296 case OPCODE_ATTR_2F_NV:
10297 fprintf(f, "ATTR_2F_NV attr %d: %f %f\n",
10298 n[1].i, n[2].f, n[3].f);
10299 break;
10300 case OPCODE_ATTR_3F_NV:
10301 fprintf(f, "ATTR_3F_NV attr %d: %f %f %f\n",
10302 n[1].i, n[2].f, n[3].f, n[4].f);
10303 break;
10304 case OPCODE_ATTR_4F_NV:
10305 fprintf(f, "ATTR_4F_NV attr %d: %f %f %f %f\n",
10306 n[1].i, n[2].f, n[3].f, n[4].f, n[5].f);
10307 break;
10308 case OPCODE_ATTR_1F_ARB:
10309 fprintf(f, "ATTR_1F_ARB attr %d: %f\n", n[1].i, n[2].f);
10310 break;
10311 case OPCODE_ATTR_2F_ARB:
10312 fprintf(f, "ATTR_2F_ARB attr %d: %f %f\n",
10313 n[1].i, n[2].f, n[3].f);
10314 break;
10315 case OPCODE_ATTR_3F_ARB:
10316 fprintf(f, "ATTR_3F_ARB attr %d: %f %f %f\n",
10317 n[1].i, n[2].f, n[3].f, n[4].f);
10318 break;
10319 case OPCODE_ATTR_4F_ARB:
10320 fprintf(f, "ATTR_4F_ARB attr %d: %f %f %f %f\n",
10321 n[1].i, n[2].f, n[3].f, n[4].f, n[5].f);
10322 break;
10323
10324 case OPCODE_MATERIAL:
10325 fprintf(f, "MATERIAL %x %x: %f %f %f %f\n",
10326 n[1].i, n[2].i, n[3].f, n[4].f, n[5].f, n[6].f);
10327 break;
10328 case OPCODE_BEGIN:
10329 fprintf(f, "BEGIN %x\n", n[1].i);
10330 break;
10331 case OPCODE_END:
10332 fprintf(f, "END\n");
10333 break;
10334 case OPCODE_RECTF:
10335 fprintf(f, "RECTF %f %f %f %f\n", n[1].f, n[2].f, n[3].f,
10336 n[4].f);
10337 break;
10338 case OPCODE_EVAL_C1:
10339 fprintf(f, "EVAL_C1 %f\n", n[1].f);
10340 break;
10341 case OPCODE_EVAL_C2:
10342 fprintf(f, "EVAL_C2 %f %f\n", n[1].f, n[2].f);
10343 break;
10344 case OPCODE_EVAL_P1:
10345 fprintf(f, "EVAL_P1 %d\n", n[1].i);
10346 break;
10347 case OPCODE_EVAL_P2:
10348 fprintf(f, "EVAL_P2 %d %d\n", n[1].i, n[2].i);
10349 break;
10350
10351 case OPCODE_PROVOKING_VERTEX:
10352 fprintf(f, "ProvokingVertex %s\n",
10353 _mesa_enum_to_string(n[1].ui));
10354 break;
10355
10356 /*
10357 * meta opcodes/commands
10358 */
10359 case OPCODE_ERROR:
10360 fprintf(f, "Error: %s %s\n", enum_string(n[1].e),
10361 (const char *) get_pointer(&n[2]));
10362 break;
10363 case OPCODE_CONTINUE:
10364 fprintf(f, "DISPLAY-LIST-CONTINUE\n");
10365 n = (Node *) get_pointer(&n[1]);
10366 break;
10367 case OPCODE_NOP:
10368 fprintf(f, "NOP\n");
10369 break;
10370 case OPCODE_END_OF_LIST:
10371 fprintf(f, "END-LIST %u\n", list);
10372 done = GL_TRUE;
10373 break;
10374 default:
10375 if (opcode < 0 || opcode > OPCODE_END_OF_LIST) {
10376 printf
10377 ("ERROR IN DISPLAY LIST: opcode = %d, address = %p\n",
10378 opcode, (void *) n);
10379 goto out;
10380 }
10381 else {
10382 fprintf(f, "command %d, %u operands\n", opcode,
10383 InstSize[opcode]);
10384 }
10385 }
10386 /* increment n to point to next compiled command */
10387 if (opcode != OPCODE_CONTINUE) {
10388 n += InstSize[opcode];
10389 }
10390 }
10391 }
10392
10393 out:
10394 fflush(f);
10395 if (fname)
10396 fclose(f);
10397 }
10398
10399
10400
10401 /**
10402 * Clients may call this function to help debug display list problems.
10403 * This function is _ONLY_FOR_DEBUGGING_PURPOSES_. It may be removed,
10404 * changed, or break in the future without notice.
10405 */
10406 void
10407 mesa_print_display_list(GLuint list)
10408 {
10409 GET_CURRENT_CONTEXT(ctx);
10410 print_list(ctx, list, NULL);
10411 }
10412
10413
10414 /**********************************************************************/
10415 /***** Initialization *****/
10416 /**********************************************************************/
10417
10418 static void
10419 save_vtxfmt_init(GLvertexformat * vfmt)
10420 {
10421 vfmt->ArrayElement = _ae_ArrayElement;
10422
10423 vfmt->Begin = save_Begin;
10424
10425 vfmt->CallList = save_CallList;
10426 vfmt->CallLists = save_CallLists;
10427
10428 vfmt->Color3f = save_Color3f;
10429 vfmt->Color3fv = save_Color3fv;
10430 vfmt->Color4f = save_Color4f;
10431 vfmt->Color4fv = save_Color4fv;
10432 vfmt->EdgeFlag = save_EdgeFlag;
10433 vfmt->End = save_End;
10434
10435 vfmt->EvalCoord1f = save_EvalCoord1f;
10436 vfmt->EvalCoord1fv = save_EvalCoord1fv;
10437 vfmt->EvalCoord2f = save_EvalCoord2f;
10438 vfmt->EvalCoord2fv = save_EvalCoord2fv;
10439 vfmt->EvalPoint1 = save_EvalPoint1;
10440 vfmt->EvalPoint2 = save_EvalPoint2;
10441
10442 vfmt->FogCoordfEXT = save_FogCoordfEXT;
10443 vfmt->FogCoordfvEXT = save_FogCoordfvEXT;
10444 vfmt->Indexf = save_Indexf;
10445 vfmt->Indexfv = save_Indexfv;
10446 vfmt->Materialfv = save_Materialfv;
10447 vfmt->MultiTexCoord1fARB = save_MultiTexCoord1f;
10448 vfmt->MultiTexCoord1fvARB = save_MultiTexCoord1fv;
10449 vfmt->MultiTexCoord2fARB = save_MultiTexCoord2f;
10450 vfmt->MultiTexCoord2fvARB = save_MultiTexCoord2fv;
10451 vfmt->MultiTexCoord3fARB = save_MultiTexCoord3f;
10452 vfmt->MultiTexCoord3fvARB = save_MultiTexCoord3fv;
10453 vfmt->MultiTexCoord4fARB = save_MultiTexCoord4f;
10454 vfmt->MultiTexCoord4fvARB = save_MultiTexCoord4fv;
10455 vfmt->Normal3f = save_Normal3f;
10456 vfmt->Normal3fv = save_Normal3fv;
10457 vfmt->SecondaryColor3fEXT = save_SecondaryColor3fEXT;
10458 vfmt->SecondaryColor3fvEXT = save_SecondaryColor3fvEXT;
10459 vfmt->TexCoord1f = save_TexCoord1f;
10460 vfmt->TexCoord1fv = save_TexCoord1fv;
10461 vfmt->TexCoord2f = save_TexCoord2f;
10462 vfmt->TexCoord2fv = save_TexCoord2fv;
10463 vfmt->TexCoord3f = save_TexCoord3f;
10464 vfmt->TexCoord3fv = save_TexCoord3fv;
10465 vfmt->TexCoord4f = save_TexCoord4f;
10466 vfmt->TexCoord4fv = save_TexCoord4fv;
10467 vfmt->Vertex2f = save_Vertex2f;
10468 vfmt->Vertex2fv = save_Vertex2fv;
10469 vfmt->Vertex3f = save_Vertex3f;
10470 vfmt->Vertex3fv = save_Vertex3fv;
10471 vfmt->Vertex4f = save_Vertex4f;
10472 vfmt->Vertex4fv = save_Vertex4fv;
10473 vfmt->VertexAttrib1fARB = save_VertexAttrib1fARB;
10474 vfmt->VertexAttrib1fvARB = save_VertexAttrib1fvARB;
10475 vfmt->VertexAttrib2fARB = save_VertexAttrib2fARB;
10476 vfmt->VertexAttrib2fvARB = save_VertexAttrib2fvARB;
10477 vfmt->VertexAttrib3fARB = save_VertexAttrib3fARB;
10478 vfmt->VertexAttrib3fvARB = save_VertexAttrib3fvARB;
10479 vfmt->VertexAttrib4fARB = save_VertexAttrib4fARB;
10480 vfmt->VertexAttrib4fvARB = save_VertexAttrib4fvARB;
10481
10482 vfmt->PrimitiveRestartNV = save_PrimitiveRestartNV;
10483 }
10484
10485
10486 void
10487 _mesa_install_dlist_vtxfmt(struct _glapi_table *disp,
10488 const GLvertexformat *vfmt)
10489 {
10490 SET_CallList(disp, vfmt->CallList);
10491 SET_CallLists(disp, vfmt->CallLists);
10492 }
10493
10494
10495 /**
10496 * Initialize display list state for given context.
10497 */
10498 void
10499 _mesa_init_display_list(struct gl_context *ctx)
10500 {
10501 static GLboolean tableInitialized = GL_FALSE;
10502
10503 /* zero-out the instruction size table, just once */
10504 if (!tableInitialized) {
10505 memset(InstSize, 0, sizeof(InstSize));
10506 tableInitialized = GL_TRUE;
10507 }
10508
10509 /* extension info */
10510 ctx->ListExt = CALLOC_STRUCT(gl_list_extensions);
10511
10512 /* Display list */
10513 ctx->ListState.CallDepth = 0;
10514 ctx->ExecuteFlag = GL_TRUE;
10515 ctx->CompileFlag = GL_FALSE;
10516 ctx->ListState.CurrentBlock = NULL;
10517 ctx->ListState.CurrentPos = 0;
10518
10519 /* Display List group */
10520 ctx->List.ListBase = 0;
10521
10522 save_vtxfmt_init(&ctx->ListState.ListVtxfmt);
10523
10524 InstSize[OPCODE_NOP] = 1;
10525 }
10526
10527
10528 void
10529 _mesa_free_display_list_data(struct gl_context *ctx)
10530 {
10531 free(ctx->ListExt);
10532 ctx->ListExt = NULL;
10533 }