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